This page is the canonical research record for Vraxion. It carries three things in one place: the run contract behind every public claim, a latest-first chronology of what changed, and the archive residue worth keeping after raw noise is stripped away. Read the top block as a standalone reference for how findings are graded and promoted; read the timeline below for the day-by-day trail that led to the current architecture line.

Vraxion Home is the mission-first front door, INSTNCT Architecture is the implementation explainer, and Rust Implementation Surface carries detailed Rust validation. All public URLs are collected once in Core Surfaces; the rest of this record references them by name rather than repeating links inline.

One list of live public surfaces for the project. Everywhere else in this record refers back to these by name instead of repeating URLs inline.

• Main repository: https://github.com/VRAXION/VRAXION
• Latest release (v5.0.0-beta.2): https://github.com/VRAXION/VRAXION/releases/tag/v5.0.0-beta.2
• All releases: https://github.com/VRAXION/VRAXION/releases
• GitHub Pages site: https://vraxion.github.io/VRAXION/
• Public wiki home: https://github.com/VRAXION/VRAXION/wiki
• Key in-repo docs: README.md, BETA.md, CHANGELOG.md, VALIDATED_FINDINGS.md, docs/PUBLIC_BETA_TRAINING.md, docs/GROWER_RUN_CONTRACT.md, docs/BYTE_OPCODE_V1_CONTRACT.md

• The stable public release is still v4.2.0; the active architecture line is INSTNCT Architecture. See Core Surfaces for the release list.
• The Rust v5.0.0-beta lane (instnct-core) is substantial enough to deserve rich chronology, but remains a beta implementation surface rather than the shipped default.
• The biggest unresolved pressure is no longer basic trainability. It is whether language evaluation, seed variance, and context-dependent task learning survive repeated adversarial reruns, and whether the C19 + float-gradient + fraction-quantization pipeline generalizes beyond the current task suite.
• The current frontier recipe: L0 Byte Interpreter LOCKED — flat 8->4 binary {-1,+1}, pure integer deployment (POPCOUNT -> int32 sum -> int8 output), no C19, no float, no multiply. L1 Input Merger is the next design target. The older C19 + float gradient + fraction extraction pipeline remains valid for the grower lane and L2+ prediction tasks where binary weights are insufficient.

This is the contract behind public research claims. It keeps shipped code, validated findings, and experimental lines separate even when the chronology gets messy. Every meaningful run needs an objective metric, one budget mode, hard fail gates, and a minimum evidence bundle. A Current mainline claim must match code on main; reproducible but unshipped results stay under Validated finding, and active non-default work stays under Experimental branch.

The minimum bundle is four files. Optional extras (checkpoints, plots, CSV exports, live logs) are useful but never replace the core bundle.

These gates apply uniformly to probes, sweeps, and training runs. Any single hit invalidates the run.

• Choose exactly one budget mode per sweep: iso-VRAM, iso-params, or iso-FLOPs/step.
• Run the systems curve first (throughput, stability, step-time tails, resource limits). Only run the quality curve after the systems curve is stable.
• Start coarse, then rerun the best cells with multiple seeds under the same contract.
• If a result does not reproduce under the same contract, treat it as unconfirmed.

Era-level summary of the research arc. Per-day detail lives in the timeline below; this rail exists so a new reader can place any entry into the larger narrative in one glance.

timeline
    title VRAXION research eras
    section Pre-INSTNCT substrate
        Early 2026       : Diamond Code / LCX era
                         : External memory, swarm, LCX
        2026-02-08/10    : Swarm sprint, AGC diagnostics
        2026-02-14/18    : Diamond Code v3 consolidation
                         : One-level LCX, C19 bottleneck
        2026-02-19/22    : Probe ladder, plateau diagnosis
    section English line hardens
        2026-03-22/26    : Schedules, controls, edge format
                         : Voltage medium leak 22.11%
        2026-03-27       : Tentacle I/O, SDR input
        2026-03-28       : Phi overlap 20.8%
        2026-03-29       : Compact channel, breed 24.4%
    section Rust v5 beta foundation
        2026-04-02/03    : Owned Network, deterministic bench
        2026-04-05       : Seed variance mapped, rayon search
        2026-04-06       : Hyperparameter exhaustion, 17-18% band
        2026-04-07       : Smoke-port, ListNet, branch cleanup
    section Topology falsification
        2026-04-08       : Edges dont matter on bigram
                         : Edges MATTER for addition +52pp
                         : 72% ceiling unbreakable
                         : INCREMENTAL BUILD 10 neurons = 100%
    section Generalization regime
        2026-04-09       : Readout fix 7/10 tasks solved
                         : Float gradient all 8 tasks
                         : ReLU perfect recurrent generalization
                         : Connection Point validated
                         : Connectome passive relay wins
    section Deploy pipeline
        2026-04-10       : Float gradient 200/200 ADD
                         : C19 beats ReLU 250/250 vs 189/250
                         : Two-pool C19 structural advantage
                         : Binary+C19 3/5 tasks
                         : Fraction extraction 4-6 bit integer
        2026-04-12       : Bias-free persistent grower
    section Abstract-core pipeline
        2026-04-13       : All-binary preprocessor 77 bits
                         : Language model 34.5% float baseline
        2026-04-14       : Ternary byte encoder 3 neurons = 100%
                         : Linear merger 100% at 86% compression
                         : Conv pattern finder 96.6% train
                         : Overfitting discovered train 97% vs test 49%
                         : Named layer architecture L0-L3
                         : L0 CANONICAL binary 4n 36b POPCOUNT
                         : Bitwidth sweep 1b/ternary/2b
                         : Backprop STE validates gradient path
        2026-04-15       : Pure binary pipeline LOCKED
                         : No C19 no float no multiply
                         : POPCOUNT to int8 end-to-end
                         : Multi-layer WORSE than flat
                         : L0 FROZEN L1 next
    section Beukers gate + brain validation
        2026-04-15/16    : L0 Embedding 16-dim LOCKED
                         : Beukers gate xy/(1+|xy|) novel discovery
                         : k=7 optimal kernel 83.6% record
                         : Single layer beats deep
                         : Brain on frozen features +1.4%
                         : 21 activation functions tested
                         : Record 77.4 to 80.1 to 82.1 to 83.6

Open gates that still block stronger promotion claims or a cleaner public-beta posture. Each row describes what must hold and what promotion would change.

This record absorbs durable findings into canon chronology and only leaves raw material separate when it still carries unique source value. Retired surfaces point to their current home below.

Retention rules

• Keep a raw page only if it still carries unique config, ticket, source, script, or long-form result detail that is not safely compressed into canon prose.
• Demote raw material out of the primary stack and point back to its canon replacement surface.
• If a raw leaf and a canon page disagree, the canon page wins.
• When a new important finding lands, add it at the top of the timeline, keep What changed to 2-3 bullets and Why it mattered to 1-2 bullets, add one inline evidence object, and say explicitly whether the finding changed canon or stayed experimental.

Inferred spans and remaining migration work

• 2026-03-30 to 2026-04-01 (Inferred): the public record suggests a transition period rather than a single headline discovery, with work shifting from Python-side architecture gains into Rust-port stabilization and benchmark-methodology hardening.
• Archive migration still incomplete: several probe leaves, research-intake pages, workbench-era notes, and benchmark-era raw dumps still exist outside this record. They should only disappear once their unique ticket/config/source value is safely captured elsewhere.

The timeline is ordered latest-first. Each day is a self-contained H3 section with its own evidence table — scan the date header to jump, then read the table rows for the findings and their status. Rows marked BREAKTHROUGH in the Status column mark genuine regime shifts (incremental build, Connection Point, passive relay, float gradient, C19 robustness win). Anything before roughly 2026-03-22 lives in the Older Timeline block near the bottom, preserving the LCX / Diamond-Code-era record for historical lookup.

Theme: Comprehensive quantization sweep on RTX 4070 Ti Super. 50+ experiment runs across 4 protocols (staged INQ, QAT STE, progressive growing, random rotation) × 7 precision levels (binary/ternary/int4/int5/int8/fp16/float32) × 2 tasks (FineWeb 30MB + code corpus 2.9MB) × 4 network sizes (nf=32/64/96/128 CPU + nf=1024 GPU). Total wallclock ~2.5h. Revised the prior day's finding: the "+1.4pp int4 beats float" claim was a protocol artifact — the staged INQ protocol gives quantized runs 200 extra training epochs vs the float baseline. New absolute winner identified: QAT int8 = 86.40% FineWeb at nf=1024, beating pure float_long (86.20%) at 4× compression. Ternary's earlier catastrophic 55% was diagnosed as a protocol bug (staged scale/2 threshold over-prunes); QAT STE lifts ternary to 71.50% (+16.5pp). Binary "info-ceiling at 49%" was capacity-bound; at nf=1024 binary reaches 70.70% (staged) / 71.50% (QAT), reconfirming BitNet b1.58 scaling literature. Pareto frontier reduces to four precision points: float32 (1×, 86.20%), int8-QAT (4×, 86.40% — winner), int4-staged (8×, 84.75% — sweet spot), binary-QAT (32×, 71.50% — IoT niche with Beukers LUT). Failed alternatives documented: progressive per-neuron growth (−14.85pp), generational cluster stacking (−5.2pp), random-rotation sparse training (dominated), stacked exhaustive clusters (dominated by float+PTQ in every metric), true ternary exhaustive D=16 (21.25% vs float 30.25%, −9pp sparsity cost). Full playground visualization at docs/playground/quant_final_verdict.html. All scripts documented in tools/README.md. See VALIDATED_FINDINGS.md "Quantization championship (2026-04-17/18) — revised final story" section for the canonical table.

Four branches merged or archived to leave main as the single canonical branch:

• cleanup/wiki-examples-2026-04-17 (PR #127 merged 2026-04-18) — 10 commits adding the quantization championship research artifacts (13 Python scripts, 3 Rust sweep examples, parquet feature, FineWeb code corpus fixture, final-verdict playground HTML, VALIDATED_FINDINGS + wiki updates). Successfully merged to main via PR with full merge history preserved.

• origin/claude/review-main-branch-LL64D (dates: 2026-04-13, 5 unique commits, cherry-picked to main) — one-day growth-run on the persistent neuron grower adding forever-network mode, crash-safe incremental persist, manual neuron-pick overrides (--force-pick, --preview-only), ternary-bake-based candidate selection (--bake-best), and per-task alpha refit. All five commits cherry-picked cleanly onto main (only instnct-core/examples/c19_grower.rs modified, no conflicts). The crash-safe persist commit specifically implements the pattern in feedback_persistent_state memory note. Branch deleted.

• origin/claude/check-progress-resume-vwFYv (dates: 2026-04-14, 3 unique commits, archive-only) — explored BERT-style MLM pretraining as an L2 feature extractor, then tried per-neuron learnable C19 rho, hitting 47.87% masked-char accuracy (+5.31pp over fixed C19). The result was obsoleted within a day when Beukers-gate work on main reached 80.1% then 83.6% on the same metric. Commits archived rather than cherry-picked because cherry-picking would add dead-end code that duplicates already-superseded functionality. Preserved in git history via reflog; branch label removed.

• origin/experiment/connectome-gradient-pipeline (dates: 2026-04-10 → 2026-04-12, 25 unique commits, 1 cherry-picked + 24 archived) — 3-day exploration spike covering analytic backprop, holographic fully-connected nets, sparse-dense sandwich architectures, C19 logic-gate/ALU/CPU synthesis, Equilibrium Propagation, and canonical neuron builders. Produced the "C19 rho=8 WINS +2.2% vs ReLU" shallow-net result (later contradicted by deep-net finding on main, now captured in project_activation_sweep_findings) and an exhaustive-verified C19 ALU/CPU at 4-bit and 8-bit. Main subsequently pivoted to the binary-byte/Beukers-gate pipeline (43K+ lines of divergence since branch base), rendering these directions dormant rather than wrong. Only the .gitignore chore commit was cherry-picked (runtime-log exclusions); the 24 experimental commits are preserved in git history via reflog; branch label removed.

Exploratory tools/*.py scripts deleted from disk on 2026-04-18 during mainline cleanup. Git history remains authoritative for the code itself; the entries below preserve the idea so each experiment can be recreated from scratch without re-reading commits. Scripts still shipping on main (e.g. diag_qat_ste.py, diag_quant_sweep_gpu.py, run_grid3_curriculum.py) are not listed here.

Theme: Massive overnight session: 10+ commits, 30+ configs, 21 activation functions swept. The pipeline re-architected around a new three-stage design: L0 Embedding (16-dim char lookup table, 100% lossless, LOCKED), L1 Conv (Beukers gate activation xy/(1+|xy|), k=7, novel discovery from zeta/number theory), Brain (validates on frozen conv features with +1.4% improvement over end-to-end training). The Beukers gate is a novel 2-input activation function derived from number theory (Beukers' proof of Apery's theorem on zeta(3)), discovered during an exhaustive sweep of 21 candidate activations. Record accuracy progression: 77.4% -> 80.1% -> 82.1% -> 83.6% (all Beukers, final with k=7, nf=128). Key architectural findings: single conv layer strictly beats deep (2-layer Beukers is worse), k=7 is the optimal kernel size (14 chars = 2-3 words receptive field), embedding achieves 100% lossless round-trip.

Theme: Final L0 byte encoder consolidation. The deployment pipeline eliminates C19, floats, and multiply instructions entirely: binary {-1,+1} weights mean each operation is pass-or-negate, POPCOUNT computes the dot product, int32 accumulator sums, and int8 output is the final code. Multi-layer binary encoders tested and confirmed WORSE than flat (hidden layer creates bottleneck, not benefit). Bitflip-only encoding (no sum) shown trivial but needs 5 outputs vs 4 with sum. Backprop STE validated as matching exhaustive search but unnecessary for byte encoder (exhaustive is faster at this scale). Architecture decisions locked: L0 is FROZEN, L1 Input Merger is the next design target.

Theme: Exhaustive bitwidth sweep across 1-bit, ternary, and 2-bit weight precisions settles the L0 Byte Interpreter design. The 1-bit binary {-1,+1} encoder wins on total model size (36 bits), search speed (0.05s exhaustive), and hardware simplicity (pure POPCOUNT, no multiplications). Backprop STE validated as fast alternative to exhaustive search for higher bitwidths. Key architectural insight: topology matters more than weight precision for encoding tasks — binary weights suffice when the output space is small and discrete. INSTNCT's sparse edge-list format unifies naturally with binary-to-ternary deployment. Four-layer pipeline architecture diagram created.

Theme: The abstract-core pipeline solidified into a named four-layer architecture (L0-L3). Three layers built and validated end-to-end. L0 Byte Interpreter: ternary {-1,0,+1} encoder achieves 100% byte encoding with only 3 neurons and 22 connections — a new record beating 4-neuron binary. L1 Input Merger: linear projection 112->96 achieves exact 100% reconstruction at 86% compression by removing sigmoid (was 99.98% ceiling). L2 Feature Extractor: Conv1D(k=3,f=64)+MLP hits 96.6% train accuracy (+33pp over one-hot 93.8%), but overfitting discovered (test 48.5% with 474K params, train 97% vs test 49%). Binary weights shown to be perfect for encoding but FAIL for prediction; int8 weights are lossless for prediction. ReLU beats C19 in deep networks (70% vs 42%); C19 beats ReLU in shallow networks. Fair A/B comparison: MLP backprop is ~18x more parameter-efficient than INSTNCT evolution. Minimum model: 1 hidden neuron (487 params) beats INSTNCT 24.6%. ctx=16 optimal for 100KB corpus. Merger scrambles spatial structure, hurting conv by -7pp. Ternary sparse list format unifies with INSTNCT ConnectionGraph.

Theme: Abstract-core preprocessor deep dive — exhaustive architecture search from dense MLP to all-binary sparse grower. Validated the full pipeline from byte encoding through bottleneck compression, activation function comparison (C19 vs ReLU), quantization limits, and first language model test. Key result: all-binary {-1,+1} weights with C19 activation achieve 100% lossless byte encoding in just 77 bits (10 bytes), exhaustive-search guaranteed optimal. Language model float baseline reaches 34.5% next-char accuracy (vs INSTNCT 24.6%) but naïve binary quantization collapses; int8 or QAT quantization is the next step.

Theme: Hierarchical byte preprocessing via mirrored autoencoder — explored tied-weight autoencoders, MLP backprop + int8 quantization, and bit-width sweep for the abstract-core preprocessor concept. Established that backprop-trained tied-weight MLP at H=12 achieves 100% lossless byte round-trip encoding through a 7-bit bottleneck, int8 quantization is lossless, and int5 (±15) is the minimum bit-width for perfect encoding at H=12. The total frozen preprocessor fits in 219 bytes (int8) — less than a single cache line.

Theme: Validated the c19 grower end-to-end as an integer-deployable activation: identified and fixed a 14.5pp Python/Rust voting semantics divergence, confirmed full int8 quantization is lossless across 48 neurons, isolated a deterministic 50% stall on perfectly balanced binary tasks and proved the c19 architecture is capable on those tasks (the defect is in the Rust scout oracle's strict-positive-delta accept gate, not the activation), and head-to-head benchmarked the c19 path against the consolidated bias-free threshold baseline on grid3_copy. Built a multi-head exhaustive bit-decomposition explorer in Python that landed three full task levels (grid3_copy, grid3_invert, grid3_shift_right) at 100% val/test plus 6/9 of grid3_reflect_h. Surfaced a label-polarity rule that explains why c19 bit-heads need 1 vs 2 neurons depending on whether f(0) = 1 or f(0) = 0.

Theme: Validated cleanup of the persistent grower path: remove redundant bias parameter, make the threshold neuron store/evaluate in direct dot >= threshold form.

Theme: Binary-space native-output impossible; float gradient solves everything; fraction extraction converts floats to 4-6 bit integer weights. Two-pool connectome proves C19's structural advantage.

[Float gradient solve rates — 2026-04-10]

Init scale=0.5 best. Loss landscape smooth — one valley, no local minima. Gradient converges in 50-100 steps.

[C19 vs ReLU — 5 tasks × 50 seeds — 2026-04-10]

Learnable parameter convergence (not fixed 4.0):

• rho: ~5.1 for ADD/MUL; ~4.1 for |a-b|
• C: ADD≈5.0, MAX≈3.0, MIN≈2.5, |a-b|≈1.5 (task-dependent)

Two-pool connectome (MIN task only): ReLU 10/50 vs C19 50/50 — 40pp structural gap.

[Circuit reuse speedups — frozen ADD as pre-trained substrate — 2026-04-10]

Circuit reuse helps only when output format is compatible. Binary-output tasks converge slower with a frozen float ADD substrate.

[Overnight scaling sweep — 2026-04-10]

Overparameterization hurts at 15d (10w beats 20w). EXP 2 generalization gap shrinks from 24pp at 5d to 3pp at 20d.

[Two-pool connectome — C19 vs ReLU bottleneck gap — 2026-04-10]

C19 advantage GROWS with bottleneck severity: single-pool gap=61pp → two-pool gap=80pp. ReLU degrades with more ticks (overprocessing); C19 stays 50/50. Periodic wave genuinely helps cross-cluster information transfer.

[Binary ±1 + C19 exhaustive sweep — 2026-04-10]

ReLU binary: 0/5 solved (best=88% on MUL). C19's periodic wave makes binary search space viable; binary+ReLU was 0/8192 configurations.

[Fraction extraction to integer weights — 2026-04-10]

All 5 tasks convert to integer; no search needed — float training finds ratios, denominator d∈[1,30] gives integer grid via weights = round(float×d)/d. C baked as LUT.

Theme: Complete holographic capability map; nearest-mean readout unlocks 5 more tasks; float gradient + per-neuron bias solves everything; ReLU uniquely generalizes across tick depth; Connection Point architecture validated.

[Holographic capability map — 2026-04-09]

Area encoding proves MUL is an ENCODING problem, not a network problem. Depth is task-specific: helps PARITY, hurts SUB. Width/weight scaling do not help.

Theme: Edges don't matter on bigram, do matter (+52pp) on addition; memorization vs generalization; 72% ceiling unbreakable by search; incremental build achieves 100% generalization with 10 neurons; resting potential replaces BIAS; holographic > pathway; shared W > layered W; activation sweep; spike erases amplitude.

[Paradigm progression — held-out generalization solve rate]

[ListNet vs INSTNCT head-to-head — H=256 — 2026-04-08]

Accuracy noise-equivalent. At H=2048: ListNet gives 2.5x speedup with identical accuracy.

[Edge cap sweep — H=1024 — 2026-04-08]

[H=512 long stability run — 5 seeds × 300s — 2026-04-08]

[Fair 1+1 vs 1+1 — INSTNCT library speedup by H — 2026-04-08]

Corrects earlier "ListNet 6x faster" claim, which was an unfair 1+1 ES vs 1+9 jackpot comparison. Packed NeuronParams (threshold+channel+polarity in one 4-byte struct): 8-10% faster spike loop at all H.

[Four alternative topology representations — H=256 — 2026-04-08]

[Edges matter for addition — INSTNCT vs ListNet — 2026-04-08]

Task: a+b in 0-4 (25 examples), random baseline = 11.1%.

INSTNCT beats ListNet on addition (56-60% vs 24-44%) despite same edge count. Answers "do edges matter": task-dependent — bigram = lookup (phi-overlap short-circuit, 0pp); addition = computation (edge topology builds the computing circuit).

[Incremental build growth trace — 2026-04-08]

Previous best with 256 neurons: 72% train, 0% test. Each step searches 3^19 instead of 3^90 (frozen layers + incremental expansion).

[Approach comparison — held-out addition generalization]

Theme: Smoke-port branch merged (compact types, skip-inactive, sparse tick/input, CoW snapshots). Steam Deck benchmarking. ListNet = 6x INSTNCT at identical accuracy. Branch cleanup.

[Smoke-port branch — optimization performance deltas — 2026-04-07]

Prefetch, nibble packing, and bitset dirty_member correctly rejected with benchmarked evidence.

Theme: 11 tuning axes fail to lift 17-18% band; pocket-pair parity; shared-female refuted; Watts-Strogatz falsified; library hardening (EvolutionConfig split, atomic checkpoint persistence).

Theme: Rust port becomes real evolution substrate (snapshots, mutation API, CSR, genome persistence, rayon multi-seed). Seed variance mapped as first-class problem.

Theme: v5.0.0-beta becomes clean Rust-port branch with owned Network. Deterministic benchmark discipline replaces looser micro-opt claims.

Theme: Transition from Python architecture gains to Rust-port stabilization and benchmark methodology hardening. No single headline discovery.

Theme: Frozen random temporal diversity beats learnable freq/phase → compact per-neuron channel. Breed + crystallize hits 24.4%.

Theme: Output-dimension sweeps + phi-style proportioning + overlap experiments → strongest public architecture story. output_dim=160 and phi overlap push reported peaks.

Theme: Tentacle I/O beats holographic; SDR input baked into Python stack; charge readout beats state; learnable theta opens next quality jump.

Theme: English line settled around a conservative public recipe while side branches competed on schedules, mutation rules, decay handling, and edge representation. Voltage medium leak, decision-tree control, and sign+mag magnitude resample emerge as strongest historical results.

[Accuracy ceiling across time — next-char / bigram (H≈256-512)]

Theme: Resonator Chamber theory formalized with FlyWire validation; public theory framing locked onto destructive interference as fixed-point mechanism.

Theme: Triangle convergence → fixed English recipe 2 add / 1 flip / 5 decay. Sign+mag edge representation as best quality-per-edge. Canon boundaries tightened; archive branches cut ahead of public beta push.

Theme: Repo-tracked docs became canonical; GitHub wiki became the mirror surface. Schedule-control work became the main live research frontier.

Theme: Training-run analysis exposed v4 GPU bottlenecks. Locked v4 baseline around B=8, D=256, M=256-class ring sizing. Precomputed attention weights + hidden_dim/slot_dim split landed, reducing ring-clone VRAM.

[Input width sweep — D=256, GPU, echo task — 2026-02-26]

Theme: BN width / D ablation / depth / bootstrap / LCX write-strategy / catastrophic-forgetting / plateau probes converged on a harsher picture of memory-side behavior. LCX whiteboard underperformance → cross-batch contamination + weak write signal.

Theme: Dense probe burst on cold-brain activation, depth, learning rate, attention temperature, state EMA, jump tau, LCX tau, top-k, undetach behavior. Mostly eliminative signal.

Theme: VRAM leaks/detach mistakes/observability gaps fixed. Score-margin telemetry, LCX bottleneck design, one-level LCX hardened. Goldilocks Nano / Ant, binary-bits encoding dominated by 2026-02-18.

Theme: 34-session sprint establishing AGC diagnostic campaign; architecture shifted away from older GRU-style framing toward think_proj; dashboard-style observability mandatory. VRA-78 frontier scans separated GPU "biomass" from expert "brain mass".

Theme: Early intake pages gathered swarm scaling postmortems, memory stability research, biological dimensionality arguments. First explicit "resolution over reshuffling" doctrine.

Theme: Diamond Code / LCX dominated public architecture story before INSTNCT. External memory, dreaming, observability, Goldilocks-style probes as visible front line. Historical substrate that the later INSTNCT line replaced.