SESSION-HANDOFF.md

★ 2026-07-04 BYTE-EXACT vs FP ANSWERED + #47 ECHO FIXED + FP-PROFILE FOUNDATION. Operator asked how much byte-exactness buys and whether a standard-FP sibling is viable. (1) Recon: the FP path already exists — every byte-exact CUDA kernel is if(sp_byteexact_attn())/else (default-off) and served recall is FP cosine; the "sibling" is a cargo feature, not a fork. Doc papers/DESIGN-NO-EXACT-PROFILE.md. (2) Flag-flip A/B on the live 12B (G-NOEXACT-OBEY-AB, no rebuild, per-request byteexact true/false): faithfulness EXACT TIE (54/61 == 54/61, identical 7 parametric-prior misses), FP 1.06× faster, determinism 6/6==6/6 on one pinned box (CUBLAS pin makes FP deterministic too → exact's win is CROSS-MACHINE). Byte-exact's value = determinism/auditability (SWARM/PoUW) only; FP-default + byteexact-as-audit-mode indicated. (3) #47 echo DIAGNOSED then FIXED: the short-prompt "echo" is system-prompt recital on contentless prompts (Sure.→"You are Shannon-Prime…"), present in exact AND FP equally (G-ECHO-HUNT-47) — not a byteexact artifact, premise refuted. FIX (G-ECHO-FIX, engine 47b82ed): a no-repeat-ngram guard seeded with the prompt tokens on the greedy path (sampler.rs ban_repeat_ngram + no_repeat_ngram param; routes.rs reads SP_NO_REPEAT_NGRAM, trim-robust; run_console_chat.bat sets =3). LIVE: Sure.→"You're welcome.", name/2+2/brevity preserved; only in the chat launcher (recall OFF) so faithful recall + G-ONECONFIG untouched; default-unset = byte-identical null floor. GOTCHA banked: env parse needs .trim() (a launcher trailing space silently zeroed the flag). (4) FP-profile foundation LANDED (engine e58150d, default build GREEN): cargo exact feature (DEFAULT-ON), build.rs skips the 4 ring archives under !exact, ntt_ffi gated. Remaining for FP-link-green (G-NOEXACT-BUILD): cfg-gate network/quic_shard.rs's 3 NTT-recombine sites (the QUIC garner mesh), then --no-default-features build; plus the exact_islands.c→cl.exe build-cpu edit (separate). CUDA byteexact NOT gated (no __int128, zero cost off). MEM-OKF: noexact-fp-ab-finding, echo-47-diagnosed, echo-47-fix.

★ 2026-07-04 PERSONALITY FRAMEWORK COMPLETE — PF-B4 + PF-B5 GREEN (self-modifiable AND system-curatable). The personality is now closed end-to-end: the model self-modifies it (tags PF-B3 + decorators PF-B4) AND the system curates it (NIGHTSHIFT PF-B5). PF-B4 (G-PF-DECORATORS, harness d35a723): harness/personality/tools.py — @personality=skill(pack=personality), so adjust_mood/set_voice/set_trait(trait,action)/remember_self register into SKILL_REGISTRY with OpenAI schemas and the model CALLS them via the exact run_with_tools tool_code loop to durably write persona state (PF-B2) + self-model (PF-B1); fixed self_model._resolve_root (arg>SP_SELF_MODEL_ROOT>default). PF-B5 (G-PF-CURATE, harness e35cfdf): harness/personality/curator.py consolidate_personality mirrors consolidate_conversation — (1) EXTRACTS the shifts the model expressed in a transcript (reuses PF-B3 apply_personality_tags on assistant turns), (2) PRUNES/dedups stale traits (MAX_TRAITS=8, drift-control), (3) SNAPSHOTS the personality into a content-addressed memory-okf-personality/ OKF tier (mem_class persona / mem_owner self); wired into agency.py consolidate_current gated SP_PERSONALITY; deterministic (no model call). Gate: transcript shifts extracted (mood/voice/+trait/−trait), duplicate trait pruned, OKF snapshot written. Contract CONTRACT-PERSONALITY.md marked GREEN (PF-B1..B5); PF-B6 (engine-native personality head) stays DEFERRED. MEM-OKF pf-b4-personality-decorators + pf-b5-personality-curation. Lattice aa390cb. NEXT: PF-B6 deferred; the personality axis is done — resume the roadmap (open BACKLOG: #35/#36 MoE dials, #46 dp4a GEMM, #47 byteexact-default re-eval).

★ 2026-07-03 SEED-DIVERSITY RETRAIN 83.3%→93.3% (the loop improved itself) + PERSONALITY FRAMEWORK PLANNED. (a) Expanded DF-B2's seed (counterfact/fact/episodic-event +10 varied templates each → mem_class_combined 906), reran the autonomous loop end-to-end — Colab T4 retrain → distinct held-out 83.3%→93.3% (28/30) → gate_and_promote MUST_IMPROVE → PROMOTED (registry active 9f3a1fce/0.933; prior c0efdf40/0.833 demoted). Harness 017a6b6; adapter on KnackAU/sp-mem-class-adapter. The self-improvement loop demonstrably raised its own accuracy. (b) papers/CONTRACT-PERSONALITY.md (OKF-GREEN) — the operator's self-modifiable personality vision, grounded anti-rebuild in a fresh harness recon (persona.md live-load + load_agent_system; @skill+SKILL_REGISTRY+run_with_tools; StreamProcessor already extracts [MOOD]/[VOICE]/[TRAIT] tags; comms_framework InterceptorPipeline + MCPFramework state; memory.py; consolidate_conversation). Bricks: PF-B1 fact-ownership (self-fact vs user-fact — an orthogonal owner axis, no classifier retrain) · PF-B2 structured persona.md · PF-B3 tag-persistence (a PersonalityStateInterceptor persists+hydrates the tags the model already emits) · PF-B4 @personality decorators (mirror @skill so the MODEL self-modifies durably) · PF-B5 NIGHTSHIFT curation (memory-okf-personality tier) · PF-B6 personality head (DEFERRED, engine-native, same call as the mem_class LatentHead). ADR-002 framing: personality = DECISION → clean tag/decorator/label → EXECUTE. MEM-OKF 6e70a998. PF-B1 DONE (G-PF-OWNERSHIP, harness a1c59ea): harness/personality/self_model.py — mem_owner axis (self|user) orthogonal to mem_class, set at capture by source (no classifier); owner-tagged OKF concepts in memory-okf-self/ (compose with store-merge + curator); remember_self/remember_user/render_self_model (self-facts only, never leaks user-facts). Gate: 2 self + 2 user, distinct, OKF-conformant, self-model render excludes user-facts. PF-B2 DONE (G-PF-PERSONA, harness 27c5c3b): harness/personality/persona_file.py (parse_persona never-raises, render_state, write_state = the self-modify seam) + load_agent_system extended to split VOICE prose from a machine-parseable ## Personality state block and inject state (voice/mood/traits) + the PF-B1 self-model, graceful fallback; persona.md got a live state block (framework ACTIVE). Gate: parsed+injected, header not leaked, self-model folded, live-edit reflects, malformed=graceful. PF-B3 DONE (G-PF-TAGS, harness b72ece1): the model self-modifies its personality via tags. harness/personality/interceptor.py apply_personality_tags ([MOOD]/[VOICE]/[TRAIT+/-] → persona state via write_state, strips tags); harness/interceptors/personality_state.py PersonalityStateInterceptor (post-call, priority 72, registered only when SP_PERSONALITY=1 — it writes persona.md); stream_processor gains [TRAIT] pattern+strip. Gate: reply tags persisted (mood/voice set, +mischievous/−formal, curious kept) + stripped + registration verified. NEXT: PF-B4 — @personality decorators (mirror @skill + run_with_tools) so the model DURABLY self-modifies by calling set_trait/adjust_mood/remember_self (not just tags) → PF-B5 NIGHTSHIFT curation (memory-okf-personality tier). ★ 2026-07-03 SELF-IMPROVEMENT LOOP COMPLETE + AUTONOMOUS — graduated to VERIFIED-SCOREBOARD (12 VERIFIED). Three follow-ons closed the data-gen phase (engine 6d418a4, harness bfaa4eb): (1) G-DF-LIVE — the deployed loop runs LIVE end-to-end: the harness 0.5B curator corrects a mis-classed concept while the engine serves it, and the engine's new reconcile-on-edit (load_and_mint_okf_store re-reads an already-loaded concept's frontmatter and updates the in-memory policy in place when mem_class changed — LM-B1 cache-invalidation) serves the correction with no restart (class flip + telemetry redacted flip). (2) G-DF-PARITY — the replacement-quality A/B (SP_MEM_REFINE_LOGALL logs the 12B verdict per concept). BIG FINDING: the deployed 0.5B doesn't just match the 12B model_classify it replaces — it BEATS it, 0.83 vs 0.33 vs ground truth on 30 distinct held-out. The 12B was a weak classifier (over-fires private-secret); the 0.5B is 2.5× more accurate AND ~24× smaller AND off the hot path — retroactively justifying the whole phase. (3) G-DF-AUTOTRAIN (DF-B5) — datagen/auto_train.py (lifts CosySim auto_train): accrued NON-redacted telemetry ≥ threshold fires convert→merge→train/promote (pluggable callback, no CU in gate); idempotent; run_agency._start_autotrain gated SP_AUTOTRAIN, DRY unless SP_AUTOTRAIN_LIVE. THE LOOP IS AUTONOMOUS: telemetry → [threshold] → convert+seed → train (Colab) → eval/promote → deploy curator → feeds next telemetry → repeat. CONTRACT-DATAGEN-FINETUNE marked GREEN-LIVE; scoreboard row added. MEM-OKF 6e70a998. Remaining (optional): engine-native rungs (LatentHead / telepathy delegate) for in-forward classify; a bigger/more-diverse seed to push 83.3% higher. ★ 2026-07-03 DF-B6 GREEN — THE SELF-IMPROVEMENT LOOP IS CLOSED (G-DF-DEPLOY, harness b8785b1). The promoted 0.5B classifier is DEPLOYED as the harness curator (operator-confirmed rung: ADR-002 idle-vs-hot-path — classification is an offline Tier-1 decider, so it lives where the PyTorch adapter lives, not in the resident engine). datagen/mem_class_curator.py loads the promoted adapter (Qwen2.5-0.5B + LoRA) on CPU (CUDA_VISIBLE_DEVICES empty — never touches the engine GPU), classify() + curate_store() = the drop-in replacement for the engine's 12B model_classify (safety-monotone; Python mirror of rewrite_okf_class; resolves the active adapter from model_registry.json). run_agency._start_mem_curator runs it as a background thread, gated SP_MEM_CURATOR=1 (default off). GATE: CPU classify acc 0.833 (reproduces DF-B4 in the harness) + corrects counterfact→private-secret + counterfact→persona + safety-monotone holds on a genuine secret + rewrites disk. THE LOOP: telemetry (LM-B2) → convert (DF-B1) + seed (DF-B2) → train (DF-B3 cloud) → eval/promote (DF-B4) → deploy (DF-B6) → the deployed classifier curates the store the engine serves → feeds the next telemetry. MEM-OKF 6e70a998. FOLLOW-ONS (all pre-scoped): (a) live curator+engine-reconcile in one run (each half already GREEN); (b) 12B-parity A/B (formal replacement-quality receipt); (c) DF-B5 auto-train trigger (accrued telemetry → fire DF-B3→B4→promote); (d) engine-native rungs — LatentHead (the MTP-head idea; cheapest in-forward, for hot-path classify) / telepathy delegate (0.5B resident in-engine) — if in-forward classification is ever needed. ★ 2026-07-03 DF-B4 GREEN — the mem_class adapter GENERALIZES (20%→83.3%) and is PROMOTED (G-DF-EVAL, harness c76baa1). The real generalization test: a distinct 30-example held-out (hand-written phrasings, NOT augmentation-shared). On Colab T4, eval_colab.py A/B'd both models — base Qwen2.5-0.5B zero-shot = 0.200 (6/30, ~chance), finetuned adapter = 0.833 (25/30), delta +0.633 — pushed eval_report.json to the adapter repo. datagen/model_registry.py lifts CosySim's registry (register/benchmark/promote), drops the Pareto+engine glue, and adds an explicit gate_and_promote (NO_REGRESSION / MUST_IMPROVE vs baseline). promote_run.py registered + benchmarked (0.833) + gated → PROMOTE (active mem_class = c0efdf40 → KnackAU/sp-mem-class-adapter), persisted to datagen/model_registry.json. Colab stopped, no billing. MEM-OKF 6e70a998. Honest: 83.3% is generalization (DF-B3's 100% was memorization); baseline = un-finetuned base (proves finetune value); it climbs as the live telemetry corpus grows. NEXT: DF-B6 — deploy the promoted adapter behind a flag to replace LM-B3's 12B model_classify micro-forward on the served refine path (engine-side), gated by parity vs the 12B on the classify corpus + a latency win. That closes the self-improvement loop. ★ 2026-07-03 DF-B3 CLOSED VIA CLOUD — the mem_class classifier LoRA is TRAINED and lives on HF (G-DF-TRAIN-CLOUD, harness 4e6282a). The env-blocked local smoke was run on the intended Colab lane instead, HF-mediated end-to-end. Flow (datagen/cloud/): hf_stage.py uploads mem_class_combined (782, 6 balanced) + train_colab.py to private HF dataset KnackAU/sp-mem-class; colab new -s memtrain --gpu T4; token piped via colab_secret.sh (runtime read, never echoed); colab_launch.py fetches the script from HF + nohup detached (survives the 30s exec wall); poll /content/STATUS; train_colab.py = label-masked LoRA (r=8 q/k/v/o) over Qwen2.5-0.5B-Instruct via a plain transformers Trainer (version-robust, == CosySim's trl path), eval, push adapter → HF. RESULT: acc=1.000 (78/78), loss 0.395, train 25.5s on T4; adapter → hf.co/KnackAU/sp-mem-class-adapter (config + safetensors + tokenizer + metrics), verified via hf_verify.py. GOTCHA banked: Colab ships torchao 0.10 which newer peft hard-rejects in its LoRA dispatcher → pip uninstall -y torchao in the train script. colab stop done, sessions.json clean (no VM billing). MEM-OKF 6e70a998. Honest scope: 100% held-out = pipeline+learning proof (held-out shares templates via augmentation), NOT generalization — real generalization is DF-B4's job. NEXT: DF-B4 — lift CosySim evaluation_gate + model_registry + promote_adapter, re-point the model bridge at SP, and A/B the adapter vs the 12B model_classify on distinct phrasings + the live distribution → then DF-B6 deploy the adapter behind a flag (replace the 12B micro-forward on the served refine path). ★ 2026-07-03 DF-B3 PARTIAL — mem_class LoRA trainer built + data-path GREEN; GPU training deferred to cloud (G-DF-TRAIN, harness bbfb52e). datagen/finetune_mem_class.py lifts CosySim finetune_local.py _finetune_hf (AutoModelForCausalLM + LoRA r=8 + trl SFTTrainer + PeftModel eval), dataset-agnostic on our mem_class corpus, CLI-overridable so the cloud run reuses it unchanged. G-DF-TRAIN-PLUMBING GREEN (no heavy import): _load_dataset 180, _text format, _parse_label 7/7 — the data path is proven. The actual LoRA smoke is BLOCKED locally (honest, not a code fault): (1) gotcha banked — a corrupted pip leftover ~uggingface_hub (invalid dist in site-packages) HUNG every import trl/transformers; fix = delete the ~* dirs → import trl back to 0.3s; (2) then torch/CUDA init stalled on a stuck CUDA context (GPU held ~590 MiB @ 0%) left by repeated debug hard-kills — a fresh shell/boot clears it. Real training lane = Colab (Unsloth 4-bit) / RunPod BAKE (_xbar/p2b) per ENVIRONMENT.md — deferred there, no false green. Deps now installed: peft 0.19.1, trl 1.7.0, datasets, accelerate (transformers 5.5.4, torch 2.6.0+cu124); base Qwen2.5-0.5B-Instruct cached. MEM-OKF 6e70a998. NEXT: run the real mem_class QLoRA on mem_class_combined (clean local shell, or Colab/RunPod) → DF-B4 eval/promote → DF-B6 deploy behind a flag (replace model_classify). ★ 2026-07-03 DF-B2 GREEN — synthetic mem_class seed generator (G-DF-SEED, harness c2ec999). datagen/seed_mem_class.py lifts CosySim generate_router_v3.py (balanced gen + augmentation), swaps the 16-class game taxonomy for our 6 mem_class labels; emits Alpaca {statement→class} to datasets/mem_class_train.jsonl. Classifies memory STATEMENTS (matches model_classify = the DF-B6 deploy target, NOT DF-B1's query-intent view). Supplies private-secret (synthetic fake credentials) — the one class the DF-B1 privacy choke point excludes from live (never train on a real secret). Gate: 6 balanced classes (deterministic, Alpaca, private-secret present), merges with DF-B1 live → mem_class_combined.jsonl (182 at gate; 780+live at default 130/class). Fixed a dedup bug the gate caught (seen-set mixed str/tuple → dup lines → merge shrank 180→148; now unique-by-statement, 12 augment variants). MEM-OKF 6e70a998. NEXT: DF-B3 — lift CosySim finetune_local.py, train a tiny mem_class QLoRA on mem_class_combined (Windows HF+PEFT fallback smoke → Colab Unsloth / RunPod BAKE via _xbar/p2b) → DF-B4 eval/promote → DF-B6 deploy behind a flag (replace model_classify's 12B micro-forward). ★ 2026-07-03 DF-B1 GREEN — the telemetry→JSONL converter (data-gen phase, first brick) (G-DF-CONVERT, harness b3fb755). datagen/prepare_from_telemetry.py lifts CosySim prepare_from_live.py (SAME Alpaca {instruction,output} contract → DF-B3 trainer consumes unchanged), data source swapped to our content-addressed telemetry corpus; emits mem_class classifier examples (query→class), decision+turn deduped. PRIVACY CHOKE POINT (load-bearing): redacted:true records SKIPPED on the flag → private-secret NOT learned from live telemetry (comes from the DF-B2 synthetic seed; never train on a real secret). GATE: synthetic corpus incl. an ADVERSARIAL redacted-record-carrying-secret-text → 2 clear examples, labels correct, deduped, redaction PASS (secret 0 hits), idempotent. MEM-OKF 6e70a998. Compute-lane correction (from ENVIRONMENT.md §2): the recon's "no RunPod" is right for CosySim but we have a RunPod BAKE lane (HF-mediated _xbar/p2b pattern) + Colab (colab CLI, "nihilistau") + local HF-fallback — DF-B3 cloud training REUSES these, folded into CONTRACT-DATAGEN-FINETUNE.md. NEXT: DF-B3 — lift finetune_local.py, train a tiny mem_class QLoRA on this JSONL (local HF-fallback smoke, then Colab/RunPod) → DF-B4 eval/promote → DF-B6 deploy behind a flag; DF-B2 synthetic seed fills the private-secret class. ★ 2026-07-03 FLYWHEEL SELF-FILLING + DATA-GEN/FINETUNE PHASE PLANNED (anti-rebuild on CosySim). (a) Auto-collect GREEN (G-HARNESS-TELEMETRY-AUTOCOLLECT, harness 3effc60): run_agency.py _start_telemetry_sink spawns TelemetrySink.run on a daemon thread beside the agency loop, gated SP_TELEMETRY_SINK (default on; SP_TELEMETRY_SINK_ROOT); import/connect failures caught (never breaks agency). Gate: disabled=no-op, enabled→4 records auto-collected, 0 leak. The corpus now fills whenever the harness runs. (b) CosySim + Nexus reconned (operator granted C:\Files\Models\CosySim + C:\Files\Nexus; anti-rebuild map banked MEM-OKF 6e70a998): CosySim has a COMPLETE reusable telemetry→dataprep→finetune→eval→promote pipeline (Qwen2.5-0.5B QLoRA via Unsloth[Colab]/HF-fallback[Windows]; local+Colab, NO RunPod). Directly liftable: prepare_from_live.py (telemetry→JSONL), finetune_local.py (QLoRA both backends), evaluation_gate.py+model_registry.py+promote_adapter.py (A/B+promote), data_collector.py, auto_train.py. Glue to replace: the engine.* imports (all try/except), the game 16-class taxonomy (→our mem_class set), absolute paths; re-point LMSTaskBridge at SP /v1/chat. Nexus = separate SQLite KB (stores run REPORTS, not the trainer; we have MEM-OKF so it's optional). (c) Phase plan written: papers/CONTRACT-DATAGEN-FINETUNE.md (OKF-GREEN) — 6 bricks DF-B1..B6, each lifting a named CosySim module; first target = a small QLoRA mem_class classifier to replace LM-B3's 12B micro-forward; first brick = DF-B1 telemetry→labelled JSONL converter (the privacy choke point). Lives in a new datagen/ tier in shannon-prime-harness (cosysim-lineage), NOT a new repo. ★ 2026-07-03 TELEMETRY FLYWHEEL END-TO-END — the harness sinks /v1/events into a durable content-addressed corpus (G-HARNESS-TELEMETRY-SSE, harness 7a131c3). The harness half of the SSE sink. SPDaemonClient.subscribe_events(want=["telemetry"]) = a long-lived GET /v1/events consumer (extends the lifted CosySim client, no rebuild); harness/telemetry/sink.py TelemetrySink = a content-addressed idempotent store (records/<sha16>.json + log.jsonl index, dedup by content hash, writes the record VERBATIM — already engine-redacted, never un-redacts — stdlib only, .run(client,stop) loop for a daemon thread). It's a distinct tier from the Nexus KB and memory-okf/ episodes: the raw telemetry corpus. GATE: live daemon + 2 queries → 4 records sinked (2 decision + 2 turn), redaction PASS (secret 0 hits in every file), dedup idempotent. So the flywheel is now end-to-end: engine decision+turn telemetry → /v1/events → harness subscribe → durable corpus that accumulates across sessions, privacy preserved on the wire AND at rest. MEM-OKF 6e70a998. RECON FINDING (banked): the harness runtime IS lifted from cosysim ("do NOT rebuild, extend the lifted modules"); the proven router-finetune-on-telemetry pipeline lives in external cosysim/nexus proper — needs operator access. NEXT: (a) wire TelemetrySink.run into run_agency.py/agency.py as an idle-safe background thread so collection is automatic; then (b) the data-gen/finetuning phase — recon external cosysim/nexus FIRST (anti-rebuild). ★ 2026-07-03 TELEMETRY SSE-SINK GREEN (engine half) — the flywheel now has a LIVE egress (G-LM-SSE, engine c142d09). LM-B2/B2b wrote telemetry to a local JSONL; this adds the live channel: the same already-redacted record is broadcast on the existing /v1/events SSE bus as DaemonEvent::Telemetry{record}. state.rs new Telemetry variant; routes.rs telem_sink(rec, evt) does file-append (if SP_TELEMETRY_LOG) and broadcast (if a sender is passed) — independent; both emit sites pass Some(&app.events_tx); /v1/events new telemetry arm streams the byte-identical JSON. GATE: subscribe to /v1/events + 2 queries → 4 live telemetry events (2 decision + 2 turn), redaction on the wire PASS (secret 0 hits). Default-off byte-identical. MEM-OKF 6e70a998. FOLLOW-ON (harness half, queued): the harness subscribes to /v1/events, filters event:telemetry, and sinks each record into the durable MEM-OKF telemetry store (append + content-address) so the corpus accumulates across real sessions — this is what fills the pipe for the data-gen/finetuning framework (recon cosysim/nexus first). ★ 2026-07-03 LIVING-MEMORY STACK CONSOLIDATED + GRADUATED TO VERIFIED-SCOREBOARD (G-LM-COMPOSE, engine 930929e — 11 VERIFIED, 0 false-greens). The four LM bricks (B1 hot-reload · B2 decision-telemetry · B2b turn-outcome · B3 idle refine) were each isolated-gated, then proven to COMPOSE in one run: all flags on, store-merge serves 3 policies (counterfact/private-secret/persona) while the idle thread BOTH reconciles a concept written mid-run (+1 hot-loaded → served "Marlowe City", no restart) AND model-refines a mis-classed secret (counterfact→private-secret on idle); every turn logs a decision + turn record (4+4); the private-secret stays redacted (secret 0 hits). FAITHFULNESS-NEUTRAL (the key null-floor): run_console_faithful.bat sets none of these flags, and none touches L5 selection scoring, so the 54/61 one-config stack is byte-identical to before the LM phase. Row 11 added to papers/VERIFIED-SCOREBOARD.md. MEM-OKF 6e70a998. NEXT (agreed order): (1) LM SSE-sink — emit the turn/decision record as a telemetry event on events_tx so the harness StreamProcessor sinks it into the durable MEM-OKF store (fills the pipe from real sessions); then (2) NEXT MAJOR PHASE = the data-gen + classifier + finetuning framework (operator vision, banked 6e70a998/OPEN): pull HF corpora → run through SP → emit MEM-OKF-class labelled training data → local/Colab/RunPod finetune pipeline, telemetry-triggered A/B→promote. ANTI-REBUILD FIRST: recon the EXISTING cosysim/nexus router-finetune-on-telemetry system (complete + well-documented) before building anything. The learned classifier stays data-gated until this framework generates real volume. ★ 2026-07-03 LM-B2b GREEN — THE FLYWHEEL IS COMPLETE: decision ⋈ OUTCOME (G-LM-TURNTELEM, engine 70e4992). LM-B2 logged what the memory system DECIDED; LM-B2b logs what it actually SAID. routes.rs telem_emit_turn appends a kind:"turn" record at the delivered-recall [DONE] site — output, out_len, n_out, decode_s, tok_s, and obeyed (did the answer use the recalled fact's salient tokens? = the label). The query/class/secret are stashed at the TEXT-IN-CONTEXT deliver branch (next to recalled_text); decode timing from just before the loop. PRIVACY (ADR-005 §3b): a private-secret turn REDACTS both the query (hash) and the output ({redacted,sha,len} — secret text NEVER logged); non-secret turns keep query→output in the clear = the finetune signal. GATE: gold counterfact (output in clear, tok_s 19.82, obeyed) + Meridian secret (output redacted to sha+len, tok_s 19.97, obeyed); REDACTION PASS (secret 0 hits), non-secret output present in clear. Off the token path, default-off null floor. MEM-OKF e9189a3c. So the telemetry stream now carries, per delivered turn, a labelled example (query→output, obeyed) + speed — the raw material to finetune / tune faithfulness / watch drift, secrets redacted on both sides. FOLLOW-ON: emit the turn record as a telemetry SSE event on events_tx for the harness StreamProcessor to sink live; PoUW SpinorReceipt per turn; prefill_s + first-token latency. ★ 2026-07-03 LM-B3 GREEN — ADAPTIVE CLASSIFICATION: the idle model-refine AUTONOMOUSLY corrects a heuristic miss (G-LM-REFINE, engine e272f4a). The flywheel closes: heuristic capture → idle model-refine → corrected self-governance. The capture classifier is a fast keyword HEURISTIC (instant, but misses keyword-less secrets); LM-B3 adds an idle NIGHTSHIFT pass — routes.rs model_classify (one 12B micro-forward → class) + refine_okf_store (per store concept: re-classify the body; on change, update the served episode's policy in app.nightshift and rewrite the OKF frontmatter; safety-monotone, never downgrades a private-secret) — wired into the LM-B1 idle reconciler, gated SP_MEM_CLASSIFY_REFINE=1, default-off. GATE (clean two-phase A/B): a keyword-less secret ("recovery phrase for the Meridian vault archive…") stored mis-classified counterfact → idle refine reclassifies → private-secret (log MEM-REFINE … counterfact -> private-secret; frontmatter persisted). SAME concept + SAME queries FLIP: class counterfact→private-secret, delivery systemecho→recite, privacy telemetry redacted:false (clear) → redacted:true (hashed). No restart. MEM-OKF 0fcc29b1. GOTCHA banked: store-merge recall needs SP_RECALL_REGISTRY set (even to an empty file) to enable the L5 scan. NOTE: the absent-probe confab→decline needs absent-ratio ≥ attr-gate τ(0.5); a probe sharing ≥3 entity tokens stays below (orthogonal to LM-B3; that path already GREEN in G-LM-TELEMETRY). Third Living-Memory brick — the store now hot-reloads (B1), records its own decisions as data (B2), AND re-classifies itself on idle (B3). FOLLOW-ON: model-emitted [MEM_CLASS] inline tag (harness StreamProcessor) as a 2nd signal; persona-vs-agent split; a learned classifier once the LM-B2 telemetry set is large. ★ 2026-07-03 LM-B2 GREEN — THE TELEMETRY FLYWHEEL is turning (G-LM-TELEMETRY, engine 6431e55). The engine now logs every recall DECISION as a structured, class-redacted telemetry-okf JSONL record — the data to tune/finetune/detect-drift. routes.rs telem_emit_recall(query, entry, class, cos, margin, delivery, decision) fires at all 3 terminal branches (decline / margin-skip / deliver); a private-secret query is replaced by a hash (redacted:true) so telemetry can never carry a value the delivery path declined (ADR-005 §3b). Gated SP_TELEMETRY=1 + SP_TELEMETRY_LOG, off the token path (one JSONL append at the decision point), default-off null floor. GATE: mixed classify corpus → 6 records (private-secret 4 [2 deliver/recite + 2 decline], counterfact 1 systemecho, persona 1 system); cos[deliver] 0.985 vs cos[decline] 0.932 (real separability data); REDACTION PASS — secret "K9X-4M2-8QP" appears 0× in the log. telemetry_report.py = the per-class/decision/delivery + cos/margin tuning view. MEM-OKF 02311c39. FOLLOW-ON (LM-B2 remainder): per-turn timings + the OUTPUT-join (engine emits a telemetry SSE event on events_tx; harness StreamProcessor sinks it with the answer + obey/leak outcome) + a PoUW SpinorReceipt per record. NEXT: LM-B3 adaptive classification (NIGHTSHIFT model-refine on idle + [MEM_CLASS] tag) + personality. ★ 2026-07-03 LIVING-MEMORY PHASE OPENED (ADR-005) + LM-B1 GREEN — the store is now LIVE. Planned the next phase: papers/PPT-LAT-ADR-005-LIVING-MEMORY.md + papers/CONTRACT-LIVING-MEMORY.md (validator GREEN). Decisions: (1) live reconciliation = hybrid idle NIGHTSHIFT reconciler + /v1/memory endpoint, NOT a head; (2) telemetry flywheel — per-decision PoUW SpinorReceipt + class-redacted telemetry-okf record (query/recall/decision/output/timing), the data to tune τ/margins, finetune, detect drift, via events_tx/SSE + harness StreamProcessor sink; (3) adaptive classification = tiered heuristic→NIGHTSHIFT-model-refine-on-idle→[MEM_CLASS] inline tag, learned head data-gated-deferred; (4) personality = persona.md (live) + persona/agent-persona classes. Composes the toolbox (PoUW ledger, events_tx, StreamProcessor tags, Nexus, agency loop, content-addressing) — the harness run_agency_scheduler IS the offline NIGHTSHIFT to reuse. LM-B1 BUILT+GREEN (G-LM-RECONCILE, engine de8506e): load_and_mint_okf_store incremental + a daemon idle-gated reconciler thread (SP_MEM_RECONCILE=1, interval SP_MEM_RECONCILE_SEC, gated on inference_active) hot-loads NEW concepts off the token path. Gate: engine booted with an EMPTY store, the harness okf_mem.py add-ed a concept WHILE running, the reconciler hot-loaded + minted its key in <interval, and the engine served "Lake Baikal-9" per counterfact→systemecho with no restart. Default-off null floor. MEM-OKF d826a9c5. NEXT: LM-B1 remainder (/v1/memory low-latency endpoint, supersedes-drop, body-hash cache stamp) → LM-B2 telemetry flywheel → LM-B3 adaptive classify + personality. ★ 2026-07-03 THE FULL STORE-MERGE — one content-addressed store, both callers; harness WRITES, engine SERVES (G-STORE-MERGE #76/77/78, engine 6c84ca1). The last big piece of "the whole system as one." Gated SP_MEM_OKF_STORE=<root> (default-off = engine's own registry only, byte-identical): after the model boots, routes::load_and_mint_okf_store loads every memory-okf/full/*.md concept (text + OKF policy), MINTS its L5 selection key from the body at startup (question-space, cached full/<addr>.l5), and pushes a text-delivery Episode into nightshift so the live L5 recall path selects it. recall.rs gained parse_okf_policy(str) + okf_body(str). GATE 3/3: two policy-bearing concepts written by the HARNESS via okf_mem.py add (zero engine involvement) — engine minted their keys at boot ("What is the tallest mountain on Earth?", "What is the launch code for Falcon-9?"), recalled + served counterfact→systemecho ("Mount Kea"), private-secret→recite ("Z7Q-3RT-9WX") + zero-inference DECLINE on absent ("Who built Falcon-9?"). Bidirectional with #72 (engine writes ep.okf.md concepts): ONE content-addressed, policy-bearing store the whole stack reads AND writes — engine spine (EXECUTE), harness Nexus (INGEST), agency/NIGHTSHIFT (CURATE), L5/Nexus-vector/qmd (RETRIEVE), all one OKF format. THE MEM-OKF / ADR-004 SYSTEM IS NOW COMPLETE AND UNIFIED END-TO-END. Receipt G-STORE-MERGE.log; MEM-OKF 0a580332. FOLLOW-ONS (smaller): live hot-reload while running (merge is at boot today); L5-key cache invalidation on concept edit (content-hash); finer classes; FM rung-2 (speculative, independent). ★ 2026-07-03 MEM-OKF LOOP CLOSED — three stitches, one gate, all GREEN (G-MEMOKF-FINISH, engine fc12733). #74 persona: classify_mem_class gains first-person identity/preference → persona (system delivery); mixed corpus classify 4/4 incl. persona ("My name is Aldric Vance" → persona → recalls "Aldric Vance"). #75 attr-gate tightened: ROOT of last turn's miss was the paraphrase entity-guard blocking the decline when the query carries only the plain entity name; a private-secret entry now BYPASSES the guard (it's known-private) → "Who designed Vault-7?" DECLINES (was LEAK) while "override code?" still recites — secrets recite present 2/2 + decline absent 2/2, 0 leak/confab on natural queries (not just the SNE mismatch_q construction). #72 engine ⋈ MEM-OKF: recall::write_episode_okf emits a conformant ep.okf.md MEM-OKF v2 concept per episode (type: memory + mem_class/mem_delivery/mem_decline frontmatter + body); load_registry reads policy from ep.okf.md as AUTHORITATIVE (load_episode_okf_policy(dir).or(inline)) — the engine now speaks the exact OKF format the harness/okf_mem writes; 4/4 sidecars written+read at gate. Default-off preserved (SP_MEM_CLASSIFY/SP_MEM_POLICY unset = env path). The full loop is now autonomous AND clean: ingest classifies (private-secret/persona/counterfact) → writes an OKF concept → served spine reads OKF-frontmatter policy → dispatches per entry, decline aggressive on natural queries. Receipt G-MEMOKF-FINISH.log; MEM-OKF 6c00a35a. REMAINING (larger): engine load memory-okf/full/*.md directly (full store-merge); FM rung-2 (speculative, independent). ★ 2026-07-03 THE MEM-OKF LOOP IS NOW AUTONOMOUS — NIGHTSHIFT auto-classifies mem_class AT CAPTURE (G-MEMCLASSIFY-SERVED #73, engine 6d8039b). The last stitch: live episodes previously loaded policy=None→env; now, gated SP_MEM_CLASSIFY=1, the capture path (capture_live_episode + B4 inline) runs recall::classify_mem_class(text) — deterministic, no model call: a secret keyword (code/password/pin/token/override…) or a high-entropy code token ⇒ private-secret (attr-gate-strict); else a user-asserted memory ⇒ counterfact (systemecho) — writes mem_class into the persisted registry row + sets Episode.policy = MemPolicy::from_class. Mixed corpus stored live via the memory verb ("Remember that …"): auto-classified 4/4 correct, persisted, served per its OWN auto-policy (secrets recite the code present-attr, counterfacts systemecho). So the full loop runs with NO manual tag: ingest classifies → the store carries policy → the served spine dispatches per entry (ADR-004). HONEST LIMIT (attr-gate, not the classifier): absent-attribute DECLINE was imperfect on two ad-hoc queries (entity-overlap dropped absent-ratio below τ / no shared entity token kept the paraphrase-guard off) — the attr-gate's known envelope; on the proper SNE crucible the same auto-policy gives 100% decline/0 hallucination. On FLOW-MATCHING × MEM-OKF (asked): they're orthogonal tiers (FM=latent DECIDE, MEM-OKF=text EXECUTE); FM-steering is convicted as a delivery method (destructive) so combining is NOT worth it — the delivery-method ranking already answers it; the only un-convicted FM lever is rung-2 (different seam), independent of MEM-OKF. Receipt G-MEMCLASSIFY-SERVED.log. REMAINING: finer classes; tighten attr-gate for entity-sharing absent queries; #72 (point the served registry at the memory-okf/ store). ★ 2026-07-03 BOTH SERVED ADR-004 ARMS PROVEN + FRESH FLOW-MATCHING DATA (engine 36ce60e). (1) G-MEMPOLICY-SERVED-DECLINE GREEN — the SECOND served arm: the SNE crucible registry (20 high-entropy secrets) tagged mem_class=private-secret, env attr-gate OFF, served A/B (only SP_MEM_POLICY differs): =0 → MISMATCH-hallucination 1/20, decline 3/20; =1 → hallucination 0/20, decline 20/20, recall 20/20. The entry's OWN policy forced the zero-inference shield on the metal (log: ATTR-DECLINE … [mem-policy]). Combined with G-MEMPOLICY-SERVED (counterfact→systemecho 11→21, 17→0 leak), both delivery arms are now proven per-entry on the served spine — counterfact→systemecho + private-secret→decline; safety monotone realized. (2) G-FM-STEER-RECONFIRM — fresh GEODESIC steering data reconfirms the honest-negative: pre-head v-bar steering is dose-dependently DESTRUCTIVE (alpha0 55% → alpha8 0/20, generation collapses to empty); no help direction, final-norm seam convicted (rung-2 = different seam remains, ADR-003). CONSOLIDATED DELIVERY-METHOD RANKING (the class→delivery mapping MEM-OKF v2 encodes): systemecho 22-30/30@0 (BEST, general/counterfact) · attr-gate-strict 100%/0 (private) · recite 11/17-leak (fallback) · full-context 25/4 (leaks) · two-stage 22/3 (REFUTED) · yes/no + latent-steering (convicted). Receipts G-MEMPOLICY-SERVED-DECLINE.log + G-FM-STEER-RECONFIRM.log. REMAINING (#73): NIGHTSHIFT assigns mem_class at capture so live episodes self-classify (today policy=None→env). ★ 2026-07-03 ADR-004 REALIZED ON THE METAL — per-entry MEM-OKF policy drives the SERVED spine (G-MEMPOLICY-SERVED GREEN, engine 51e53e6). The served recall path (routes.rs L5 block) now reads each recalled entry's recall::MemPolicy (mem_class/mem_delivery/mem_decline_*, loaded per registry row) and resolves an effective delivery_mode + attr_gate from it, OVERRIDING the global SP_RECALL_L5_PROMPT/SP_RECALL_ATTR_GATE env flags, behind SP_MEM_POLICY=1 (default-off = env path, byte-identical). SERVED A/B (decisive): same daemon, global SP_RECALL_L5_PROMPT=plain, V3 registry tagged mem_class=counterfact — SP_MEM_POLICY=0 → OBEY 11/30 · 17 leak (plain); SP_MEM_POLICY=1 → 21/30 · 0 leak (the entry's own policy forced systemecho per-entry on the metal; served log: MEM-POLICY: entry '..' class=counterfact delivery=systemecho -> mode=systemecho). Build: recall.rs MemPolicy+Episode.policy+class_default_delivery; routes.rs effective delivery_mode + policy attr-gate + policy decline-message + dispatch log; scored tuple carries per-episode policy. ADR-004 sp_status: GREEN. FOLLOW-ONS (honest): NIGHTSHIFT assigns mem_class at capture (live episodes load policy=None→env today); a served private-secret episode to re-prove the decline arm on the metal; point the served registry at the memory-okf/ store to unify with the MEM-OKF v2 tiers. Receipt G-MEMPOLICY-SERVED.log. ★ 2026-07-03 MEM-OKF v2 + ADR-004 DESIGNED & BUILT — memory is now a GOVERNING LAYER co-equal with the spine; per-entry policy composition DEMONSTRATED; E8 two-stage REFUTED (G-MEMPOLICY-V3, engine 1317718). The whole faithfulness campaign's meta-result: NO single global delivery tool is right — each proven tool (zero-inference decline, systemecho, recite, pass) is correct for a DIFFERENT class of memory. So the memory ENTRY must carry its own policy and the spine dispatches on it. Built: ADR-004 (PPT-LAT-ADR-004-MEMORY-GOVERNANCE) — the retrieved entry's declared policy drives the LatentDecision; 5 laws (every entry declares policy · decider consults not hard-codes · decline at the zero-decode seam · safety monotone in class · default-off null-floor). MEM-OKF v2 spec (PPT-LAT-MEM-OKF-V2-SPEC) — the per-entry policy block (mem_class/mem_retrieval/mem_delivery/mem_decline/mem_authority/mem_links), OKF-conformant (vanilla consumer ignores it), Karpathy-LLM-wiki-shaped (compounding, cross-linked, Ingest/Query/Lint), and §8 "the whole system as ONE": MEM-OKF v2 is the single format the engine-spine (EXECUTE), harness-Nexus (INGEST: harness/nexus/*), the agency loop = NIGHTSHIFT (CURATE: harness/control/agency.py), and L5/Nexus-vector/qmd (RETRIEVE, pluggable) all speak — one store, many callers. Reference impl: tools/okf_mem.py v2 (policy add/verify; a private-secret with a leaky delivery is a G-MEM-OKF-CONFORM RED — safety monotone enforced; auto zero-inference-safe). G-MEMPOLICY-V3: ONE store, per-entry dispatch — counterfact→systemecho 30/30 @ 0 leak (delivery is PERFECT given the right entry ⇒ the 22/30 live ceiling is PURELY selection, the representation limit, NOT delivery), secret→recall 5/5 + 0 confab, secret-decline via the proven attr-gate. E8 two-stage REFUTED (SELECT 22 / OBEY 22 / LEAK 3 ≤ systemecho: discrete select = the selection ceiling + leak on off-topic mis-select; E1's +3 was generation-integration, not selection) ⇒ same-template default corrected two-stage→systemecho. FOLLOW-ON: wire mem_policy into the SERVED spine (routes.rs behind SP_MEM_POLICY) — the harness proves the composition; the daemon wiring carries it to the metal. Reused (do NOT rebuild): the harness Nexus ingest/embed/query-router + the agency/NIGHTSHIFT curator already exist. Receipts G-E1-E2-DELIVERY + G-MEMPOLICY-V3; MEM-OKF cada52f5. ★ 2026-07-03 EXPERIMENT QUEUE OPENED + E1/E2 RUN — generation-time disambiguation WORKS but dilutes authority; two-stage (E8) is the synthesis (G-E1-E2-DELIVERY, engine 88b0280). New doc papers/PPT-LAT-EXPERIMENT-QUEUE.md = 8 prioritized falsifiable experiments (3 tiers: sidestep the ceiling / test the representation / new axes) opened after the selector campaign closed. Ran the two Tier-1 probes: E1 full-candidate delivery (all grown facts in one systemecho context, let generation pick) = OBEY 22→25 (recovered the hamlet/starry_night/evolution cross-picks the L5 key buried — generation CAN disambiguate same-template) BUT LEAK 0→4 (multi-fact context dilutes the single-fact authority that gives 0 leak; fuji→Japan etc.). E2 binary yes/no grounding CONVICTED both framings — "does it ANSWER" invokes truth (all-NO on counterfacts), "is it ABOUT the same thing" (topicality) gives the magnet YES too (same-template = same-topic). THE LEVER THIS SURFACES = E8 two-stage delivery: SELECT via full-context "which numbered fact answers this?" (an index — no value spoken ⇒ no leak) → GENERATE that single fact with systemecho authority (0-leak). Hypothesis: E8 = E1's +3 obey AND systemecho's 0 leak; recommended next probe (G-E8-TWOSTAGE). Do NOT ship full-context (leak regression); do NOT use yes/no grounding (convicted). Also in the queue: E3 question-space per-layer key sweep (the clean version of the free layer_probe, which was confounded by statement-space mean-K), E4 subject-token position match, E5 SWARM 2-node, E6 GEODESIC rung 2, E7 attend-don't-select. Receipt G-E1-E2-DELIVERY.log; MEM-OKF 8b6bda98. ★ 2026-07-03 THE SELECTOR CAMPAIGN IS CLOSED — a learned relevance head does NOT generalize same-template discrimination (G-WCHEAD-SAMETEMPLATE, engine 933ea88, PRE-FLIGHT NEGATIVE). The last unconvicted cross-pick lever, built on the EXISTING machinery (anti-rebuild: SP_B3_QDUMP capture + b3_make_dataset + b3_train_wc_holdout + the deployed WcHead). Captured 108 positive + 20 foreign query-Q over the 30 V3 same-template episodes (K from ep.k), trained the W_c relevance head (the same arch that scored 360/361 on UNIQUE-SUBJECT needles). Held-out-EPISODE generalization: train-diagonal 96.6/64.4/97.7% but HOLDOUT top-1 = 0/21, 0/21, 0/22 = 0.0% across r={16,4,8}×wd×dropout×seed; misses systematically cross-pick onto TRAINED same-template episodes; foreign-reject 100%. The head MEMORIZES trained episodes but learns ZERO generalizable query-subject↔episode-subject matching ⇒ useless for the NOVEL live episodes it must place. The same-template instance-selection ceiling is a REPRESENTATION limit of the global-Q/K features, not a tuning gap. Every cross-pick lever now convicted with a receipt: rerank (buried >8) · lexical overlap (adversarial paraphrase) · name-the-subject (leaks the answer) · margin-NULL (net-negative) · veto head (outcome-neutral) · learned relevance head (0% holdout). NOT SHIPPED (pre-flight RED ⇒ no deployed head, ADR-003 discipline); data+pipeline KEPT reproducible so a DIFFERENT feature (earlier/lexical capture layer, cross-encoder over raw tokens) can be tested against this exact held-out bar. SCOPE (honest): V3 is an adversarial worst case — real episodic memory is unique-subject where L5 already recalls ~100%. Net shipped faithfulness stands: systemecho delivery + question-space keys = 21-22/30 obey @ 0 leak on the crucible, ~100% unique-subject. Receipt G-WCHEAD-SAMETEMPLATE.log; MEM-OKF 90fa9ecc. ★ 2026-07-03 QUESTION-MINTING EXEMPLAR-COPY BUG FOUND+FIXED; the same-template cross-pick ceiling is STRUCTURAL, not key-quality (G-QKEYS-MINTFIX, engine 18a22dc). Chased the 8 V3 cross-picks to the source. DIAGNOSTICS (new SP_RECALL_L5_DUMPRANK telemetry + rank_diag/subj_diag/canon_probe.py): the correct episode is buried at rank >8 for 7/8 cross-picks (top-K rerank hopeless); raw-query subject-overlap adversarial-fails (dynamite/hamlet/radium share ZERO salient tokens with their fact) and would regress 7/22 correct; the name-the-subject micro-forward names the real ANSWER not the topic ("dynamite"→"Alfred Nobel") = useless AND a leak vector. ROOT BUG (ep.q audit): mint_question_l5's few-shot exemplar ("The user's dog is named Biscuit") got COPIED verbatim on hard facts ⇒ 3/30 episodes (dynamite/hamlet/radium) minted "What is the name of the user's dog?" ⇒ keys landed in "user's dog" space ⇒ buried. FIX SHIPPED: neutral on-domain exemplar + anti-copy guard (generated Q must share a salient token with the fact via canon_overlap; else zero-shot retry; else statement-key fallback). Re-grew V3: suspect Qs 3/30→0/30. THE HONEST RESULT: fixing the keys did NOT fix the cross-picks — it MOVED the magnet (insulin→radium); systemecho nohead OBEY 22→21 (noise), LEAK stays 0. radium_disc recovered (was dog-bug buried→now rank-1) but the radium episode became the new magnet for the "attribution" family. => the same-template cross-pick ceiling is STRUCTURAL L5 collapse ("who discovered/invented/attributed X" = one L5 neighborhood, one member always marginally nearest each sibling), matching RUNBOOK §13 (selector CLOSED at diminishing returns). WHAT SHIPS: the minting anti-copy fix (real correctness win, still SP_QKEY_MINT default-off + fallback) + SP_RECALL_L5_DUMPRANK. DEFERRED (the only unconvicted lever): a LEARNED same-template relevance head trained on same-template HARD NEGATIVES over the full registry (not a top-K rerank; the veto head was outcome-neutral because it wasn't trained on this) — a training campaign, not a lever. Receipt G-QKEYS-MINTFIX.log; MEM-OKF 6d191b79. ★ 2026-07-03 THE QKEYS-V3 RESIDUAL WAS A PLAIN-DELIVERY ARTIFACT — systemecho re-gate: faithfulness on the novel-counterfact crucible is 22/30 obey @ ZERO leak; head + margin-NULL both convicted inert here (G-QKEYS-SYSTEMECHO, engine d0d4f93). The prior QKEYS-V3 receipt ran the gate with plain delivery and blamed "parametric-prior override." Re-ran V3 under the CANONICAL systemecho delivery (RUNBOOK §11 winner). A/B/C/D on the same question-keyed registry: plain nohead 11/30·18leak → plain head 16/30·9 → systemecho nohead 22/30·0leak → systemecho head 22/30·0. FINDINGS: (1) systemecho delivery IS the lever — nohead OBEY 11→22, LEAK 18→0; the "model refuses the counterfact" residual was plain under-instructing the override (the daily/RUNBOOK config already uses systemecho — only run_v3_gate.bat hardcoded plain = the artifact). (2) The veto head is OUTCOME-NEUTRAL in the systemecho regime (22/0==22/0; it VETO/pass-evaluated all 30 but caught none of the 8 cross-picks) ⇒ the pre-registered "veto-head retrain" (task #58 half 2) is NOT the bottleneck and is NOT worth building. (3) margin-NULL is NET-NEGATIVE here — magnet cross-picks land at healthy margins (0.0485/0.0655) and declining a counterfact turn REINTRODUCES leaks via the clean prompt ⇒ pre-registered "margin-aware NULL" (task #58 half 1) convicted inert-to-harmful, kept default-off. (4) The ENTIRE residual = 8 same-template SEMANTIC cross-picks — the "insulin/Jonas Salk" counterfact is a magnet for every "who first discovered/invented/isolated X" question (dynamite→Tesla, radium→Meitner, telescope→Kepler, evolution→Wallace, david→Donatello). ROOT: the L5 question-key encodes question STRUCTURE more than SUBJECT. (5) V3 pins are unsatisfiable-by-construction under systemecho (head OBEY ≥ nohead+8 ⇒ ≥30 ⇒ perfect); pins were tuned for the weak plain baseline — a pins-DESIGN note, not a silent revision; V3 stays PARTIAL, the A/B/C/D table is the signal. NEXT (pre-scoped, NOT built): same-template subject disambiguation — CANON-always on detected same-template clusters (current SP_RECALL_L5_CANON is margin-gated so it never fires on the healthy-margin magnet), OR fold the query SUBJECT token into the L5 key so "who discovered radium" ≠ "who isolated insulin". Receipt G-QKEYS-SYSTEMECHO.log + both gate outs + serve logs tracked; run_v3_gate_se.bat added. ★ 2026-07-03 QUESTION-SPACE KEYS BUILT + V3 RE-GATED (engine d0d4f93) — the key-space cause is CLOSED; V3 residual MOVED off the keys. Proved the root cause at SOURCE: curated ep.l5 keys come from facts.json q (question-space, write_ep_l5.py) but mint_live_ep_l5 minted from the ASSERTION (statement-space) — the same provenance comment was false. FIX SHIPPED: mint_question_l5 (routes.rs, SP_QKEY_MINT default-off + statement fallback) generates the question the fact answers (scratch micro-forward, canon decode) and keys it EXACTLY like a live query. Question gen WORKS (receipted: ...Danube -> What is the longest river in the world?). G-QKEYS-V3: nohead OBEY 7->11 (+4) = SELECTION IMPROVED = the statement-space cross-pick cause (cat 0.0101, my-name 0.0004) CLOSED. V3 promotion STILL PARTIAL (head 16/30 obey, 9 leak vs pins 19/2) BUT the 9 leaks are PARAMETRIC-PRIOR OVERRIDES not cross-picks (hamlet->Shakespeare-refuses-Marlowe; right episode WAS delivered, model's prior refused it, veto head didn't catch all). The diagnosis advanced keys->(parametric-override + veto-head generalization + the pre-registered-unbuilt margin-NULL). NEXT LEVERS: (1) margin-aware NULL on near-ties (the other half of the pre-registered fix); (2) veto-head retrain on the improved-selection distribution; (3) live cat/name transcript replay (confirmatory). SP_QKEY_MINT proven-improving + never-worse (fallback) -> add to the growth launcher. Receipt G-QKEYS-V3.log + both gate outs tracked; engine pushed. ★ 2026-07-03 SESSION END — OPERATOR VERDICT ACCEPTED, QUIET-MEMORY IS THE LIVE DEFAULT (engine 10a0773). Round-3 live testing rendered the honest verdict: recall interjection made chat WORSE than baseline ("what is my name" → the sister record at margin 0.0004; the plain-delivery branch also re-introduced the run-3 history-discard conviction — recall turns amnesia'd the conversation). Live chat is now QUIET-MEMORY: base-model conversation (coherent, history-driven — the state the operator rightly preferred) + silent B4 growth + un-confabulatable store confirms; SP_AUTO_RECALL_DEFAULT=0 in the everything-launcher until the question-space-keys gate is GREEN. FILED for the return: (1) plain/scaled/sandwich/factecho delivery branches discard orig_msgs (only systemecho preserves the conversation — port the fix to all); (2) the symbolic seam logs "ATTR-DECLINE" for store confirms; (3) harness-only: strict prompt + temp-0 self-conditions into apology loops (console defaults don't). THE RETURN PATH IS STILL ONE BUILD: question-space ep.l5 keys → cat (0.0101) + my-name (0.0004) + V3 pin-2 all fall together → re-gate V3 + the live transcript → only then does recall come back to chat. The day's assets stand regardless: the veto head (leak 20→1 item-held-out), the growth seal, GEODESIC's measured physics, 13 gates of receipts — all pushed.

★ 2026-07-03 LAYER-2 STORE SHIPPED + THE SELECTION VERDICT IS TRIPLE-CONFIRMED (engine 3e92b02) — where the story picks up, now with proof. Operator round-2 live testing: identity/name/dog/door/knowledge all correct, honest declines, zero Hodor — and "store in your memory X" exposed the last UX gap (the system stored silently while the MODEL denied being able to store). Shipped: SP_MEM_STORE=1 — deterministic store-verb intent → capture_live_episode on the attributed payload (K + C2 + L5 key + persist) → SYMBOLIC confirm at the zero-decode seam ("Stored to memory: …") — un-confabulatable by construction. Live-verified working. Then the freshly-stored cat fact lost top-1 recall to the dog record by cos 0.0101 — the THIRD independent live miss tracing to statement-space ep.l5 keys (my-name margin 0.0002; V3 pin-2). THE ONE BUILD THAT FIXES ALL THREE: question-space key minting at capture (mint from a question-form of the assertion; consider multi-key episodes + margin-aware NULL on near-ties). Then: re-run G-SPECTEST-V3 unchanged (pin 2), replay the live cat/name transcript (should go GREEN), and the promotion path opens. Cosmetic: the symbolic-confirm reuses the decline seam so it logs "ATTR-DECLINE" — rename the seam log to SYMBOLIC-EXECUTE when next in routes.rs.

★ 2026-07-03 THE HODOR INCIDENT + LIVE-FIX ×4 (engine 3d894bf) — operator live-tested, four real bugs found in 20 minutes of actual use, all fixed. The everything-serve answered every turn with "From the record: My workshop door code is 4471." Diagnosis from the live log: (1) veto authority wrong — union(lexical, head) let the lexical rule override a passing head on BACKGROUND deliveries (off-topic record ⇒ draft rightly ignores it ⇒ 0/N salient ⇒ good answer replaced with the wrong record). FIX: head PRIMARY when scored, lexical only as fallback. (2) systemecho is wrong for live chat — it commands verbatim echo, so background matches parrot irrelevant records BY DESIGN. FIX: everything-launcher → plain+head (the V2-gated pairing). (3) B4 name-collision corruption — inline episode names used the in-memory index (resets per serve) while the registry accumulates ⇒ a restarted serve overwrote earlier episode dirs. FIX: millis-unique ep_live_m<ms>. Corrupted _memory_live archived + reseeded. (4) perspective bug — raw first-person records ("My name is Knack") made the model adopt the user's name as its own. FIX: delivery text attributed ("The user said: …"), selection artifacts stay raw. Post-fix live transcript: own-name/system/dog/door/France all correct, Hodor dead. Remaining known miss: "what is my name?" cross-picks (margin 0.0002 in statement-space) — THE named next build (question-space ep.l5 keys) fixes live selection AND V3 pin-2 in one stroke. Meta-lesson for the ledger: 20 minutes of operator live use found 4 bugs that 13 scripted gates couldn't — live-play is a gate class of its own.

★ 2026-07-03 V3 PROMOTION GATE RENDERED: PARTIAL, split exactly right (G-SPECTEST-V3, engine ce094c1) — THE BOOK'S LAST PAGE. Hardest config possible (30 pre-registered fresh counterfacts × grown-as-live-memories × plain±head): safety pin PASS decisively — LEAK 20→1 on wholly unseen items (the head's veto generalizes item-level; with it active the system never emitted a wrong value for a right subject — failure mode shifted confidently-wrong → faithful-to-the-wrong-page, auditable). Obey pin FAIL (10/30 vs 15 needed) with the cause isolated OUTSIDE the head: assertion-minted L5 keys cross-pick on same-register facts (statement-space vs the curated corpus's question-space keys). Promotion correctly BLOCKED by its own pre-registered pin — the discipline held at the finish line. NEXT SESSION, ONE SCOPED BUILD: question-space ep.l5 minting at B4 capture (mint from a question-form of the assertion; consider multi-key episodes), then re-run G-SPECTEST-V3 UNCHANGED — pin 2 clearing opens the oneconfig promotion path. Behind it: f0 pre-decode veto; GEODESIC rung 2; grown-registry hygiene. Day's final ledger: 13 gates — G-F3-CAPTURE GREEN · STRAIGHTNESS Tier-A · STEER honest-neg · PROBE honest-neg (superseded-in-scope) · B4-GROW-RECALL GREEN · SPECTEST-V1 PARTIAL · TESTHEAD REAL · SPECTEST-V2 GREEN · SPECTEST-V3 PARTIAL-safety-PASS — every pin pre-registered, every number receipted, both repos pushed at every step.

★ 2026-07-03 THE HALLUCINATION VETO IS LIVE: G-SPECTEST-V2 GREEN (engine 9adda35) — the true session finale. Plain delivery + the 15KB linear head (ONE dot product on the frame-1 state) = 52/61 obey / 2 leak vs pins ≥50/≤2 — two answers off systemecho (54/61·0) with NO scaffold, and the live run is MODE-HELD-OUT (head trained on 5 modes excluding plain). Ladder: 26/61·14+ → 41/61·14 (lexical) → 52/61·2 (head). Flags SP_SPECTEST+SP_SPECTEST_HEAD default-off. NEXT SESSION = V3 RIGOR GATE before any promotion: mint a FRESH fact corpus (item-level generalization — the 61 appear in training under other modes), live-gate plain+head on it; GREEN ⇒ propose plain+head as canonical delivery via G-ONECONFIG-LIVE re-gate (cheaper than the scaffold). Then: f0 pre-decode veto variant (skip the draft on predicted-leak, escalate upfront = the latency prize); grown-registry hygiene; GEODESIC rung 2. Same-day arc for the record: FM slides → ADR-003 v2 → F3 capture → Tier-A → steering convicted → probe convicted → system sealed on live memory → spectest shipped → lexical convicted → 10× data → head REAL (linear!) → veto live and GREEN. Eight GREEN/REAL results, three honest negatives (one superseded-in-scope), every number receipted, all pushed.

★ 2026-07-03 THE TEST-HEAD IS REAL (G-TESTHEAD-OFFLINE, engine 285a949) — SESSION FINALE, NEXT SESSION'S LAUNCHPAD. Mode-held-out AUC 0.901 (f1) / 0.887 (f0 = PRE-first-token DECIDE state) vs pins 0.75/0.65 pre-registered mid-capture; obey-vs-LEAK 0.78–0.98 (the value-substitution class IS separable); linear == MLP ⇒ the signal was linear all along — the earlier n=61 chance result superseded-in-scope (power+confound). Final-norm story now symmetric: READABLE (0.90) but not PUSHABLE (steering conviction stands). Data: f3/M_* 6×61 all VERIFY PASS, tracked. NEXT SESSION (fully pre-scoped): (1) retrain the linear head on all 366 (+ frame choice: f0 enables PRE-DECODE veto, f1 = one-token-in; start f1 at the existing spectest seam = zero new seams); (2) export blob + SP_SPECTEST_HEAD=<path> load in routes.rs; (3) replace/augment the lexical grounding test at the held-stream decision; (4) G-SPECTEST-V2 live gate = plain delivery + head-veto: target 14-leak class → ~0, obey → systemecho-class (54/61) WITHOUT the scaffold — if GREEN, the canonical config gets cheap delivery + latent veto and G-ONECONFIG-LIVE re-gates. Longer arc: f0-REAL means a pre-decode obey-predictor is possible (skip the draft entirely on predicted-leak turns → escalate delivery upfront = latency win, the GEODESIC §4.2 prize by another road).

★ 2026-07-03 SPECTEST LIVE (PARTIAL) + THE THREE IDEAS RESOLVED INTO ONE (engine 5a2cf1c). Idea 1 (byte-exact speculative test) SHIPPED as v1.1: SP_SPECTEST=1 holds the stream on delivery turns, grounding-tests the whole draft pre-client, VETO ⇒ clean symbolic execute from the record. Plain delivery 26/61 → 41/61 obey (+24 pts), vetoed-class leaks = 0 by construction; the 14 PASS-leaks are invariant under both lexical rules = value-substitution convicts lexical testing (subject-grounded parametric drafts). Idea 2 (telepathy low-quant tester) PARKED on the redundancy law. Idea 3 (10× probe) → the 6-mode capture is RUNNING detached (_f3_modes_capture.bat → _faithful_corpus/f3/M_{plain,scaled,sandwich,factecho,system,systemecho}, ~60 min; check _f3_modes.log for MODES_CAPTURE_DONE; 366 labeled DECIDE states, mode-held-out eval). THE CONVERGENCE (next session's build): the SPECTEST v2 semantic test-head IS the nonlinear obey/leak probe — one head, trained on the M_ data, deployed at the spectest seam; if it clears mode-held-out AUC it closes the value-substitution class and G-SPECTEST goes GREEN.* v2 rollback+regenerate (rewind + escalated re-decode) pre-scoped behind the decode-loop extraction.

★ 2026-07-03 THE SYSTEM SEALS: G-B4-GROW-RECALL-L5 GREEN (engine 934f853) — live memory grows from EMPTY, recalls by paraphrase, survives restart. Two holes closed: (1) mint_live_ep_l5 — B4/merge captures now mint ep.l5 at capture time (grown episodes were L5-INVISIBLE; the routes.rs:735 "follow-up" is done); (2) cold-start bug — EMPTY registry loaded as None ⇒ auto_recall dead for the serve ⇒ bootstrap impossible; now empty+env-set ARMS the chain (diagnosed live: run-1 grew 5 / recalled 0 / zero RECALL-L5 lines). Gate on novel facts: R 4/5 (miss=car, in-pin) · F clean (Madrid, no grown-token leak) · P persist PASS. NEW DAILY DRIVER: run_console_system.bat — Tier0+Tier1+B4 growth+persist on the PRODUCTION registry _memory_live\registry.jsonl; run_console_faithful.bat = GATE-ONLY (RUNBOOK §6 table updated + doc-update law added: launcher flag changes land in the table in the SAME commit). Idea ledger banked from the operator, not yet built: byte-exact+rewind SPECULATIVE TEST primitive (draft→test-head→rollback = T8 generalized), telepathy low-quant hallucination tester, nonlinear obey-probe on 10× data. NEXT candidates: live-grown SNE/forget hygiene on the production registry (attr-gate vs grown entities), GEODESIC rung 2 (TELE-2 seam per-layer tap), delivery-latency axis (#41 batch-prefill successor).

★ 2026-07-03 GEODESIC PROBE SIDE-GATE: G-OBEY-PROBE-OFFLINE = HONEST NEGATIVE (engine c9d3834) — the final-norm surface is now FULLY convicted. Obey/leak is not linearly readable from the F3 states at either frame (within-mode ≈ chance; the pooled 0.79 AUC = the pre-registered MODE CONFOUND — it separates prompt condition, not outcome; cross-mode anti-transfers). Combined with the steering dose-response: the final-norm state neither causes nor linearly predicts obedience — the Tier-A ray is the treatment signature; the decision is made upstream in attention over the fact text. New assets: run P (plain-delivery capture, 26/61 obey, balanced labels, tracked) + f3_obey_probe.py (F3_PROBE_FRAME). Hint banked (P frame-1 proj means 85.5 vs 28.6, variance-swamped — nonlinear/10× data to revisit). Deployed detectors remain B3-JUDGE grounding + attr-gate. The GEODESIC main line is unchanged: rung 2 = per-layer tap at the TELE-2 seam (~16–22) → straightness in that basis → SP_STEER rail pointed there. DEFAULTS DOCTRINE (operator question, answered): code defaults stay OFF (the measurement law — null floor = falsifiability); the canonical launcher IS "everything on" (one-config, gated whole); the true blocker to daily memory-on is a PRODUCTION registry (test corpus leaks SNE codes into live chat — B4 NIGHTSHIFT growth is the road).

★ 2026-07-03 GEODESIC RUNG 1 CLOSED: G-FM-STEER-OBEY = HONEST NEGATIVE, mechanism isolated (engine dd9dbbb). Pre-head steering with the Tier-A v̄ (new layer-agnostic rail gemma4_kv_steer + kv::steer_set + per-turn arm/disarm, SP_STEER_VEC/SP_STEER_ALPHA, default-off null floor): positive α dose-dependently DESTROYS obedience (slice-16 same-day: baseline 9/16·6L → α0.5 6/16·9L → α1.0 4/16·10L), α−0.5 == baseline exactly. THE FINDING: the final-norm surface expresses the obey decision (Tier-A constancy) but does not make it — the choice is made upstream in attention over the fact text (frame-1 non-constancy + TELE-2 ~16–22 seam converge on the same story). NEXT (pre-registered ladder): rung 2 = per-layer capture_feat-style tap at the TELE-2 seam (~global layers 16–22) → re-run straightness in THAT basis → inject there via the existing SP_STEER rail (only the tap layer changes). Rung 3 = full per-layer sweep (L5 sweep-then-pin on the steering axis). Receipts: engine G-FM-STEER-OBEY.log + _f3_steer_sweep.log; v̄ exports (all81 norm 146.9 / fct61 cos 0.9934) tracked in _faithful_corpus/f3/. Both repos pushed to origin this session (lattice + engine).

★ 2026-07-03 GEODESIC PRE-FLIGHT COMPLETE: G-FLOW-STRAIGHTNESS GREEN → TIER A (engine 1b3c234). The faithfulness field is CONSTANT: frame-0 topPC(unc) 0.731 / cos-to-mean 0.839 (pins 0.70/0.70, registered before the data existed); centered topPC 0.218 ⇒ the structure IS the mean vector. Tier-B legs also pass (S2 0.796 / S3 0.204) ⇒ FM head viable, HELD IN RESERVE. Robust fct/sne/no-echo; B-echo caveat RETIRED; frame-1 NOT constant (steer at the DECIDE state). HONEST NEGATIVE: curvature preview does not separate fct/sne — no free zero-prior detector. ROUTE (pre-registered §7-A): ship ONE steering vector = mean v* (frame 0, TELE-2 mechanism); NEXT GATE = G-FM-STEER-OBEY — inject at the DECIDE state on recall turns, match/beat systemecho 88.52% obey / 0 leak + coherence held + latency below the text path (the delivery-re-prefill dodge is the prize). Open design choices for that session: injection site (syn_last step residual add), magnitude dial (‖v̄‖ vs unit-norm × α sweep), and the null floor (flag off = byte-identical). Everything receipts-first: G-FLOW-STRAIGHTNESS.log + FINDINGS-LEDGER row + ADR-003 §6 stamp (sp_status MEASURED-TIER-A).

★ 2026-07-03 GEODESIC PHASE 1 EXECUTED: G-F3-CAPTURE GREEN (engine 6c03996, same session as the ADR v2). The SP_F3_CAPTURE rail is live (default-off = byte-identical null floor): two one-shot gemma4_kv_capture_feat taps per served turn (last-prompt-token + first-answer-token post-output_norm states, zero extra forwards, dangling-write guard on step-error paths; kv::capture_feat_arm = direct-symbol wrapper, no glue change). Data ON DISK + tracked: _faithful_corpus/f3/{A,B} — A = systemecho delivery w/ attr-gate OFF (capture-only config, SNE delivers ⇒ confab x1 states), B = clean parametric (0 recall turns). ALL 4 gate criteria: 61 fct + 20 SNE pairs both runs · determinism 4/4+4/4 rerun byte-identical · meta+env complete · loader PASS. First physics: Δ(A−B) norm mean 173.6 last-prompt / 193.5 first-answer, never degenerate. Receipt tests/fixtures/chat_fullstack/G-F3-CAPTURE.log. NEXT = G-FLOW-STRAIGHTNESS (ADR-003 §6, one afternoon, engine untouched: S1 field-constancy PCA / S2 kNN coupling-conflict / S3 ridge 1-step transport error → tier A single-vector / B FM-head / C reflow). Pre-registered caveat: B no-system turns sometimes ECHO the question — capture B2 (neutral prompt) before concluding if tiers look degenerate.

★ 2026-07-03 GEODESIC: ADR-003 REWRITTEN v2 (lattice, this session). papers/PPT-LAT-ADR-003-FLOW-TRANSPORT.md rewritten as the canonical flow-transport framework (supersedes 9fbf0f2). Four v1 errors corrected against receipts: (1) recall judge was parked for SIGNAL redundancy not speed (native judge WON OOD H2H 94.4%; its ~50% plateau = methodology gap, depth+SC refuted); (2) baselines fixed — 86.89% REGRESSED, honest bar = systemecho 88.52%/0-leak, ceiling = selector 54/61 CLOSED; (3) FM must NOT touch the T8 byte-exact verify — it upgrades the DRAFTER (baseline mean_accept 1.78/8); (4) exactness envelope named (transport exact, v_θ float). NEW: F3 capture spec (G-F3-CAPTURE, rails SP_ARM_DUMP/SP_B3_QDUMP + new SP_F3_CAPTURE; capture_feat COMMITS cache routes.rs:787 — offline OK, serve-time needs v1.1 non-committing tap) + pre-registered tiered G-FLOW-STRAIGHTNESS (A=constant field ⇒ TELE-2 single vector, B=straight ⇒ 1-2 step FM head, C=curved ⇒ reflow-on-NIGHTSHIFT) + curvature-as-signal (free zero-prior detector). VERIFIED: F3 pairs DO NOT EXIST on disk (all-repo sweep). Build order forced: G-F3-CAPTURE → G-FLOW-STRAIGHTNESS → tier-routed heads. G-OKF-CONFORM GREEN 163/163.

★ 2026-07-03 12B SERVE CAMPAIGN CLOSED (engine d9ee34b). All three #38-follow-ups done: (1) G-12B-SERVE-ROOTCAUSE PMAX->4096 = 13-22.6 tok/s coherent; (2) #39 G-RECALL-DEADSCAN-SKIP = dead TAU=inf B3-v2 scan elided (~50%/turn off non-firing recall, byte-safe); (3) #40 G-ONECONFIG-LIVE RE-GATED GREEN at 4096 = P 54/61 IDENTICAL to the 20000 gate (whole speed campaign faithfulness-neutral). Turn-4 delivery re-prefill (71s) RE-DIAGNOSED as launch-bound per-token prefill -> #41 BATCH-PREFILL project (CUDA graphs/multi-position g4_kv; shared win for cold chat + delivery + qwen36). LAUNCHER SPLIT: run_console_chat.bat = daily driver (no test registry, recall off); run_console_faithful.bat = GATE only (loads 61-fact TEST corpus; a live console chat against it leaked an SNE code). Console 404 fixed (ServeDir resolves beside the exe). NEXT = #41 batch prefill (highest-leverage remaining serve item) then the phase-2 backlog #35-37.

★ 2026-07-03 12B SERVE FIXED (G-12B-SERVE-ROOTCAUSE, engine a41658c). The operator's "1 tok/s if lucky" = PMAX=20000: (a) 78KB shared silently killed the float attention (= the "float garbage" — corrected narrative), (b) VRAM oversubscription = ~0.6ms WDDM tax per attention launch. PMAX→4096 in run_console_faithful: coherent both paths, 22.6 tok/s short / 13 @340ctx, growth turns 1-3 at 1-1.9 effective. Launch-failure telemetry now permanent. OPEN: (1) recall-chain multi-prefill (turn-4 86.9s; skip dead TAU=inf B3-v2 scan + no pipeline re-run on delivery prompt); (2) RE-GATE G-ONECONFIG-LIVE at PMAX=4096 (faithfulness numbers were gated at 20000 — NOT re-claimed); (3) qwen36 serve GREEN 5.3-5.5 tok/s (CONTRACT-QWEN36-SERVE).

★ 2026-07-02 SESSION EDGE (speed campaign, appended by session end-law). ONE-CONFIG GREEN-LIVE (systemecho 88.52%/0-leak, RUNBOOK-ONE-CONFIG.md). SPEED_NORTHSTAR VALIDATED: qwen36 35B-A3B (GDN+MoE) runs 6.073 tok/s / 337x on the 2060 (G-MOE-GPU4-PINNED; ladder receipts G-MOE-* in engine chat_fullstack). LRU expert cache CONVICTED not-worth-building (32.6% locality). Serve wiring S1 DONE (sp_q36gpu_boot @engine c12d1ea); NEXT = S2/S3 per papers/CONTRACT-QWEN36-SERVE.md (Rust FFI/arch-8 tokenizer/routes lane/launcher/G-QWEN36-SERVE). Phase-2 backlog (operator-ordered) = RUNBOOK s15: expert-count dial, GPU/CPU split, 26B redo, gemma4 1-vs-26 tok/s discrepancy (suspect served byteexact default-ON — investigate FIRST). Submodule branch qwen36-gen-coherence @5d1fdaa (main diverged from origin — push branch + bump pointer, NEVER force). 🛑 STALE — FROZEN AT 2026-06-24 (banner added by AUDIT-2026-07-02). This doc was NOT updated across the 2026-06-28→07-02 sessions and no longer reflects where things stand. Current canon: papers/START-HERE.md → papers/VERIFIED-SCOREBOARD.md (10 VERIFIED · 0 PARTIAL) → papers/PPT-LAT-FINDINGS-LEDGER.md → papers/RUNBOOK-ONE-CONFIG.md (canonical run config) → papers/AUDIT-2026-07-02.md (audit + plan). Since this doc froze: faithfulness axis CLOSED (L5-cosine + attr-gate, judge PARKED), NIGHTSHIFT criterion-5 CLOSED, SP-SWARM L0–L4 GREEN, T4-of-weights CONVICTED redundant. Open item this doc still owns: the prefix-KV default-on values call (1.621×, accuracy-neutral, 11/140 fp-jitter flips) — still undecided. Below: the 2026-06-24 state, kept as provenance. WARNING CORRECTION (2026-06-24, later in session) -- two claims in this section are SUPERSEDED by direct source reads; read this first: (1) The "recall regression / self-cond was load-bearing" framing is WITHDRAWN. The harness self-conditioning is CORRECTLY wired (verified tests/test_diffjudge_denoise.c:437 if (use_sc && have_prev) -> step-0 = plain forward, steps 1+ feed the prior step's logits; matches the reference step-0-gated-off SC). The killed run scored 5/60 = 8.3% recall. That is NOT an OOB-fix regression: the 95.6% is the EXTERNAL llama.cpp oracle; our NATIVE judge was always weak (~25% single-forward, f8f76a5). Honest finding: the "iterative multi-step denoise rescues the native judge" hypothesis (the reason test_diffjudge_denoise exists) is REFUTED -- multi-step 8.3% is no better than single-forward ~25%. The dg_self_cond OOB fix remains a genuine correctness fix; it did not cause a recall regression. (2) The prefix-KV refutation is OVERTURNED (Cola E1, verified from source). _diffgemma_reference/diffusion-gemma.cpp:43-54 + ARCH-NOTES.md:40-52: the mask is ASYMMETRIC -- prompt queries are causal-over-prompt and NEVER attend the canvas; only canvas queries are bidirectional. So prompt K/V is canvas-invariant BY CONSTRUCTION, and the reference SHIPS a prefix-KV decode variant (llm_graph_input_attn_diffusion_decode, rectangular [P+C,C], cache prompt K/V, forward only canvas). Our 6.9e-4/NaN was FALSE (fp-noise + the now-fixed OOB NaN). prefix-KV is VALID on the current model -- not a train-time property, not a Cola finetune. Cola block-causal does NOT map to prefix-KV. See papers/DESIGN-COLA-DLM-MAPPING.md section 2 (corrected). (3) Async HOLD reason corrected: SP_DG_ASYNC is byte-exact + correct; the HOLD was predicated on a regression that does not exist. Stays byte-exact / default-off as a conservative perf default. NEW TOP NEXT [UPDATED -- prefix-KV RECLAIMED, answer-lossless]: the proof was re-run -- K/V byte-delta persists at 3.901e-4/6.590e-4 = fp NON-ASSOCIATIVITY (our mask is verified asymmetric, cuda_forward.cu:5477-5482, prompt causal-over-prompt), NOT logical coupling, so the byte-delta is the WRONG gate. The ANSWER-PARITY gate is GREEN (G-DG-PREFIXKV-PARITY): SP_DG_PREFIXKV=0 (full) vs =1 (canvas-only) are BIT-IDENTICAL on every pick AND ans_tok across 3 items (n_div_000 pick2/8686, n_div_001 pick9/236773, foreign pick0/236917), fast measurably quicker. The fast path already EXISTS behind SP_DG_PREFIXKV (the N6 port); the N6 canvas-collapse bug was downstream of the OOB and is gone. NEXT = wider parity + production speedup sweep (CANVAS=256, STEPS=12+, more items) to harden + measure the real speedup, then gate + promote. Receipt tests/fixtures/chat_fullstack/G-DG-PREFIXKV-PARITY.log. PRODUCTION CONFIRMED (CANVAS=256, STEPS=4): parity HOLDS (base==fast bit-identical picks+ans_tok 3/3) + SPEEDUP ~1.5-1.6x (33-38% faster); receipt G-DG-PREFIXKV-PROD.log. prefix-KV is SHIP-IT (~1.6x). FULL GATE DONE (G-DG-PREFIXKV-FULL, 140 items STEPS=12): accuracy-lossless (LEG A==LEG B aggregate recall 44/90 + reject 49/50) + 1.621x, BUT 11/140 per-item flips (net-zero, fp-jitter over 12 steps) => "accuracy-neutral, NOT byte-exact at depth"; default-on is a values call. Native full-config = 48.9% recall / 98.0% reject (reject BEATS oracle). DEPTH (STEPS=48) saturates (~51% ~= 48.9%) => gap to oracle is NOT depth => T33 DONE: self-cond masked-vs-raw REFUTED (SC A/B, recall flat 55->50%, reject 90->100%, N=30). BOTH depth + self-cond refuted -> native judge PLATEAUS ~50%/~95%. Likely real gap = METHODOLOGY (oracle reasons before the tag; our harness is a blind constrained classifier). NEXT = bake-off T32 (resident 12B generative = proven 85.7%, sidesteps the rabbit hole). -- type: session-handoff title: SESSION-HANDOFF.md — where things stand description: "Updated: 2026-06-21 (PHASE 4 SEALED + PHASE 5 DIFFUSION JUDGE PROVEN SUPERIOR + native port begun." tags: [session-handoff] timestamp: 2026-06-21T02:55:56Z resource: ./SESSION-HANDOFF.md sp_status: ACTIVE sp_gate: none sp_commit: TBD sp_repro: none

---

SESSION-HANDOFF.md — where things stand

Updated: 2026-06-24 (whole-machine diffusion-judge ~2x perf [scratch-reuse default-on + async byte-exact], the Cola block-causal north-star doc, and a self-cond-OOB-fix recall regression IN FLIGHT — see the new top section. Prior 2026-06-22 (NIGHTSHIFT offline curator GREEN-on-synthetic + MEM-OKF anti-rebuild store ACTIVE + 4-repo fleet doc overhaul + the OOD diffusion kill-test IN FLIGHT. Prior milestones below.)

⚠ CORRECTION to a prior header ("Phase 5 diffusion judge PROVEN SUPERIOR"): the original framing was an apples-to-oranges compare (diffusion bounded-K vs W_c full-registry). The fair OOD head-to-head has now been RUN at matched K=8 — and diffusion WINS decisively (94.4% vs 28.3%). See §0.

§0-NOW IN-FLIGHT (2026-06-24) — READ FIRST

NEXT SESSION OPENER (LOCKED 2026-06-24): wire + gate + ship the 12B->26B CASCADE before any new campaign. The judge architecture is decided by measured data: 12B = recall engine (84% real) that CANNOT abstain at argmax (0% reject real, even on gibberish, T34/G-JUDGE-FORCEPROMPT); diffusion judge = 98% reject real; the validator now runs ~3.2x (async + scratch-reuse + prefix-KV). Build in order: (1) BASELINE -- re-run the forcing-prompt 12B (terminal "ANSWER:" + single-tag parse, tools/xbar_lsh/forceprompt.py) over the full 140 (90+50) to lock the TRUE Stage-1 retriever recall + confirm reject ~0. (2) WIRE -- hook the diffusion judge as a constrained {tag, NULL} VALIDATOR on the 12B's single picked tag only (1-candidate verify). (3) GATE -- measure end-to-end cascade recall + reject; if it HOLDS ~84% recall AND ~98% reject, promote SP_DG_PREFIXKV default-on (accuracy-neutral values call) + wire into the validator path (closes T31) and ship. Detail + receipts: memory project_perf_wholemachine.md. Do NOT pivot to Cola E2-E4 / NIGHTSHIFT B4 / throughput levers until the cascade ships.

WHOLE-MACHINE DIFFUSION-JUDGE PERF: ~2x stacked, byte-exact — SHIPPED on the bidirectional model we run today. Two stacked levers on the diffusiongemma-26B-A4B MoE judge (RTX 2060 12GB, NUC11, PCIe gen3 x8):

• SP_DG_SCRATCHREUSE — PROVEN, default-on (engine e31c70d). Hoists the per-expert synchronizing cudaMalloc/cudaFree into a reused device pool. Reversed 2x2 A/B: OFF 281/285s vs ON 193/194s (order-independent) = ~1.46x. Byte-identical by construction (allocation-only).
• SP_DG_ASYNC — byte-exact, default-OFF, promotion HELD (engine 2a1c830). Pinned double-buffer prefetch of spillover experts (overlap upload of expert N+1 with compute of expert N): dedicated dg_ustream, 4 fixed double-buffered slots, up_ev/cons_ev ordering + host-W-A-R guard. Determinism oracle SP_DG_MOECHK (per-layer f64 sum + FNV-1a of dmoe): single-item 240/240 bit-identical (commit gate); tonight's 6-diverse-item concurrency stress = 1440/1440 MOECHK byte-exact OFF==ON (uncommitted receipt). Marginal ~1.3x (order-confounded; clean reversed A/B is the named next step), ~2x stacked.

THE ROOT CAUSE + THE REGRESSION IT EXPOSED (the honest part). Async parity required fixing a PRE-EXISTING dg_self_cond out-of-bounds: the harness sized the self-conditioning buffer to canvas CL=16 but the forward writes C=256 → a vocab-space softmax (dg_k_softmax_rows over V=262144) over-read uninitialised memory. compute-sanitizer memcheck pinpointed it; fixed by zero-init dev alloc + sizing the harness buffer to the full model canvas. BUT the full-corpus recall re-run on the OOB-FIXED baseline (90 needles + 50 foreign, STEPS=12, async ON) is running severely degraded (single-digit %: 2/28 at last poll, vs the prior 95.6% oracle / 360-of-361 W_c) → FINDING: the buggy self-cond garbage was LOAD-BEARING for the judge's discrimination — correct (zeroed) self-conditioning at step-0 washes out the canvas signal. This is the "new baseline reality" check the operator asked for, and it returned a real regression. DECISION: HOLD the SP_DG_ASYNC default-on promotion — async is byte-exact vs baseline either way, so this is a JUDGE-quality regression, NOT a concurrency bug. Run still in flight; full number to land. Detail: memory project_perf_wholemachine.md.

COLA NORTH-STAR doc landed: papers/DESIGN-COLA-DLM-MAPPING.md (design, OKF GREEN). Receipts-first mapping of Unified-Cola (block-causal continuous-latent diffusion) onto the stack. THE GOLD (verified): block-causal attention EXPLAINS our prefix-KV refutation — diffusion-gemma is bidirectional so the prompt attends the noisy canvas → prompt K/V is NOT canvas-invariant (our measured 6.9e-4 / NaN), which IS the refuted prefix-KV premise; Cola's block-causal mask would make it invariant → prefix-KV exact. HONEST CORRECTION to "flip the mask in cuda_forward.cu": block-causal is a TRAIN-TIME property (Cola pretrains under it), NOT an inference-time flip on our bidirectionally-trained weights → it's a MODEL bet (block-causal finetune / from-scratch SP latent-diffusion core), not a kernel edit. Falsifiable next steps E1-E4 in the doc (E1 = read the reference mask, FREE; E2 = inference block-causal probe, expected-to-degrade; E3 = O_K-latent diffusion feasibility; E4 = block-causal finetune, deferred). Transferable kernel = diffuse-in-latent / avoid the vocab softmax (the exact bug class that bit us tonight).

DOC FLEET SWEEP this session (local commits; orchestrator reviews + pushes): Cola design doc (lattice, OKF G-OKF-CONFORM GREEN 133/133); math-core CONVENTIONS refresh (system a85a2fd); public LEDGER+README perf/NIGHTSHIFT rows (Position_Is_Arithmetic d42fcc1); lattice STATE/Roadmap/index/this-handoff; engine root scratch cleanup; MEM-OKF facts banked.

§0 IN-FLIGHT (2026-06-22) — READ FIRST

• OOD diffusion kill-test (G-DIFFJUDGE-OOD-H2H) — RESOLVED: DIFFUSION WINS. The fork is CLOSED, the Phase-5 native lane (incl. N5b) is JUSTIFIED. At matched K=8 on the held-out OOD corpus: diffusion judge 94.4% recall / 98.0% reject vs W_c 28.3% / 96.9% = +66.1pp recall (far outside the ±11% N=72 noise) at ≥96.9% reject → clears the pre-registered §4 kill-criterion (+10pp recall AND ≥96.9% reject). ⚠ ANALYST-ERROR CORRECTED (this session): my first pass called this run INVALID ("no tags, 94.4% is a scoring artifact") — that was my mistake, not the oracle's. I grepped the harness's per-query result line, which prints only reply.strip()[:40] — the first 40 chars are a benign llama init warning ('W init: embeddings required … -> overriding'); the real model output is past the cutoff. A verbose 2-query probe (_diffjudge_probe.log) confirmed the full replies contain real _TAGPOOL tags (K4N X3K Z6K T5D…), the <|channel>thought reasoning block, and active denoising (diffusion step: 7/48). parse_tag has NO ground-truth fallback; got=gt for 17/18 is only possible with real judgment. So BOTH runs are valid: G-DIFFJUDGE-1 (div, K=12) 95.6%, OOD (K=8) 94.4%. W_c floor stands: K=8 = 28.3% / 96.9% (W_c is an in-distribution MEMORIZER — full-registry OOD only 11.1%). Architecture: W_c = cheap Stage-1 (in-dist); the diffusion judge = zero-shot Stage-2 adjudicator (94.4% OOD) over the W_c/LSH top-K — exactly the structural role the memorizer finding demanded. NB: 94.4% is the external 26B oracle (llama-diffusion-cli, PR-24423) as the capability proxy; our NATIVE single-forward judge was ~25% → N5b (resident reservoir) + the iterative entropy-bound sampler is the build that makes our native judge fast enough to match it. Receipts: papers/CONTRACT-DIFFJUDGE-OOD-H2H.md §5, tests/fixtures/chat_fullstack/G-DIFFJUDGE-OOD-H2H.log, probe _diffjudge_probe.log. Lesson banked: grep the VERBOSE full capture for the token signature, never the truncated result-line; verify the verifier.
• Architectural finding (banked): W_c does NOT generalize to unseen needles → NIGHTSHIFT-curated NEW episodes are OOD for the deployed head → a zero-shot Stage-2 adjudicator is the structural fix (this is what the kill-test evaluates the diffusion judge for).
• NIGHTSHIFT curator = gated-GREEN-on-synthetic (G-NIGHTSHIFT-CURATOR criteria 1-4, engine 6107f3e); criterion-5 live = Strike 1 (re-capture real chat turns under the step-0 B4 hook → curate → in-distribution for W_c).
• MEM-OKF + OKFS ACTIVE; the okf_mem lookup pre-flight is binding; fleet README/AGENTS/HISTORY overhaul done across all 4 repos; new RFC-ORGANISM + roadmap (two strikes).

Updated (prior): 2026-06-21 (PHASE 4 SEALED + native diffusion port begun — but note the "proven superior" claim is CORRECTED above. See the older §0 below for the native-port detail.)

---

0. PHASE 4 SEALED + PHASE 5 OPENED — diffusion judge beats AR on both axes; native port N0 GREEN (2026-06-21)

Full detail in memory project_generative_judge.md (the canonical record for this arc).

PHASE 4 — SEALED (engine 81049bb, pushed). The open-set recall "terminus" was OVERTURNED: a GENERATIVE judge (12B reading candidate TEXTS via the chat template, tag-based copy-able selection) does query-conditioned open-set recall (85.7% recall@1 on _needle_corpus_div) where every geometric/W_c signal failed. Live conversational-memory organism end-to-end: observe→capture (NIGHTSHIFT)→index (C2 sig)→page (KAIROS recency+salience, routes.rs)→SELECT (generative judge)→RECITE (text-in-context, not lossy latent injection — the α-sweep proved latent inject of a live episode has NO recitation operating point; recall is generative). SP_B3_JUDGE default-off=null floor. Commits 447dfc5 (judge) → 4da0718 (KAIROS window) → 81049bb (text-in-context sealer + cold-reset + inject attenuation). Honest caveats (AR-spine diseases, deferred): foreign selectivity wobble + NIGHTSHIFT question-echo capture (no admission gate).

PHASE 5 — diffusion judge PROVEN the structural cure (lattice 6bac6e1). Contract CONTRACT-PPT-LAT-PHASE-5.md + DESIGN-diffgemma-native-port.md (committed 6e9634b/bff897a). G-DIFFJUDGE-1 GREEN on the metal: the bidirectional masked-diffusion judge (DiffusionGemma 26B-A4B, run via the PR-24423 oracle build) = recall@1 95.6% (86/90) AND foreign-reject 96.0% (48/50) — BEATS the AR judge (85.7%) on BOTH axes, incl. the wobble the AR judge couldn't fix. Constrained {tags,NULL} canvas + bidirectional attention = the antidote to both AR pathologies. Receipt tests/fixtures/chat_fullstack/G-DIFFJUDGE-1.log; harness tools/xbar_lsh/diffjudge_recall_test.py. NATIVE-ONLY MANDATE (contract §5): write the diffusion arch + MoE + entropy sampler into OUR O_K/Q4B CUDA backends; NO llama.cpp/ggml in the shipped engine. PR 24423 = reference (_diffgemma_reference/ARCH-NOTES.md + 8 source files) + parity oracle ONLY (D:\F\llama-diffgemma-pr24423). N0 GREEN (G-DG-N0): sp_transcode now parses diffusion-gemma → our .sp-model (C:\sp_models\diffusiongemma-26B-A4B.sp-model, 13.27GB, arch_id=9, canvas_length=256, 128/8 experts). Added SP_ARCH_ID_DIFFUSION_GEMMA=9, dg_* arch_info fields, SP_WDT_Q5_0, the new tensor maps + a --stream low-RAM path. N0 code UNCOMMITTED (clean working tree — engine sp_transcode.c + sp_model.h; submodule lib/shannon-prime-system 4 files: weight_dtype.c, sp_l1.h, sp_model.h, weight_dtype.h).

NEXT QUEUE (start here)

DONE this session (the native DiffusionGemma forward is BUILT, end-to-end, on our engine): git hygiene (submodule divergence resolved); N1a loader (G_DG_N1 26/26); N5a CUDA MoE forward (gemma4_moe_ffn_cuda, byte-exact vs CPU, rel-err 3.2e-7, engine 0d6f4b8) + N5a-packed (real OK_Q4B experts via dp4a, expert-select identical, int8-floor exact, f7813a2); N1b full diffusion_gemma_forward_cuda (ce06ec6/fddbe9c, +605/-0 additive, dense path byte-identical): region mask + canvas rmsnorm embed + enc/dec scalar split + dense+128/8-MoE, runs the real 26B-A4B in <1 min via arena streaming + expert-major batching; 256/256 finite in-vocab logits; null floor holds; structurally verified vs the reference (mask/RoPE/scalar/embed all exact).

★ KEY REFRAME — the N1b "oracle logit parity" gate is MIS-SPECIFIED. The PR-24423 oracle runs the Q4_K_M GGUF; our forward runs our OK_Q4B .sp-model — different 4-bit quants of the same bf16 weights → byte-exact logit parity is impossible by construction (per-layer quant delta compounds → the measured ~40% one-sided attenuation; the 73% top-1 is on a degenerate all-BOS canvas that maxes argmax instability). Do NOT chase byte-exact logits.

1. ★ N4 native judge — RUNNING (decision pending the ~8h aggregate). The forward streaming deadlock is FIXED (8309d90, G-DG-STREAMFIX 5/5, dg_dequant_resident_rows = owned-heap copy of the mmap-aliased per-layer weights; ~71s/run reliable, peak WS 3.3GB). The native judge test_diffjudge_native (constrained {tags,NULL} argmax on the native forward) is running DETACHED over _needle_corpus_div (~140 fwd × ~200s ≈ ~8h, log tests/fixtures/chat_fullstack/G-DIFFJUDGE-NATIVE-run.log). CHECK THAT LOG for the aggregate recall@1 + foreign-reject. ⚠ FIRST result (1/140) = MISS on the canonical Marlock (oracle got it right) — confidently picked a same-archetype distractor. THE BRANCH: the agent's N4 is a SINGLE constrained forward + argmax, but the oracle's G-DIFFJUDGE-1 (95.6/96.0) ran the FULL iterative entropy-bound DENOISING (48 steps + bidirectional refinement + self-conditioning). A diffusion step-0 forward is a rough first guess; discrimination comes from the refinement. SO: if the aggregate is HIGH → single-forward suffices, wire the native judge into routes.rs (N6). If LOW → N4 needs the FULL entropy-bound sampler (multi-step denoise loop, _diffgemma_reference/diffusion-sampling.cu + ARCH-NOTES §2) + self-conditioning (N3) — that is the real next build, GPU-bound (wait for the ~8h run to free the 2060). The forward is RELIABLE; the sampler DEPTH is the open question.
2. Optional drift bounds (if you want a forward-correctness number first): (a) re-measure logit parity on a NON-degenerate canvas (factors out argmax instability); (b) build the diffusion forward at f32/OK_Q8 to isolate forward correctness from quant; (c) gate CUDA-vs-CPU on the SAME OK_Q4B .sp-model (needs a CPU diffusion forward). Diagnostic: SP_DG_DUMP_OURS (per-position) + the reference cb("l_out") for a per-layer bisect if a real drift is found beyond the quant delta. Then N3 (self-cond multi-step) → N6 (wire the native judge into routes.rs) → N7 (drafter) → N5b (hetero split). Plan: DESIGN-diffgemma-native-port.md.
3. ENV FLAG: C: pagefile switched fixed-16GB→system-managed during the N0 OOM workaround (reboot-pending); revert if desired. The .sp-model is C:\sp_models\diffusiongemma-26B-A4B.sp-model (13GB, out-of-tree). The diffusion GGUF IS on disk: D:\Files\Models\Gemma4\gemma-difussion\diffusiongemma-26B-A4B-it-Q4_K_M.gguf.

---

0d. B3-WC AUTONOMOUS LIBRARIAN — learned-head recall LIVE on the 12B chat (2026-06-19)

B4 NIGHTSHIFT (2026-06-20) — machinery LIVE + GREEN; live-recall calibration OPEN. The daemon now GROWS memory live behind SP_B4_NIGHTSHIFT=1 (default-off = null floor): a user turn stating a fact is captured at position-0 (scratch kv::open→prefill→read_global_k) into a live Episode (recall.rs tokens:Option<Vec<i32>>), hot-appended to AppState.nightshift: Arc<RwLock<..>>, scored jointly with the 91 curated in the (E+1)-NULL argmax, and recalled via kv::inject_tokens. PROVEN on metal: matched stated fact self-selects (ep_live_000 41.3, beats NULL + all curated). Launcher run_console_nightshift.bat. Engine 54bd612 (machinery) + 19d09af (K-norm calib). Receipts tests/fixtures/chat_fullstack/G-CHAT-B4-NIGHTSHIFT{,-calib}.log. OPEN (honest negative): live episodes super-attract query-independently → foreign-reject FAILS; NOT a scalar K-norm (live 1.415 vs curated 2.774, ×1.96 didn't fix; logsumexp isn't scale-linear) but a distributional-shape mismatch between live read_global_k and the curated ep.k the W_c head trained on. B4-v2 levers: align live-K provenance to ep.k (likely a C/CUDA change), or retrain the head on live-path K, or per-channel/covariance calib, or wire the teacher-forced ablation admission gate (also: v1 captures every turn>=4 toks, no admission yet). Detail: memory project_b4_nightshift.md.

DOC-SYNC COMPLETE (2026-06-20): the fleet documentation sweep for this milestone is landed + pushed — lattice d817dd5 (15 living docs) + e3f8b4e (README full-stack diagram redrawn, OKF papers 121/121 GREEN); engine 89832dd (CLAUDE) + 50388be (README recall-path ASCII + env table + run_console_recall quickstart + stop button); math-core e09b904 (CLAUDE) + 3b0fcc2 (README ARM surface + four-ring diagram); public Position_Is_Arithmetic bdba9a4 (papers 22/23/24 front-doors + LEDGER X-B3-* + SERIES + HF post posts/hf_update_2026-06-20.md) + c74afe8 (paper.md long-forms + README tables). Formal PPT-ARM Part I/II (papers/PPT-ARM/PPT-ARM-{Theory,System}.md, non-git) carry a 2026-06-20 status note (proofs untouched; .tex/.pdf need a LaTeX regen). Non-blocking: regen stale .pdf; engine tree has pre-existing untracked artifacts + a local PMAX=20000 bump in run_console_recall.bat (committed 4096). The autonomous-recall campaign is fully CLOSED + documented; NEXT falsifiable step = B4 NIGHTSHIFT (pre-scoped below).

The autonomous-recall campaign is RESOLVED end-to-end (model + deploy). The learned W_c head selects the right stored episode for a chat query, or refuses if none is relevant, LIVE on the resident Gemma-4-12B. Engine edc8079 (pushed). Receipt tests/fixtures/chat_fullstack/G-CHAT-B3-WC-DEPLOY.log.

WHAT IT IS: recall.rs WcHead/load_wc/wc_score score each registry episode by the W_c projection with the logsumexp-mean reduction (stable LSE over positions via max-subtraction, then mean over (layer,head)) -- the metric the head trains on and the ONLY one that's int16-exact (max/top-m collapse). routes.rs SP_B3_WC branch: (E+1)-way argmax over [episodes, NULL=s0]; episode wins -> replay it (SP_REPLAY_MTARGET=42 clamps the injection mass); NULL wins -> clean prompt. Default-off (env unset) = null floor; runs WITHOUT SP_B3_DISPOSER / SP_B3_TAU_QK so the legacy q.K block stays telemetry-only.

OFFLINE GATE (G-CHAT-B3-WC-DIV2, 90-needle diverse corpus): 360/361 instance recall + 50/50 foreign reject, f32==int16 lossless, s0=+0.102. Diversity (mint_corpus_v2, unique subjects) took instance top-1 34%->100% -- corpus diversity was the binding constraint all along, not the machinery. LIVE on metal (this session): matched "Which recovery code authorizes the Marlock mag-rail depot?" -> RECALL ep_n_div_000 (9.858, clear argmax); foreign "What is the capital of France?" -> whole population negative (best ep_ctrl_paris -0.026 < s0) -> NULL -> clean "Paris."

HOW TO RUN / PLAY (verified by parts -- recall env proven live this session; ring+web-console is the established run_console.bat path):

run_console_recall.bat (engine root) wait for "listening", open http://127.0.0.1:3000/ , chat. Watch the daemon console for "B3-WC ... RECALL ''" or "NULL wins -> REJECT". It = run_console.bat (coherent byte-exact SWA-ring chat) + 3 env vars: SP_RECALL_REGISTRY=_needle_corpus_div\registry.jsonl SP_B3_WC=_b3_wc\wc_deploy.bin SP_REPLAY_MTARGET=42 Deploy blob rebuilt anytime via: python tools\xbar_lsh\export_wc_deploy.py Plain run_console.bat (no recall) still works unchanged.

ARTIFACTS: head lsh_Wc_f32_div2.npz + int16 lsh_Wc_i16_s14.bin; deploy blob _b3_wc/wc_deploy.bin (WCB1 hd=512 r=32 s0=+0.1021 sscale=0.17678); registry _needle_corpus_div/ (90 needles + ep_ctrl_paris control).

NEXT (B4 NIGHTSHIFT -- between-turn consolidation, DEFERRED, pre-scoped): Goal: after each chat turn, the daemon folds the turn's content into the episode store so memory GROWS during a conversation (today the registry is static, captured offline by the curator). Cheapest correct path (reuse, don't rebuild):

1. On turn end, mint an episode from the turn the SAME way the curator does (the turn's tokens ARE the ep.tok; capture ep.k/ep.v/ep.mf via the existing SP_XBAR_RECALL_WRITE / sp_xbar_manifest_serialize path used by _b3_capture_ep -- it already runs inside the resident decode).
2. ADMIT it through the teacher-forced ablation oracle (SP_B3_DISPOSER=2 + ep.secret) so only load-bearing (non-parametric) turns enter -- the proven admission gate, collapse < TAU=-8.
3. Append the admitted episode to the in-memory registry (hot-add) so the W_c head scores it on the NEXT turn. The W_c head needs NO retrain to score a new episode (it projects content, order-free); only the s0 NULL threshold is fixed. Optional: NIGHTSHIFT consolidation = fold/dedup similar episodes via the native Ring-3 bind (tools/ring3/ok_bind.py is the integer reference). Effort: a daemon Rust change (turn->capture->admit->hot-append to the registry Vec) + rebuild + a 2-turn live test (state a secret turn 1, recall it turn 2). ~1 focused session. NOT started -- too large to land safely in the remaining budget without risking a half-wired tree.

WARN (recurring this session): the sandbox->Windows mount TRUNCATED a Python open().write() of routes.rs (82KB) mid-file -> "unclosed delimiter". RECOVERY THAT WORKED: restore intact via git checkout/git show on WINDOWS, re-insert the edit via PowerShell [System.IO.File]::WriteAllText (no-BOM UTF8, LF joins), then verify line-count + last-line + brace-balance on the Windows disk BEFORE building. bash cat >> append (recall.rs) survived fine; large Python/Edit writes are the risk.

---

0c. CHAT-FULLSTACK — the operator console chats the real 12B (2026-06-19)

run_console.bat → http://127.0.0.1:3000/ chats the real Gemma-4-12B through L2 daemon → L1 ABI → CUDA backend, COHERENT. Contract + run-records: papers/CONTRACT-CHAT-FULLSTACK.md. Stages all GREEN (coherence-gated, not just SHA — the hard lesson of this arc):

• #115 daemon FFIs the proven engine C gemma4 BPE tokenizer (58b6c2d lineage; parity 5432/5432).
• A1/A2 L2 sampler (temp/top-p/top-k/rep-pen, seedable) + CUDA-graph resident decode (~15 tok/s, memory-bandwidth-bound on the 2060 = the physical ceiling, not a stall). Engine 91b4177.
• A2-polish id-agnostic control-token suppression + turn-stop. Engine cc4e26c.
• B1 per-session byte-exact "auditable mode" (ABI sp_l1.h §6c). Engine 66e30bc.
• S1 (the coherence keystone) ROOT CAUSE of the earlier token-soup: the daemon imposed the gemma3 <start_of_turn> template on a gemma4 model whose vocab has NO such tokens (real turn toks <|turn>=105/<turn|>=106; <turn|> was even being suppressed so it could never stop). Fixed: token-level template w/ real ids + config-driven suppress/eos from generation_config.json (suppress_tokens:[258883,258882], eos=1) + byte-exact integer decode as the DEFAULT (build-independent determinism — kills the FP-reorder coherent↔garbage flip). 6/6 coherent, byte-identical across two builds. Engine 58b6c2d.
• B5 (the single entry point — operator's image-1) text/audio/memory all enter ONE residual seam (gemma4_kv_inject_seq). gemma4_kv_inject_tokens stages embed×√E device-side + steps the real id (PLE parity) ⇒ text-via-seam == prefill 6/6 BIT-IDENTICAL. inject_frames channel exposed for the audio/memory sources. ABI sp_l1.h §6e. Engine 18a5f78, submodule cb601e9.
• B2-ring (O(1) VRAM) the SWA ring is fixed + RE-ARMED (served default). Root cause: the float ring kernel lost S1's byte-exact FP-reorder immunity on 40 SWA layers → soup; fix = k_attn_decode_ring_bx (exact-integer ring) + journal auto-advance + reset-not-rewind. 3-leg coherence gate GREEN: coherent past 64 tok / ring==ring-off byte-identical / VRAM flat ~10–20 MiB across 6k→12k. Engine 7eb7231.

Daemon currently LIVE on :3000 (ring-armed, byte-exact default). run_console.bat is the launcher (ring re-armed). No closed gate regressed throughout (G-WIRE-CUDA-DECODE-GEMMA4 32/32==oracle).

REMAINING (next stages, documented in CONTRACT-CHAT-FULLSTACK, NOT blocking a coherent chat): B3 (ARM two-ring on the gemma4 decode — today log-only on gemma4, real on qwen3 CPU); B4 (NIGHTSHIFT between turns); wire the real AUDIO source (EAR/GNA / voxtral-mini-realtime-rs) + memory-as-residual into the B5 inject_frames channel (the channel exists; the projector wiring is the work); a rank-2..N coherence assertion in the decode gate (the determinism-gate-blindness lesson). HONEST artifact ceiling: the OK_Q4B b1 sometimes runs on past the turn at greedy (correct content, weak turn-discipline) — bounded by max_tokens.

⚠ REPO-HYGIENE TO RECONCILE (binding submodule lesson): the standalone shannon-prime-system (300d32c) DIVERGED from the engine submodule (cb601e9, the canonical/ahead copy the engine builds against). Same §6e content, different history (B2's §6d was committed only to the submodule). The engine is correct (builds against cb601e9); the standalone needs a deliberate rebase onto the submodule lineage — do NOT auto-force; reconcile explicitly. Flagged, not silently left.

---

0. State in one paragraph

The XBAR memory architecture is now UNIFIED onto the exact-integer O_K substrate (Q(√−163), the dual-prime negacyclic CRT-NTT in core/ntt_crt+core/poly_ring, already linked into the engine — zero new linkage, because the gemma4_kv_* cache is pure f32 and the only int8 path is the weight gemv). The container wins: Ring-3 bind re-carried native (Leg A, engine 0019b86) is 256/256 bit-identical to the integer reference, ±1 carrier recall lossless, and the superposition M is byte-identical across 8 summation orders (the float M diverges 4.44e-15 — reduction-order immunity, a correctness guarantee); the Frobenius integer Ring-2 store (G-R2-FROB, dbe4103/d076797, Theorem-T4 form) reaches sub-ULP at 24b / lossless at 16b with bit-width as the compression lever; the full organism loop ran native on real episodes (G-XBAR-ORGANISM-FULL, 15e7051): continuous audio → discrete integer memory → continuous KV out, autonomous, C2 sig accepts-audio/rejects-text, SP_REPLAY checks=5 fails=0; and the period-6 rebase is CLOSED (d2d7ceb, decoy separation 154→129). The content does not: four honest negatives bound the win — Dirichlet-character carriers (Leg B, d7d96fe, inert), Möbius-on-M (1e70763), entropy-on-codes (e6d17bb), and T2-Möbius-on-real-weights (ac76c8e, worse than random). The boundary thesis is the session keystone: the substrate's value is exact arithmetic — the indestructible algebraic container — not number-theoretic structure imposed on the high-entropy content. The prior XBAR stack (P3, C2 curator, Ring-3 Path A, #222, GNA EAR, KAIROS) is unchanged and still closed.

No runs in flight. No pods. No schtasks. RunPod balance: $0.

---

0b. BYTE-EXACT FORWARD — campaign status (2026-06-18, late session)

Goal: the entire gemma-4-12B forward byte-exact (cross-machine bit-identical, deterministic-integer) — auditability mission, not compression (see papers/CONTRACT-BYTEEXACT-forward.md). Course-correction landed (operator): the byte-exact math is owned by the UNIVERSAL Rust crate engine tools/sp_dsp_smoke (L2 orchestrator + scalar bit-exact reference), NOT hand-rolled per backend. The crate already had the LINEAR algebra bit-exact-gated (Barrett, mod-q matmul, Garner CRT w/ Q1_INV_MOD_Q2=894602413, the NTT ladder); this session's offline ATTN-NTT/ATTN-FULL prototypes + the CUDA bx_* re-derived it (lesson banked).

DONE + GREEN this session:

• Islands → crate (the genuinely-new nonlinear piece): sp_dsp_smoke/src/sp_islands_q_ref.rs (rmsnorm/softmax/gelu_q_ref, FB30 exact-integer) + host gate sp_islands_q_ref_test.rs — G-ISLANDS-Q-REF GREEN (RMS 5.8e-6 / softmax 1.3e-6 / GELU 2.8e-6, order-immune; cargo run --bin sp_islands_q_ref_test, host x86 no DSP). Engine 4511a10.
• Bridge step 1: case SP_ARCH_GEMMA4: gemma4_forward_cuda added to tools/sp_daemon/c_backend_cuda/sp_daemon_cuda_glue.c — the crate's existing register_forward_backend hook (feature wire_cuda_backend, gate T_WIRE_CUDA_RUNTIME_ACTIVE) can now drive the real 12B. Engine 3f021d9.
• (provisional) committed CUDA k_attn_decode_win_bx (exact-integer dual-prime attention, on-12B PPL 4.6069 vs 4.6665 baseline, 9c2aad3) — left as a CUDA-side datapoint pending reconciliation into the crate-driven path. The wrong-layer CUDA RMS edits were reverted.

ALL FOUR ISLANDS in the crate + the 3-agent fleet closed the remaining bridge work (2026-06-18, late):

• RoPE island DONE — rope_q_ref + cordic_cossin (deterministic fixed-point CORDIC, no libm) — all 4 islands GREEN (engine 38dc133).
• #265 wire_cuda bridge GREEN (engine eee3aac): the universal daemon drives gemma4_forward_cuda on the real 12B through sp_session_register_forward_backend (cuda_forward_count 0→1, wire_cuda_active:true). Build fix = added xbar_episode.c to the CUDA-backend CMake (build-system only); stale math-core libs rebuilt. Receipt G-WIRE-CUDA-GEMMA4.log.
• Persistent-KV decode verb SCAFFOLDED (engine 9da91f6): sp_session_register_kvdecode_backend (open/prefill/decode_step/rewind/pos/close) → tools/sp_daemon/WIRE-CUDA-DECODE-GEMMA4.md + Rust trampoline cuda_kvdecode_dispatch.rs + C glue + AppState slot; cargo check GREEN w/ and w/o wire_cuda_backend. The one ABI gap: an additive gemma4_kv_decode_logits (decode currently returns argmax ids, not logits). Gate = G-WIRE-CUDA-DECODE-GEMMA4.
• .sp-model Q4B loader RECONCILED (engine e9fb9b0, decision B): the crate consumes the engine's resident qwen3_model*/g_w device weights; OK_Q4B is decoded engine-side; a 2nd crate decode would risk a divergent dequant. The crate's HVX sp_model_layer.rs Q8 loader stays HVX-track-only. Doc SP-MODEL-Q4B-RECONCILIATION.md.
• #261 island exactness gate PRE-REGISTERED + harness written (engine 92b93d2, lattice 34a93d1): G-BYTEEXACT-ISLANDS-CUDA (contract §5.1) — env-gated SP_BYTEEXACT_DUMP seam in gemma4_cuda_probe (default-off null floor) dumps real-12B RMSNorm/GELU/RoPE in+out → host comparator bin bx_islands_compare diffs vs the crate *_q_ref (thresholds RMS/GELU/RoPE relerr<1e-4, softmax max|Δp|<1e-5). RUN DEFERRED (needs the warm VS22/CUDA test_gemma4_cuda.exe rebuild — run procedure in §5.1).

ALL THREE "NEXT" ITEMS NOW DONE GREEN (2026-06-18, 3 sequential build agents):

• G-BYTEEXACT-ISLANDS-CUDA RAN GREEN on the 12B (engine b93f157): dumped real-12B island in/out at layer 24, bx_islands_compare vs the crate *_q_ref → RMSNorm relerr 3.84e-5 / GELU 8.18e-7 / RoPE 9.62e-6 (softmax gated offline 1.3e-6), all < 1e-4. The integer refs ARE faithful to the float kernels on real activations. Receipt G-BYTEEXACT-ISLANDS-CUDA.log.
• G-WIRE-CUDA-DECODE-GEMMA4 GREEN (submodule d9d96f3 → engine 6b9a786): the universal daemon token-by-token DECODES the real 12B through the new L1 verb sp_session_register_kvdecode_backend (+ additive gemma4_kv_decode_logits, null floor byte-untouched) — 32/32 tokens bit-identical to the gemma4_kv_decode oracle, VRAM flat (O(1) cache). Submodule-first ABI discipline followed. Receipt G-WIRE-CUDA-DECODE-GEMMA4.log.
• G-BYTEEXACT-FORWARD-12B GREEN — the whole forward is byte-exact (engine 69c0588, lattice §5.2 9b93000): all four islands (RMSNorm/GELU/RoPE/softcap) + attention converted to exact-integer CUDA kernels behind SP_BYTEEXACT (__constant__ d_bx_flag, no __int128 — __umul64hi + the 64-bit isqrt split + CORDIC). LEG A off = PPL 4.6665 == baseline byte-identical (null floor); LEG B on = PPL 4.6569 parity; run-to-run BIT-IDENTICAL (4.6569==4.6569, the order-immunity cross-machine proxy). Receipt G-BYTEEXACT-FORWARD-12B.log.

BYTE-EXACT CAMPAIGN: COMPLETE on-12B. The entire gemma-4-12B forward — linear algebra (dp4a + crate Barrett/Garner/NTT), attention (dual-prime CRT), and all four nonlinear islands — runs exact-integer/deterministic under SP_BYTEEXACT=1, at PPL parity, byte-identical run-to-run, with the flag-off path the citable null floor. The one open item is EXTERNAL: a true two-physical-GPU bit-identical logit check (needs a second machine). NEXT real frontier returns to the project mainline (XBAR/KAIROS), or the gguf-v4 Mersenne co-design. Build note: crate host bins run cargo run --bin <name>; the CUDA backend builds under VS18 BuildTools (D:\Program Files (x86)\...\18\BuildTools, cl 14.50) + CUDA 13.2, feature wire_cuda_backend.

---

1. IN FLIGHT right now (nothing; all clean)

• No active GPU runs. No pods. No schtasks. GPU clocks at default. This session's closures (engine 0019b86→d2d7ceb, all pushed; receipts in engine tests/fixtures/xbar_r3/ + tests/fixtures/xbar_organism/):
• ✓ XBAR UNIFIED onto exact-integer O_K substrate — ten receipts GREEN/honest-negative (2026-06-18). G-R3-BIND-on-OK Leg A GREEN (0019b86); Leg B honest-negative (d7d96fe); organism-native FFT-ripped-out GREEN (1f0f6be); G-R2-FROB integer store GREEN (dbe4103/d076797); G-R2-FROB-ENTROPY negative (e6d17bb); G-R3-MOBIUS negative (1e70763); G-XBAR-ORGANISM-FULL GREEN (15e7051); G-T2-WEIGHTS negative (ac76c8e); G-PERIOD6-REBASE GREEN (d2d7ceb). Period-6 rebase + host-numpy→native Z_q/NTT port both CLOSED here. Previously closed (all on record, nothing in flight):
• ✓ C2 Memo curator CLOSED Steps 1–3.1 + #222 + G-XBAR-ORGANISM step 1 GREEN (2026-06-17). Contracts: CONTRACT-XBAR-C2-memo-curator-loop.md.
• ✓ Ring-3 Path A CLOSED R3.1→R3.4 GREEN, parameter-free (2026-06-17). Contract: CONTRACT-XBAR-R3-consolidation.md.
• ✓ XBAR P3 CLOSED P3.0→P3.4 GREEN (2026-06-17). Contract: CONTRACT-XBAR-P3-ring-on-exec.md.
• ✓ GNA EAR CLOSED on physical silicon (2026-06-17). Contract: CONTRACT-KAIROS-K0-K1.md §7.4–7.6.
• ✓ G-KAIROS-1 6h soak GREEN (2026-06-16); KAI-1/1b/1c CLOSED; KAI-2 CLOSED-BOUNDED; KAI-3 CLOSED GREEN. Contract: CONTRACT-KAIROS-K0-K1.md §5.5–5.9, §6.6, §7.3.
• ✓ Phase C alloc-shrink + C-c NIAH CLOSED (2026-06-14). §P3.2-b-2b LSH 8× +0.47% CLOSED (2026-06-13). Contracts: CONTRACT-XBAR-P3-ring-on-exec.md.

2. The decision queue (locked order — do not reshuffle without the operator)

STATUS (2026-06-18): the locked queue's prior top two are SPENT. XBAR / NIGHTSHIFT is now COMPLETE end-to-end and KAIROS was already closed; T4-on-weights is convicted. The next campaign is an open strategic call (see item 1).

0. ✓ XBAR / NIGHTSHIFT COMPLETE end-to-end (2026-06-18). Mechanisms all GREEN (P1→P3.4 + C2 Steps 1–3.1 + #222 + Ring-3 Path A R3.1→R3.4 + organism + native O_K bind) AND the native-C core/-resident port CLOSED — core/ring3/ (ring3.c + include/sp/ring3.h) ports the VSA layer + NIGHTSHIFT state machine onto native sp_pr_mul; gate T_RING3_NATIVE 42/42 (bind/unbind/superpose bit-identical to the Python ok_bind reference; NIGHTSHIFT reproduced [32,8]@D=1024 + gate-before-cap@D=128; order-immune); carriers unified to splitmix64 (no Python regression). Math-core e0fccd3, engine submodule bump 7b992d2, engine ok_bind unify f331da2. The resident consolidation loop is now deployable native C. Remaining XBAR items are optional / deferred-by-choice → moved to the hygiene queue (item 3): N1 unattended soak, G-R3-PROV, Path B.

1. ▶▶ NEXT = open strategic inflection (operator's call). The major campaigns are all closed — XBAR/NIGHTSHIFT, the byte-exact forward, KAIROS, GNA EAR. T4 Frobenius π^k on the WEIGHTS is NOT a candidate — it is CONVICTED: the incoherence-rotation / Hadamard-fold compression was ruled REDUNDANT vs per-32-block OK_Q4B (G-WEIGHT-FOLD-ORACLE 8ae8825, "do NOT build" — the boundary thesis on weights), and the byte-exact OK_Q8-per-tensor-π^k angle was absorbed into the closed byte-exact forward (dp4a integer accumulate already makes OK_Q4B exact). Candidate next campaigns to choose among: (a) harden→publish — P3.4 larger-N multi-chunk hardening run + the R1–R5 prepublication checklist, toward releasing the staged papers; (b) gguf-v4 Mersenne co-design — the from-scratch format/model where a Mersenne hidden-dim unlocks the exact integer-RMS shortcut (byte-exact is its foundation); (c) the diffusion lane (DiffusionGemma drafter / spec-decode, Stage-Gamma). The one carried-forward external item is the 2-physical-GPU byte-exact check (needs a 2nd machine).

2. ▶ N1 — the deployed subconscious (optional; the lone remaining NIGHTSHIFT item). The consolidation mechanism is closed (item 0); N1 is the deployment: episode persistence across sessions (the C1-lite {Kstore,Vstore,manifest} file-set, reload-and-recall) + an unattended schtasks-owned consolidation soak (net-positive gated promotions, zero canonical corruption, full receipt log — the consolidation analogue of the proven KAIROS 6h soak). Deferrable by choice like the KAIROS ≥24h gate; pre-register CONTRACT-XBAR-N1 before running if pursued.

3. Hygiene queue (non-blocking; pick up when convenient).

   • #220 cudaEvent journal-tax (exact per-tick overhead; wall-clock floor on 2060 makes it noise otherwise).
   • gemma4_kv_decode first-token boundary reconcile (the #222 OPEN from 2026-06-14; kv-path seam alignment with the one-shot SP_XBAR_EMB path).
   • Compact-slab globals wrap-rewind (slab + SWA-ring journal = the joint regime; not exercised yet).
   • P3.4 larger-N multi-chunk hardening run (the named pre-public lever; deterministic, not noise-flippable, just a wider corpus run).
   • G-R3-PROV provenance tag (Ring-3 deferred item; the Z_q/NTT engine port is now DONE via Leg A + organism-native).

3. Open threads (persistent small items)

• HF model bucket KnackAU/sp-diffusion-stage — staged for diffusion/spec-decode prototypes; no active run.
• WSL gcloud unauthed (fine; Windows is canonical).
• HF-token path: _xbar/p2b scripts read archive/notes_and_stuff/claude-hf-token.txt; creds/claude-hf-token.txt is the authoritative path — keep in sync or repoint scripts.

4. Standing watch procedure

No pods, no RunPod balance to check. Before any new cloud run: check_pods.py (any pods?) → verify papers/RUNBOOK-cloud-compute.md pattern → per-unit upload in the loop → verify-then-terminate. ⬢