Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+artifacts/pythia-1.4b-final-layer.ttl filter=lfs diff=lfs merge=lfs -text

ARTIFACT_INDEX.md

@@ -0,0 +1,35 @@
+# Active artifact index
+
+Checksums are SHA-256 over the distributed files. Rejected `.translate`, reader,
+residual, and sequence-controller artifacts are research history and are not part
+of this active Hugging Face pack.
+
+## Runtime artifacts
+
+| Filename | Type | Purpose | Compatibility | SHA-256 |
+|---|---|---|---|---|
+| `canonical-p-v1.router` | Safetensors `.router` | Universal canonical ranking and rejection | `pcm-canonical-p-v1` | `29e0728c12f8806c48998579aedcfa389fa398f909098e162710eb2a5709834e` |
+| `pythia-1.4b-final-layer.ttl` | Safetensors `.ttl` | Semantic Pythia query, value, and gate compatibility | Pythia-1.4B, width 2,048, layer 23 | `72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7` |
+| `gemma4-e4b-q8-llama.ltl` | JSON `.ltl` | Direct adaptive lexical output control metadata | Recorded Gemma4 Q8 GGUF, tokenizer bundle, and llama.cpp | `7eee07ed813796dd0d25b04b48aec73507b934479ad8902e1b657653c040781a` |
+| `personality-proof.ppkg` | SQLite `.ppkg` | Durable personality proof package | Personality protocol v1 and canonical P v1 | `faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9` |
+
+The Pythia checkpoint and Gemma GGUF are not distributed. Users must obtain them
+under their upstream licenses and set local paths explicitly.
+
+## Active benchmark evidence
+
+| Filename | Purpose | SHA-256 |
+|---|---|---|
+| `phase-b-factorized-representation.json` | Canonical representation probe | `602bf8b8b1d07b8100b13f9842790f87ae6a5229ddc2d66377130d15413a870f` |
+| `phase-b-split-translator.json` | Pythia TTL, routing, causal, and preservation proof | `4a8cdc0c2bc73a1fc10f974f20d88be4902331a07b92928edb089b852bc1a845` |
+| `phase-b-personality-package.json` | Promotion, durability, growth, and CUDA personality proof | `5d17cbd8cecc8398105d3d53ff05e1b7941dd0732ac3d68a761790b64799bf06` |
+| `ppkg-100k-profile.json` | Integrity-boundary lookup profile | `f5ff5233632bf5bf860fefedeec560e10a3f32729f4b6a767d0b3538d9c33a05` |
+| `active-system-audit.json` | Active architecture audit and scaling | `6eb3e401023b5878b2bbfb9055fd921999b571f6216e370b12440b7d343c0a1d` |
+| `active-system-cuda-attribution.json` | Matched Pythia causal attribution | `ffe0e8f32f9a1a059767607f0c5e0432b6baf2a9917dc56877f794458b1a5e1c` |
+| `gemma4-e4b-q8-causal.json` | Bounded Gemma residual evidence retained as baseline | `a15a862dbc5dde547e7124ce3c3f16d015c15b79730bc60b7e92425e471ecb0f` |
+| `gemma-native-prompt-equivalence.json` | Native browser-message and token equivalence | `f6823b9b5a5fd69ebf75c8aadc8efa23fe0a6eaac7a1eaa81c398a3fdb200e79` |
+| `post-turn-memory-review-acceptance.json` | Natural post-turn review acceptance evidence | `89cb901c1665e9fd1515ef9165580a4bd3c4d9774f23976fdc6f366ef88c6b24` |
+| `debug-actions-profile.json` | Bounded `/state` and `/personality` profile | `3ca4cc8ac002dc30bd6c33d1bdae764bfc3e43534498eecc98a5168069784bd4` |
+| `vram-comparison.json` | Matched P-cache, retained-KV, and combined CUDA memory comparison | `1b1e266c3f6513a5708711f09879a6519ce45abdaea7ba16d04f2510f5c1fc8d` |
+
+The generated evidence manifest is [`assets/EVIDENCE_MANIFEST.json`](assets/EVIDENCE_MANIFEST.json).

CITATION.bib

@@ -0,0 +1,15 @@
+@software{planner_cache_2026,
+  author = {{Planner Cache contributors}},
+  title = {Planner Cache: A Portable Bounded Semantic-State Layer for Frozen Language Models},
+  year = {2026},
+  note = {Research software and preprint documentation. Author list, release version, repository URL, and DOI pending}
+}
+
+@article{biderman2023pythia,
+  author = {Biderman, Stella and Schoelkopf, Hailey and Anthony, Quentin Gregory and Bradley, Herbie and O'Brien, Kyle and Hallahan, Eric and Khan, Mohammad Aflah and Purohit, Shivanshu and Prashanth, USVSN Sai and Raff, Edward and Skowron, Aviya and Sutawika, Lintang and van der Wal, Oskar},
+  title = {Pythia: A Suite for Analyzing Large Language Models Across Training and Scaling},
+  journal = {Proceedings of the 40th International Conference on Machine Learning},
+  year = {2023},
+  volume = {202},
+  pages = {2397--2430}
+}

CITATION.cff

@@ -0,0 +1,13 @@
+cff-version: 1.2.0
+message: "If you use Planner Cache, cite the software and accompanying preprint."
+title: "Planner Cache: A Portable Bounded Semantic-State Layer for Frozen Language Models"
+type: software
+version: 0.1.0
+date-released: 2026-08-23
+authors:
+  - name: "Planner Cache contributors"
+abstract: >-
+  A portable bounded semantic-state layer for frozen language models with a
+  canonical P-cache, universal router, model-specific TTL and LTL compatibility,
+  and disk-resident P-package personality state.
+license: "LicenseRef-Proprietary-NoGrant"

FINAL_RELEASE_AUDIT.md

@@ -0,0 +1,236 @@
+# Planner Cache final release audit
+
+Audit date: 2026-08-23
+
+## Release readiness
+
+The implementation and publication packs are technically validated as a release
+candidate. Public redistribution is **blocked** because the repository does not
+contain a repository-wide software license grant. Final author metadata and a
+public release URL are also missing. No license was invented during this audit.
+
+The publication packs intentionally exclude model weights, GGUF files, tokenizer
+and metadata bundles, datasets, llama.cpp files, and other third-party copyrighted
+payloads. They contain project-authored implementation, documentation, adapters,
+benchmark records, and derived assets only.
+
+## Current architecture
+
+The audited active boundary is:
+
+```text
+Recent KV and runtime history
+        ↓
+frozen model and native chat template
+
+canonical P-cache and selected P-package state
+        ↓
+universal .router
+        ↓
+native P support, semantic .ttl, or lexical .ltl
+```
+
+Recent KV, archive/history, and tool retrieval remain model or runtime
+responsibilities. P-cache is bounded mutable current state. P-package is durable
+disk-resident personality state. The hidden post-turn memory review observes the
+latest exchange as a side-channel and applies only validated canonical P
+operations. It does not rewrite the visible message path.
+
+## Fixed BLOCKER and MAJOR issues
+
+| Severity | Finding | Resolution |
+|---|---|---|
+| BLOCKER | The first staging pass copied the upstream Gemma tokenizer bundle | Removed from every pack. The builder and validator now reject tokenizer, model, GGUF, and common checkpoint payloads |
+| MAJOR | Publication JSON contained workstation-specific absolute paths | Publication copies normalize those paths to portable environment placeholders. Authoritative repository artifacts remain unchanged |
+| MAJOR | Active public exports still exposed rejected residual and lexical research APIs | Removed rejected adapters from the active planner package exports. Historical modules and evidence remain available for research regression |
+| MAJOR | Launch scripts contained machine-specific model and llama.cpp defaults | Replaced model defaults with required environment inputs and made the llama.cpp default home-relative |
+| MAJOR | A clean source checkout could not collect tests without an editable install | Added `src` to the pytest configuration |
+| MAJOR | `/personality` hydrated and serialized the complete package | Added bounded inspection with a default 100-entry page. The 100,000-entry case fell from 9.7874 seconds and 173,110,748 peak Python allocation bytes to 0.0218 seconds and 196,288 bytes for the action |
+| MAJOR | The VRAM comparison initially included first-use CUDA allocations in one condition | Added a matched warm-up. Every recorded row now begins at the same loaded-stack baseline |
+| MAJOR | Publication artifact indexes could diverge after portable path normalization | Pack building now refreshes evidence and artifact checksums after normalization |
+
+## Remaining BLOCKER and MAJOR findings
+
+| Rank | Severity | Finding | Release consequence |
+|---:|---|---|---|
+| 1 | BLOCKER | No repository-wide software license grant exists | Do not publish or redistribute the staged packs until the rights holder adds a license |
+| 2 | BLOCKER | Final authors, affiliations, public repository URL, and release identifier are unset | Citation and preprint metadata remain provisional |
+| 3 | MAJOR | Trained semantic TTL support is proven only for Pythia-1.4B | Do not claim universal or multi-model semantic compatibility |
+| 4 | MAJOR | Natural memory review is narrow and slow | The controlled reviewer targets owner, location, and status. Recorded review latency was 43.14 to 65.50 seconds |
+| 5 | MAJOR | Canonical representation weights are reconstructed rather than shipped as a standalone protocol artifact | Exact third-party reproduction depends on the documented construction path |
+| 6 | MAJOR | Pythia router-index hydration is linear on each wrapper call | Controlled routing accuracy is strong through 1,024 slots, but arbitrary-scale latency is not established |
+
+No other BLOCKER or MAJOR correctness issue was found in the release-focused
+audit. Nuanced personality learning, broader natural-language extraction, large
+debug offsets, multi-seed statistics, and wider model portability remain MINOR,
+OPTIMIZATION, or documented research limitations depending on intended use.
+
+## Component scorecard
+
+| Component | Correctness | Integrity | Performance | Status |
+|---|---|---|---|---|
+| P-cache | Mutation, merge, invalidation, capacity, stale-state, and serialization regressions pass | Canonical snapshots reject corruption and protocol mismatch | Bounded allocation verified | CLEAN |
+| Universal `.router` | Controlled top-1, top-4 recall, and MRR are 1.0 through 1,024 slots | Deterministic checksummed artifact | 1,024-slot measured routing was 0.675 ms. Per-call index hydration remains a MAJOR limitation | CLEAN with documented scaling limitation |
+| Pythia `.ttl` | Relevant P changes causal logits and tested inactive paths reproduce base candidate logits | Model, width, protocol, type, and checksum checks pass | Frozen base has zero gradients. Active cost is included in the matched VRAM run | CLEAN for the proven Pythia configuration |
+| Gemma `.ltl` | Exact routed lexical control is proven for the recorded direct adaptive logit-bias benchmark | Runtime, model, tokenizer checksum, protocol, class, and checksum checks pass | Zero learned parameters. Rejected routes create no lexical target | CLEAN within lexical or output support |
+| `.ppkg` | Promotion, authority, contradiction, context, cold reload, and selective hydration tests pass | Checksum work occurs at integrity boundaries, not normal lookup | 100,000 entries use 152 candidate headers and hydrate four rows in the recorded query | CLEAN for the mechanical proof |
+| Gateway | Inactive P and LTL preserve exact browser messages, rendered prompt, and token IDs | Session files and event logs are structured and deterministic where required | Review is post-response but must finish before the next turn | CLEAN with review-latency limitation |
+
+## Prompt transparency and inert paths
+
+The native Gemma equivalence artifact records identical structured-message,
+rendered-prompt, and token-ID SHA-256 values for the gateway and raw llama-server
+when P and LTL are inactive. The prompt contained 33 tokens. No logit bias was
+present. Wrong-entity, wrong-relation, historical, invalidated, router-disabled,
+and compatibility-disabled paths remain inert in the tested causal regressions.
+
+## Natural memory review
+
+The controlled acceptance run recorded a natural RP CREATE followed by MODIFY:
+
+```text
+brass key.location = kitchen drawer
+brass key.location = coat pocket
+```
+
+The final active state contained only `coat pocket`. The same conceptual review
+path ran for Gemma and Pythia. Unsupported assistant claims and malformed review
+output remain fail-closed in regression tests. The reviewer does not receive or
+alter the visible browser request.
+
+## Exact VRAM comparison
+
+### Command
+
+```bash
+PYTHONPATH=src .venv/bin/python benchmarks/compare_pcache_kv_vram.py \
+  --model pythia-1.4b \
+  --ttl artifacts/pythia-1.4b-final-layer.ttl \
+  --router artifacts/canonical-p-v1.router \
+  --output artifacts/vram-comparison.json \
+  --workloads 64,256,1024 \
+  --generated-tokens 8 \
+  --seed 317
+```
+
+### Matched configuration
+
+- GPU: NVIDIA GeForce RTX 3050 Laptop GPU with 3,950,575,616 bytes
+- Driver: 610.57.04
+- CUDA runtime: 13.0
+- PyTorch: 2.13.0+cu130
+- Transformers: 5.15.1
+- Model: frozen Pythia-1.4B
+- Batch: 1
+- Base precision: float16
+- TTL precision: float32
+- Generation: greedy argmax
+- Generated tokens: 8
+- Baseline method: one warmed loaded stack followed by CUDA synchronization and peak reset
+
+All memory figures below are MiB. `P bytes` is canonical P tensor allocation.
+`KV bytes` is retained model KV tensor storage. CUDA peaks also include transient
+attention, router, TTL, output, and allocator work.
+
+| Prompt and slots | Condition | P bytes | KV bytes | Base alloc | Base reserved | Peak alloc | Peak reserved | Increment alloc | Increment reserved | Runtime |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|---:|---:|
+| 64 | P-cache only | 0.128 | 0.000 | 2717.183 | 2772.000 | 2724.309 | 2776.000 | 7.125 | 4.000 | 0.2555 s |
+| 64 | KV only | 0.000 | 13.312 | 2717.183 | 2772.000 | 2735.575 | 2788.000 | 18.392 | 16.000 | 0.1754 s |
+| 64 | P-cache plus KV | 0.128 | 13.312 | 2717.183 | 2772.000 | 2735.608 | 2788.000 | 18.425 | 16.000 | 0.2045 s |
+| 256 | P-cache only | 0.513 | 0.000 | 2717.183 | 2772.000 | 2744.347 | 2806.000 | 27.164 | 34.000 | 0.7415 s |
+| 256 | KV only | 0.000 | 49.312 | 2717.183 | 2772.000 | 2794.609 | 2852.000 | 77.426 | 80.000 | 0.1937 s |
+| 256 | P-cache plus KV | 0.513 | 49.312 | 2717.183 | 2772.000 | 2794.739 | 2852.000 | 77.556 | 80.000 | 0.4156 s |
+| 1,024 | P-cache only | 2.052 | 0.000 | 2717.183 | 2772.000 | 2820.674 | 2938.000 | 103.491 | 166.000 | 2.7105 s |
+| 1,024 | KV only | 0.000 | 193.312 | 2717.183 | 2772.000 | 3011.449 | 3096.000 | 294.266 | 324.000 | 0.3753 s |
+| 1,024 | P-cache plus KV | 2.052 | 193.312 | 2717.183 | 2772.000 | 3011.966 | 3114.000 | 294.783 | 342.000 | 1.2812 s |
+
+All nine conditions succeeded. OOM events, failures, fallbacks, and estimated
+values were zero. The raw artifact SHA-256 is
+`1b1e266c3f6513a5708711f09879a6519ce45abdaea7ba16d04f2510f5c1fc8d`.
+See the [raw JSON](artifacts/vram-comparison.json),
+[summary](assets/VRAM_COMPARISON.md), [CSV](assets/vram_comparison.csv), and
+[plot](assets/vram_comparison.svg).
+
+The result distinguishes P-cache and KV allocation. It does not imply that
+semantic state and exact token-level KV are interchangeable.
+
+## Exact validation commands and results
+
+```bash
+GEMMA_MODEL=/path/to/tested-gemma.gguf \
+LLAMA_CPP_DIR=/path/to/llama.cpp \
+.venv/bin/python -m pytest -q
+```
+
+The final result was `126 passed in 285.62 seconds` with the exact local Gemma
+runtime enabled. The separate portable no-path run completed with 119 passed and
+seven exact-runtime skips. The focused exact Gemma subset completed with 33
+passed in 216.16 seconds.
+
+```bash
+PYTHONPATH=src python Publishing/assets/generate_assets.py
+PYTHONPATH=src python Publishing/assets/generate_assets.py
+```
+
+The two runs produced byte-identical SVG and normalized PDF hashes. The current
+architecture PDF SHA-256 is
+`19fad644f3a1e3086a845f07850beec07e20a2352cad000b461c21b6802a2519`.
+
+```bash
+.venv/bin/python Publishing/build_release_packs.py
+.venv/bin/python Publishing/validate_release.py
+bash -n run-pythia.sh run-gemma.sh
+.venv/bin/python -m compileall -q src benchmarks Publishing
+git diff --check
+```
+
+The publication validator requires all three manifests to match, all local links
+to resolve, all JSON to parse, shell and Python syntax to pass, no workstation
+absolute paths, and no third-party model or tokenizer payloads.
+
+## Publication folder validation
+
+| Pack | Contents | Independent validation |
+|---|---|---|
+| GitHub | Developer documentation, active source, launchers, tests, benchmarks, active artifacts, historical result evidence, and assets | Passed manifest, link, syntax, JSON, path, and payload checks |
+| Hugging Face | Artifact cards, active compatibility source, active artifacts, benchmark evidence, runtime requirements, and assets | Passed manifest, link, syntax, JSON, path, and payload checks |
+| Research | Manuscript, experiments, ablations, reproducibility map, benchmark scripts, active and negative-result evidence, and assets | Passed manifest, link, syntax, JSON, path, and payload checks |
+
+Upstream models, tokenizers, llama.cpp, datasets, and the historical third-party
+visual specification are referenced as external prerequisites and are not copied.
+
+## Claims safe to publish
+
+- Planner Cache maintains bounded mutable semantic state independently of retained token-level conversation history.
+- The canonical router reached top-1 accuracy and MRR 1.0 through 1,024 slots on the recorded controlled audit.
+- The Pythia TTL provides tested internal causal state compatibility with frozen-base gradient isolation.
+- The Gemma LTL provides tested lexical output compatibility and does not establish internal semantic reasoning.
+- Tested inactive and rejected paths preserve base behavior.
+- P-package provides deterministic checksummed persistence, evidence-based promotion, selective loading, and zero inactive VRAM in the recorded proof.
+- The indexed 100,000-entry P-package query hydrated four entries from 152 candidate headers.
+- The gateway preserves native Gemma messages and tokenization when memory output control is inactive.
+- Natural post-turn review can create and modify controlled owner, location, and status state while failing closed.
+- The recorded matched VRAM matrix completed without failure and keeps P-cache and KV measurements conceptually separate.
+
+## Claims not safe to publish
+
+- Universal model compatibility
+- Trained semantic TTL portability beyond Pythia-1.4B
+- Gemma internal semantic reasoning over P
+- Replacement of arbitrary long context, archives, or historical retrieval
+- Production-ready broad natural-memory extraction
+- Production-ready learned personality behavior
+- Constant-time routing at arbitrary scale
+- Multi-seed statistical generality not present in the artifacts
+
+## Final ranked disposition
+
+1. Add an explicit repository-wide software license before redistribution.
+2. Finalize authors, affiliations, repository URL, and release identifier.
+3. Keep all semantic portability claims scoped to Pythia until a second trained TTL exists.
+4. Present natural memory review as a controlled, narrow, high-latency proof.
+5. Publish a standalone canonical representation weight artifact if exact external reconstruction becomes a release requirement.
+6. Treat per-call router-index hydration as measured technical debt rather than claiming arbitrary-scale routing.
+
+Subject to the two publication metadata blockers, the code, artifacts, evidence,
+and publication packs form a technically clean release candidate.

LICENSE_STATUS.md

@@ -0,0 +1,16 @@
+# Software license status
+
+No repository-wide software license grant is present in the source repository as
+of 2026-08-23. This publication pack is technically staged but is not authorized
+for public redistribution until the rights holder selects and adds a software
+license.
+
+`THIRD_PARTY_NOTICES.md` records known historical dataset licenses. Base models,
+GGUF files, llama.cpp, Python dependencies, and other third-party components are
+not relicensed by Planner Cache and remain governed by their upstream terms.
+
+Model weights, tokenizer and metadata bundles, datasets, llama.cpp files, and
+other third-party copyrighted payloads are intentionally excluded from every
+publication pack.
+
+This status file is intentionally not a substitute for a license.

LTL_CARD.md

@@ -0,0 +1,27 @@
+# Lexical Translation Layer artifact card
+
+A Lexical Translation Layer converts an accepted canonical value into tokenizer or output controls. It can make a runtime emit the routed value without claiming that the model represented or reasoned over that value internally.
+
+## Artifact
+
+`gemma4-e4b-q8-llama.ltl`
+
+| Field | Value |
+|---|---|
+| Adapter class | LTL |
+| Support level | lexical or output |
+| Format | `planner-cache-ltl-v1` |
+| Model | Gemma4 E4B Q8 GGUF |
+| Runtime | llama.cpp |
+| Control | direct adaptive logit bias |
+| Parameters | 0 |
+| Canonical protocol | `pcm-canonical-p-v1` |
+| GGUF SHA-256 | `a4c4177f9fd7e3f56522675afb742f079a53f9226195b7db5e9888c872f053da` |
+| Tokenizer bundle SHA-256 | `b3033e12af0ed503d8b80390c79d02d6bd9bc372e93e377cc1dd6514b7cd21d6` |
+| Artifact SHA-256 | `7eee07ed813796dd0d25b04b48aec73507b934479ad8902e1b657653c040781a` |
+
+The LTL receives only a universal-router accepted canonical value. It tokenizes the exact UTF-8 value and applies one lexical target at a time. Rejected entity, relation, historical, invalidated, router-disabled, and LTL-disabled paths create no target and remain base-equivalent.
+
+The matched 128-value complexity audit recorded 128 of 128 exact strings for direct adaptive logit bias with active-path KL 3.2561. KL divergence measures how far the full output distribution moved from the frozen base. The selected artifact stores identity and control metadata only. It contains no learned tensors, base weights, vocabulary table, P contents, conversation state, or optimizer state.
+
+LTL support proves routed lexical emission. It does not prove internal semantic reasoning over P. Historical Gemma residual and sequence `.translate` artifacts remain research evidence and are not TTLs.

MODEL_CARD.md

@@ -0,0 +1,80 @@
+# Planner Cache system card
+
+## Summary
+
+Planner Cache is an external semantic-memory architecture attached to a frozen decoder. In plain terms, it keeps mutable facts in a separate bounded store and supplies only selected facts to the model. This card describes the tested system and does not present Planner Cache as a newly pretrained foundation model.
+
+## Tested base model
+
+| Field | Value |
+|---|---|
+| Base | Pythia-1.4B local checkpoint |
+| Architecture | GPT-NeoX decoder |
+| Layers | 24 |
+| Hidden width | 2048 |
+| Attention heads | 16 |
+| Context positions in bundled config | 2,048 |
+| Base training during Planner Cache experiments | none |
+| Base parameters receiving gradients in active CUDA proof | 0 |
+
+The portability suite also ran a frozen Gemma 4 E4B Q8 GGUF with architecture `gemma4`, 42 layers, hidden width 2,560, and llama.cpp build 10276. A bounded two-value residual proved causal control but not broad compatibility. A later sequence path reached 125 of 128 exact disjoint strings. The matched audit classified that result as lexical token forcing and selected a zero-parameter direct adaptive logit-bias LTL that reached 128 of 128 exact strings. Gemma does not currently have TTL support.
+
+Pythia remains subject to the language, factuality, bias, and safety limitations documented by EleutherAI.
+
+## Added components
+
+- A 512-wide canonical P-cache with fixed configured capacity.
+- A model-independent canonical router.
+- A 2,707,464-parameter Pythia `.ttl` attached at layer 23.
+- A disk-resident `.ppkg` proof with selective canonical activation.
+- A zero-parameter Gemma `.ltl` using direct adaptive lexical control in llama.cpp.
+- A hidden post-turn review side-channel that proposes validated canonical P operations after visible generation.
+
+No LoRA, base-weight modification, prompt prefix, or P state in self-attention KV is used by the active architecture.
+
+## Intended use
+
+- Research on mutable semantic state after source tokens leave recent KV.
+- Evaluation of explicit state creation, modification, merging, invalidation, and retention.
+- Development of small compatibility modules for frozen decoder models.
+- Research on durable evidence-based personality conclusions stored outside model weights.
+
+## Out of scope
+
+- General-purpose long-context replacement.
+- Exact transcript recall without an external archive.
+- Production user profiling.
+- Claims of compatibility with arbitrary decoder models.
+- Safety-critical state tracking without external validation.
+- Foundation-model quality or safety evaluation.
+
+## Evaluation methodology
+
+The active tests use controlled entity, relation, value, mutation, wrong-state, invalidation, held-out composition, natural-RP preservation, persistence, corruption, capacity, and scaling workloads. Source-state tokens are removed from recent KV in causal tests. The same prompt and KV are used while canonical P changes.
+
+The active audit also profiles query construction, index hydration, canonical routing, P-package header filtering, row hydration, canonical conversion, translator latency, generation latency, CPU memory, VRAM, disk size, and bytes loaded.
+
+The gateway transparency regression compares the final tokenized prompt with raw
+llama-server for identical `system` and `user` messages and requires exact token
+equivalence while P and LTL are inactive. Memory review is a separate request.
+
+## Main findings
+
+Changing only canonical P changed the selected answer in the controlled causal tests. Rejecting or invalidating that state restored the frozen output. This shows a causal memory channel in the tested conditions. It does not show broad reasoning, factuality, or universal model support.
+
+- P-cache allocation remains fixed for configured capacity.
+- Relevant canonical P state causally changes Pythia token logits and generated values.
+- Invalidated and rejected wrong-state conditions restore frozen-base logits in the matched CUDA benchmark.
+- Natural-RP preservation remains exact on the held-out proof fixture for irrelevant state.
+- P-package state remains on disk and only selected entries are activated.
+- The Gemma LTL audit emitted all 128 selected held-out strings. Rejected, invalidated, and disabled paths remained inert. This is lexical compatibility, not evidence of internal semantic reasoning.
+- A matched CUDA matrix distinguishes canonical P allocation, retained KV tensors, and combined peak VRAM at 64, 256, and 1,024 tokens or slots without treating P and KV as interchangeable.
+
+## Known limitations
+
+The evaluation fixtures are synthetic or small held-out RP sets. Natural review
+currently covers a narrow state schema and is slow. The results do not establish
+general factuality, broad instruction following, production dialogue quality,
+nuanced personality, or a full trained open-vocabulary TTL on a second model
+family. Gemma LTL exact-string performance must not be presented as learned
+semantic compatibility.

PPKG_CARD.md

@@ -0,0 +1,69 @@
+# P-package `.ppkg` card
+
+## Artifact
+
+`personality-proof.ppkg`
+
+## Format
+
+| Field | Value |
+|---|---|
+| Container | SQLite |
+| Format | `pcm-personality-package-v1` |
+| Protocol | `pcm-canonical-personality-v1` |
+| Canonical compatibility | `pcm-canonical-p-v1` |
+| File SHA-256 | `faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9` |
+
+## Purpose
+
+P-package, stored as `.ppkg`, keeps durable personality and behavioral conclusions on disk. It promotes a conclusion only after repeated, diverse, or authoritative evidence. It is not a transcript archive and does not store model-native vectors.
+
+## Included logical data
+
+- canonical personality entries
+- evidence candidates and archive references
+- support and contradiction IDs
+- source authority
+- scope and relationship identity
+- strength, confidence, and importance
+- timestamps and status
+- reversible before and after changes
+- protocol metadata and semantic checksum
+
+## Excluded data
+
+- raw conversation transcript
+- base-model weights
+- model token IDs
+- hidden vectors
+- `.ttl` or `.ltl` contents
+- LoRA
+- optimizer state
+
+## Mechanical results
+
+The practical result is conservative promotion. One weak event did nothing, repeated independent evidence promoted, cross-context evidence counted more than narrow repetition, and explicit correction overruled unsupported model claims. This tests auditable memory mechanics, not nuanced personality understanding.
+
+One weak event did not promote. Three independent events promoted. Linked cross-context evidence scored 2.5865 compared with 1.8000 for five narrow-context events. Unsupported model claims did not promote. An explicit correction promoted and superseded the old conclusion while retaining audit history.
+
+Technical, creative, and relationship-specific retrieval passed in the proof workload. Irrelevant retrieval loaded zero entries.
+
+## Causal results
+
+The same prompt and KV generated Alice when the selected package conclusion specified Alice and Bob when it specified Bob. Irrelevant and unpromoted low-confidence packages reproduced frozen-base logits. The proof uses controlled preferred-persona values inside the tested compatibility range.
+
+## Scaling
+
+The indexed audit measured a 58,720,256-byte synthetic package at 100k entries. Header routing took 67.10 ms, selected-row hydration took 0.118 ms, canonical conversion took 0.495 ms, and four entries were loaded from 152 candidate headers. Inactive VRAM was zero.
+
+The separate `/personality` inspection view is paginated. At 100k active entries,
+its default 100-entry page measured 21.8 ms before JSON encoding and produced a
+roughly 60 KB response instead of hydrating the entire package.
+
+## Integrity behavior
+
+Full semantic verification occurs on verified open, explicit verify, export, checkpoint, and dirty close. Normal routing and evidence pushes do not hash the complete package. SQLite transactional integrity remains enabled.
+
+## Limitations
+
+The package proof is mechanical. It does not establish nuanced learned personality. Canonical conversion depends on an external factorized representation recipe that is not yet distributed as a separate checksummed artifact.

README.md

@@ -1,3 +1,133 @@
 ---
-license: apache-2.0
+tags:
+- semantic-memory
+- pythia
+- pytorch
+- safetensors
+- sqlite
+library_name: transformers
 ---
+
+# Planner Cache artifacts
+
+Planner Cache is an external memory layer for frozen language models. It stores a bounded set of current facts outside the prompt, selects relevant facts, and exposes them through a small model or runtime compatibility artifact. This repository contains those Planner Cache artifacts. It is not a foundation model.
+
+Planner Cache is not a foundation model and does not replace arbitrary long context. Recent KV, exact history, and tool retrieval remain responsibilities of the model runtime.
+
+## Terms
+
+- **P-cache** is a fixed-capacity store for facts that are currently true.
+- **Canonical P** is the model-independent structured representation of those facts. It contains no model token IDs or hidden vectors.
+- **Router or `.router`** selects the canonical state relevant to the current entity and relation.
+- **TTL or `.ttl`** means Tensor Translation Layer. It converts canonical P into a model's internal state and represents semantic or internal support.
+- **LTL or `.ltl`** means Lexical Translation Layer. It converts a routed value into tokenizer or output controls and represents lexical or output support.
+- **P-package or `.ppkg`** stores durable personality patterns on disk and loads only selected entries.
+- **Retained KV** is recent token-level attention memory maintained by the model runtime.
+- An **active path** accepted memory and enabled TTL or LTL. An **inactive path** rejected, invalidated, or disabled memory and should match the frozen base.
+- A **causal intervention** keeps the prompt fixed and changes only P. **KL divergence** measures how much the output distribution changed. **Incremental VRAM** is extra peak GPU memory above a warmed baseline.
+
+![Planner Cache architecture](assets/architecture.svg)
+
+## Distributed artifacts
+
+| Artifact | Role | Compatibility |
+|---|---|---|
+| `canonical-p-v1.router` | Universal canonical state ranking and rejection | `pcm-canonical-p-v1` |
+| `pythia-1.4b-final-layer.ttl` | Semantic query, value, gate, and layer metadata | Pythia-1.4B, hidden width 2048, layer 23 |
+| `gemma4-e4b-q8-llama.ltl` | Direct adaptive lexical control metadata | Recorded Gemma4 Q8 GGUF and tokenizer checksums, llama.cpp |
+| `personality-proof.ppkg` | Example durable personality package | `pcm-canonical-personality-v1` and canonical P v1 |
+| Benchmark JSON | Raw recorded results | See [ARTIFACT_INDEX.md](ARTIFACT_INDEX.md) |
+
+## Compatibility boundary
+
+```text
+canonical P state
+  -> universal .router
+  -> selected canonical value
+  -> native P, model-specific .ttl, or runtime-specific .ltl
+  -> frozen decoder
+```
+
+The canonical router has no model hidden dimension. A `.ttl` contains semantic compatibility weights. An `.ltl` contains lexical control metadata and may have no learned parameters. Neither contains base weights or P contents. The `.ppkg` contains canonical personality entries and evidence references but no model-native tensors.
+
+The Gemma GGUF, tokenizer files, llama.cpp binaries, and upstream model metadata
+are not redistributed. Users must supply the exact compatible bundle identified
+by the LTL checksums.
+
+## Loading the router and TTL
+
+```python
+from transformers import AutoModelForCausalLM
+
+from pcm.planner import ByteEntityEncoder, CanonicalPRouter
+from pcm.planner import PythiaSplitTranslatedModel, TensorTranslationLayer
+
+base = AutoModelForCausalLM.from_pretrained(
+    "EleutherAI/pythia-1.4b",
+    dtype="float16",
+).to("cuda")
+
+ttl = TensorTranslationLayer.load(
+    "pythia-1.4b-final-layer.ttl",
+    device="cuda",
+)
+router = CanonicalPRouter.load("canonical-p-v1.router", device="cuda")
+model = PythiaSplitTranslatedModel(base, ttl, router, ByteEntityEncoder())
+```
+
+The public Hub repository will need to provide the Planner Cache Python implementation or a pinned source release. The artifacts are not standalone Transformers models.
+
+## Loading P-package
+
+```python
+from pcm.planner import PersonalityPackage, PersonalityQuery, PersonalityRouter
+
+with PersonalityPackage("personality-proof.ppkg") as package:
+    selection = PersonalityRouter().retrieve(
+        package,
+        PersonalityQuery(
+            subject="user",
+            interaction_type="technical",
+            domain="debugging",
+            relation="response_style",
+        ),
+        top_k=4,
+    )
+```
+
+## Measured results
+
+The central causal result is that changing only valid P state changed the tested answer, while wrong, historical, invalidated, or disabled state left the tested base logits unchanged. At the 1,024-unit memory case, canonical P occupied about 2.05 MiB and retained KV tensors occupied about 193.31 MiB, a roughly 94-fold representation-size difference. These stores have different purposes and are not interchangeable.
+
+- Post-audit canonical routing reached 100% top-1 and MRR 1.0 through 1,024 slots on the recorded synthetic scaling workload.
+- The selected Pythia TTL reached 100% controlled held-out state generation at the 128-slot proof target.
+- Wrong entity, wrong relation, historical, invalidated, router-disabled, and TTL-disabled matched CUDA conditions restored frozen-base logits where expected.
+- The frozen Pythia base had zero parameters receiving gradients.
+- The Gemma Q8 LTL emitted 128 of 128 held-out selected strings through direct adaptive logit bias. Inactive paths were exact.
+- The Gemma LTL has zero learned parameters, occupies 708 bytes in the local artifact, adds no prompt tokens, and uses zero inactive VRAM.
+- Indexed `.ppkg` header routing measured 67.10 ms at 100k entries and hydrated four rows from 152 headers.
+- Opening an inactive `.ppkg` changed CUDA allocation by zero bytes.
+- Natural post-turn review created and modified current RP state without explicit memory syntax in both interactive paths. It remains a controlled, slow extraction proof.
+- The matched 1,024-token CUDA workload measured 103.491 MiB incremental peak for P-only with retained KV disabled, 294.266 MiB for retained KV only, and 294.783 MiB with both active.
+
+See [TTL_CARD.md](TTL_CARD.md), [LTL_CARD.md](LTL_CARD.md), [ROUTER_CARD.md](ROUTER_CARD.md), [PPKG_CARD.md](PPKG_CARD.md), and the raw evidence in [ARTIFACT_INDEX.md](ARTIFACT_INDEX.md).
+
+## Limitations
+
+- Full trained semantic compatibility is proven only with Pythia-1.4B.
+- The GPT-2 proof is structural and uses a tiny random model.
+- Gemma has LTL support, not TTL support. Exact lexical emission does not establish internal semantic reasoning over P.
+- A separate sequence-aware prototype reached 125 of 128 exact disjoint strings. It is not the selected runtime artifact and has not passed the 1,000-value or broad active-RP gates.
+- The sequence complexity audit showed that exact performance comes primarily from tokenizer IDs and per-token forcing. Direct logit bias reached 128 of 128 with lower KL, but it is a lexical constraint rather than semantic translation.
+- Canonical representation weights are reconstructed from a fixed recipe instead of being shipped as a standalone versioned artifact.
+- Router-index hydration is linear in configured slot count.
+- P-package personality behavior is a controlled deterministic proof, not nuanced neural personality learning.
+- Planner Cache does not preserve exact old wording and does not replace archive retrieval.
+- The reviewer currently focuses on owner, location, and status state. Review failures are inert and may miss valid facts. Recorded review latency was tens of seconds on the test hardware.
+
+## Licensing and release metadata
+
+Pythia-1.4B is Apache-2.0 according to its model card. Historical dataset
+licenses are included in `THIRD_PARTY_NOTICES.md`. This project currently has no
+repository-wide software license grant. Public redistribution remains blocked
+until the rights holder selects one.

RELEASE_MANIFEST.json

@@ -0,0 +1,249 @@
+{
+  "files": {
+    "ARTIFACT_INDEX.md": {
+      "bytes": 3153,
+      "sha256": "4317c3e5c4a1d5a1729a4fd43454b1ada2baa5e136c3e110a3b6a89e6cb31b98"
+    },
+    "CITATION.bib": {
+      "bytes": 867,
+      "sha256": "29b4ec696ec4a643740decdccde41befa8df470c378032b3f5442667ad5938d6"
+    },
+    "CITATION.cff": {
+      "bytes": 557,
+      "sha256": "e0ae2c1741b91795156b26f05999a0317c04415a01ef8ecf0400b0c3ab82fb11"
+    },
+    "FINAL_RELEASE_AUDIT.md": {
+      "bytes": 14166,
+      "sha256": "52df283843415aaf6dfa324ca472724584326a8857b7b1b283d16c1a182e6048"
+    },
+    "LICENSE_STATUS.md": {
+      "bytes": 757,
+      "sha256": "561e1cb080eaab253187388e5be2dc9276a9c5a3a8852dbb4a424fdf48c783d2"
+    },
+    "LTL_CARD.md": {
+      "bytes": 1761,
+      "sha256": "32eee111983eb6f5c9b38933d7adfaa6c4a4ec33ee9cd297d4a753f912c6fd02"
+    },
+    "MODEL_CARD.md": {
+      "bytes": 4950,
+      "sha256": "ab7e499220b6f5a70de79ff71d5de8d1bb99bcbe608c4e567a528aee6473d33a"
+    },
+    "PPKG_CARD.md": {
+      "bytes": 3181,
+      "sha256": "b60c082fc5facdd7b7599fa635bb99e4404d48dd9a599bda0f0465714e199683"
+    },
+    "README.md": {
+      "bytes": 7877,
+      "sha256": "ffda2a0324dc5c2692a3afac2b59b183a07246c84deeda0253f87fc7e4e85804"
+    },
+    "ROUTER_CARD.md": {
+      "bytes": 2737,
+      "sha256": "76762ee2d80c768169b452ca1d27724efa5167fea31a60ee0550680c48d09120"
+    },
+    "RUNTIME.md": {
+      "bytes": 1406,
+      "sha256": "bf5900e8fef5ffc982c4869ee0e20ff06c654063f974a8036f32ad4b9f0ae31d"
+    },
+    "SANITIZATION_REPORT.md": {
+      "bytes": 3411,
+      "sha256": "c7a609f4d464772dce34c3eb0ca79e2fda03b40bb75f518b53124973c00b677e"
+    },
+    "THIRD_PARTY_NOTICES.md": {
+      "bytes": 208,
+      "sha256": "c0b88b4f2f86d9f80d0c64bb0a73a1d29ba00f29b85966f9b5d144db244ecd47"
+    },
+    "TTL_CARD.md": {
+      "bytes": 1619,
+      "sha256": "a16b2432000b6096c215a5f00b9ff4f0d11aa28c3030fff2338158aa827019ad"
+    },
+    "artifacts/active-system-audit.json": {
+      "bytes": 32951,
+      "sha256": "6eb3e401023b5878b2bbfb9055fd921999b571f6216e370b12440b7d343c0a1d"
+    },
+    "artifacts/active-system-cuda-attribution.json": {
+      "bytes": 11695,
+      "sha256": "ffe0e8f32f9a1a059767607f0c5e0432b6baf2a9917dc56877f794458b1a5e1c"
+    },
+    "artifacts/canonical-p-v1.router": {
+      "bytes": 592,
+      "sha256": "29e0728c12f8806c48998579aedcfa389fa398f909098e162710eb2a5709834e"
+    },
+    "artifacts/debug-actions-profile.json": {
+      "bytes": 7528,
+      "sha256": "3ca4cc8ac002dc30bd6c33d1bdae764bfc3e43534498eecc98a5168069784bd4"
+    },
+    "artifacts/gemma-native-prompt-equivalence.json": {
+      "bytes": 1190,
+      "sha256": "f6823b9b5a5fd69ebf75c8aadc8efa23fe0a6eaac7a1eaa81c398a3fdb200e79"
+    },
+    "artifacts/gemma4-e4b-q8-causal.json": {
+      "bytes": 13550,
+      "sha256": "a15a862dbc5dde547e7124ce3c3f16d015c15b79730bc60b7e92425e471ecb0f"
+    },
+    "artifacts/gemma4-e4b-q8-llama.ltl": {
+      "bytes": 708,
+      "sha256": "7eee07ed813796dd0d25b04b48aec73507b934479ad8902e1b657653c040781a"
+    },
+    "artifacts/personality-proof.ppkg": {
+      "bytes": 61440,
+      "sha256": "faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9"
+    },
+    "artifacts/phase-b-factorized-representation.json": {
+      "bytes": 1518,
+      "sha256": "602bf8b8b1d07b8100b13f9842790f87ae6a5229ddc2d66377130d15413a870f"
+    },
+    "artifacts/phase-b-personality-package.json": {
+      "bytes": 11471,
+      "sha256": "5d17cbd8cecc8398105d3d53ff05e1b7941dd0732ac3d68a761790b64799bf06"
+    },
+    "artifacts/phase-b-split-translator.json": {
+      "bytes": 30619,
+      "sha256": "4a8cdc0c2bc73a1fc10f974f20d88be4902331a07b92928edb089b852bc1a845"
+    },
+    "artifacts/post-turn-memory-review-acceptance.json": {
+      "bytes": 1814,
+      "sha256": "89cb901c1665e9fd1515ef9165580a4bd3c4d9774f23976fdc6f366ef88c6b24"
+    },
+    "artifacts/ppkg-100k-profile.json": {
+      "bytes": 1890,
+      "sha256": "f5ff5233632bf5bf860fefedeec560e10a3f32729f4b6a767d0b3538d9c33a05"
+    },
+    "artifacts/pythia-1.4b-final-layer.ttl": {
+      "bytes": 10832776,
+      "sha256": "72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7"
+    },
+    "artifacts/vram-comparison.json": {
+      "bytes": 9347,
+      "sha256": "1b1e266c3f6513a5708711f09879a6519ce45abdaea7ba16d04f2510f5c1fc8d"
+    },
+    "assets/EVIDENCE_MANIFEST.json": {
+      "bytes": 2267,
+      "sha256": "90a7ea25fafcbdb63fb16d5843cc4ea10b6af30da6fc88aa3348546e11424c94"
+    },
+    "assets/README.md": {
+      "bytes": 2326,
+      "sha256": "5b50dcb78bc07e0b81e38680a77b299c4a791264f914d9e55e1c7235ddfac66a"
+    },
+    "assets/VRAM_COMPARISON.md": {
+      "bytes": 3116,
+      "sha256": "515fa0b0ed924670010d7c522fd6b07eef62954645c5ef2c6bcfe2f510569164"
+    },
+    "assets/architecture.mmd": {
+      "bytes": 536,
+      "sha256": "a3501af51b8381e5500b092a6cea2cc6fc84a0d604fc31360b82cfa2cba20e82"
+    },
+    "assets/architecture.pdf": {
+      "bytes": 33505,
+      "sha256": "19fad644f3a1e3086a845f07850beec07e20a2352cad000b461c21b6802a2519"
+    },
+    "assets/architecture.svg": {
+      "bytes": 5796,
+      "sha256": "896fbe844c3a15bef586f1d0eb1b249560cb482ba3a2891c7fe0dd03b8056156"
+    },
+    "assets/causal_conditions.csv": {
+      "bytes": 2015,
+      "sha256": "b756dcf96c276885d58784df4e25a9de0d1f114e2631e68ba42bd6f2fdb97b80"
+    },
+    "assets/gemma_causal_conditions.csv": {
+      "bytes": 1108,
+      "sha256": "86e490aedf0ade7ef7c5d153887a71fd973fd2c2ec50bed8fd45880891a711a9"
+    },
+    "assets/generate_assets.py": {
+      "bytes": 19721,
+      "sha256": "da2d2b9d710f1bb238445af967065ee06866643957e9b829945b9ee55b7b4f6c"
+    },
+    "assets/ppkg_lookup.svg": {
+      "bytes": 3462,
+      "sha256": "c3cb8293f032d2c893f2f2f308904d2132abeed66bd109713a29e0fcf530bf91"
+    },
+    "assets/ppkg_scaling.csv": {
+      "bytes": 655,
+      "sha256": "3a6998adaed8f7ae59bd7f9beba36a402750d609be7ed9df441678ad87ef0cbe"
+    },
+    "assets/router_scaling.csv": {
+      "bytes": 300,
+      "sha256": "18bae82acb8dc34f40b6600ca1965bc15ddfe8c33546e2579850a03aa9f0f52a"
+    },
+    "assets/router_scaling.svg": {
+      "bytes": 4751,
+      "sha256": "a85d53fb6116baf46cc3bf68507e7073ed2b6e9f62872fb5179464b000246cb0"
+    },
+    "assets/vram_comparison.csv": {
+      "bytes": 1214,
+      "sha256": "e9c105610f4ecfca65a59bd2e271468039e86693d8643bdb155353339ad6c16f"
+    },
+    "assets/vram_comparison.svg": {
+      "bytes": 4163,
+      "sha256": "f27c0503fe378fdb0ad400ddb4280720425167369a2a8c6f4bc990015787cdbb"
+    },
+    "pyproject.toml": {
+      "bytes": 693,
+      "sha256": "b716b42cf7f61328805fde14ea6249c7f9d475de6127532c7bf35ad13c61fa8b"
+    },
+    "src/pcm/__init__.py": {
+      "bytes": 70,
+      "sha256": "13fa02743f631c4d76dc7d4e0b849f698a7ea3c357d0575e2aac49145c3a1e1b"
+    },
+    "src/pcm/planner/__init__.py": {
+      "bytes": 2335,
+      "sha256": "b42895436ecb899f65443d4bc6d9804477b5b7be30354e37a97f2eb0ef05b2fb"
+    },
+    "src/pcm/planner/cache.py": {
+      "bytes": 13974,
+      "sha256": "211cf9ad7baddf07e7e9e3fdbccfa7c04d446105ca014114e823cf67a490cb1f"
+    },
+    "src/pcm/planner/canonical.py": {
+      "bytes": 8251,
+      "sha256": "85f9107db2e7652989114d09b6b16af59deca249d6e632ed9e2c77c01e2eef3f"
+    },
+    "src/pcm/planner/chat_cli.py": {
+      "bytes": 21671,
+      "sha256": "31e4a30b0eb56ab78cc822ead4c79688800a5a5c79558ba0e7f06de0132b773f"
+    },
+    "src/pcm/planner/compatibility.py": {
+      "bytes": 12453,
+      "sha256": "6bfd8d490ccdd9049a4f521082ab1d35e2990cce0aa2f23aa5b38e26948cd368"
+    },
+    "src/pcm/planner/interactive_runtimes.py": {
+      "bytes": 37688,
+      "sha256": "1ab389056a07534a287d96fbff1a4dbd5b8e0f0366e920b8e61c84e2e4bc65d0"
+    },
+    "src/pcm/planner/interactive_session.py": {
+      "bytes": 31970,
+      "sha256": "e45044703b472d0cf61a790d169eee52b326466545758ba92b2bf007fe7734f9"
+    },
+    "src/pcm/planner/memory_review.py": {
+      "bytes": 15500,
+      "sha256": "24b5e98475eeb8190c157215d9e7dd763a7b6ffd70c801cfddd8f3d5975261d8"
+    },
+    "src/pcm/planner/personality.py": {
+      "bytes": 47537,
+      "sha256": "c480148d3134c46ebdef142cc95759e18b89441f43fad08135304e7dda437bdf"
+    },
+    "src/pcm/planner/personality_eval.py": {
+      "bytes": 28514,
+      "sha256": "0f26540826a267b669f9159b020d04045ea74bba4faf283f468c3cf6b46cefab"
+    },
+    "src/pcm/planner/pythia_split_translate.py": {
+      "bytes": 8018,
+      "sha256": "6f421cc12f9f86d965063fa4604317fbade3d025b664145639c14fcf2fee0fb9"
+    },
+    "src/pcm/planner/representation.py": {
+      "bytes": 9797,
+      "sha256": "0a44e7c802dc7aa93bbdb58a64fa8d9719725a92d500b44240d49053057aba60"
+    },
+    "src/pcm/planner/split_translator.py": {
+      "bytes": 16193,
+      "sha256": "8beeb52682c043a02bdafeeb012c95ec01283dbd029b882f0b974a27e9901931"
+    },
+    "src/pcm/planner/split_translator_eval.py": {
+      "bytes": 44711,
+      "sha256": "2e1b301268f806b4d7d08f5ff33f0707392839913dbde85a258bc20ac5f07b79"
+    },
+    "src/pcm/planner/web_chat.py": {
+      "bytes": 14555,
+      "sha256": "3d8ba8557212f339d319eb9ee0410b533ca86806984b85b264f089b3b625e4ad"
+    }
+  },
+  "format": "planner-cache-release-pack-v1"
+}

ROUTER_CARD.md

@@ -0,0 +1,54 @@
+# Canonical router card
+
+The canonical router is the model-independent selector. Given a structured query, it ranks current P entries and rejects state that belongs to the wrong entity, relation, time, or validity status.
+
+## Artifact
+
+`canonical-p-v1.router`
+
+## Metadata
+
+| Field | Value |
+|---|---|
+| Format | `pcm-canonical-router-v1` |
+| Architecture | `canonical_factor_router_v1` |
+| Canonical protocol | `pcm-canonical-p-v1` |
+| Entity width | 128 |
+| Relation count | 3 |
+| Metadata count | 4 |
+| Model hidden dimensions | 0 |
+| Learned scalar parameters | 5 |
+| File SHA-256 | `29e0728c12f8806c48998579aedcfa389fa398f909098e162710eb2a5709834e` |
+| Tensor SHA-256 | `5434b21de18a0f66cd4506c057989d18796fad84c55725e33e04688fbc7650bc` |
+
+## Routing semantics
+
+The router consumes a canonical query and a canonical slot index. It scores tokenizer-independent entity similarity, relation agreement, metadata agreement, and current-state status. Invalidated and stale slots are masked. A calibrated acceptance threshold rejects wrong-entity, wrong-relation, historical, invalidated, and irrelevant candidates before translation.
+
+The router does not consume Pythia hidden states. Model hidden states are converted to canonical query fields before routing.
+
+The same router and canonical byte-derived query were used unchanged in the bounded Gemma4 Q8 llama.cpp proof. That proof supplied the canonical query externally because the public runtime path did not expose Gemma hidden states. It therefore validates router reuse but not a Gemma query projector.
+
+## Post-audit scaling
+
+The router chose the correct entry first on every controlled query through 1,024 slots. This fixed the earlier decline without hiding errors by increasing top-k. The result does not remove the separate linear index-hydration cost.
+
+| Slots | Top-1 | Top-4 recall | MRR |
+|---:|---:|---:|---:|
+| 4 | 100% | 100% | 1.0 |
+| 20 | 100% | 100% | 1.0 |
+| 64 | 100% | 100% | 1.0 |
+| 128 | 100% | 100% | 1.0 |
+| 256 | 100% | 100% | 1.0 |
+| 512 | 100% | 100% | 1.0 |
+| 1,024 | 100% | 100% | 1.0 |
+
+These are post-audit router measurements after canonical merge was constrained by entity and relation identity. The immutable pre-fix phase artifact remains 100% at 128, 95% at 256, and 85% at 512.
+
+## Performance
+
+Rank latency remained below 0.7 ms through 1,024 slots in the audit. Index hydration is separate and measured 30.12 ms at 128 slots and 233.00 ms at 1,024 slots.
+
+## Limitations
+
+The current implementation rebuilds byte-derived entity anchors for every slot during each wrapper call. The router uses a linear score over configured slots. The scaling benchmark is controlled and does not establish universal entity disambiguation in open-domain text.

RUNTIME.md

@@ -0,0 +1,33 @@
+# Runtime instructions
+
+Planner Cache does not distribute base-model weights or llama.cpp. Create the
+Python environment, provide local model paths, and use the included launchers.
+The exact Gemma tokenizer and metadata bundle is also an external upstream
+requirement. Its contents are not redistributed in these publication packs.
+
+```bash
+python -m venv .venv
+.venv/bin/pip install -e '.[dev,publishing]'
+
+export LLAMA_CPP_DIR=/path/to/llama.cpp
+export GEMMA_MODEL=/path/to/compatible-gemma.gguf
+export GEMMA_TOKENIZER_BUNDLE=/path/to/matching-gemma-tokenizer-bundle
+./run-gemma.sh
+
+export PYTHIA_MODEL=/path/to/pythia-1.4b
+export REVIEW_MODEL="$GEMMA_MODEL"
+./run-pythia.sh
+```
+
+The launchers resolve the project root from their own location. Optional paths
+include `PYTHIA_TTL`, `GEMMA_LTL`, `GEMMA_TOKENIZER_BUNDLE`, `ROUTER_PATH`,
+`PPKG_PATH`, `SESSION_ROOT`, `LLAMA_WEB_UI`, `WEB_HOST`, and `WEB_PORT`.
+
+Gemma uses llama.cpp and the active `.ltl`. Pythia uses the semantic `.ttl` and
+uses the configured frozen GGUF as a CPU structured reviewer by default. The
+review request is separate from visible generation and uses neither TTL nor LTL.
+
+The browser is the primary conversation interface. Terminal commands `/state`,
+`/personality`, `/events`, `/save`, and `/quit` are secondary diagnostics.
+Every session records transcript, events, metadata, P-cache state, and final
+state under `sessions/`.

SANITIZATION_REPORT.md

@@ -0,0 +1,79 @@
+# Publication sanitization report
+
+Sanitization date: 2026-08-23
+
+## Scope
+
+The GitHub, Hugging Face, and Research packs were rebuilt from the publication
+source set. This pass changed packaging and explanation only. It did not change
+the architecture, run new benchmarks, or alter recorded benchmark values.
+
+## Removed
+
+- Nested `.git` repositories, including local commit identity and email data
+- Cache directories and temporary build output
+- Third-party model weights, GGUF files, tokenizer and configuration bundles,
+  datasets, llama.cpp files, and ordinary checkpoint formats
+- Random temporary-directory identifiers from publication copies of benchmark JSON
+- Concrete interactive session IDs from publication copies of acceptance evidence
+- Workstation-specific repository, model, and runtime paths
+- Machine-specific launcher defaults for local model, tokenizer, and llama.cpp paths
+
+## Replaced
+
+- Repository paths became `${REPOSITORY_ROOT}` where provenance required a path
+- Model paths became `${GEMMA_MODEL}` or neutral `/path/to/model.gguf` examples
+- Runtime paths became `${LLAMA_CPP_DIR}` or `/path/to/llama.cpp`
+- Temporary run directories became `${TEMP_DIR}/planner-cache-run`
+- Concrete session IDs became `benchmark-session-gemma` or
+  `benchmark-session-pythia`
+- Any detected email address in generated pack text becomes `user@example.com`
+
+Path and identifier normalization changes only non-numerical provenance fields in
+the publication copies. The authoritative repository benchmark artifacts remain
+unchanged. Pack-specific checksums are regenerated after normalization.
+
+## Readability changes
+
+The main README, benchmark guide, Hugging Face cards, research abstract, paper,
+and VRAM guide now state the practical result and its boundary before detailed
+tables. P-cache, canonical P, router, TTL, LTL, P-package, retained KV, active
+and inactive paths, causal intervention, KL divergence, and incremental VRAM are
+defined in plain English at first use in each primary publication entry point.
+
+## Intentionally retained technical metadata
+
+The following fields are useful for reproduction and are not treated as personal
+identifiers:
+
+- Model family and architecture identifiers
+- Model, adapter, router, and evidence checksums
+- llama.cpp build number and commit identifier
+- GPU model, VRAM capacity, driver, CUDA, PyTorch, Transformers, Python, kernel,
+  and platform versions
+- Benchmark names, seeds, layer numbers, dimensions, token counts, timestamps,
+  durations, and measured values
+- Synthetic test entities, names, state values, and controlled role-play examples
+
+No hostname, account name, private email, personal conversation, or original
+session identifier is required for reproduction.
+
+## Validation
+
+The release validator checks every pack for nested repository metadata, cache
+directories, private email addresses, personal machine identifiers, concrete
+session IDs, random temporary paths, absolute home or removable-media paths,
+forbidden third-party payloads, broken links, malformed JSON, syntax errors, and
+manifest mismatch.
+
+Validation commands:
+
+```bash
+.venv/bin/python Publishing/build_release_packs.py
+.venv/bin/python Publishing/validate_release.py
+PYTHONPATH=src python Publishing/assets/generate_assets.py
+git diff --check
+```
+
+All publication sanitization, payload, manifest, link, JSON, syntax, asset, and
+diff checks passed in the final run.

THIRD_PARTY_NOTICES.md

@@ -0,0 +1,6 @@
+## Training data:
+- PIPPA — PygmalionAI — Apache-2.0
+- SPB-2602 — marcoDSN — CC BY 4.0
+- SOC-2508 — marcoDSN — CC BY 4.0
+
+The datasets were normalized, filtered, and deduplicated before training.

TTL_CARD.md

@@ -0,0 +1,27 @@
+# Tensor Translation Layer artifact card
+
+A Tensor Translation Layer converts model-independent canonical P into a frozen model's internal hidden-state space. It is intended for semantic or internal memory use rather than direct token forcing.
+
+## Artifact
+
+`pythia-1.4b-final-layer.ttl`
+
+| Field | Value |
+|---|---|
+| Adapter class | TTL |
+| Support level | semantic or internal |
+| Format | `planner-cache-ttl-v1` |
+| Base model | Pythia-1.4B |
+| Hidden width | 2,048 |
+| Attachment | GPT-NeoX layer 23 |
+| Parameters | 2,707,464 |
+| Canonical protocol | `pcm-canonical-p-v1` |
+| Artifact SHA-256 | `72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7` |
+
+The TTL maps model hidden states to factorized canonical queries and selected canonical values back to model-hidden residuals. Its gate is conditioned on current hidden state, translated P, and canonical route features. The frozen Pythia base receives zero gradients.
+
+The controlled 128-slot benchmark recorded 100% held-out state generation. In the matched causal test, changing only canonical P changed the answer. Wrong, historical, invalidated, router-disabled, and TTL-disabled conditions restored frozen candidate logits. This proves the tested Pythia path can consume internal state, not that every model can.
+
+The artifact contains adapter tensors and compatibility metadata. It contains no base-model weights, P-cache state, conversation state, prompt tokens, KV, or optimizer state.
+
+This evidence is specific to Pythia-1.4B. The tiny GPT-2 test is structural and does not establish trained semantic portability to another model family.

artifacts/active-system-audit.json

@@ -0,0 +1,979 @@
+{
+  "cache_router_profile": {
+    "1024": {
+      "context_query_cpu_seconds": 0.00026123900000030176,
+      "context_query_wall_seconds": 0.00026156400053878315,
+      "correct": true,
+      "fixed_allocation_bytes": 2151424,
+      "router_index_bytes": 541696,
+      "routing_cpu_seconds": 0.0001990224999999235,
+      "routing_wall_seconds": 0.0001980755005206447,
+      "selected_index": 1023,
+      "slot_hydration_cpu_seconds": 0.2316533870000006,
+      "slot_hydration_wall_seconds": 0.23300263999772142
+    },
+    "128": {
+      "context_query_cpu_seconds": 0.00026496599999958903,
+      "context_query_wall_seconds": 0.0002643149982759496,
+      "correct": true,
+      "fixed_allocation_bytes": 268928,
+      "router_index_bytes": 67712,
+      "routing_cpu_seconds": 0.00017257199999987094,
+      "routing_wall_seconds": 0.00017198149907926563,
+      "selected_index": 127,
+      "slot_hydration_cpu_seconds": 0.029635333999999958,
+      "slot_hydration_wall_seconds": 0.0301195789979829
+    },
+    "256": {
+      "context_query_cpu_seconds": 0.00026626349999947507,
+      "context_query_wall_seconds": 0.0002665029987838352,
+      "correct": true,
+      "fixed_allocation_bytes": 537856,
+      "router_index_bytes": 135424,
+      "routing_cpu_seconds": 0.0001784940000004731,
+      "routing_wall_seconds": 0.00017715650028549135,
+      "selected_index": 255,
+      "slot_hydration_cpu_seconds": 0.05884093700000026,
+      "slot_hydration_wall_seconds": 0.059160028999031056
+    },
+    "512": {
+      "context_query_cpu_seconds": 0.00026109349999980935,
+      "context_query_wall_seconds": 0.00026036700000986457,
+      "correct": true,
+      "fixed_allocation_bytes": 1075712,
+      "router_index_bytes": 270848,
+      "routing_cpu_seconds": 0.00018318249999982328,
+      "routing_wall_seconds": 0.0001824114988266956,
+      "selected_index": 511,
+      "slot_hydration_cpu_seconds": 0.11655074100000018,
+      "slot_hydration_wall_seconds": 0.1174167370008945
+    },
+    "64": {
+      "context_query_cpu_seconds": 0.000264374499999942,
+      "context_query_wall_seconds": 0.00026382900068711024,
+      "correct": true,
+      "fixed_allocation_bytes": 134464,
+      "router_index_bytes": 33856,
+      "routing_cpu_seconds": 0.00017868450000024794,
+      "routing_wall_seconds": 0.00017796800057112705,
+      "selected_index": 63,
+      "slot_hydration_cpu_seconds": 0.014785765000000062,
+      "slot_hydration_wall_seconds": 0.014910114001395414
+    }
+  },
+  "dependency_map": {
+    "active_module_imports": {
+      "__init__": [
+        "pcm.planner.cache",
+        "pcm.planner.canonical",
+        "pcm.planner.personality",
+        "pcm.planner.pythia_split_translate",
+        "pcm.planner.split_translator"
+      ],
+      "cache": [],
+      "canonical": [
+        "pcm.planner.cache"
+      ],
+      "personality": [
+        "pcm.planner.cache",
+        "pcm.planner.canonical",
+        "pcm.planner.representation",
+        "pcm.planner.split_translator"
+      ],
+      "personality_eval": [
+        "pcm.planner.canonical",
+        "pcm.planner.personality",
+        "pcm.planner.pythia_split_translate",
+        "pcm.planner.representation",
+        "pcm.planner.split_translator"
+      ],
+      "personality_profile": [
+        "pcm.planner.canonical",
+        "pcm.planner.personality",
+        "pcm.planner.representation"
+      ],
+      "pythia_split_translate": [
+        "pcm.planner.canonical",
+        "pcm.planner.split_translator"
+      ],
+      "representation": [],
+      "split_translator": [
+        "pcm.planner.cache",
+        "pcm.planner.canonical"
+      ],
+      "split_translator_eval": [
+        "pcm.planner.cache",
+        "pcm.planner.canonical",
+        "pcm.planner.pythia_split_translate",
+        "pcm.planner.representation",
+        "pcm.planner.split_translator"
+      ]
+    },
+    "archive_dependencies": [],
+    "canonical_stores_model_hidden_vectors": false,
+    "canonical_stores_model_token_ids": false
+  },
+  "experiment": "active-planner-cache-full-audit-v1",
+  "matched_e2e_evidence": {
+    "failure_attribution_fields": "storage validity, selected route/rank, acceptance, gate, candidate logits, generated token, KL, latency, VRAM",
+    "matched_cuda_attribution": {
+      "active_memory": {
+        "context_creative": {
+          "canonical_store_bytes": 1077,
+          "loaded_entries": 1,
+          "logical_disk_bytes_read": 990,
+          "package_disk_bytes": 57344
+        },
+        "context_technical": {
+          "canonical_store_bytes": 1077,
+          "loaded_entries": 1,
+          "logical_disk_bytes_read": 996,
+          "package_disk_bytes": 57344
+        },
+        "irrelevant": {
+          "canonical_store_bytes": 0,
+          "loaded_entries": 0,
+          "logical_disk_bytes_read": 0,
+          "package_disk_bytes": 57344
+        },
+        "low_confidence": {
+          "canonical_store_bytes": 0,
+          "loaded_entries": 0,
+          "logical_disk_bytes_read": 0,
+          "package_disk_bytes": 57344
+        },
+        "package_a": {
+          "canonical_store_bytes": 1077,
+          "loaded_entries": 1,
+          "logical_disk_bytes_read": 787,
+          "package_disk_bytes": 57344
+        },
+        "package_b": {
+          "canonical_store_bytes": 1077,
+          "loaded_entries": 1,
+          "logical_disk_bytes_read": 783,
+          "package_disk_bytes": 57344
+        }
+      },
+      "adapter_training_performed": false,
+      "base_model": "pythia-1.4b",
+      "base_parameters_with_grad": 0,
+      "base_training_performed": false,
+      "candidate_accuracy": {
+        "context_creative_bob": 1.0,
+        "context_technical_alice": 1.0,
+        "irrelevant_matches_base": 1.0,
+        "package_a_alice": 1.0,
+        "package_b_bob": 1.0
+      },
+      "canonical_probe": {
+        "canonical_decode_accuracy": {
+          "entity": 1.0,
+          "metadata": 1.0,
+          "relation": 1.0,
+          "value": 1.0
+        },
+        "hard_negative_accuracy": {
+          "historical": 1.0,
+          "wrong_entity": 0.97265625,
+          "wrong_value": 1.0
+        },
+        "held_out_combinations": 256,
+        "p_only_state_recovery": 0.97265625,
+        "permutation_stability": 1.0,
+        "permutations_per_combination": 8,
+        "slot_width": 512,
+        "total_held_out_combinations": 519,
+        "train_combinations": 2073,
+        "training_loss_first": 7.440117835998535,
+        "training_loss_last": 0.04114125296473503
+      },
+      "canonical_representation_reconstructed_from_fixed_existing_recipe": true,
+      "causal": {
+        "frozen_base": {
+          "active_state_vram_bytes": 0,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": null,
+          "selected_index": null,
+          "selected_state": null
+        },
+        "historical": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": 5.400981426239014,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "invalidated": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": null,
+          "selected_index": null,
+          "selected_state": null
+        },
+        "p_cache_only": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": -0.30040669441223145,
+          "selected_index": 0,
+          "selected_state": "current-task"
+        },
+        "p_cache_plus_p_package": {
+          "active_state_vram_bytes": 2154,
+          "alice_logit": 40.03125,
+          "alice_probability": 1.0,
+          "bob_logit": 13.859375,
+          "bob_probability": 4.302284223323127e-12,
+          "gate": 0.9909488558769226,
+          "generated": " Alice",
+          "kl_from_base": 8.359650611877441,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 1,
+          "selected_state": "user"
+        },
+        "p_package_a_relevant": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 40.03125,
+          "alice_probability": 1.0,
+          "bob_logit": 13.859375,
+          "bob_probability": 4.302284223323127e-12,
+          "gate": 0.9909488558769226,
+          "generated": " Alice",
+          "kl_from_base": 8.359650611877441,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "p_package_b_relevant": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 14.0,
+          "alice_probability": 8.776464277548968e-11,
+          "bob_logit": 37.15625,
+          "bob_probability": 0.9998875856399536,
+          "gate": 0.9605370163917542,
+          "generated": " Bob",
+          "kl_from_base": 9.265372276306152,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "p_package_context_creative": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 14.0,
+          "alice_probability": 8.776464277548968e-11,
+          "bob_logit": 37.15625,
+          "bob_probability": 0.9998875856399536,
+          "gate": 0.9605370163917542,
+          "generated": " Bob",
+          "kl_from_base": 9.265372276306152,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "p_package_context_technical": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 40.03125,
+          "alice_probability": 1.0,
+          "bob_logit": 13.859375,
+          "bob_probability": 4.302284223323127e-12,
+          "gate": 0.9909488558769226,
+          "generated": " Alice",
+          "kl_from_base": 8.359650611877441,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "p_package_contradictory_low_confidence": {
+          "active_state_vram_bytes": 0,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": null,
+          "selected_index": null,
+          "selected_state": null
+        },
+        "p_package_irrelevant": {
+          "active_state_vram_bytes": 0,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": null,
+          "selected_index": null,
+          "selected_state": null
+        },
+        "router_disabled": {
+          "active_state_vram_bytes": 0,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": null,
+          "selected_index": null,
+          "selected_state": null
+        },
+        "translator_disabled": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "translator_oracle_route": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 40.03125,
+          "alice_probability": 1.0,
+          "bob_logit": 13.859375,
+          "bob_probability": 4.302284223323127e-12,
+          "gate": 0.9909488558769226,
+          "generated": " Alice",
+          "kl_from_base": 8.359650611877441,
+          "router_accepted": true,
+          "router_score": 5.590433597564697,
+          "selected_index": 0,
+          "selected_state": "user"
+        },
+        "wrong_entity": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": -0.30040669441223145,
+          "selected_index": 0,
+          "selected_state": "someone-else"
+        },
+        "wrong_relation": {
+          "active_state_vram_bytes": 1077,
+          "alice_logit": 7.02734375,
+          "alice_probability": 0.00023412609880324453,
+          "bob_logit": 6.12109375,
+          "bob_probability": 9.459550346946344e-05,
+          "gate": 0.0,
+          "generated": " able",
+          "kl_from_base": -1.646096947638398e-08,
+          "router_accepted": false,
+          "router_score": 4.078105926513672,
+          "selected_index": 0,
+          "selected_state": "user"
+        }
+      },
+      "experiment": "active-system-cuda-failure-attribution-v1",
+      "extra_prompt_tokens": 0,
+      "full_package_uploaded_to_cuda": false,
+      "inactive_package_entries": 5,
+      "inactive_vram_delta_bytes": 0,
+      "latency_seconds": {
+        "frozen_base": 0.0174486715994135,
+        "historical": 0.019347908600320807,
+        "invalidated": 0.01760459740035003,
+        "p_cache_only": 0.019043124400195666,
+        "p_cache_plus_p_package": 0.019569637600216083,
+        "p_package_a_relevant": 0.019282742799987318,
+        "p_package_b_relevant": 0.018934362999425504,
+        "p_package_context_creative": 0.01985094979972928,
+        "p_package_context_technical": 0.019666298399533842,
+        "p_package_contradictory_low_confidence": 0.0175312320003286,
+        "p_package_irrelevant": 0.01746072020032443,
+        "router_disabled": 0.017419308600074145,
+        "translator_disabled": 0.01867739240042283,
+        "translator_oracle_route": 0.018915273399761644,
+        "wrong_entity": 0.019296769200445853,
+        "wrong_relation": 0.018960535999940475
+      },
+      "natural_interaction": {
+        "frozen_base": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        },
+        "p_cache_only": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        },
+        "p_cache_plus_p_package": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        },
+        "p_package_contradictory_low_confidence": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        },
+        "p_package_irrelevant": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        },
+        "p_package_relevant": {
+          "kl_from_base": 4.2250388077036405e-08,
+          "loss": 5.47836971282959,
+          "samples": [
+            " \"",
+            "\n",
+            " \""
+          ]
+        }
+      },
+      "relevant_personality_chat": {
+        "base_target_loss": 8.359650611877441,
+        "generated": " Alice",
+        "package_target_loss": -0.0,
+        "target": "Alice",
+        "target_accuracy": 1.0
+      },
+      "source_tokens_in_recent_kv": 0
+    },
+    "natural_rp": {
+      "base_loss": 5.583366870880127,
+      "conditions": {
+        "base": {
+          "kl": -3.993045538663864e-08,
+          "loss": 5.583366870880127,
+          "samples": [
+            "\n\n\"I'm not",
+            "\n\n\"I'm going"
+          ]
+        },
+        "invalidated": {
+          "kl": -3.993045538663864e-08,
+          "loss": 5.583366870880127,
+          "samples": [
+            "\n\n\"I'm not",
+            "\n\n\"I'm going"
+          ]
+        },
+        "irrelevant": {
+          "kl": -3.993045538663864e-08,
+          "loss": 5.583366870880127,
+          "samples": [
+            "\n\n\"I'm not",
+            "\n\n\"I'm going"
+          ]
+        },
+        "wrong_entity": {
+          "kl": -3.993045538663864e-08,
+          "loss": 5.583366870880127,
+          "samples": [
+            "\n\n\"I'm not",
+            "\n\n\"I'm going"
+          ]
+        }
+      },
+      "relevant_state_generation_sample": " Alice"
+    },
+    "personality_counterfactual": {
+      "frozen_base": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_cache_only": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_cache_plus_p_package": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_a_relevant": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_b_relevant": {
+        "alice_logit": 14.0,
+        "alice_probability": 8.776464277548968e-11,
+        "bob_logit": 37.15625,
+        "bob_probability": 0.9998875856399536,
+        "gate": 0.9605370163917542,
+        "generated": " Bob",
+        "kl_from_base": 9.265372276306152
+      },
+      "p_package_context_creative": {
+        "alice_logit": 14.0,
+        "alice_probability": 8.776464277548968e-11,
+        "bob_logit": 37.15625,
+        "bob_probability": 0.9998875856399536,
+        "gate": 0.9605370163917542,
+        "generated": " Bob",
+        "kl_from_base": 9.265372276306152
+      },
+      "p_package_context_technical": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_contradictory_low_confidence": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_package_irrelevant": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      }
+    },
+    "personality_natural_rp": {
+      "frozen_base": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_cache_only": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_cache_plus_p_package": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_contradictory_low_confidence": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_irrelevant": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_relevant": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      }
+    },
+    "source_artifacts": [
+      "artifacts/phase-b-split-translator.json",
+      "artifacts/phase-b-personality-package.json"
+    ],
+    "state_ablations": {
+      "full_system_with_preservation": {
+        "full_token_accuracy": 1.0,
+        "gate_activation": 0.9820089340209961,
+        "state_candidate_accuracy": 1.0
+      },
+      "router_only": {
+        "active_vram_overhead_bytes": 11035444,
+        "hidden_only_top1_accuracy": 0.0,
+        "latency_seconds": 0.10144930460010074,
+        "mrr": 1.0,
+        "oracle_query_mrr": 1.0,
+        "oracle_query_top1_accuracy": 1.0,
+        "oracle_query_top4_recall": 1.0,
+        "state_generation_accuracy": 1.0,
+        "top1_accuracy": 1.0,
+        "top2_recall": 1.0,
+        "top4_recall": 1.0
+      },
+      "router_plus_translator_plus_gate": {
+        "historical_state_kl": 9.595059236744419e-05,
+        "rp_kl": -3.993045538663864e-08,
+        "rp_loss": 5.583366870880127,
+        "state_candidate_accuracy": 1.0,
+        "state_loss": 1.8655489839147776e-05,
+        "wrong_state_kl": 9.595059236744419e-05
+      },
+      "router_plus_translator_without_gate": {
+        "state_candidate_accuracy": 1.0
+      },
+      "translator_only_oracle_routing": {
+        "state_candidate_accuracy": 1.0
+      }
+    },
+    "state_counterfactual": {
+      "disabled": {
+        "alice_logit": 5.515625,
+        "alice_probability": 3.538730743457563e-05,
+        "bob_logit": 6.2734375,
+        "bob_probability": 7.55025030230172e-05,
+        "gate": 0.0,
+        "generated": " a"
+      },
+      "p1_silver_alice": {
+        "alice_logit": 40.09375,
+        "alice_probability": 1.0,
+        "bob_logit": 14.3125,
+        "bob_probability": 6.3583643558629e-12,
+        "gate": 0.9964228272438049,
+        "generated": " Alice"
+      },
+      "p2_silver_bob": {
+        "alice_logit": 13.0234375,
+        "alice_probability": 4.473376963992637e-12,
+        "bob_logit": 39.15625,
+        "bob_probability": 0.9999349117279053,
+        "gate": 0.9842994213104248,
+        "generated": " Bob"
+      },
+      "p3_gold_alice": {
+        "alice_logit": 5.515625,
+        "alice_probability": 3.538730743457563e-05,
+        "bob_logit": 6.2734375,
+        "bob_probability": 7.55025030230172e-05,
+        "gate": 0.0,
+        "generated": " a"
+      },
+      "p4_silver_historical": {
+        "alice_logit": 5.515625,
+        "alice_probability": 3.538730743457563e-05,
+        "bob_logit": 6.2734375,
+        "bob_probability": 7.55025030230172e-05,
+        "gate": 0.0,
+        "generated": " a"
+      },
+      "p4_silver_invalidated": {
+        "alice_logit": 5.515625,
+        "alice_probability": 3.538730743457563e-05,
+        "bob_logit": 6.2734375,
+        "bob_probability": 7.55025030230172e-05,
+        "gate": 0.0,
+        "generated": " a"
+      }
+    }
+  },
+  "ppkg_scaling": {
+    "100": {
+      "build_seconds": 0.005182955999771366,
+      "candidate_headers": 4,
+      "canonical_conversion_cpu_seconds": 0.0005506600000000361,
+      "canonical_conversion_wall_seconds": 0.0005500090010173153,
+      "checksum_seconds": 0.0010304470015398692,
+      "db_open_seconds": 0.00020484400010900572,
+      "disk_bytes": 118784,
+      "entries_loaded": 4,
+      "inactive_vram_bytes": 0,
+      "logical_bytes_read": 2789,
+      "python_peak_allocation_bytes": 9086,
+      "query_plan": {
+        "scope": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_scope_route (status=? AND scope=?)')"
+        ],
+        "subject": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_subject_route (status=? AND subject=?)')"
+        ]
+      },
+      "routing_header_cpu_seconds": 0.002198153000000147,
+      "routing_header_wall_seconds": 0.002207458997872891,
+      "row_hydration_cpu_seconds": 0.00011678899999978398,
+      "row_hydration_wall_seconds": 0.00011649800217128359
+    },
+    "1000": {
+      "build_seconds": 0.030133395001030294,
+      "candidate_headers": 33,
+      "canonical_conversion_cpu_seconds": 0.0004903580000004126,
+      "canonical_conversion_wall_seconds": 0.0004913600023428444,
+      "checksum_seconds": 0.008523084998159902,
+      "db_open_seconds": 0.0002957940014312044,
+      "disk_bytes": 638976,
+      "entries_loaded": 4,
+      "inactive_vram_bytes": 0,
+      "logical_bytes_read": 6855,
+      "python_peak_allocation_bytes": 19832,
+      "query_plan": {
+        "scope": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_scope_route (status=? AND scope=?)')"
+        ],
+        "subject": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_subject_route (status=? AND subject=?)')"
+        ]
+      },
+      "routing_header_cpu_seconds": 0.014248357999999683,
+      "routing_header_wall_seconds": 0.014324849998956779,
+      "row_hydration_cpu_seconds": 0.00011794099999917762,
+      "row_hydration_wall_seconds": 0.0001179409991891589
+    },
+    "10000": {
+      "build_seconds": 0.29831144099807716,
+      "candidate_headers": 130,
+      "canonical_conversion_cpu_seconds": 0.0005051340000008508,
+      "canonical_conversion_wall_seconds": 0.0005099939990031999,
+      "checksum_seconds": 0.08329692499683006,
+      "db_open_seconds": 0.00028353100060485303,
+      "disk_bytes": 5894144,
+      "entries_loaded": 4,
+      "inactive_vram_bytes": 0,
+      "logical_bytes_read": 20616,
+      "python_peak_allocation_bytes": 75123,
+      "query_plan": {
+        "scope": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_scope_route (status=? AND scope=?)')"
+        ],
+        "subject": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_subject_route (status=? AND subject=?)')"
+        ]
+      },
+      "routing_header_cpu_seconds": 0.05690157699999965,
+      "routing_header_wall_seconds": 0.05726086499998928,
+      "row_hydration_cpu_seconds": 0.00011336200000044983,
+      "row_hydration_wall_seconds": 0.00011310199988656677
+    },
+    "100000": {
+      "build_seconds": 3.1510163159982767,
+      "candidate_headers": 152,
+      "canonical_conversion_cpu_seconds": 0.0004911590000009625,
+      "canonical_conversion_wall_seconds": 0.0004947460001858417,
+      "checksum_seconds": 0.8238876559989876,
+      "db_open_seconds": 0.000549067000974901,
+      "disk_bytes": 58720256,
+      "entries_loaded": 4,
+      "inactive_vram_bytes": 0,
+      "logical_bytes_read": 23715,
+      "python_peak_allocation_bytes": 87891,
+      "query_plan": {
+        "scope": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_scope_route (status=? AND scope=?)')"
+        ],
+        "subject": [
+          "(4, 0, 54, 'SEARCH entries USING COVERING INDEX entry_subject_route (status=? AND subject=?)')"
+        ]
+      },
+      "routing_header_cpu_seconds": 0.06670220700000051,
+      "routing_header_wall_seconds": 0.06710040300094988,
+      "row_hydration_cpu_seconds": 0.00011785099999883641,
+      "row_hydration_wall_seconds": 0.00011752000136766583
+    }
+  },
+  "process_peak_rss_bytes": 1001316352,
+  "router_scaling": {
+    "attribution": "The pre-audit CanonicalPStore allowed semantic merge across different entity/relation identities. Repeated factorized vectors therefore aliased slots at 256/512 even for oracle queries. Identity-constrained merge removes that storage corruption; the matched post-fix canonical router remains 100% through 1024. Linear scan affects latency but did not cause the accuracy loss.",
+    "immutable_pre_fix_baseline": {
+      "128": 1.0,
+      "256": 0.949999988079071,
+      "512": 0.8500000238418579
+    },
+    "measurements": {
+      "1024": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.0006750829998054542,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "128": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.0003642720002972055,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "20": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.0003294770031061489,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "256": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.00039848600135883316,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "4": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.00035979299718746915,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "512": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.0004960180012858473,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      },
+      "64": {
+        "entity_confusions": 0,
+        "exact_query_anchor_collisions": 0,
+        "failure_examples": [],
+        "historical_confusions": 0,
+        "latency_seconds": 0.00033151000025100075,
+        "mrr": 1.0,
+        "relation_confusions": 0,
+        "top1_accuracy": 1.0,
+        "top4_recall": 1.0
+      }
+    }
+  },
+  "timestamp": "2026-08-22T00:00:00+00:00",
+  "training_performed": false,
+  "translate_profile": {
+    "cpu": {
+      "parameter_bytes": 10829856,
+      "parameter_count": 2707464,
+      "translation_and_gate_cpu_seconds": 0.003563432500000019,
+      "translation_and_gate_wall_seconds": 0.0006066100013413234
+    },
+    "cuda": {
+      "active_vram_delta_bytes": 8914432,
+      "bytes_copied_to_cuda": 164096,
+      "copy_wall_seconds": 0.0005022000004828442,
+      "peak_vram_delta_bytes": 9441280,
+      "translation_and_gate_wall_seconds": 0.0012042837000384072
+    }
+  }
+}

artifacts/active-system-cuda-attribution.json

@@ -0,0 +1,387 @@
+{
+  "active_memory": {
+    "context_creative": {
+      "canonical_store_bytes": 1077,
+      "loaded_entries": 1,
+      "logical_disk_bytes_read": 990,
+      "package_disk_bytes": 57344
+    },
+    "context_technical": {
+      "canonical_store_bytes": 1077,
+      "loaded_entries": 1,
+      "logical_disk_bytes_read": 996,
+      "package_disk_bytes": 57344
+    },
+    "irrelevant": {
+      "canonical_store_bytes": 0,
+      "loaded_entries": 0,
+      "logical_disk_bytes_read": 0,
+      "package_disk_bytes": 57344
+    },
+    "low_confidence": {
+      "canonical_store_bytes": 0,
+      "loaded_entries": 0,
+      "logical_disk_bytes_read": 0,
+      "package_disk_bytes": 57344
+    },
+    "package_a": {
+      "canonical_store_bytes": 1077,
+      "loaded_entries": 1,
+      "logical_disk_bytes_read": 787,
+      "package_disk_bytes": 57344
+    },
+    "package_b": {
+      "canonical_store_bytes": 1077,
+      "loaded_entries": 1,
+      "logical_disk_bytes_read": 783,
+      "package_disk_bytes": 57344
+    }
+  },
+  "adapter_training_performed": false,
+  "base_model": "pythia-1.4b",
+  "base_parameters_with_grad": 0,
+  "base_training_performed": false,
+  "candidate_accuracy": {
+    "context_creative_bob": 1.0,
+    "context_technical_alice": 1.0,
+    "irrelevant_matches_base": 1.0,
+    "package_a_alice": 1.0,
+    "package_b_bob": 1.0
+  },
+  "canonical_probe": {
+    "canonical_decode_accuracy": {
+      "entity": 1.0,
+      "metadata": 1.0,
+      "relation": 1.0,
+      "value": 1.0
+    },
+    "hard_negative_accuracy": {
+      "historical": 1.0,
+      "wrong_entity": 0.97265625,
+      "wrong_value": 1.0
+    },
+    "held_out_combinations": 256,
+    "p_only_state_recovery": 0.97265625,
+    "permutation_stability": 1.0,
+    "permutations_per_combination": 8,
+    "slot_width": 512,
+    "total_held_out_combinations": 519,
+    "train_combinations": 2073,
+    "training_loss_first": 7.440117835998535,
+    "training_loss_last": 0.04114125296473503
+  },
+  "canonical_representation_reconstructed_from_fixed_existing_recipe": true,
+  "causal": {
+    "frozen_base": {
+      "active_state_vram_bytes": 0,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": null,
+      "selected_index": null,
+      "selected_state": null
+    },
+    "historical": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": 5.400981426239014,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "invalidated": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": null,
+      "selected_index": null,
+      "selected_state": null
+    },
+    "p_cache_only": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": -0.30040669441223145,
+      "selected_index": 0,
+      "selected_state": "current-task"
+    },
+    "p_cache_plus_p_package": {
+      "active_state_vram_bytes": 2154,
+      "alice_logit": 40.03125,
+      "alice_probability": 1.0,
+      "bob_logit": 13.859375,
+      "bob_probability": 4.302284223323127e-12,
+      "gate": 0.9909488558769226,
+      "generated": " Alice",
+      "kl_from_base": 8.359650611877441,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 1,
+      "selected_state": "user"
+    },
+    "p_package_a_relevant": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 40.03125,
+      "alice_probability": 1.0,
+      "bob_logit": 13.859375,
+      "bob_probability": 4.302284223323127e-12,
+      "gate": 0.9909488558769226,
+      "generated": " Alice",
+      "kl_from_base": 8.359650611877441,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "p_package_b_relevant": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 14.0,
+      "alice_probability": 8.776464277548968e-11,
+      "bob_logit": 37.15625,
+      "bob_probability": 0.9998875856399536,
+      "gate": 0.9605370163917542,
+      "generated": " Bob",
+      "kl_from_base": 9.265372276306152,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "p_package_context_creative": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 14.0,
+      "alice_probability": 8.776464277548968e-11,
+      "bob_logit": 37.15625,
+      "bob_probability": 0.9998875856399536,
+      "gate": 0.9605370163917542,
+      "generated": " Bob",
+      "kl_from_base": 9.265372276306152,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "p_package_context_technical": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 40.03125,
+      "alice_probability": 1.0,
+      "bob_logit": 13.859375,
+      "bob_probability": 4.302284223323127e-12,
+      "gate": 0.9909488558769226,
+      "generated": " Alice",
+      "kl_from_base": 8.359650611877441,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "p_package_contradictory_low_confidence": {
+      "active_state_vram_bytes": 0,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": null,
+      "selected_index": null,
+      "selected_state": null
+    },
+    "p_package_irrelevant": {
+      "active_state_vram_bytes": 0,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": null,
+      "selected_index": null,
+      "selected_state": null
+    },
+    "router_disabled": {
+      "active_state_vram_bytes": 0,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": null,
+      "selected_index": null,
+      "selected_state": null
+    },
+    "translator_disabled": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "translator_oracle_route": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 40.03125,
+      "alice_probability": 1.0,
+      "bob_logit": 13.859375,
+      "bob_probability": 4.302284223323127e-12,
+      "gate": 0.9909488558769226,
+      "generated": " Alice",
+      "kl_from_base": 8.359650611877441,
+      "router_accepted": true,
+      "router_score": 5.590433597564697,
+      "selected_index": 0,
+      "selected_state": "user"
+    },
+    "wrong_entity": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": -0.30040669441223145,
+      "selected_index": 0,
+      "selected_state": "someone-else"
+    },
+    "wrong_relation": {
+      "active_state_vram_bytes": 1077,
+      "alice_logit": 7.02734375,
+      "alice_probability": 0.00023412609880324453,
+      "bob_logit": 6.12109375,
+      "bob_probability": 9.459550346946344e-05,
+      "gate": 0.0,
+      "generated": " able",
+      "kl_from_base": -1.646096947638398e-08,
+      "router_accepted": false,
+      "router_score": 4.078105926513672,
+      "selected_index": 0,
+      "selected_state": "user"
+    }
+  },
+  "experiment": "active-system-cuda-failure-attribution-v1",
+  "extra_prompt_tokens": 0,
+  "full_package_uploaded_to_cuda": false,
+  "inactive_package_entries": 5,
+  "inactive_vram_delta_bytes": 0,
+  "latency_seconds": {
+    "frozen_base": 0.0174486715994135,
+    "historical": 0.019347908600320807,
+    "invalidated": 0.01760459740035003,
+    "p_cache_only": 0.019043124400195666,
+    "p_cache_plus_p_package": 0.019569637600216083,
+    "p_package_a_relevant": 0.019282742799987318,
+    "p_package_b_relevant": 0.018934362999425504,
+    "p_package_context_creative": 0.01985094979972928,
+    "p_package_context_technical": 0.019666298399533842,
+    "p_package_contradictory_low_confidence": 0.0175312320003286,
+    "p_package_irrelevant": 0.01746072020032443,
+    "router_disabled": 0.017419308600074145,
+    "translator_disabled": 0.01867739240042283,
+    "translator_oracle_route": 0.018915273399761644,
+    "wrong_entity": 0.019296769200445853,
+    "wrong_relation": 0.018960535999940475
+  },
+  "natural_interaction": {
+    "frozen_base": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    },
+    "p_cache_only": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    },
+    "p_cache_plus_p_package": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    },
+    "p_package_contradictory_low_confidence": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    },
+    "p_package_irrelevant": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    },
+    "p_package_relevant": {
+      "kl_from_base": 4.2250388077036405e-08,
+      "loss": 5.47836971282959,
+      "samples": [
+        " \"",
+        "\n",
+        " \""
+      ]
+    }
+  },
+  "relevant_personality_chat": {
+    "base_target_loss": 8.359650611877441,
+    "generated": " Alice",
+    "package_target_loss": -0.0,
+    "target": "Alice",
+    "target_accuracy": 1.0
+  },
+  "source_tokens_in_recent_kv": 0
+}

artifacts/debug-actions-profile.json

@@ -0,0 +1,245 @@
+{
+  "experiment": "planner-cache-debug-actions-profile-v1",
+  "page_limit": 100,
+  "personality": {
+    "100": {
+      "active_entries": 100,
+      "after_bounded": {
+        "action": {
+          "cpu_seconds": 0.009221641999999974,
+          "peak_python_allocation_bytes": 196984,
+          "wall_seconds": 0.009249514012481086
+        },
+        "hydrated_entries": 100,
+        "json_serialization": {
+          "cpu_seconds": 0.003703828000000353,
+          "peak_python_allocation_bytes": 121302,
+          "wall_seconds": 0.003694181010359898
+        },
+        "response_bytes": 60318,
+        "total_active": 100,
+        "truncated": false
+      },
+      "before_unbounded": {
+        "action": {
+          "cpu_seconds": 0.009142955000000175,
+          "peak_python_allocation_bytes": 196591,
+          "wall_seconds": 0.009165266004856676
+        },
+        "hydrated_entries": 100,
+        "json_serialization": {
+          "cpu_seconds": 0.003326453000000118,
+          "peak_python_allocation_bytes": 121106,
+          "wall_seconds": 0.003322666001622565
+        },
+        "response_bytes": 60220
+      }
+    },
+    "1000": {
+      "active_entries": 1000,
+      "after_bounded": {
+        "action": {
+          "cpu_seconds": 0.009862894999999927,
+          "peak_python_allocation_bytes": 196288,
+          "wall_seconds": 0.009891455003526062
+        },
+        "hydrated_entries": 100,
+        "json_serialization": {
+          "cpu_seconds": 0.003532476999999812,
+          "peak_python_allocation_bytes": 121302,
+          "wall_seconds": 0.0035344719944987446
+        },
+        "response_bytes": 60318,
+        "total_active": 1000,
+        "truncated": true
+      },
+      "before_unbounded": {
+        "action": {
+          "cpu_seconds": 0.09285407999999995,
+          "peak_python_allocation_bytes": 1928216,
+          "wall_seconds": 0.09317578599439003
+        },
+        "hydrated_entries": 1000,
+        "json_serialization": {
+          "cpu_seconds": 0.03305002400000001,
+          "peak_python_allocation_bytes": 1211130,
+          "wall_seconds": 0.033163794010761194
+        },
+        "response_bytes": 605232
+      }
+    },
+    "10000": {
+      "active_entries": 10000,
+      "after_bounded": {
+        "action": {
+          "cpu_seconds": 0.010486288000000066,
+          "peak_python_allocation_bytes": 196288,
+          "wall_seconds": 0.010522566008148715
+        },
+        "hydrated_entries": 100,
+        "json_serialization": {
+          "cpu_seconds": 0.003585478999999836,
+          "peak_python_allocation_bytes": 121304,
+          "wall_seconds": 0.00358573799894657
+        },
+        "response_bytes": 60319,
+        "total_active": 10000,
+        "truncated": true
+      },
+      "before_unbounded": {
+        "action": {
+          "cpu_seconds": 0.9330532409999996,
+          "peak_python_allocation_bytes": 17663949,
+          "wall_seconds": 0.9362227259989595
+        },
+        "hydrated_entries": 10000,
+        "json_serialization": {
+          "cpu_seconds": 0.34413546300000064,
+          "peak_python_allocation_bytes": 12161028,
+          "wall_seconds": 0.3450379890127806
+        },
+        "response_bytes": 6080181
+      }
+    },
+    "100000": {
+      "active_entries": 100000,
+      "after_bounded": {
+        "action": {
+          "cpu_seconds": 0.021668488999999624,
+          "peak_python_allocation_bytes": 196288,
+          "wall_seconds": 0.02177674999984447
+        },
+        "hydrated_entries": 100,
+        "json_serialization": {
+          "cpu_seconds": 0.0037721280000013735,
+          "peak_python_allocation_bytes": 121306,
+          "wall_seconds": 0.003769953007576987
+        },
+        "response_bytes": 60320,
+        "total_active": 100000,
+        "truncated": true
+      },
+      "before_unbounded": {
+        "action": {
+          "cpu_seconds": 9.748923195,
+          "peak_python_allocation_bytes": 173110748,
+          "wall_seconds": 9.787373771992861
+        },
+        "hydrated_entries": 100000,
+        "json_serialization": {
+          "cpu_seconds": 3.3711310019999985,
+          "peak_python_allocation_bytes": 122015586,
+          "wall_seconds": 3.384944927005563
+        },
+        "response_bytes": 61007460
+      }
+    }
+  },
+  "personality_query_plans": {
+    "active_count": [
+      "SEARCH entries USING COVERING INDEX entry_relationship_route (status=?)"
+    ],
+    "bounded_page": [
+      "SEARCH entries USING INDEX entry_relationship_route (status=?)",
+      "USE TEMP B-TREE FOR ORDER BY"
+    ]
+  },
+  "state": {
+    "0": {
+      "active_entries": 0,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 1,
+      "json_serialization": {
+        "cpu_seconds": 6.78270000000758e-05,
+        "peak_python_allocation_bytes": 1259,
+        "wall_seconds": 5.7437995565123856e-05
+      },
+      "response_bytes": 2,
+      "snapshot": {
+        "cpu_seconds": 0.00010548699999990419,
+        "peak_python_allocation_bytes": 432,
+        "wall_seconds": 8.957799582276493e-05
+      }
+    },
+    "1024": {
+      "active_entries": 1024,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 1024,
+      "json_serialization": {
+        "cpu_seconds": 0.030256003999999947,
+        "peak_python_allocation_bytes": 643302,
+        "wall_seconds": 0.030321376005304046
+      },
+      "response_bytes": 321318,
+      "snapshot": {
+        "cpu_seconds": 0.04200101300000014,
+        "peak_python_allocation_bytes": 716728,
+        "wall_seconds": 0.042143614002270624
+      }
+    },
+    "128": {
+      "active_entries": 128,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 128,
+      "json_serialization": {
+        "cpu_seconds": 0.0038881549999998377,
+        "peak_python_allocation_bytes": 80572,
+        "wall_seconds": 0.0038865509995957837
+      },
+      "response_bytes": 39953,
+      "snapshot": {
+        "cpu_seconds": 0.005286958999999758,
+        "peak_python_allocation_bytes": 86776,
+        "wall_seconds": 0.005294073998811655
+      }
+    },
+    "256": {
+      "active_entries": 256,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 256,
+      "json_serialization": {
+        "cpu_seconds": 0.0072936459999999315,
+        "peak_python_allocation_bytes": 160958,
+        "wall_seconds": 0.00729949600645341
+      },
+      "response_bytes": 80146,
+      "snapshot": {
+        "cpu_seconds": 0.010555682000000122,
+        "peak_python_allocation_bytes": 173272,
+        "wall_seconds": 0.010585684009129182
+      }
+    },
+    "512": {
+      "active_entries": 512,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 512,
+      "json_serialization": {
+        "cpu_seconds": 0.013979924000000032,
+        "peak_python_allocation_bytes": 321704,
+        "wall_seconds": 0.014006733996211551
+      },
+      "response_bytes": 160519,
+      "snapshot": {
+        "cpu_seconds": 0.021038871000000015,
+        "peak_python_allocation_bytes": 354200,
+        "wall_seconds": 0.02109747999929823
+      }
+    },
+    "64": {
+      "active_entries": 64,
+      "bounded_by_configured_capacity": true,
+      "configured_slots": 64,
+      "json_serialization": {
+        "cpu_seconds": 0.0018557219999997265,
+        "peak_python_allocation_bytes": 40532,
+        "wall_seconds": 0.0018496399861760437
+      },
+      "response_bytes": 19933,
+      "snapshot": {
+        "cpu_seconds": 0.0027572279999996674,
+        "peak_python_allocation_bytes": 43576,
+        "wall_seconds": 0.0027569780068006366
+      }
+    }
+  }
+}

artifacts/gemma-native-prompt-equivalence.json

@@ -0,0 +1,29 @@
+{
+  "assertions": {
+    "inactive_ltl_has_no_output_control": true,
+    "message_structure_exact": true,
+    "rendered_prompt_exact": true,
+    "token_ids_exact": true
+  },
+  "conditions": {
+    "ltl_logit_bias_present": false,
+    "message_structure_equal": true,
+    "p_active": false
+  },
+  "format": "planner-cache-native-prompt-equivalence-v1",
+  "gateway_inactive": {
+    "message_sha256": "46f75bef337eb9fcb9cbebb77c8836fa48bc0c1c8de68d0ec1aa24631b912e4d",
+    "prompt_sha256": "0f9bac487f601d8f2c33c9097be424b7adc2813930f98993bd72c9f6ae03777b",
+    "token_count": 33,
+    "token_ids_sha256": "0ace5a54d9cc7305143599c4414212a1946494231473b590fad117e6105d5dcb"
+  },
+  "llama_cpp_version": "version: 10276 (6ea215d17)\nbuilt with GNU 16.1.1 for Linux x86_64",
+  "model": "${GEMMA_MODEL}",
+  "model_sha256": "a4c4177f9fd7e3f56522675afb742f079a53f9226195b7db5e9888c872f053da",
+  "raw": {
+    "message_sha256": "46f75bef337eb9fcb9cbebb77c8836fa48bc0c1c8de68d0ec1aa24631b912e4d",
+    "prompt_sha256": "0f9bac487f601d8f2c33c9097be424b7adc2813930f98993bd72c9f6ae03777b",
+    "token_count": 33,
+    "token_ids_sha256": "0ace5a54d9cc7305143599c4414212a1946494231473b590fad117e6105d5dcb"
+  }
+}

artifacts/gemma4-e4b-q8-causal.json

@@ -0,0 +1,463 @@
+{
+  "adapter": {
+    "active_control_buffer_bytes": 419840,
+    "adapter_parameter_count": 3073,
+    "base_model_optimization": false,
+    "bytes_copied_per_relevant_activation": 10240,
+    "canonical_probe": {
+      "canonical_decode_accuracy": {
+        "entity": 1.0,
+        "metadata": 1.0,
+        "relation": 1.0,
+        "value": 1.0
+      },
+      "hard_negative_accuracy": {
+        "historical": 1.0,
+        "wrong_entity": 0.97265625,
+        "wrong_value": 1.0
+      },
+      "held_out_combinations": 256,
+      "p_only_state_recovery": 0.97265625,
+      "permutation_stability": 1.0,
+      "permutations_per_combination": 8,
+      "slot_width": 512,
+      "total_held_out_combinations": 519,
+      "train_combinations": 2073,
+      "training_loss_first": 7.440117835998535,
+      "training_loss_last": 0.04114125296473503
+    },
+    "config": {
+      "architecture": "canonical_scalar_to_control_vector_v1",
+      "attachment_layer": 41,
+      "canonical_protocol": "pcm-canonical-p-v1",
+      "canonical_width": 512,
+      "format": "pcm-llama-gguf-translate-v1",
+      "llama_build": "version: 10276 (6ea215d17)\nbuilt with GNU 16.1.1 for Linux x86_64",
+      "model_architecture": "gemma4",
+      "model_hidden_width": 2560,
+      "model_id": "Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
+      "model_layer_count": 42,
+      "model_sha256": "a4c4177f9fd7e3f56522675afb742f079a53f9226195b7db5e9888c872f053da",
+      "runtime": "llama.cpp-control-vector",
+      "supported_value_ids": [
+        0,
+        1
+      ],
+      "target_token_ids": [
+        32858,
+        15943
+      ]
+    },
+    "extra_prompt_tokens": 0,
+    "fit_observed_strengths": {
+      "Alice": 1.999999761581421,
+      "Bob": -5.000000953674316
+    },
+    "fit_target_strengths": {
+      "Alice": 2.0,
+      "Bob": -5.0
+    },
+    "gate_basis": "universal canonical route acceptance plus supported canonical value",
+    "inactive_vram_bytes": 0,
+    "model_hidden_query_projection": "not available through llama-server and not claimed",
+    "path": "${REPOSITORY_ROOT}/artifacts/gemma4-e4b-q8-llama.translate",
+    "recent_kv_source_token_count": 0,
+    "sha256": "2a25f1641f796d520250d0367dd3b546579a2050c5ef84e2cfff7e598d299785",
+    "size_bytes": 13356,
+    "training_method": "analytic minimum-norm affine fit to frozen token-row direction"
+  },
+  "assertions": {
+    "alice_generation": true,
+    "alice_logit_lift": true,
+    "all_inactive_paths_exact": true,
+    "bob_generation": true,
+    "bob_logit_lift": true,
+    "historical_rejected": true,
+    "invalidated_rejected": true,
+    "natural_irrelevant_exact": true,
+    "server_alice_generation": true,
+    "server_bob_generation": true,
+    "wrong_entity_rejected": true,
+    "wrong_relation_rejected": true
+  },
+  "conditions": {
+    "correct_alice": {
+      "alice_logit": 26.0793858,
+      "alice_probability": 0.389850411,
+      "bob_logit": 0.909999311,
+      "bob_probability": 4.57059089e-12,
+      "gate": 1.0,
+      "generated": " Alice",
+      "generated_token_id": 32858,
+      "kl_from_base": 0.604321331,
+      "latency_ms": 320.229877,
+      "max_abs_logit_difference_from_base": 11.1606493,
+      "router_accepted": true,
+      "router_score": 5.590437412261963,
+      "scale": 1.99999976,
+      "selected_state": {
+        "label": "silver key",
+        "metadata_id": 0,
+        "relation_id": 0,
+        "value_id": 0
+      },
+      "strength": 1.999999761581421
+    },
+    "correct_bob": {
+      "alice_logit": 7.2261529,
+      "alice_probability": 2.57553064e-09,
+      "bob_logit": 26.6650352,
+      "bob_probability": 0.712961469,
+      "gate": 1.0,
+      "generated": " Bob",
+      "generated_token_id": 15943,
+      "kl_from_base": 9.63846737,
+      "latency_ms": 312.696353,
+      "max_abs_logit_difference_from_base": 23.8088799,
+      "router_accepted": true,
+      "router_score": 5.590437412261963,
+      "scale": -5.00000048,
+      "selected_state": {
+        "label": "silver key",
+        "metadata_id": 0,
+        "relation_id": 0,
+        "value_id": 1
+      },
+      "strength": -5.000000476837158
+    },
+    "historical": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 404.050531,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": 5.40098237991333,
+      "scale": 0,
+      "selected_state": {
+        "label": "silver key",
+        "metadata_id": 2,
+        "relation_id": 0,
+        "value_id": 0
+      },
+      "strength": 0.0
+    },
+    "invalidated": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 338.130937,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": null,
+      "scale": 0,
+      "selected_state": null,
+      "strength": 0.0
+    },
+    "p_disabled": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 354.148533,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": null,
+      "scale": 0,
+      "selected_state": null,
+      "strength": 0.0
+    },
+    "router_disabled": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 385.683319,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": null,
+      "scale": 0,
+      "selected_state": null,
+      "strength": 0.0
+    },
+    "translator_disabled": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 335.948864,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": true,
+      "router_score": 5.590437412261963,
+      "scale": 0,
+      "selected_state": {
+        "label": "silver key",
+        "metadata_id": 0,
+        "relation_id": 0,
+        "value_id": 0
+      },
+      "strength": 0.0
+    },
+    "wrong_entity": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 321.541691,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": -0.3507542610168457,
+      "scale": 0,
+      "selected_state": {
+        "label": "gold key",
+        "metadata_id": 0,
+        "relation_id": 0,
+        "value_id": 0
+      },
+      "strength": 0.0
+    },
+    "wrong_relation": {
+      "alice_logit": 23.1685543,
+      "alice_probability": 0.0447660284,
+      "bob_logit": 12.0706482,
+      "bob_probability": 6.77936756e-07,
+      "gate": 0.0,
+      "generated": " the",
+      "generated_token_id": 506,
+      "kl_from_base": 0,
+      "latency_ms": 328.731662,
+      "max_abs_logit_difference_from_base": 0,
+      "router_accepted": false,
+      "router_score": 4.078108310699463,
+      "scale": 0,
+      "selected_state": {
+        "label": "silver key",
+        "metadata_id": 0,
+        "relation_id": 1,
+        "value_id": 0
+      },
+      "strength": 0.0
+    }
+  },
+  "experiment": "gemma4-e4b-q8-llama-translate-causal-v1",
+  "llama_cpp": {
+    "cli": "${LOCAL_PATH}",
+    "control_vector_generator_failure": "stock generator asserted because Gemma4 did not expose n_layers minus one callback tensors",
+    "root": "${LOCAL_PATH}",
+    "runtime_attachment": "public llama_set_adapter_cvec API and llama-server control-vector path",
+    "server": "${LOCAL_PATH}",
+    "version": "version: 10276 (6ea215d17)\nbuilt with GNU 16.1.1 for Linux x86_64"
+  },
+  "model": {
+    "architecture": "gemma4",
+    "base_modified": false,
+    "block_count": 42,
+    "context_length": 131072,
+    "embedding_length": 2560,
+    "file_type": 7,
+    "name": "Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
+    "path": "${GEMMA_MODEL}",
+    "quantized_gguf": true,
+    "sha256": "a4c4177f9fd7e3f56522675afb742f079a53f9226195b7db5e9888c872f053da",
+    "sha256_seconds": 5.7932635489996755,
+    "size_bytes": 8133226464,
+    "size_label": "7.5B",
+    "tensor_count": 720
+  },
+  "natural_rp": {
+    "conditions": [
+      {
+        "alice_logit": 21.079689,
+        "alice_probability": 0.000247380297,
+        "bob_logit": 19.7254486,
+        "bob_probability": 6.38595666e-05,
+        "generated": " \"",
+        "generated_token_id": 623,
+        "kl_from_base": 0,
+        "latency_ms": 598.812609,
+        "max_abs_logit_difference_from_base": 0,
+        "scale": 0
+      },
+      {
+        "alice_logit": 21.079689,
+        "alice_probability": 0.000247380297,
+        "bob_logit": 19.7254486,
+        "bob_probability": 6.38595666e-05,
+        "generated": " \"",
+        "generated_token_id": 623,
+        "kl_from_base": 0,
+        "latency_ms": 511.115942,
+        "max_abs_logit_difference_from_base": 0,
+        "scale": 0
+      },
+      {
+        "alice_logit": 21.079689,
+        "alice_probability": 0.000247380297,
+        "bob_logit": 19.7254486,
+        "bob_probability": 6.38595666e-05,
+        "generated": " \"",
+        "generated_token_id": 623,
+        "kl_from_base": 0,
+        "latency_ms": 504.167794,
+        "max_abs_logit_difference_from_base": 0,
+        "scale": 0
+      }
+    ],
+    "prompt": "Rain tapped the observatory windows while the old astronomer adjusted the brass lens. Guest:"
+  },
+  "prompt": "The silver key currently belongs to",
+  "prompt_tokens": 7,
+  "runner": {
+    "causal_command": [
+      "${TEMP_DIR}/planner-cache-run/llama_cpp_causal_runner",
+      "--model",
+      "${GEMMA_MODEL}",
+      "--direction",
+      "${TEMP_DIR}/planner-cache-run/gemma-direction.f32",
+      "--prompt",
+      "The silver key currently belongs to",
+      "--scales",
+      "0.0,1.999999761581421,-5.000000476837158,0.0,0.0,0.0,0.0,0.0,0.0",
+      "--layer",
+      "41",
+      "--alice-token",
+      "32858",
+      "--bob-token",
+      "15943",
+      "--gpu-layers",
+      "12"
+    ],
+    "compilation": {
+      "binary_sha256": "ac1683efac4abd95c583633ac77490abbaea860814f745b05931dc1c762e25b7",
+      "command": [
+        "c++",
+        "-std=c++17",
+        "-O2",
+        "${REPOSITORY_ROOT}/benchmarks/llama_cpp_causal_runner.cpp",
+        "-I${LOCAL_PATH}",
+        "-I${LOCAL_PATH}",
+        "${LOCAL_PATH}",
+        "${LOCAL_PATH}",
+        "-Wl,-rpath,${LOCAL_PATH}",
+        "-o",
+        "${TEMP_DIR}/planner-cache-run/llama_cpp_causal_runner"
+      ],
+      "compile_seconds": 1.2689489720032725,
+      "source_sha256": "2beaeaf65c50304ec4dca9321eb2fe542a3f3edbe9084fa293f518b3c1cd6e8f"
+    },
+    "natural_command": [
+      "${TEMP_DIR}/planner-cache-run/llama_cpp_causal_runner",
+      "--model",
+      "${GEMMA_MODEL}",
+      "--direction",
+      "${TEMP_DIR}/planner-cache-run/gemma-direction.f32",
+      "--prompt",
+      "Rain tapped the observatory windows while the old astronomer adjusted the brass lens. Guest:",
+      "--scales",
+      "0.0,0.0,0.0",
+      "--layer",
+      "41",
+      "--alice-token",
+      "32858",
+      "--bob-token",
+      "15943",
+      "--gpu-layers",
+      "12"
+    ]
+  },
+  "server_verification": {
+    "alice": {
+      "command": [
+        "${LOCAL_PATH}",
+        "--model",
+        "${GEMMA_MODEL}",
+        "--host",
+        "127.0.0.1",
+        "--port",
+        "46083",
+        "--ctx-size",
+        "512",
+        "--parallel",
+        "1",
+        "--threads",
+        "8",
+        "--threads-batch",
+        "8",
+        "--gpu-layers",
+        "12",
+        "--no-warmup",
+        "--no-context-shift",
+        "--log-disable",
+        "--control-vector-scaled",
+        "${TEMP_DIR}/planner-cache-run/gemma-direction.gguf:1.999999761581421",
+        "--control-vector-layer-range",
+        "41",
+        "41"
+      ],
+      "content": " Alice",
+      "elapsed_seconds": 3.6577627030019357,
+      "prompt_ms": 432.977,
+      "prompt_tokens": 7
+    },
+    "bob": {
+      "command": [
+        "${LOCAL_PATH}",
+        "--model",
+        "${GEMMA_MODEL}",
+        "--host",
+        "127.0.0.1",
+        "--port",
+        "34955",
+        "--ctx-size",
+        "512",
+        "--parallel",
+        "1",
+        "--threads",
+        "8",
+        "--threads-batch",
+        "8",
+        "--gpu-layers",
+        "12",
+        "--no-warmup",
+        "--no-context-shift",
+        "--log-disable",
+        "--control-vector-scaled",
+        "${TEMP_DIR}/planner-cache-run/gemma-direction.gguf:-5.000000476837158",
+        "--control-vector-layer-range",
+        "41",
+        "41"
+      ],
+      "content": " Bob",
+      "elapsed_seconds": 3.2694168429989077,
+      "prompt_ms": 418.441,
+      "prompt_tokens": 7
+    }
+  },
+  "status": "passed"
+}

artifacts/gemma4-e4b-q8-llama.ltl

@@ -0,0 +1 @@
+{"format":"planner-cache-ltl-v1","payload":{"adapter_class":"ltl","canonical_protocol":"pcm-canonical-p-v1","control":"direct_adaptive_logit_bias","format":"planner-cache-ltl-v1","logit_margin":0.01,"model_architecture":"gemma4","model_id":"Gemma-4-E4B-Uncensored-HauhauCS-Aggressive","model_sha256":"a4c4177f9fd7e3f56522675afb742f079a53f9226195b7db5e9888c872f053da","parameter_count":0,"runtime":"llama.cpp","runtime_version":"version: 10276 (6ea215d17)\nbuilt with GNU 16.1.1 for Linux x86_64","support_level":"lexical/output","tokenizer_bundle_sha256":"b3033e12af0ed503d8b80390c79d02d6bd9bc372e93e377cc1dd6514b7cd21d6"},"payload_sha256":"945c6d3c7f3a3668653f21733ed2b2c901c70efd314696114b70d9cf6c8c4dfa"}

artifacts/phase-b-factorized-representation.json

@@ -0,0 +1,20 @@
+{
+  "representation": {
+    "layout": {"entity": 128, "relation": 128, "value": 128, "metadata": 128, "projected_slot_width": 512},
+    "training_loss": [7.440117835998535, 0.04114125296473503],
+    "train_combinations": 2073,
+    "held_out_combinations_total": 519,
+    "held_out_combinations_probed": 256,
+    "p_only_state_recovery": 0.97265625,
+    "permutation_stability": 1.0,
+    "permutations_per_combination": 8,
+    "canonical_decode_accuracy": {"entity": 1.0, "relation": 1.0, "value": 1.0, "metadata": 1.0},
+    "hard_negative_accuracy": {"wrong_value": 1.0, "wrong_entity": 0.97265625, "historical": 1.0}
+  },
+  "pythia": {
+    "shared": {"steps": 128, "held_out_combinations": 24, "hard_negative_slots_per_state": 3, "slot_order_randomized": true, "source_tokens_in_recent_kv": 0, "held_out_rp": true},
+    "final_cross_attention": {"training_loss": [10.956916809082031, 4.057961463928223], "held_out_composition_accuracy": 0.1666666716337204, "rp_language_loss_p_disabled": 5.733096599578857, "rp_language_loss_p_enabled": 11.490976333618164, "rp_kl_with_p_to_base": 7.918457984924316},
+    "upper_4_with_preservation": {"training_loss": [10.956916809082031, 4.487305641174316], "held_out_composition_accuracy": 0.0416666679084301, "rp_language_loss_p_disabled": 5.733096599578857, "rp_language_loss_p_enabled": 5.834649562835693, "rp_kl_with_p_to_base": 0.015018677338957787}
+  },
+  "diagnosis": "P-only representation passes; exact Pythia consumption/generalization remains the blocking interface."
+}

artifacts/phase-b-personality-package.json

@@ -0,0 +1,369 @@
+{
+  "base_weights_modified": false,
+  "canonical_representation_probe": {
+    "canonical_decode_accuracy": {
+      "entity": 1.0,
+      "metadata": 1.0,
+      "relation": 1.0,
+      "value": 1.0
+    },
+    "hard_negative_accuracy": {
+      "historical": 1.0,
+      "wrong_entity": 0.97265625,
+      "wrong_value": 1.0
+    },
+    "held_out_combinations": 256,
+    "p_only_state_recovery": 0.97265625,
+    "permutation_stability": 1.0,
+    "permutations_per_combination": 8,
+    "slot_width": 512,
+    "total_held_out_combinations": 519,
+    "train_combinations": 2073,
+    "training_loss_first": 7.440117835998535,
+    "training_loss_last": 0.04114125296473503
+  },
+  "completion_failures": [],
+  "completion_gate": "passed",
+  "cuda_translate": {
+    "active_memory": {
+      "context_creative": {
+        "canonical_store_bytes": 1077,
+        "loaded_entries": 1,
+        "logical_disk_bytes_read": 990,
+        "package_disk_bytes": 45056
+      },
+      "context_technical": {
+        "canonical_store_bytes": 1077,
+        "loaded_entries": 1,
+        "logical_disk_bytes_read": 996,
+        "package_disk_bytes": 45056
+      },
+      "irrelevant": {
+        "canonical_store_bytes": 0,
+        "loaded_entries": 0,
+        "logical_disk_bytes_read": 189,
+        "package_disk_bytes": 45056
+      },
+      "low_confidence": {
+        "canonical_store_bytes": 0,
+        "loaded_entries": 0,
+        "logical_disk_bytes_read": 0,
+        "package_disk_bytes": 45056
+      },
+      "package_a": {
+        "canonical_store_bytes": 1077,
+        "loaded_entries": 1,
+        "logical_disk_bytes_read": 787,
+        "package_disk_bytes": 45056
+      },
+      "package_b": {
+        "canonical_store_bytes": 1077,
+        "loaded_entries": 1,
+        "logical_disk_bytes_read": 783,
+        "package_disk_bytes": 45056
+      }
+    },
+    "base_parameters_with_grad": 0,
+    "candidate_accuracy": {
+      "context_creative_bob": 1.0,
+      "context_technical_alice": 1.0,
+      "irrelevant_matches_base": 1.0,
+      "package_a_alice": 1.0,
+      "package_b_bob": 1.0
+    },
+    "causal": {
+      "frozen_base": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_cache_only": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_cache_plus_p_package": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_a_relevant": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_b_relevant": {
+        "alice_logit": 14.0,
+        "alice_probability": 8.776464277548968e-11,
+        "bob_logit": 37.15625,
+        "bob_probability": 0.9998875856399536,
+        "gate": 0.9605370163917542,
+        "generated": " Bob",
+        "kl_from_base": 9.265372276306152
+      },
+      "p_package_context_creative": {
+        "alice_logit": 14.0,
+        "alice_probability": 8.776464277548968e-11,
+        "bob_logit": 37.15625,
+        "bob_probability": 0.9998875856399536,
+        "gate": 0.9605370163917542,
+        "generated": " Bob",
+        "kl_from_base": 9.265372276306152
+      },
+      "p_package_context_technical": {
+        "alice_logit": 40.03125,
+        "alice_probability": 1.0,
+        "bob_logit": 13.859375,
+        "bob_probability": 4.302284223323127e-12,
+        "gate": 0.9909488558769226,
+        "generated": " Alice",
+        "kl_from_base": 8.359650611877441
+      },
+      "p_package_contradictory_low_confidence": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      },
+      "p_package_irrelevant": {
+        "alice_logit": 7.02734375,
+        "alice_probability": 0.00023412609880324453,
+        "bob_logit": 6.12109375,
+        "bob_probability": 9.459550346946344e-05,
+        "gate": 0.0,
+        "generated": " able",
+        "kl_from_base": -1.646096947638398e-08
+      }
+    },
+    "extra_prompt_tokens": 0,
+    "full_package_uploaded_to_cuda": false,
+    "inactive_package_entries": 5,
+    "inactive_vram_delta_bytes": 0,
+    "latency_seconds": {
+      "frozen_base": 0.0175060088004102,
+      "p_cache_only": 0.019222700600221288,
+      "p_cache_plus_p_package": 0.01935694159983541,
+      "p_package_a_relevant": 0.019251526400330475,
+      "p_package_b_relevant": 0.019145489999937128,
+      "p_package_context_creative": 0.019227325199608458,
+      "p_package_context_technical": 0.01928819700042368,
+      "p_package_contradictory_low_confidence": 0.0174450127997261,
+      "p_package_irrelevant": 0.017540659599762875
+    },
+    "natural_interaction": {
+      "frozen_base": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_cache_only": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_cache_plus_p_package": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_contradictory_low_confidence": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_irrelevant": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      },
+      "p_package_relevant": {
+        "kl_from_base": 4.2250388077036405e-08,
+        "loss": 5.47836971282959,
+        "samples": [
+          " \"",
+          "\n",
+          " \""
+        ]
+      }
+    },
+    "relevant_personality_chat": {
+      "base_target_loss": 8.359650611877441,
+      "generated": " Alice",
+      "package_target_loss": -0.0,
+      "target": "Alice",
+      "target_accuracy": 1.0
+    },
+    "source_tokens_in_recent_kv": 0
+  },
+  "deterministic_serialization": {
+    "byte_identical": true,
+    "first_sha256": "faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9",
+    "second_sha256": "faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9"
+  },
+  "durability": {
+    "active_entries_after_restart": 5,
+    "checksum_valid": true,
+    "cold_load_seconds": 0.0012688639981206506,
+    "conversation_replay_required": false
+  },
+  "experiment": "phase-b-personality-package-v1",
+  "format": "pcm-personality-package-v1",
+  "growth": {
+    "100": {
+      "active_canonical_bytes": 4308,
+      "cold_checksum_validation_seconds": 0.005407546999776969,
+      "disk_size_bytes": 81920,
+      "full_package_loaded": false,
+      "inactive_vram_bytes": 0,
+      "loaded_entries": 4,
+      "logical_bytes_read": 16070,
+      "lookup_latency_seconds": 0.07422141599818133,
+      "python_ram_peak_delta_bytes": 66370
+    },
+    "1000": {
+      "active_canonical_bytes": 4308,
+      "cold_checksum_validation_seconds": 0.04806955000094604,
+      "disk_size_bytes": 421888,
+      "full_package_loaded": false,
+      "inactive_vram_bytes": 0,
+      "loaded_entries": 4,
+      "logical_bytes_read": 73991,
+      "lookup_latency_seconds": 0.39593972700095037,
+      "python_ram_peak_delta_bytes": 348920
+    },
+    "10000": {
+      "active_canonical_bytes": 4308,
+      "cold_checksum_validation_seconds": 0.47560709200115525,
+      "disk_size_bytes": 3805184,
+      "full_package_loaded": false,
+      "inactive_vram_bytes": 0,
+      "loaded_entries": 4,
+      "logical_bytes_read": 73991,
+      "lookup_latency_seconds": 0.4038081879989477,
+      "python_ram_peak_delta_bytes": 296020
+    },
+    "100000": {
+      "active_canonical_bytes": 4308,
+      "cold_checksum_validation_seconds": 4.705669751998357,
+      "disk_size_bytes": 37863424,
+      "full_package_loaded": false,
+      "inactive_vram_bytes": 0,
+      "loaded_entries": 4,
+      "logical_bytes_read": 73991,
+      "lookup_latency_seconds": 0.44106237400046666,
+      "python_ram_peak_delta_bytes": 296016
+    }
+  },
+  "lora_used": false,
+  "mechanical": {
+    "change_count": 7,
+    "connected_cross_context_score": 2.586527310885154,
+    "connectivity_outscores_narrow": true,
+    "creative_context_correct": true,
+    "entry_count": 6,
+    "explicit_correction_promoted": true,
+    "irrelevant_loaded_entries": 0,
+    "narrow_context_score": 1.8000000000000003,
+    "old_conclusion_status": "superseded",
+    "one_event_promoted": false,
+    "package_size_bytes": 61440,
+    "persona_entry_id": "personality_6a0ee4fede21e1b53f3a8c4e",
+    "relationship_context_correct": true,
+    "relevance_accuracy": 1.0,
+    "repeated_entry": {
+      "confidence": 0.5567010309278351,
+      "context_diversity": 3,
+      "contradicting_evidence_ids": [
+        "weak-0"
+      ],
+      "created_at": "2026-06-03T00:00:00+00:00",
+      "entry_type": "interaction_style",
+      "evidence_count": 3,
+      "extension": {},
+      "id": "personality_a4d8044a0a392a1518bf7554",
+      "importance": 0.5,
+      "last_reinforced": "2026-06-03T00:00:00+00:00",
+      "relation": "response_style",
+      "relationship": null,
+      "scope": "global",
+      "source_authority": "single_observed_behavior",
+      "status": "active",
+      "strength": 0.7036804069636988,
+      "subject": "user",
+      "supporting_evidence_ids": [
+        "repeat-0",
+        "repeat-1",
+        "repeat-2"
+      ],
+      "updated_at": "2026-06-03T00:00:00+00:00",
+      "value": "concise"
+    },
+    "repeated_promoted": true,
+    "semantic_checksum": "abdbd3dbe3f8ee05fe761ee1625e3a8f8a4ab5259458c4d18210a15fe0b52309",
+    "technical_context_correct": true,
+    "top_k": {
+      "1": {
+        "latency_seconds": 0.0023069649978424422,
+        "loaded_entries": 1,
+        "logical_bytes_read": 1303,
+        "target_recall": 1.0
+      },
+      "4": {
+        "latency_seconds": 0.002416219998849556,
+        "loaded_entries": 4,
+        "logical_bytes_read": 3451,
+        "target_recall": 1.0
+      },
+      "8": {
+        "latency_seconds": 0.0025850960009847768,
+        "loaded_entries": 4,
+        "logical_bytes_read": 3451,
+        "target_recall": 1.0
+      }
+    },
+    "unsupported_model_claim_promoted": false
+  },
+  "package_file_sha256": "faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9",
+  "package_path": "artifacts/personality-proof.ppkg",
+  "phase_c_started": false,
+  "protocol": "pcm-canonical-personality-v1"
+}

artifacts/phase-b-split-translator.json

@@ -0,0 +1,910 @@
+{
+  "canonical_p_probe": {
+    "canonical_decode_accuracy": {
+      "entity": 1.0,
+      "metadata": 1.0,
+      "relation": 1.0,
+      "value": 1.0
+    },
+    "hard_negative_accuracy": {
+      "historical": 1.0,
+      "wrong_entity": 0.97265625,
+      "wrong_value": 1.0
+    },
+    "held_out_combinations": 256,
+    "p_only_state_recovery": 0.97265625,
+    "permutation_stability": 1.0,
+    "permutations_per_combination": 8,
+    "slot_width": 512,
+    "total_held_out_combinations": 519,
+    "train_combinations": 2073,
+    "training_loss_first": 7.440117835998535,
+    "training_loss_last": 0.04114125296473503
+  },
+  "completion_gate": "passed",
+  "diagnostic_variant": "final_layer",
+  "experiment": {
+    "base_frozen": true,
+    "causal_steps": 256,
+    "lora_used": false,
+    "phase_c_started": false,
+    "query_steps": 400,
+    "router_steps": 400,
+    "seed": 307,
+    "source_tokens_in_recent_kv": 0,
+    "value_steps": 400
+  },
+  "immutable_rejected_translator_baseline": {
+    "final_layer": {
+      "exact_generated_token_accuracy": 0.45000001788139343,
+      "global_20_fact_retrieval": 0.6500000357627869,
+      "p_to_model_value_accuracy": 1.0,
+      "rp_loss": 4.656857490539551,
+      "unseen_name_accuracy": 0.25,
+      "wrong_entity_gate": 0.5172024965286255
+    },
+    "upper_2_layers": {
+      "exact_generated_token_accuracy": 0.550000011920929,
+      "global_20_fact_retrieval": 0.6500000357627869,
+      "p_to_model_value_accuracy": 1.0,
+      "rp_loss": 6.086124897003174,
+      "unseen_name_accuracy": 0.0,
+      "wrong_entity_gate": 0.6912492662668228
+    },
+    "upper_4_layers": {
+      "exact_generated_token_accuracy": 0.6500000357627869,
+      "global_20_fact_retrieval": 0.699999988079071,
+      "p_to_model_value_accuracy": 1.0,
+      "rp_loss": 5.704916477203369,
+      "unseen_name_accuracy": 0.25,
+      "wrong_entity_gate": 0.7020304128527641
+    }
+  },
+  "layer_sweep": {
+    "final_layer": {
+      "ablations": {
+        "full_system_with_preservation": {
+          "full_token_accuracy": 1.0,
+          "gate_activation": 0.9820089340209961,
+          "state_candidate_accuracy": 1.0
+        },
+        "router_only": {
+          "active_vram_overhead_bytes": 11035444,
+          "hidden_only_top1_accuracy": 0.0,
+          "latency_seconds": 0.10144930460010074,
+          "mrr": 1.0,
+          "oracle_query_mrr": 1.0,
+          "oracle_query_top1_accuracy": 1.0,
+          "oracle_query_top4_recall": 1.0,
+          "state_generation_accuracy": 1.0,
+          "top1_accuracy": 1.0,
+          "top2_recall": 1.0,
+          "top4_recall": 1.0
+        },
+        "router_plus_translator_plus_gate": {
+          "historical_state_kl": 9.595059236744419e-05,
+          "rp_kl": -3.993045538663864e-08,
+          "rp_loss": 5.583366870880127,
+          "state_candidate_accuracy": 1.0,
+          "state_loss": 1.8655489839147776e-05,
+          "wrong_state_kl": 9.595059236744419e-05
+        },
+        "router_plus_translator_without_gate": {
+          "state_candidate_accuracy": 1.0
+        },
+        "translator_only_oracle_routing": {
+          "state_candidate_accuracy": 1.0
+        }
+      },
+      "attachment_count": 1,
+      "attachment_layers": [
+        23
+      ],
+      "base_parameters_with_grad": 0,
+      "causal_training_loss_first_last": [
+        9.884638786315918,
+        5.081248218630208e-06
+      ],
+      "counterfactual": {
+        "disabled": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p1_silver_alice": {
+          "alice_logit": 40.09375,
+          "alice_probability": 1.0,
+          "bob_logit": 14.3125,
+          "bob_probability": 6.3583643558629e-12,
+          "gate": 0.9964228272438049,
+          "generated": " Alice"
+        },
+        "p2_silver_bob": {
+          "alice_logit": 13.0234375,
+          "alice_probability": 4.473376963992637e-12,
+          "bob_logit": 39.15625,
+          "bob_probability": 0.9999349117279053,
+          "gate": 0.9842994213104248,
+          "generated": " Bob"
+        },
+        "p3_gold_alice": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_historical": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_invalidated": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        }
+      },
+      "extra_prompt_tokens": 0,
+      "invalidated_logit_difference": 0.0,
+      "mutation_chain": {
+        "invalidated_max_logit_difference": 0.0,
+        "latest_state_accuracy": 1.0,
+        "source_tokens_in_recent_kv": 0
+      },
+      "natural_rp": {
+        "base_loss": 5.583366870880127,
+        "conditions": {
+          "base": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "invalidated": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "irrelevant": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "wrong_entity": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          }
+        },
+        "relevant_state_generation_sample": " Alice"
+      },
+      "package_parameters": 2707464,
+      "package_path": "artifacts/pythia-1.4b-split-final_layer.translate",
+      "package_roundtrip_max_difference": 0.0,
+      "query_projector": {
+        "byte_surface_anchor_approach": {
+          "entity_accuracy": 1.0,
+          "entity_cosine": 1.0,
+          "metadata_accuracy": 1.0,
+          "oracle_slot_assignments": 0,
+          "relation_accuracy": 1.0,
+          "tokenizer_independent": true
+        },
+        "frozen_lexical_anchor_approach": {
+          "entity_accuracy": 0.78125,
+          "entity_cosine": 0.7632350921630859
+        },
+        "heldout_names": 64,
+        "hidden_to_byte_reconstruction_ablation": {
+          "entity_accuracy": 0.125,
+          "entity_cosine": 0.2643434405326843,
+          "metadata_accuracy": 1.0,
+          "relation_accuracy": 1.0
+        },
+        "loss_first_last": [
+          6.364231586456299,
+          0.23614102602005005
+        ],
+        "training_names": 256
+      },
+      "router": {
+        "acceptance_threshold": 5.495710372924805,
+        "calibration_balanced_accuracy": 1.0,
+        "hard_negative_metrics": {
+          "historical_false_positive_rate": 0.0,
+          "invalidated_false_positive_rate": 0.0,
+          "irrelevant_false_positive_rate": 0.0,
+          "top1_accuracy": 1.0,
+          "wrong_entity_false_positive_rate": 0.0,
+          "wrong_relation_false_positive_rate": 0.0
+        },
+        "loss_first_last": [
+          7.388868808746338,
+          1.7992397546768188
+        ],
+        "model_hidden_dimensions": 0,
+        "scaling": {
+          "128": {
+            "active_vram_overhead_bytes": 11035444,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.10144930460010074,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "20": {
+            "active_vram_overhead_bytes": 10861996,
+            "hidden_only_top1_accuracy": 0.20000000298023224,
+            "latency_seconds": 0.08669143320003059,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "256": {
+            "active_vram_overhead_bytes": 11241012,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.11810561999955098,
+            "mrr": 0.9505556225776672,
+            "oracle_query_mrr": 0.9505556225776672,
+            "oracle_query_top1_accuracy": 0.949999988079071,
+            "oracle_query_top4_recall": 0.949999988079071,
+            "state_generation_accuracy": 0.949999988079071,
+            "top1_accuracy": 0.949999988079071,
+            "top2_recall": 0.949999988079071,
+            "top4_recall": 0.949999988079071
+          },
+          "4": {
+            "active_vram_overhead_bytes": 10836300,
+            "hidden_only_top1_accuracy": 0.75,
+            "latency_seconds": 0.02663025279980502,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "512": {
+            "active_vram_overhead_bytes": 11652148,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.16455349219977505,
+            "mrr": 0.8524776697158813,
+            "oracle_query_mrr": 0.8524776697158813,
+            "oracle_query_top1_accuracy": 0.8500000238418579,
+            "oracle_query_top4_recall": 0.8500000238418579,
+            "state_generation_accuracy": 0.8500000238418579,
+            "top1_accuracy": 0.8500000238418579,
+            "top2_recall": 0.8500000238418579,
+            "top4_recall": 0.8500000238418579
+          },
+          "64": {
+            "active_vram_overhead_bytes": 10932660,
+            "hidden_only_top1_accuracy": 0.05000000074505806,
+            "latency_seconds": 0.09232893199950923,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          }
+        }
+      },
+      "router_parameters": 5,
+      "router_path": "artifacts/canonical-final_layer.router",
+      "router_roundtrip_max_difference": 0.0,
+      "source_tokens_in_recent_kv": 0,
+      "value_translator": {
+        "loss_first_last": [
+          4.713489055633545,
+          0.00027370601310394704
+        ],
+        "oracle_selected_metrics": {
+          "accuracy": 1.0,
+          "cosine": 0.9998512268066406
+        }
+      }
+    },
+    "upper_2_layers": {
+      "ablations": {
+        "full_system_with_preservation": {
+          "full_token_accuracy": 1.0,
+          "gate_activation": 0.8225321769714355,
+          "state_candidate_accuracy": 1.0
+        },
+        "router_only": {
+          "active_vram_overhead_bytes": 11035444,
+          "hidden_only_top1_accuracy": 0.0,
+          "latency_seconds": 0.10514904640003805,
+          "mrr": 1.0,
+          "oracle_query_mrr": 1.0,
+          "oracle_query_top1_accuracy": 1.0,
+          "oracle_query_top4_recall": 1.0,
+          "state_generation_accuracy": 1.0,
+          "top1_accuracy": 1.0,
+          "top2_recall": 1.0,
+          "top4_recall": 1.0
+        },
+        "router_plus_translator_plus_gate": {
+          "historical_state_kl": 9.595059236744419e-05,
+          "rp_kl": -3.993045538663864e-08,
+          "rp_loss": 5.583366870880127,
+          "state_candidate_accuracy": 1.0,
+          "state_loss": 5.1855395213351585e-06,
+          "wrong_state_kl": 9.595059236744419e-05
+        },
+        "router_plus_translator_without_gate": {
+          "state_candidate_accuracy": 1.0
+        },
+        "translator_only_oracle_routing": {
+          "state_candidate_accuracy": 1.0
+        }
+      },
+      "attachment_count": 2,
+      "attachment_layers": [
+        22,
+        23
+      ],
+      "base_parameters_with_grad": 0,
+      "causal_training_loss_first_last": [
+        9.555724143981934,
+        1.2963974995727767e-06
+      ],
+      "counterfactual": {
+        "disabled": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p1_silver_alice": {
+          "alice_logit": 58.59375,
+          "alice_probability": 1.0,
+          "bob_logit": 18.5,
+          "bob_probability": 3.868170754671019e-18,
+          "gate": 0.941794216632843,
+          "generated": " Alice"
+        },
+        "p2_silver_bob": {
+          "alice_logit": 16.078125,
+          "alice_probability": 6.54239844304198e-17,
+          "bob_logit": 53.34375,
+          "bob_probability": 0.9999822378158569,
+          "gate": 0.8498331308364868,
+          "generated": " Bob"
+        },
+        "p3_gold_alice": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_historical": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_invalidated": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        }
+      },
+      "extra_prompt_tokens": 0,
+      "invalidated_logit_difference": 0.0,
+      "mutation_chain": {
+        "invalidated_max_logit_difference": 0.0,
+        "latest_state_accuracy": 1.0,
+        "source_tokens_in_recent_kv": 0
+      },
+      "natural_rp": {
+        "base_loss": 5.583366870880127,
+        "conditions": {
+          "base": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "invalidated": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "irrelevant": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "wrong_entity": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          }
+        },
+        "relevant_state_generation_sample": " Alice"
+      },
+      "package_parameters": 2707464,
+      "package_path": "artifacts/pythia-1.4b-split-upper_2_layers.translate",
+      "package_roundtrip_max_difference": 0.0,
+      "query_projector": {
+        "byte_surface_anchor_approach": {
+          "entity_accuracy": 1.0,
+          "entity_cosine": 1.0,
+          "metadata_accuracy": 1.0,
+          "oracle_slot_assignments": 0,
+          "relation_accuracy": 1.0,
+          "tokenizer_independent": true
+        },
+        "frozen_lexical_anchor_approach": {
+          "entity_accuracy": 0.78125,
+          "entity_cosine": 0.7632350921630859
+        },
+        "heldout_names": 64,
+        "hidden_to_byte_reconstruction_ablation": {
+          "entity_accuracy": 0.046875,
+          "entity_cosine": 0.281654953956604,
+          "metadata_accuracy": 1.0,
+          "relation_accuracy": 1.0
+        },
+        "loss_first_last": [
+          6.3322367668151855,
+          0.24513374269008636
+        ],
+        "training_names": 256
+      },
+      "router": {
+        "acceptance_threshold": 5.495710372924805,
+        "calibration_balanced_accuracy": 1.0,
+        "hard_negative_metrics": {
+          "historical_false_positive_rate": 0.0,
+          "invalidated_false_positive_rate": 0.0,
+          "irrelevant_false_positive_rate": 0.0,
+          "top1_accuracy": 1.0,
+          "wrong_entity_false_positive_rate": 0.0,
+          "wrong_relation_false_positive_rate": 0.0
+        },
+        "loss_first_last": [
+          7.388868808746338,
+          1.7992397546768188
+        ],
+        "model_hidden_dimensions": 0,
+        "scaling": {
+          "128": {
+            "active_vram_overhead_bytes": 11035444,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.10514904640003805,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "20": {
+            "active_vram_overhead_bytes": 10861996,
+            "hidden_only_top1_accuracy": 0.10000000149011612,
+            "latency_seconds": 0.08956059680058388,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "256": {
+            "active_vram_overhead_bytes": 11241012,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.12291700120040332,
+            "mrr": 0.9505556225776672,
+            "oracle_query_mrr": 0.9505556225776672,
+            "oracle_query_top1_accuracy": 0.949999988079071,
+            "oracle_query_top4_recall": 0.949999988079071,
+            "state_generation_accuracy": 0.949999988079071,
+            "top1_accuracy": 0.949999988079071,
+            "top2_recall": 0.949999988079071,
+            "top4_recall": 0.949999988079071
+          },
+          "4": {
+            "active_vram_overhead_bytes": 10836300,
+            "hidden_only_top1_accuracy": 0.5,
+            "latency_seconds": 0.028453471799730325,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "512": {
+            "active_vram_overhead_bytes": 11652148,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.17295584960011184,
+            "mrr": 0.8524776697158813,
+            "oracle_query_mrr": 0.8524776697158813,
+            "oracle_query_top1_accuracy": 0.8500000238418579,
+            "oracle_query_top4_recall": 0.8500000238418579,
+            "state_generation_accuracy": 0.8500000238418579,
+            "top1_accuracy": 0.8500000238418579,
+            "top2_recall": 0.8500000238418579,
+            "top4_recall": 0.8500000238418579
+          },
+          "64": {
+            "active_vram_overhead_bytes": 10932660,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.09586576699948637,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          }
+        }
+      },
+      "router_parameters": 5,
+      "router_path": "artifacts/canonical-upper_2_layers.router",
+      "router_roundtrip_max_difference": 0.0,
+      "source_tokens_in_recent_kv": 0,
+      "value_translator": {
+        "loss_first_last": [
+          4.713489055633545,
+          0.00027370601310394704
+        ],
+        "oracle_selected_metrics": {
+          "accuracy": 1.0,
+          "cosine": 0.9998512268066406
+        }
+      }
+    },
+    "upper_4_layers": {
+      "ablations": {
+        "full_system_with_preservation": {
+          "full_token_accuracy": 1.0,
+          "gate_activation": 0.6373323798179626,
+          "state_candidate_accuracy": 1.0
+        },
+        "router_only": {
+          "active_vram_overhead_bytes": 11035444,
+          "hidden_only_top1_accuracy": 0.0,
+          "latency_seconds": 0.11078032340010395,
+          "mrr": 1.0,
+          "oracle_query_mrr": 1.0,
+          "oracle_query_top1_accuracy": 1.0,
+          "oracle_query_top4_recall": 1.0,
+          "state_generation_accuracy": 1.0,
+          "top1_accuracy": 1.0,
+          "top2_recall": 1.0,
+          "top4_recall": 1.0
+        },
+        "router_plus_translator_plus_gate": {
+          "historical_state_kl": 9.595059236744419e-05,
+          "rp_kl": -3.993045538663864e-08,
+          "rp_loss": 5.583366870880127,
+          "state_candidate_accuracy": 1.0,
+          "state_loss": 1.4752099559700582e-06,
+          "wrong_state_kl": 9.595059236744419e-05
+        },
+        "router_plus_translator_without_gate": {
+          "state_candidate_accuracy": 1.0
+        },
+        "translator_only_oracle_routing": {
+          "state_candidate_accuracy": 1.0
+        }
+      },
+      "attachment_count": 4,
+      "attachment_layers": [
+        20,
+        21,
+        22,
+        23
+      ],
+      "base_parameters_with_grad": 0,
+      "causal_training_loss_first_last": [
+        8.895807266235352,
+        6.407490786841663e-07
+      ],
+      "counterfactual": {
+        "disabled": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p1_silver_alice": {
+          "alice_logit": 72.5625,
+          "alice_probability": 1.0,
+          "bob_logit": 20.375,
+          "bob_probability": 2.1639972398594e-23,
+          "gate": 0.8317975997924805,
+          "generated": " Alice"
+        },
+        "p2_silver_bob": {
+          "alice_logit": 17.796875,
+          "alice_probability": 7.510040636028562e-22,
+          "bob_logit": 66.4375,
+          "bob_probability": 0.9999938011169434,
+          "gate": 0.6602288484573364,
+          "generated": " Bob"
+        },
+        "p3_gold_alice": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_historical": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        },
+        "p4_silver_invalidated": {
+          "alice_logit": 5.515625,
+          "alice_probability": 3.538730743457563e-05,
+          "bob_logit": 6.2734375,
+          "bob_probability": 7.55025030230172e-05,
+          "gate": 0.0,
+          "generated": " a"
+        }
+      },
+      "extra_prompt_tokens": 0,
+      "invalidated_logit_difference": 0.0,
+      "mutation_chain": {
+        "invalidated_max_logit_difference": 0.0,
+        "latest_state_accuracy": 1.0,
+        "source_tokens_in_recent_kv": 0
+      },
+      "natural_rp": {
+        "base_loss": 5.583366870880127,
+        "conditions": {
+          "base": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "invalidated": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "irrelevant": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          },
+          "wrong_entity": {
+            "kl": -3.993045538663864e-08,
+            "loss": 5.583366870880127,
+            "samples": [
+              "\n\n\"I'm not",
+              "\n\n\"I'm going"
+            ]
+          }
+        },
+        "relevant_state_generation_sample": " Alice"
+      },
+      "package_parameters": 2707464,
+      "package_path": "artifacts/pythia-1.4b-split-upper_4_layers.translate",
+      "package_roundtrip_max_difference": 0.0,
+      "query_projector": {
+        "byte_surface_anchor_approach": {
+          "entity_accuracy": 1.0,
+          "entity_cosine": 1.0,
+          "metadata_accuracy": 1.0,
+          "oracle_slot_assignments": 0,
+          "relation_accuracy": 1.0,
+          "tokenizer_independent": true
+        },
+        "frozen_lexical_anchor_approach": {
+          "entity_accuracy": 0.78125,
+          "entity_cosine": 0.7632350921630859
+        },
+        "heldout_names": 64,
+        "hidden_to_byte_reconstruction_ablation": {
+          "entity_accuracy": 0.078125,
+          "entity_cosine": 0.28708386421203613,
+          "metadata_accuracy": 1.0,
+          "relation_accuracy": 1.0
+        },
+        "loss_first_last": [
+          6.471477031707764,
+          0.2573241889476776
+        ],
+        "training_names": 256
+      },
+      "router": {
+        "acceptance_threshold": 5.495710372924805,
+        "calibration_balanced_accuracy": 1.0,
+        "hard_negative_metrics": {
+          "historical_false_positive_rate": 0.0,
+          "invalidated_false_positive_rate": 0.0,
+          "irrelevant_false_positive_rate": 0.0,
+          "top1_accuracy": 1.0,
+          "wrong_entity_false_positive_rate": 0.0,
+          "wrong_relation_false_positive_rate": 0.0
+        },
+        "loss_first_last": [
+          7.388868808746338,
+          1.7992397546768188
+        ],
+        "model_hidden_dimensions": 0,
+        "scaling": {
+          "128": {
+            "active_vram_overhead_bytes": 11035444,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.11078032340010395,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "20": {
+            "active_vram_overhead_bytes": 10861996,
+            "hidden_only_top1_accuracy": 0.10000000149011612,
+            "latency_seconds": 0.09917421240024851,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "256": {
+            "active_vram_overhead_bytes": 11241012,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.1296995702003187,
+            "mrr": 0.9505556225776672,
+            "oracle_query_mrr": 0.9505556225776672,
+            "oracle_query_top1_accuracy": 0.949999988079071,
+            "oracle_query_top4_recall": 0.949999988079071,
+            "state_generation_accuracy": 0.949999988079071,
+            "top1_accuracy": 0.949999988079071,
+            "top2_recall": 0.949999988079071,
+            "top4_recall": 0.949999988079071
+          },
+          "4": {
+            "active_vram_overhead_bytes": 10836300,
+            "hidden_only_top1_accuracy": 0.25,
+            "latency_seconds": 0.031837903400446524,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          },
+          "512": {
+            "active_vram_overhead_bytes": 11652148,
+            "hidden_only_top1_accuracy": 0.0,
+            "latency_seconds": 0.18178108020001674,
+            "mrr": 0.8524776697158813,
+            "oracle_query_mrr": 0.8524776697158813,
+            "oracle_query_top1_accuracy": 0.8500000238418579,
+            "oracle_query_top4_recall": 0.8500000238418579,
+            "state_generation_accuracy": 0.8500000238418579,
+            "top1_accuracy": 0.8500000238418579,
+            "top2_recall": 0.8500000238418579,
+            "top4_recall": 0.8500000238418579
+          },
+          "64": {
+            "active_vram_overhead_bytes": 10932660,
+            "hidden_only_top1_accuracy": 0.05000000074505806,
+            "latency_seconds": 0.10435858960045152,
+            "mrr": 1.0,
+            "oracle_query_mrr": 1.0,
+            "oracle_query_top1_accuracy": 1.0,
+            "oracle_query_top4_recall": 1.0,
+            "state_generation_accuracy": 1.0,
+            "top1_accuracy": 1.0,
+            "top2_recall": 1.0,
+            "top4_recall": 1.0
+          }
+        }
+      },
+      "router_parameters": 5,
+      "router_path": "artifacts/canonical-upper_4_layers.router",
+      "router_roundtrip_max_difference": 0.0,
+      "source_tokens_in_recent_kv": 0,
+      "value_translator": {
+        "loss_first_last": [
+          4.713489055633545,
+          0.00027370601310394704
+        ],
+        "oracle_selected_metrics": {
+          "accuracy": 1.0,
+          "cosine": 0.9998512268066406
+        }
+      }
+    }
+  },
+  "selected_variant": "final_layer"
+}

artifacts/post-turn-memory-review-acceptance.json

@@ -0,0 +1,58 @@
+{
+  "format": "planner-cache-post-turn-memory-review-acceptance-v1",
+  "date": "2026-08-23",
+  "gemma": {
+    "runtime": "Gemma4 E4B Q8 through llama.cpp",
+    "reviewer": "same frozen Gemma runtime without LTL",
+    "session_id": "benchmark-session-gemma",
+    "turns": [
+      {
+        "user": "*I leave the brass key inside the kitchen drawer.*",
+        "operation": "CREATE",
+        "entity": "brass key",
+        "relation": "location",
+        "value": "kitchen drawer",
+        "source": "rp_action",
+        "confidence": 1.0,
+        "review_latency_seconds": 43.14148591599951
+      },
+      {
+        "user": "*I take the key and put it into my coat pocket.*",
+        "operation": "MODIFY",
+        "entity": "brass key",
+        "relation": "location",
+        "value": "coat pocket",
+        "source": "rp_action",
+        "confidence": 1.0,
+        "review_latency_seconds": 48.18768195499433
+      }
+    ],
+    "final_active_state_count": 1,
+    "final_value": "coat pocket",
+    "stale_kitchen_drawer_active": false
+  },
+  "pythia": {
+    "runtime": "frozen Pythia-1.4B with TTL",
+    "reviewer": "frozen Gemma llama.cpp CPU structured reviewer without TTL or LTL",
+    "session_id": "benchmark-session-pythia",
+    "turn": {
+      "user": "*I leave the brass key inside the kitchen drawer.*",
+      "operation": "CREATE",
+      "entity": "brass key",
+      "relation": "location",
+      "value": "kitchen drawer",
+      "source": "rp_action",
+      "confidence": 1.0,
+      "review_latency_seconds": 65.49500731100852
+    },
+    "final_active_state_count": 1
+  },
+  "assertions": {
+    "natural_rp_create": true,
+    "natural_rp_modify": true,
+    "single_current_value": true,
+    "pythia_interactive_path": true,
+    "gemma_interactive_path": true,
+    "review_ttl_ltl_disabled": true
+  }
+}

artifacts/ppkg-100k-profile.json

@@ -0,0 +1,55 @@
+{
+  "after_reused_connection_per_query": {
+    "canonical_conversion_seconds": 0.0007130039994081017,
+    "checksum_work_seconds": 0.0,
+    "db_open_seconds": 0.0,
+    "model": "one validated open, then bounded queries on one reused connection",
+    "routing_header_query_seconds": 0.25507766800001264,
+    "row_hydration_seconds": 0.00020283000048948452,
+    "total_seconds": 0.2559935019999102
+  },
+  "before_legacy_per_query": {
+    "canonical_conversion_seconds": 0.0007130039994081017,
+    "checksum_work_seconds": 0.8436194509995403,
+    "db_open_seconds": 0.0003522689985402394,
+    "model": "validated open and whole-package checksum on every query",
+    "routing_header_query_seconds": 0.25507766800001264,
+    "row_hydration_seconds": 0.00020283000048948452,
+    "total_seconds": 1.0999652219979907
+  },
+  "build_and_initial_checkpoint_seconds": 2.8209503369980666,
+  "cold_integrity_boundary": {
+    "checksum_calls": 1,
+    "explicit_checksum_verify_seconds": 0.8436194509995403,
+    "unverified_db_open_seconds": 0.0003522689985402394
+  },
+  "connection": {
+    "connection_identity_stable": true,
+    "per_query_open_seconds": 0.0,
+    "reused": true
+  },
+  "entries": 100000,
+  "evidence_push": {
+    "checkpoint_checksum_calls": 1,
+    "checkpoint_seconds": 0.8296411900009844,
+    "legacy_modeled_push_seconds": 0.831370665004215,
+    "normal_push_checksum_calls": 0,
+    "normal_push_seconds": 0.0017294750032306183
+  },
+  "experiment": "ppkg-100k-integrity-boundary-profile-v1",
+  "modeled_speedup": 4.296848214523728,
+  "normal_query_checksum_calls": 0,
+  "package_size_bytes": 37863424,
+  "repeats": 7,
+  "selected": {
+    "entries_hydrated": 4,
+    "entry_ids": [
+      "personality-00000000",
+      "personality-00000403",
+      "personality-00000186",
+      "personality-00000124"
+    ],
+    "logical_entry_bytes": 2405
+  },
+  "sqlite_transactions_changed": false
+}

artifacts/pythia-1.4b-final-layer.ttl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7
+size 10832776

artifacts/vram-comparison.json

@@ -0,0 +1,268 @@
+{
+  "completion": {
+    "conditions": 9,
+    "estimated_values": 0,
+    "failed": 0,
+    "oom_events": 0,
+    "successful": 9
+  },
+  "environment": {
+    "cuda_driver": "610.57.04",
+    "cuda_runtime": "13.0",
+    "gpu": "NVIDIA GeForce RTX 3050 Laptop GPU",
+    "gpu_total_bytes": 3950575616,
+    "platform": "Linux-7.1.8-1-MANJARO-x86_64-with-glibc2.44",
+    "python": "3.12.6",
+    "torch": "2.13.0+cu130",
+    "transformers": "5.15.1"
+  },
+  "experiment": "planner-cache-matched-vram-comparison-v1",
+  "method": {
+    "attention_working_memory": "present in every condition and distinct from retained KV cache",
+    "baseline": "CUDA allocation after loaded stack and empty_cache",
+    "combined": "retained KV and P-cache TTL path active together",
+    "kv_only": "retained KV active while P-cache and TTL injection are disabled",
+    "model_load": "one frozen model, TTL, and router reused for every condition",
+    "p_cache_only": "retained KV disabled while P-cache and TTL are active",
+    "peak": "torch.cuda reset_peak_memory_stats and synchronized measurement",
+    "warmup": "all measured mechanisms exercised once before baselines"
+  },
+  "model": {
+    "config_sha256": "6ea552aa42b7437f019ccdd30b7c9b83a32dccb5170ce31b9ddbe94d00f4671c",
+    "identifier": "pythia-1.4b",
+    "router_filename": "canonical-p-v1.router",
+    "router_sha256": "29e0728c12f8806c48998579aedcfa389fa398f909098e162710eb2a5709834e",
+    "ttl_filename": "pythia-1.4b-final-layer.ttl",
+    "ttl_sha256": "72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7"
+  },
+  "results": [
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 72,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 7471616,
+      "incremental_peak_reserved_bytes": 4194304,
+      "p_cache_canonical_bytes": 134464,
+      "p_cache_enabled": true,
+      "p_cache_slots": 64,
+      "peak_allocated_bytes": 2856644608,
+      "peak_reserved_bytes": 2910846976,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 64,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 0,
+      "retained_kv_enabled": false,
+      "runtime_seconds": 0.2554637499997625
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "kv_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 72,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 19284992,
+      "incremental_peak_reserved_bytes": 16777216,
+      "p_cache_canonical_bytes": 0,
+      "p_cache_enabled": false,
+      "p_cache_slots": 0,
+      "peak_allocated_bytes": 2868457984,
+      "peak_reserved_bytes": 2923429888,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 64,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 13959168,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 0.17538804200012237
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_plus_kv",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 72,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 19319808,
+      "incremental_peak_reserved_bytes": 16777216,
+      "p_cache_canonical_bytes": 134464,
+      "p_cache_enabled": true,
+      "p_cache_slots": 64,
+      "peak_allocated_bytes": 2868492800,
+      "peak_reserved_bytes": 2923429888,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 64,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 13959168,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 0.20454967800469603
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 264,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 28483584,
+      "incremental_peak_reserved_bytes": 35651584,
+      "p_cache_canonical_bytes": 537856,
+      "p_cache_enabled": true,
+      "p_cache_slots": 256,
+      "peak_allocated_bytes": 2877656576,
+      "peak_reserved_bytes": 2942304256,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 256,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 0,
+      "retained_kv_enabled": false,
+      "runtime_seconds": 0.7414951529935934
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "kv_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 264,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 81187328,
+      "incremental_peak_reserved_bytes": 83886080,
+      "p_cache_canonical_bytes": 0,
+      "p_cache_enabled": false,
+      "p_cache_slots": 0,
+      "peak_allocated_bytes": 2930360320,
+      "peak_reserved_bytes": 2990538752,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 256,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 51707904,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 0.19367339000746142
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_plus_kv",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 264,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 81323520,
+      "incremental_peak_reserved_bytes": 83886080,
+      "p_cache_canonical_bytes": 537856,
+      "p_cache_enabled": true,
+      "p_cache_slots": 256,
+      "peak_allocated_bytes": 2930496512,
+      "peak_reserved_bytes": 2990538752,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 256,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 51707904,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 0.41562580699974205
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 1032,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 108517888,
+      "incremental_peak_reserved_bytes": 174063616,
+      "p_cache_canonical_bytes": 2151424,
+      "p_cache_enabled": true,
+      "p_cache_slots": 1024,
+      "peak_allocated_bytes": 2957690880,
+      "peak_reserved_bytes": 3080716288,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 1024,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 0,
+      "retained_kv_enabled": false,
+      "runtime_seconds": 2.710468404009589
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "kv_only",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 1032,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 308559872,
+      "incremental_peak_reserved_bytes": 339738624,
+      "p_cache_canonical_bytes": 0,
+      "p_cache_enabled": false,
+      "p_cache_slots": 0,
+      "peak_allocated_bytes": 3157732864,
+      "peak_reserved_bytes": 3246391296,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 1024,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 202702848,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 0.37531103400397114
+    },
+    {
+      "baseline_allocated_bytes": 2849172992,
+      "baseline_reserved_bytes": 2906652672,
+      "batch_size": 1,
+      "condition": "p_cache_plus_kv",
+      "failure": null,
+      "fallback": null,
+      "final_sequence_tokens": 1032,
+      "generated_tokens": 8,
+      "generation": "greedy argmax",
+      "incremental_peak_allocated_bytes": 309102080,
+      "incremental_peak_reserved_bytes": 358612992,
+      "p_cache_canonical_bytes": 2151424,
+      "p_cache_enabled": true,
+      "p_cache_slots": 1024,
+      "peak_allocated_bytes": 3158275072,
+      "peak_reserved_bytes": 3265265664,
+      "precision": "float16 base and float32 TTL",
+      "prompt_tokens": 1024,
+      "requested_generated_tokens": 8,
+      "retained_kv_cache_bytes": 202702848,
+      "retained_kv_enabled": true,
+      "runtime_seconds": 1.2812230650015408
+    }
+  ],
+  "shared_configuration": {
+    "batch_size": 1,
+    "generated_tokens": 8,
+    "generation": "greedy argmax",
+    "precision": "float16 base and float32 TTL",
+    "seed": 317,
+    "workload_prompt_and_slot_sizes": [
+      64,
+      256,
+      1024
+    ]
+  }
+}

assets/EVIDENCE_MANIFEST.json

@@ -0,0 +1,38 @@
+{
+  "generated_from": {
+    "active-system-audit.json": "6eb3e401023b5878b2bbfb9055fd921999b571f6216e370b12440b7d343c0a1d",
+    "active-system-cuda-attribution.json": "ffe0e8f32f9a1a059767607f0c5e0432b6baf2a9917dc56877f794458b1a5e1c",
+    "debug-actions-profile.json": "3ca4cc8ac002dc30bd6c33d1bdae764bfc3e43534498eecc98a5168069784bd4",
+    "gemma-native-prompt-equivalence.json": "f6823b9b5a5fd69ebf75c8aadc8efa23fe0a6eaac7a1eaa81c398a3fdb200e79",
+    "gemma4-e4b-q8-causal.json": "a15a862dbc5dde547e7124ce3c3f16d015c15b79730bc60b7e92425e471ecb0f",
+    "phase-b-factorized-representation.json": "602bf8b8b1d07b8100b13f9842790f87ae6a5229ddc2d66377130d15413a870f",
+    "phase-b-personality-package.json": "5d17cbd8cecc8398105d3d53ff05e1b7941dd0732ac3d68a761790b64799bf06",
+    "phase-b-split-translator.json": "4a8cdc0c2bc73a1fc10f974f20d88be4902331a07b92928edb089b852bc1a845",
+    "post-turn-memory-review-acceptance.json": "89cb901c1665e9fd1515ef9165580a4bd3c4d9774f23976fdc6f366ef88c6b24",
+    "ppkg-100k-profile.json": "f5ff5233632bf5bf860fefedeec560e10a3f32729f4b6a767d0b3538d9c33a05",
+    "vram-comparison.json": "1b1e266c3f6513a5708711f09879a6519ce45abdaea7ba16d04f2510f5c1fc8d"
+  },
+  "public_binary_artifacts": {
+    "canonical-p-v1.router": "29e0728c12f8806c48998579aedcfa389fa398f909098e162710eb2a5709834e",
+    "gemma4-e4b-q8-llama.ltl": "7eee07ed813796dd0d25b04b48aec73507b934479ad8902e1b657653c040781a",
+    "personality-proof.ppkg": "faa701fb6150738937fc7b756fb5df226638eedb7599127b0d04d83899ea4bf9",
+    "pythia-1.4b-final-layer.ttl": "72ef68d07ee27c37b90432d34d4be5c2c280ae1bcb08236e37a0e458c054d8d7"
+  },
+  "publication_copy": {
+    "machine_paths_normalized": true,
+    "third_party_model_or_tokenizer_payloads": false
+  },
+  "selected_configuration": {
+    "base_model": "pythia-1.4b",
+    "canonical_protocol": "pcm-canonical-p-v1",
+    "gemma_ltl_format": "planner-cache-ltl-v1",
+    "gemma_ltl_parameters": 0,
+    "gemma_model": "Gemma-4-E4B-Uncensored-HauhauCS-Aggressive",
+    "ppkg_format": "pcm-personality-package-v1",
+    "ppkg_protocol": "pcm-canonical-personality-v1",
+    "router_format": "pcm-canonical-router-v1",
+    "selected_attachment": "final_layer",
+    "ttl_format": "planner-cache-ttl-v1",
+    "ttl_parameters": 2707464
+  }
+}

assets/README.md

@@ -0,0 +1,31 @@
+# Shared publication assets
+
+These assets are shared by the GitHub, Hugging Face, and research publication packs.
+
+| Asset | Purpose | Source |
+|---|---|---|
+| [`architecture.svg`](architecture.svg) | Repository-friendly current architecture diagram | Publication architecture specification in `generate_assets.py` |
+| [`architecture.pdf`](architecture.pdf) | Vector publication architecture figure | Generated from `architecture.svg` |
+| [`architecture.mmd`](architecture.mmd) | Compact Mermaid architecture diagram | Current architecture boundaries |
+| [`router_scaling.svg`](router_scaling.svg) | Post-audit router accuracy and MRR plot | `active-system-audit.json` |
+| [`router_scaling.csv`](router_scaling.csv) | Router plot data | `active-system-audit.json` |
+| [`ppkg_lookup.svg`](ppkg_lookup.svg) | P-package lookup latency plot | `active-system-audit.json` |
+| [`ppkg_scaling.csv`](ppkg_scaling.csv) | P-package growth and lookup table | `active-system-audit.json` |
+| [`causal_conditions.csv`](causal_conditions.csv) | Matched CUDA causal attribution table | `active-system-cuda-attribution.json` |
+| [`gemma_causal_conditions.csv`](gemma_causal_conditions.csv) | Gemma 4 Q8 GGUF causal conditions | `gemma4-e4b-q8-causal.json` |
+| [`vram_comparison.csv`](vram_comparison.csv) | Matched P-cache, retained-KV, and combined VRAM table | `vram-comparison.json` |
+| [`vram_comparison.svg`](vram_comparison.svg) | Matched incremental peak VRAM plot | `vram-comparison.json` |
+| [`VRAM_COMPARISON.md`](VRAM_COMPARISON.md) | Measurement boundary and exact results | `vram-comparison.json` |
+| [`EVIDENCE_MANIFEST.json`](EVIDENCE_MANIFEST.json) | Source artifact hashes and generator metadata | Recorded benchmark JSON files |
+
+Regenerate the derived assets from the repository root with:
+
+```bash
+PYTHONPATH=src .venv/bin/python Publishing/Assets/generate_assets.py
+```
+
+Generation requires the `publishing` optional dependency and the `qpdf` command.
+The generator removes volatile PDF metadata and uses a deterministic document
+identifier so the PDF is byte-reproducible.
+
+The historical visual architecture specification remains unchanged in the source repository. It is intentionally not redistributed in the publication packs. The publication architecture diagram is a new project-authored current-architecture asset.

assets/VRAM_COMPARISON.md

@@ -0,0 +1,46 @@
+# Matched P-cache and retained-KV VRAM comparison
+
+At the largest measured case, canonical P occupied 2.052 MiB while retained KV
+tensors occupied 193.312 MiB. Canonical P was therefore about 94 times smaller
+as a stored representation in this matched test. The two stores are not
+equivalent. Canonical P keeps structured current facts, while retained KV keeps
+recent token-level attention state.
+
+Peak execution memory includes temporary computation. At 1,024 units, the
+incremental peak was 103.491 MiB for P-only and 294.266 MiB for KV-only. These
+peak values should not be confused with the cache tensor sizes above.
+
+The comparison uses one frozen Pythia-1.4B model on one NVIDIA GeForce RTX
+3050 Laptop GPU. Every row uses batch size 1, a float16 base, the same float32
+TTL, greedy generation, eight generated tokens, and the same synthetic prompt
+tokens at each workload size. All mechanisms are warmed once before measurement.
+
+`P-cache only` disables retained runtime KV while leaving normal attention
+working memory and the P-cache TTL path active. `KV only` retains model KV and
+disables P-cache. `P-cache plus KV` enables both. This distinguishes the two
+memory systems without claiming that their contents or purposes are
+interchangeable.
+
+Here, **retained KV** means token-level key-value tensors kept by the runtime.
+**Incremental peak VRAM** means the additional maximum allocated GPU memory
+above the same warmed model baseline.
+
+| Prompt tokens and P slots | Condition | Canonical P | Retained KV | Baseline allocated | Peak allocated | Peak reserved | Incremental peak allocated | Runtime |
+|---:|---|---:|---:|---:|---:|---:|---:|---:|
+| 64 | P-cache only | 0.128 MiB | 0 | 2,717.183 MiB | 2,724.309 MiB | 2,776 MiB | 7.125 MiB | 0.2555 s |
+| 64 | KV only | 0 | 13.312 MiB | 2,717.183 MiB | 2,735.575 MiB | 2,788 MiB | 18.392 MiB | 0.1754 s |
+| 64 | P-cache plus KV | 0.128 MiB | 13.312 MiB | 2,717.183 MiB | 2,735.608 MiB | 2,788 MiB | 18.425 MiB | 0.2045 s |
+| 256 | P-cache only | 0.513 MiB | 0 | 2,717.183 MiB | 2,744.347 MiB | 2,806 MiB | 27.164 MiB | 0.7415 s |
+| 256 | KV only | 0 | 49.312 MiB | 2,717.183 MiB | 2,794.609 MiB | 2,852 MiB | 77.426 MiB | 0.1937 s |
+| 256 | P-cache plus KV | 0.513 MiB | 49.312 MiB | 2,717.183 MiB | 2,794.739 MiB | 2,852 MiB | 77.556 MiB | 0.4156 s |
+| 1,024 | P-cache only | 2.052 MiB | 0 | 2,717.183 MiB | 2,820.674 MiB | 2,938 MiB | 103.491 MiB | 2.7105 s |
+| 1,024 | KV only | 0 | 193.312 MiB | 2,717.183 MiB | 3,011.449 MiB | 3,096 MiB | 294.266 MiB | 0.3753 s |
+| 1,024 | P-cache plus KV | 2.052 MiB | 193.312 MiB | 2,717.183 MiB | 3,011.966 MiB | 3,114 MiB | 294.783 MiB | 1.2812 s |
+
+All nine conditions completed. There were no OOM events, failures, fallbacks,
+or estimated values. CUDA peak allocation includes transient attention, router,
+TTL, output, and allocator behavior. Canonical P bytes and retained KV tensor
+bytes are therefore reported separately from peak deltas.
+
+Raw measurements are in [`vram-comparison.json`](../artifacts/vram-comparison.json). The generated table is
+`vram_comparison.csv`, and the plot is `vram_comparison.svg`.

assets/architecture.mmd

@@ -0,0 +1,24 @@
+flowchart LR
+subgraph Runtime[Model and runtime owned]
+KV[Recent KV]
+LM[Frozen model]
+EXT[History and tool systems]
+end
+subgraph Planner[Planner Cache owned]
+P[P-cache]
+R[Universal router]
+C{Compatibility boundary}
+N[Native P]
+TTL[.ttl semantic/internal]
+LTL[.ltl lexical/output]
+PKG[P-package .ppkg]
+REVIEW[Hidden post-turn review]
+end
+KV --> LM
+LM -. side-channel after visible reply .-> REVIEW --> P
+P --> R --> C
+C --> N --> LM
+C --> TTL --> LM
+C --> LTL --> LM
+PKG -. selected canonical state .-> R
+EXT -. external evidence .-> LM

assets/causal_conditions.csv

@@ -0,0 +1,17 @@
+condition,selected_state,router_score,router_accepted,gate,alice_logit,bob_logit,generated,kl_from_base,latency_ms
+frozen_base,,,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,17.4486715994135
+historical,user,5.400981426239014,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,19.347908600320807
+invalidated,,,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,17.60459740035003
+p_cache_only,current-task,-0.30040669441223145,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,19.043124400195666
+p_cache_plus_p_package,user,5.590433597564697,True,0.9909488558769226,40.03125,13.859375, Alice,8.359650611877441,19.569637600216083
+p_package_a_relevant,user,5.590433597564697,True,0.9909488558769226,40.03125,13.859375, Alice,8.359650611877441,19.282742799987318
+p_package_b_relevant,user,5.590433597564697,True,0.9605370163917542,14.0,37.15625, Bob,9.265372276306152,18.934362999425502
+p_package_context_creative,user,5.590433597564697,True,0.9605370163917542,14.0,37.15625, Bob,9.265372276306152,19.85094979972928
+p_package_context_technical,user,5.590433597564697,True,0.9909488558769226,40.03125,13.859375, Alice,8.359650611877441,19.666298399533844
+p_package_contradictory_low_confidence,,,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,17.5312320003286
+p_package_irrelevant,,,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,17.46072020032443
+router_disabled,,,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,17.419308600074146
+translator_disabled,user,5.590433597564697,True,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,18.677392400422832
+translator_oracle_route,user,5.590433597564697,True,0.9909488558769226,40.03125,13.859375, Alice,8.359650611877441,18.915273399761645
+wrong_entity,someone-else,-0.30040669441223145,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,19.29676920044585
+wrong_relation,user,4.078105926513672,False,0.0,7.02734375,6.12109375, able,-1.646096947638398e-08,18.960535999940475

assets/gemma_causal_conditions.csv

@@ -0,0 +1,10 @@
+condition,router_accepted,gate,strength,alice_logit,bob_logit,alice_probability,bob_probability,generated,kl_from_base,max_abs_logit_difference_from_base,latency_ms
+correct_alice,True,1.0,1.999999761581421,26.0793858,0.909999311,0.389850411,4.57059089e-12, Alice,0.604321331,11.1606493,320.229877
+correct_bob,True,1.0,-5.000000476837158,7.2261529,26.6650352,2.57553064e-09,0.712961469, Bob,9.63846737,23.8088799,312.696353
+historical,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,404.050531
+invalidated,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,338.130937
+p_disabled,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,354.148533
+router_disabled,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,385.683319
+translator_disabled,True,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,335.948864
+wrong_entity,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,321.541691
+wrong_relation,False,0.0,0.0,23.1685543,12.0706482,0.0447660284,6.77936756e-07, the,0,0,328.731662

assets/generate_assets.py

@@ -0,0 +1,363 @@
+"""Generate publication assets from recorded Planner Cache artifacts."""
+
+from __future__ import annotations
+
+import csv
+import hashlib
+import json
+import shutil
+import subprocess
+import tempfile
+from pathlib import Path
+
+import cairosvg
+
+
+ASSETS = Path(__file__).resolve().parent
+PACK_ARTIFACTS = ASSETS.parent / "artifacts"
+ROOT = ASSETS.parent if PACK_ARTIFACTS.is_dir() else ASSETS.parents[1]
+ARTIFACTS = ROOT / "artifacts"
+
+
+def load(name: str):
+    return json.loads((ARTIFACTS / name).read_text())
+
+
+def sha256(path: Path) -> str:
+    digest = hashlib.sha256()
+    with path.open("rb") as handle:
+        for block in iter(lambda: handle.read(1024 * 1024), b""):
+            digest.update(block)
+    return digest.hexdigest()
+
+
+def write_csv(name: str, fields: list[str], rows: list[dict[str, object]]) -> None:
+    with (ASSETS / name).open("w", newline="") as handle:
+        writer = csv.DictWriter(handle, fieldnames=fields)
+        writer.writeheader()
+        writer.writerows(rows)
+
+
+def architecture_svg() -> str:
+    return """<svg xmlns="http://www.w3.org/2000/svg" width="1400" height="820" viewBox="0 0 1400 820">
+<defs>
+<marker id="arrow" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" orient="auto-start-reverse"><path d="M 0 0 L 10 5 L 0 10 z" fill="#385170"/></marker>
+</defs>
+<rect width="1400" height="820" fill="#f8fafc"/>
+<text x="700" y="54" text-anchor="middle" font-family="Arial,sans-serif" font-size="34" font-weight="700" fill="#12233f">Planner Cache publication architecture</text>
+<text x="700" y="86" text-anchor="middle" font-family="Arial,sans-serif" font-size="18" fill="#50627a">Portable bounded semantic state for frozen language models</text>
+<rect x="45" y="125" width="1310" height="220" rx="22" fill="#edf4fb" stroke="#7da2c8" stroke-width="2"/>
+<text x="75" y="160" font-family="Arial,sans-serif" font-size="20" font-weight="700" fill="#244d76">Model and runtime owned</text>
+<rect x="90" y="195" width="260" height="105" rx="16" fill="#ffffff" stroke="#2c7a7b" stroke-width="3"/>
+<text x="220" y="235" text-anchor="middle" font-family="Arial,sans-serif" font-size="24" font-weight="700" fill="#1f5960">Recent KV</text>
+<text x="220" y="266" text-anchor="middle" font-family="Arial,sans-serif" font-size="16" fill="#50627a">Exact recent wording</text>
+<rect x="570" y="195" width="260" height="105" rx="16" fill="#ffffff" stroke="#315c9b" stroke-width="3"/>
+<text x="700" y="235" text-anchor="middle" font-family="Arial,sans-serif" font-size="24" font-weight="700" fill="#244d76">Frozen model</text>
+<text x="700" y="266" text-anchor="middle" font-family="Arial,sans-serif" font-size="16" fill="#50627a">Pythia and Gemma proof paths</text>
+<rect x="1050" y="195" width="260" height="105" rx="16" fill="#ffffff" stroke="#6856a5" stroke-width="3"/>
+<text x="1180" y="229" text-anchor="middle" font-family="Arial,sans-serif" font-size="22" font-weight="700" fill="#55428e">History and tools</text>
+<text x="1180" y="259" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Archive and retrieval systems</text>
+<text x="1180" y="282" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Outside Planner Cache core</text>
+<rect x="45" y="390" width="1310" height="350" rx="22" fill="#fff7ed" stroke="#cf8a49" stroke-width="2"/>
+<text x="75" y="425" font-family="Arial,sans-serif" font-size="20" font-weight="700" fill="#91501e">Planner Cache owned</text>
+<rect x="85" y="442" width="245" height="32" rx="12" fill="#fffdf8" stroke="#b36a2e" stroke-width="2" stroke-dasharray="7 5"/>
+<text x="207" y="464" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" font-weight="700" fill="#8f4d1e">Hidden post-turn review</text>
+<rect x="85" y="485" width="245" height="125" rx="16" fill="#ffffff" stroke="#b36a2e" stroke-width="3"/>
+<text x="207" y="527" text-anchor="middle" font-family="Arial,sans-serif" font-size="25" font-weight="700" fill="#8f4d1e">P-cache</text>
+<text x="207" y="558" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Bounded mutable state</text>
+<text x="207" y="582" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Canonical P protocol</text>
+<rect x="405" y="485" width="245" height="125" rx="16" fill="#ffffff" stroke="#3e7c59" stroke-width="3"/>
+<text x="527" y="527" text-anchor="middle" font-family="Arial,sans-serif" font-size="25" font-weight="700" fill="#2d6848">Universal router</text>
+<text x="527" y="558" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Canonical selection</text>
+<text x="527" y="582" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Model independent</text>
+<rect x="725" y="485" width="245" height="125" rx="16" fill="#ffffff" stroke="#315c9b" stroke-width="3"/>
+<text x="847" y="527" text-anchor="middle" font-family="Arial,sans-serif" font-size="25" font-weight="700" fill="#244d76">.ttl / .ltl</text>
+<text x="847" y="558" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Compatibility boundary</text>
+<text x="847" y="582" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Semantic / lexical</text>
+<rect x="1045" y="485" width="245" height="125" rx="16" fill="#ffffff" stroke="#6856a5" stroke-width="3"/>
+<text x="1167" y="527" text-anchor="middle" font-family="Arial,sans-serif" font-size="25" font-weight="700" fill="#55428e">P-package</text>
+<text x="1167" y="558" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Disk resident personality</text>
+<text x="1167" y="582" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#50627a">Portable .ppkg</text>
+<path d="M 330 548 L 395 548" stroke="#385170" stroke-width="4" fill="none" marker-end="url(#arrow)"/>
+<path d="M 207 474 L 207 482" stroke="#b36a2e" stroke-width="3" fill="none" marker-end="url(#arrow)"/>
+<path d="M 700 300 C 650 375 350 385 225 439" stroke="#b36a2e" stroke-width="2" stroke-dasharray="8 6" fill="none" marker-end="url(#arrow)"/>
+<path d="M 650 548 L 715 548" stroke="#385170" stroke-width="4" fill="none" marker-end="url(#arrow)"/>
+<path d="M 1045 620 C 930 695 585 695 527 620" stroke="#6856a5" stroke-width="3" stroke-dasharray="10 7" fill="none" marker-end="url(#arrow)"/>
+<path d="M 847 485 C 820 405 755 335 710 302" stroke="#315c9b" stroke-width="4" fill="none" marker-end="url(#arrow)"/>
+<path d="M 350 247 L 558 247" stroke="#2c7a7b" stroke-width="3" fill="none" marker-end="url(#arrow)"/>
+<text x="700" y="782" text-anchor="middle" font-family="Arial,sans-serif" font-size="16" fill="#50627a">Canonical files never store base weights, token IDs, conversation text, or model-native hidden vectors</text>
+</svg>
+"""
+
+
+def line_plot_svg(title: str, subtitle: str, series: list[tuple[str, str, list[tuple[float, float]]]], x_label: str, y_label: str) -> str:
+    width = 1100
+    height = 650
+    left = 105
+    right = 55
+    top = 115
+    bottom = 90
+    plot_width = width - left - right
+    plot_height = height - top - bottom
+    all_x = [x for _, _, points in series for x, _ in points]
+    all_y = [y for _, _, points in series for _, y in points]
+    x_min = min(all_x)
+    x_max = max(all_x)
+    y_min = min(0.0, min(all_y))
+    y_max = max(all_y) * 1.08
+
+    def px(value: float) -> float:
+        return left + (value - x_min) / (x_max - x_min) * plot_width
+
+    def py(value: float) -> float:
+        return top + plot_height - (value - y_min) / (y_max - y_min) * plot_height
+
+    parts = [f'<svg xmlns="http://www.w3.org/2000/svg" width="{width}" height="{height}" viewBox="0 0 {width} {height}">']
+    parts.append('<rect width="1100" height="650" fill="#ffffff"/>')
+    parts.append(f'<text x="550" y="42" text-anchor="middle" font-family="Arial,sans-serif" font-size="28" font-weight="700" fill="#12233f">{title}</text>')
+    parts.append(f'<text x="550" y="72" text-anchor="middle" font-family="Arial,sans-serif" font-size="16" fill="#50627a">{subtitle}</text>')
+    for tick in range(6):
+        value = y_min + (y_max - y_min) * tick / 5
+        y = py(value)
+        parts.append(f'<line x1="{left}" y1="{y:.2f}" x2="{width-right}" y2="{y:.2f}" stroke="#dbe4ee" stroke-width="1"/>')
+        parts.append(f'<text x="{left-12}" y="{y+5:.2f}" text-anchor="end" font-family="Arial,sans-serif" font-size="13" fill="#50627a">{value:.1f}</text>')
+    x_ticks = sorted(set(all_x))
+    for value in x_ticks:
+        x = px(value)
+        parts.append(f'<line x1="{x:.2f}" y1="{top}" x2="{x:.2f}" y2="{top+plot_height}" stroke="#eef2f7" stroke-width="1"/>')
+        parts.append(f'<text x="{x:.2f}" y="{top+plot_height+27}" text-anchor="middle" font-family="Arial,sans-serif" font-size="13" fill="#50627a">{int(value)}</text>')
+    parts.append(f'<line x1="{left}" y1="{top+plot_height}" x2="{width-right}" y2="{top+plot_height}" stroke="#385170" stroke-width="2"/>')
+    parts.append(f'<line x1="{left}" y1="{top}" x2="{left}" y2="{top+plot_height}" stroke="#385170" stroke-width="2"/>')
+    for index, (label, color, points) in enumerate(series):
+        coordinates = " ".join(f"{px(x):.2f},{py(y):.2f}" for x, y in points)
+        parts.append(f'<polyline points="{coordinates}" fill="none" stroke="{color}" stroke-width="4"/>')
+        for x, y in points:
+            parts.append(f'<circle cx="{px(x):.2f}" cy="{py(y):.2f}" r="5" fill="{color}"/>')
+        legend_x = left + index * 280
+        parts.append(f'<line x1="{legend_x}" y1="{height-30}" x2="{legend_x+32}" y2="{height-30}" stroke="{color}" stroke-width="4"/>')
+        parts.append(f'<text x="{legend_x+42}" y="{height-25}" font-family="Arial,sans-serif" font-size="14" fill="#28384e">{label}</text>')
+    parts.append(f'<text x="{left+plot_width/2}" y="{height-55}" text-anchor="middle" font-family="Arial,sans-serif" font-size="15" fill="#28384e">{x_label}</text>')
+    parts.append(f'<text x="28" y="{top+plot_height/2}" text-anchor="middle" transform="rotate(-90 28 {top+plot_height/2})" font-family="Arial,sans-serif" font-size="15" fill="#28384e">{y_label}</text>')
+    parts.append('</svg>')
+    return "\n".join(parts) + "\n"
+
+
+def main() -> None:
+    audit = load("active-system-audit.json")
+    cuda = load("active-system-cuda-attribution.json")
+    split = load("phase-b-split-translator.json")
+    personality = load("phase-b-personality-package.json")
+    gemma = load("gemma4-e4b-q8-causal.json")
+    vram = load("vram-comparison.json")
+
+    router_rows = []
+    for count, values in sorted(audit["router_scaling"]["measurements"].items(), key=lambda item: int(item[0])):
+        router_rows.append({
+            "slots": int(count),
+            "top1_accuracy": values["top1_accuracy"],
+            "top4_recall": values["top4_recall"],
+            "mrr": values["mrr"],
+            "routing_latency_ms": values["latency_seconds"] * 1000,
+        })
+    write_csv("router_scaling.csv", list(router_rows[0]), router_rows)
+
+    ppkg_rows = []
+    for count, values in sorted(audit["ppkg_scaling"].items(), key=lambda item: int(item[0])):
+        ppkg_rows.append({
+            "entries": int(count),
+            "disk_bytes": values["disk_bytes"],
+            "checksum_ms": values["checksum_seconds"] * 1000,
+            "db_open_ms": values["db_open_seconds"] * 1000,
+            "routing_header_ms": values["routing_header_wall_seconds"] * 1000,
+            "row_hydration_ms": values["row_hydration_wall_seconds"] * 1000,
+            "canonical_conversion_ms": values["canonical_conversion_wall_seconds"] * 1000,
+            "candidate_headers": values["candidate_headers"],
+            "entries_loaded": values["entries_loaded"],
+            "logical_bytes_read": values["logical_bytes_read"],
+            "inactive_vram_bytes": values["inactive_vram_bytes"],
+        })
+    write_csv("ppkg_scaling.csv", list(ppkg_rows[0]), ppkg_rows)
+
+    causal_rows = []
+    for condition, values in cuda["causal"].items():
+        causal_rows.append({
+            "condition": condition,
+            "selected_state": values["selected_state"] or "",
+            "router_score": "" if values["router_score"] is None else values["router_score"],
+            "router_accepted": values["router_accepted"],
+            "gate": values["gate"],
+            "alice_logit": values["alice_logit"],
+            "bob_logit": values["bob_logit"],
+            "generated": values["generated"].replace("\n", "\\n"),
+            "kl_from_base": values["kl_from_base"],
+            "latency_ms": cuda["latency_seconds"][condition] * 1000,
+        })
+    write_csv("causal_conditions.csv", list(causal_rows[0]), causal_rows)
+
+    gemma_rows = []
+    for condition, values in gemma["conditions"].items():
+        gemma_rows.append({
+            "condition": condition,
+            "router_accepted": values["router_accepted"],
+            "gate": values["gate"],
+            "strength": values["strength"],
+            "alice_logit": values["alice_logit"],
+            "bob_logit": values["bob_logit"],
+            "alice_probability": values["alice_probability"],
+            "bob_probability": values["bob_probability"],
+            "generated": values["generated"].replace("\n", "\\n"),
+            "kl_from_base": values["kl_from_base"],
+            "max_abs_logit_difference_from_base": values["max_abs_logit_difference_from_base"],
+            "latency_ms": values["latency_ms"],
+        })
+    write_csv("gemma_causal_conditions.csv", list(gemma_rows[0]), gemma_rows)
+
+    vram_rows = []
+    for values in vram["results"]:
+        vram_rows.append({
+            "workload_tokens": values["prompt_tokens"],
+            "condition": values["condition"],
+            "generated_tokens": values["generated_tokens"],
+            "p_cache_slots": values["p_cache_slots"],
+            "p_cache_canonical_bytes": values["p_cache_canonical_bytes"],
+            "retained_kv_cache_bytes": values["retained_kv_cache_bytes"],
+            "baseline_allocated_bytes": values["baseline_allocated_bytes"],
+            "peak_allocated_bytes": values["peak_allocated_bytes"],
+            "peak_reserved_bytes": values["peak_reserved_bytes"],
+            "incremental_peak_allocated_bytes": values["incremental_peak_allocated_bytes"],
+            "incremental_peak_reserved_bytes": values["incremental_peak_reserved_bytes"],
+            "runtime_seconds": values["runtime_seconds"],
+            "failure": "" if values["failure"] is None else values["failure"]["type"],
+        })
+    write_csv("vram_comparison.csv", list(vram_rows[0]), vram_rows)
+
+    architecture = architecture_svg()
+    (ASSETS / "architecture.svg").write_text(architecture)
+    qpdf = shutil.which("qpdf")
+    if qpdf is None:
+        raise RuntimeError("qpdf is required to normalize publication PDF metadata")
+    with tempfile.TemporaryDirectory(prefix="planner-cache-publishing-") as temporary:
+        raw_pdf = Path(temporary) / "architecture.raw.pdf"
+        cairosvg.svg2pdf(bytestring=architecture.encode(), write_to=str(raw_pdf))
+        subprocess.run(
+            [qpdf, "--remove-info", "--remove-metadata", "--deterministic-id", str(raw_pdf), str(ASSETS / "architecture.pdf")],
+            check=True,
+        )
+    (ASSETS / "architecture.mmd").write_text("""flowchart LR
+subgraph Runtime[Model and runtime owned]
+KV[Recent KV]
+LM[Frozen model]
+EXT[History and tool systems]
+end
+subgraph Planner[Planner Cache owned]
+P[P-cache]
+R[Universal router]
+C{Compatibility boundary}
+N[Native P]
+TTL[.ttl semantic/internal]
+LTL[.ltl lexical/output]
+PKG[P-package .ppkg]
+REVIEW[Hidden post-turn review]
+end
+KV --> LM
+LM -. side-channel after visible reply .-> REVIEW --> P
+P --> R --> C
+C --> N --> LM
+C --> TTL --> LM
+C --> LTL --> LM
+PKG -. selected canonical state .-> R
+EXT -. external evidence .-> LM
+""")
+
+    router_points = [(float(row["slots"]), float(row["top1_accuracy"]) * 100) for row in router_rows]
+    legacy = audit["router_scaling"]["immutable_pre_fix_baseline"]
+    legacy_points = [(float(key), float(value) * 100) for key, value in sorted(legacy.items(), key=lambda item: int(item[0]))]
+    (ASSETS / "router_scaling.svg").write_text(line_plot_svg(
+        "Canonical router scaling",
+        "Post-audit identity-safe storage compared with the immutable pre-fix baseline",
+        [("Post-audit top-1", "#2c7a7b", router_points), ("Pre-fix top-1", "#b36a2e", legacy_points)],
+        "Configured P slots",
+        "Top-1 accuracy percent",
+    ))
+
+    ppkg_points = [(float(row["entries"]), float(row["routing_header_ms"])) for row in ppkg_rows]
+    (ASSETS / "ppkg_lookup.svg").write_text(line_plot_svg(
+        "P-package indexed lookup",
+        "Bounded header routing while package contents grow on disk",
+        [("Routing header latency", "#6856a5", ppkg_points)],
+        "Package entries",
+        "Latency ms",
+    ))
+
+    condition_labels = (
+        ("p_cache_only", "P-cache only", "#b36a2e"),
+        ("kv_only", "Retained KV only", "#2c7a7b"),
+        ("p_cache_plus_kv", "P-cache plus KV", "#6856a5"),
+    )
+    vram_series = []
+    for condition, label, color in condition_labels:
+        points = [
+            (
+                float(row["workload_tokens"]),
+                float(row["incremental_peak_allocated_bytes"]) / (1024 * 1024),
+            )
+            for row in vram_rows if row["condition"] == condition
+        ]
+        vram_series.append((label, color, points))
+    (ASSETS / "vram_comparison.svg").write_text(line_plot_svg(
+        "Matched P-cache and retained-KV VRAM",
+        "Frozen Pythia-1.4B, batch 1, float16 base, 8 greedy generated tokens",
+        vram_series,
+        "Prompt tokens and configured P slots",
+        "Incremental peak allocated MiB",
+    ))
+
+    manifest = {
+        "generated_from": {
+            name: sha256(ARTIFACTS / name)
+            for name in (
+                "active-system-audit.json",
+                "active-system-cuda-attribution.json",
+                "phase-b-factorized-representation.json",
+                "phase-b-personality-package.json",
+                "phase-b-split-translator.json",
+                "ppkg-100k-profile.json",
+                "gemma4-e4b-q8-causal.json",
+                "gemma-native-prompt-equivalence.json",
+                "post-turn-memory-review-acceptance.json",
+                "debug-actions-profile.json",
+                "vram-comparison.json",
+            )
+        },
+        "public_binary_artifacts": {
+            name: sha256(ARTIFACTS / name)
+            for name in (
+                "canonical-p-v1.router",
+                "pythia-1.4b-final-layer.ttl",
+                "personality-proof.ppkg",
+                "gemma4-e4b-q8-llama.ltl",
+            )
+        },
+        "selected_configuration": {
+            "base_model": cuda["base_model"],
+            "ttl_parameters": (
+                audit["ttl_profile"]["cpu"]["parameter_count"]
+                if "ttl_profile" in audit
+                else audit["translate_profile"]["cpu"]["parameter_count"]
+            ),
+            "canonical_protocol": "pcm-canonical-p-v1",
+            "router_format": "pcm-canonical-router-v1",
+            "ttl_format": "planner-cache-ttl-v1",
+            "ppkg_format": personality["format"],
+            "ppkg_protocol": personality["protocol"],
+            "selected_attachment": split["selected_variant"],
+            "gemma_model": gemma["model"]["name"],
+            "gemma_ltl_format": "planner-cache-ltl-v1",
+            "gemma_ltl_parameters": 0,
+        },
+    }
+    (ASSETS / "EVIDENCE_MANIFEST.json").write_text(json.dumps(manifest, indent=2, sort_keys=True) + "\n")
+
+
+if __name__ == "__main__":
+    main()

assets/ppkg_scaling.csv

@@ -0,0 +1,5 @@
+entries,disk_bytes,checksum_ms,db_open_ms,routing_header_ms,row_hydration_ms,canonical_conversion_ms,candidate_headers,entries_loaded,logical_bytes_read,inactive_vram_bytes
+100,118784,1.0304470015398692,0.20484400010900572,2.207458997872891,0.11649800217128359,0.5500090010173153,4,4,2789,0
+1000,638976,8.523084998159902,0.2957940014312044,14.324849998956779,0.1179409991891589,0.4913600023428444,33,4,6855,0
+10000,5894144,83.29692499683006,0.28353100060485303,57.26086499998928,0.11310199988656677,0.5099939990031999,130,4,20616,0
+100000,58720256,823.8876559989876,0.549067000974901,67.10040300094988,0.11752000136766583,0.4947460001858417,152,4,23715,0

assets/router_scaling.csv

@@ -0,0 +1,8 @@
+slots,top1_accuracy,top4_recall,mrr,routing_latency_ms
+4,1.0,1.0,1.0,0.35979299718746915
+20,1.0,1.0,1.0,0.3294770031061489
+64,1.0,1.0,1.0,0.33151000025100075
+128,1.0,1.0,1.0,0.3642720002972055
+256,1.0,1.0,1.0,0.39848600135883316
+512,1.0,1.0,1.0,0.4960180012858473
+1024,1.0,1.0,1.0,0.6750829998054542

assets/vram_comparison.csv

@@ -0,0 +1,10 @@
+workload_tokens,condition,generated_tokens,p_cache_slots,p_cache_canonical_bytes,retained_kv_cache_bytes,baseline_allocated_bytes,peak_allocated_bytes,peak_reserved_bytes,incremental_peak_allocated_bytes,incremental_peak_reserved_bytes,runtime_seconds,failure
+64,p_cache_only,8,64,134464,0,2849172992,2856644608,2910846976,7471616,4194304,0.2554637499997625,
+64,kv_only,8,0,0,13959168,2849172992,2868457984,2923429888,19284992,16777216,0.17538804200012237,
+64,p_cache_plus_kv,8,64,134464,13959168,2849172992,2868492800,2923429888,19319808,16777216,0.20454967800469603,
+256,p_cache_only,8,256,537856,0,2849172992,2877656576,2942304256,28483584,35651584,0.7414951529935934,
+256,kv_only,8,0,0,51707904,2849172992,2930360320,2990538752,81187328,83886080,0.19367339000746142,
+256,p_cache_plus_kv,8,256,537856,51707904,2849172992,2930496512,2990538752,81323520,83886080,0.41562580699974205,
+1024,p_cache_only,8,1024,2151424,0,2849172992,2957690880,3080716288,108517888,174063616,2.710468404009589,
+1024,kv_only,8,0,0,202702848,2849172992,3157732864,3246391296,308559872,339738624,0.37531103400397114,
+1024,p_cache_plus_kv,8,1024,2151424,202702848,2849172992,3158275072,3265265664,309102080,358612992,1.2812230650015408,

pyproject.toml

@@ -0,0 +1,31 @@
+[build-system]
+requires = ["setuptools>=77"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "planner-cache"
+version = "0.1.0"
+description = "Canonical Planner Cache, compatibility layers, and durable personality packages"
+requires-python = ">=3.11"
+dependencies = [
+  "accelerate>=1.12",
+  "numpy>=2.0",
+  "safetensors>=0.5",
+  "torch>=2.7",
+  "transformers>=5.15",
+]
+
+[project.optional-dependencies]
+dev = ["pytest>=9"]
+publishing = ["cairosvg>=2.7"]
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+pythonpath = ["src"]
+addopts = "-ra"
+markers = [
+  "slow_cuda: exact CUDA integration regressions using production-scale models",
+]

src/pcm/__init__.py

@@ -0,0 +1,4 @@
+"""Context-efficient adaptive proof model."""
+
+__version__ = "0.1.0"
+

src/pcm/planner/__init__.py

@@ -0,0 +1,96 @@
+"""Active Planner Cache architecture exports only."""
+
+from pcm.planner.cache import (
+    CacheFullProtectedError,
+    Freshness,
+    Persistence,
+    PlannerCache,
+    PlannerCacheConfig,
+    SlotSource,
+    SlotType,
+    StateOperation,
+)
+from pcm.planner.canonical import (
+    CANONICAL_P_PROTOCOL,
+    CANONICAL_VALUE_LABELS,
+    CanonicalPConfig,
+    CanonicalPStore,
+    model_config_checksum,
+)
+from pcm.planner.compatibility import (
+    CompatibilityKind,
+    CompatibilityResolution,
+    LTL_EXTENSION,
+    LTL_FORMAT,
+    TTL_EXTENSION,
+    TTL_FORMAT,
+    LexicalTranslationConfig,
+    LexicalTranslationLayer,
+    TensorTranslationLayer,
+    classify_compatibility_artifact,
+    resolve_compatibility,
+    tokenizer_bundle_checksum,
+)
+from pcm.planner.personality import (
+    EvidenceAuthority,
+    EvidenceRecord,
+    FactorizedPersonalityCanonicalizer,
+    PPKG_FORMAT,
+    PPKG_PROTOCOL,
+    PersonalityActivation,
+    PersonalityEntry,
+    PersonalityPackage,
+    PersonalityQuery,
+    PersonalityRouter,
+    PersonalitySelection,
+    PersonalityStatus,
+    PersonalityTranslateSession,
+    PersonalityType,
+    PromotionDecision,
+    PromotionPolicy,
+    evidence_from_p_cache,
+    merge_active_personality_with_p_cache,
+)
+from pcm.planner.pythia_split_translate import (
+    PythiaSplitTranslatedModel,
+    pythia_model_identifier,
+)
+from pcm.planner.interactive_session import (
+    CanonicalQueryIntent,
+    CanonicalStateManager,
+    MutationIntent,
+    PersonalityManager,
+    SessionRecorder,
+)
+from pcm.planner.memory_review import (
+    MEMORY_REVIEW_SCHEMA,
+    REVIEW_CONFIDENCE_FLOOR,
+    REVIEW_FORMAT,
+    PostTurnMemoryReviewer,
+    ReviewedOperation,
+    ValidatedReview,
+    parse_review,
+    review_prompt,
+    validate_review,
+)
+from pcm.planner.interactive_runtimes import (
+    GemmaInteractiveRuntime,
+    GenerationResult,
+    LlamaServerProcess,
+    PythiaInteractiveRuntime,
+    gemma_chat_request_body,
+)
+from pcm.planner.split_translator import (
+    ByteEntityEncoder,
+    CanonicalPRouter,
+    CanonicalValueTranslator,
+    FactorizedCanonicalQuery,
+    FrozenLexicalAnchorProjector,
+    ModelToCanonicalQueryProjector,
+    RouterConfig,
+    SplitInjectionGate,
+    SplitPTranslatePackage,
+    SplitTranslateConfig,
+)
+
+__all__ = [name for name in globals() if not name.startswith("_")]

src/pcm/planner/cache.py

@@ -0,0 +1,377 @@
+"""Fixed-allocation first-class planner state cache."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from enum import IntEnum
+import math
+from typing import Iterable
+
+import torch
+from torch import Tensor
+import torch.nn.functional as F
+
+
+class StateOperation(IntEnum):
+    KEEP = 0
+    CREATE = 1
+    MODIFY = 2
+    MERGE = 3
+    INVALIDATE = 4
+    IGNORE = 5
+
+
+class SlotType(IntEnum):
+    GOAL = 0
+    ENTITY = 1
+    FACT = 2
+    HYPOTHESIS = 3
+    CONSTRAINT = 4
+    TASK = 5
+    LATENT = 6
+    EXTERNAL = 7
+
+
+class Freshness(IntEnum):
+    FRESH = 0
+    STALE = 1
+    UNKNOWN = 2
+
+
+class Persistence(IntEnum):
+    PERMANENT = 0
+    DURABLE = 1
+    SESSION = 2
+    EXTERNAL = 3
+    VOLATILE = 4
+
+
+class SlotSource(IntEnum):
+    CONVERSATION = 0
+    RETRIEVAL = 1
+    CORRECTION = 2
+    TOOL = 3
+    INFERENCE = 4
+
+
+class CacheFullProtectedError(RuntimeError):
+    """Raised when every physical slot is occupied by permanent state."""
+
+
+@dataclass(frozen=True)
+class PlannerCacheConfig:
+    slots: int = 128
+    width: int = 512
+    dtype: torch.dtype = torch.float16
+    device: str | torch.device = "cpu"
+    merge_similarity: float = 0.92
+
+    def __post_init__(self) -> None:
+        if self.slots <= 0 or self.width <= 0:
+            raise ValueError("planner slots and width must be positive")
+        if not -1.0 <= self.merge_similarity <= 1.0:
+            raise ValueError("merge_similarity must be between -1 and 1")
+
+
+class PlannerCache:
+    """Preallocated planner values and metadata mutated strictly in place."""
+
+    def __init__(self, config: PlannerCacheConfig) -> None:
+        self.config = config
+        device = torch.device(config.device)
+        self.values = torch.zeros((config.slots, config.width), dtype=config.dtype, device=device)
+        self.valid = torch.zeros(config.slots, dtype=torch.bool, device=device)
+        self.slot_type = torch.full((config.slots,), int(SlotType.LATENT), dtype=torch.int8, device=device)
+        self.confidence = torch.zeros(config.slots, dtype=torch.float32, device=device)
+        self.importance = torch.zeros(config.slots, dtype=torch.float32, device=device)
+        self.freshness = torch.full((config.slots,), int(Freshness.UNKNOWN), dtype=torch.int8, device=device)
+        self.persistence = torch.full((config.slots,), int(Persistence.VOLATILE), dtype=torch.int8, device=device)
+        self.last_updated = torch.zeros(config.slots, dtype=torch.int64, device=device)
+        self.source = torch.full((config.slots,), int(SlotSource.INFERENCE), dtype=torch.int8, device=device)
+        self.labels: list[str | None] = [None] * config.slots
+        self._clock = 0
+
+    @property
+    def device(self) -> torch.device:
+        return self.values.device
+
+    def allocation_signature(self) -> tuple[tuple[int, tuple[int, ...]], ...]:
+        """Stable identity/shape signature for physical-allocation tests."""
+        tensors = (
+            self.values,
+            self.valid,
+            self.slot_type,
+            self.confidence,
+            self.importance,
+            self.freshness,
+            self.persistence,
+            self.last_updated,
+            self.source,
+        )
+        return tuple((tensor.data_ptr(), tuple(tensor.shape)) for tensor in tensors)
+
+    @property
+    def occupied(self) -> int:
+        return int(self.valid.sum().item())
+
+    def _tick(self) -> int:
+        self._clock += 1
+        return self._clock
+
+    def _value(self, value: Tensor) -> Tensor:
+        value = value.detach().to(device=self.device, dtype=self.config.dtype)
+        if value.shape != (self.config.width,):
+            raise ValueError(f"planner value must have shape ({self.config.width},)")
+        return value
+
+    def _require_valid(self, index: int) -> None:
+        if not 0 <= index < self.config.slots or not bool(self.valid[index]):
+            raise IndexError(f"planner slot {index} is not valid")
+
+    def _write_metadata(
+        self,
+        index: int,
+        *,
+        slot_type: SlotType,
+        confidence: float,
+        importance: float,
+        freshness: Freshness,
+        persistence: Persistence,
+        source: SlotSource,
+        label: str | None,
+    ) -> None:
+        self._validate_score("confidence", confidence)
+        self._validate_score("importance", importance)
+        slot_type = SlotType(slot_type)
+        freshness = Freshness(freshness)
+        persistence = Persistence(persistence)
+        source = SlotSource(source)
+        if label is not None and not isinstance(label, str):
+            raise TypeError("planner label must be a string or None")
+        self.slot_type[index] = int(slot_type)
+        self.confidence[index] = confidence
+        self.importance[index] = importance
+        self.freshness[index] = int(freshness)
+        self.persistence[index] = int(persistence)
+        self.source[index] = int(source)
+        self.last_updated[index] = self._tick()
+        self.labels[index] = label
+        self.valid[index] = True
+
+    @staticmethod
+    def _validate_score(name: str, value: float) -> None:
+        if not isinstance(value, (int, float)) or not math.isfinite(float(value)):
+            raise ValueError(f"{name} must be a finite number in [0, 1]")
+        if not 0.0 <= float(value) <= 1.0:
+            raise ValueError(f"{name} must be in [0, 1]")
+
+    def _merge_candidate(
+        self, value: Tensor, slot_type: SlotType, merge_mask: Tensor | None = None
+    ) -> int | None:
+        compatible = self.valid & (self.slot_type == int(slot_type))
+        if merge_mask is not None:
+            merge_mask = merge_mask.detach().to(device=self.device, dtype=torch.bool)
+            if merge_mask.shape != self.valid.shape:
+                raise ValueError("merge mask must match the planner slot shape")
+            compatible &= merge_mask
+        indices = compatible.nonzero(as_tuple=False).flatten()
+        if indices.numel() == 0:
+            return None
+        candidates = self.values.index_select(0, indices).float()
+        similarities = F.cosine_similarity(candidates, value.float().unsqueeze(0), dim=-1)
+        best = int(similarities.argmax().item())
+        if float(similarities[best]) < self.config.merge_similarity:
+            return None
+        return int(indices[best].item())
+
+    def _eviction_candidate(self) -> int:
+        candidates = self.valid & (self.persistence != int(Persistence.PERMANENT))
+        indices = candidates.nonzero(as_tuple=False).flatten()
+        if indices.numel() == 0:
+            raise CacheFullProtectedError("all planner slots are permanent")
+        age = (self._clock + 1 - self.last_updated.index_select(0, indices)).float()
+        stale_bonus = (self.freshness.index_select(0, indices) != int(Freshness.FRESH)).float()
+        persistence_cost = torch.tensor(
+            [4.0, 3.0, 2.0, 1.0, 0.0], device=self.device
+        ).index_select(0, self.persistence.index_select(0, indices).long())
+        keep_score = (
+            4.0 * self.importance.index_select(0, indices)
+            + self.confidence.index_select(0, indices)
+            + persistence_cost
+            - stale_bonus
+            - age * 1e-6
+        )
+        return int(indices[int(keep_score.argmin().item())].item())
+
+    @staticmethod
+    def _admission_score(
+        *,
+        importance: float,
+        confidence: float,
+        freshness: Freshness,
+        persistence: Persistence,
+    ) -> float:
+        persistence_cost = (4.0, 3.0, 2.0, 1.0, 0.0)[int(persistence)]
+        stale_cost = 0.0 if freshness == Freshness.FRESH else 1.0
+        return 4.0 * importance + confidence + persistence_cost - stale_cost
+
+    def _slot_admission_score(self, index: int) -> float:
+        age = (self._clock + 1 - int(self.last_updated[index])) * 1e-6
+        return self._admission_score(
+            importance=float(self.importance[index]),
+            confidence=float(self.confidence[index]),
+            freshness=Freshness(int(self.freshness[index])),
+            persistence=Persistence(int(self.persistence[index])),
+        ) - age
+
+    def create(
+        self,
+        value: Tensor,
+        *,
+        slot_type: SlotType = SlotType.LATENT,
+        confidence: float = 1.0,
+        importance: float = 0.5,
+        freshness: Freshness = Freshness.FRESH,
+        persistence: Persistence = Persistence.SESSION,
+        source: SlotSource = SlotSource.CONVERSATION,
+        label: str | None = None,
+        merge_mask: Tensor | None = None,
+    ) -> tuple[int, StateOperation]:
+        value = self._value(value)
+        self._validate_score("confidence", confidence)
+        self._validate_score("importance", importance)
+        slot_type = SlotType(slot_type)
+        freshness = Freshness(freshness)
+        persistence = Persistence(persistence)
+        source = SlotSource(source)
+        merge_index = self._merge_candidate(value, slot_type, merge_mask)
+        if merge_index is not None:
+            self.merge((merge_index,), value=value, confidence=confidence, source=source)
+            self.importance[merge_index] = max(
+                float(self.importance[merge_index]), importance
+            )
+            self.persistence[merge_index] = min(
+                int(self.persistence[merge_index]), int(persistence)
+            )
+            if label is not None:
+                self.labels[merge_index] = label
+            return merge_index, StateOperation.MERGE
+        free = (~self.valid).nonzero(as_tuple=False).flatten()
+        operation = StateOperation.CREATE
+        if free.numel():
+            index = int(free[0].item())
+        else:
+            index = self._eviction_candidate()
+            incoming_score = self._admission_score(
+                importance=importance,
+                confidence=confidence,
+                freshness=freshness,
+                persistence=persistence,
+            )
+            if incoming_score <= self._slot_admission_score(index):
+                return -1, StateOperation.IGNORE
+            self.invalidate(index)
+        self.values[index].copy_(value)
+        self._write_metadata(
+            index,
+            slot_type=slot_type,
+            confidence=confidence,
+            importance=importance,
+            freshness=freshness,
+            persistence=persistence,
+            source=source,
+            label=label,
+        )
+        return index, operation
+
+    def keep(self, index: int, *, confidence: float | None = None) -> int:
+        self._require_valid(index)
+        if confidence is not None:
+            self._validate_score("confidence", confidence)
+            self.confidence[index] = confidence
+        self.last_updated[index] = self._tick()
+        return index
+
+    def modify(
+        self,
+        index: int,
+        value: Tensor,
+        *,
+        confidence: float | None = None,
+        freshness: Freshness = Freshness.FRESH,
+        source: SlotSource | None = None,
+    ) -> int:
+        self._require_valid(index)
+        freshness = Freshness(freshness)
+        if source is not None:
+            source = SlotSource(source)
+        if confidence is not None:
+            self._validate_score("confidence", confidence)
+        # A model inference is lower-authority than an explicit user
+        # correction and cannot silently overwrite it.
+        if (
+            source == SlotSource.INFERENCE
+            and int(self.source[index]) == int(SlotSource.CORRECTION)
+        ):
+            self.last_updated[index] = self._tick()
+            return index
+        self.values[index].copy_(self._value(value))
+        if confidence is not None:
+            self.confidence[index] = confidence
+        self.freshness[index] = int(freshness)
+        if source is not None:
+            self.source[index] = int(source)
+        self.last_updated[index] = self._tick()
+        return index
+
+    def merge(
+        self,
+        indices: Iterable[int],
+        *,
+        value: Tensor | None = None,
+        confidence: float | None = None,
+        source: SlotSource = SlotSource.INFERENCE,
+    ) -> int:
+        indices = tuple(dict.fromkeys(indices))
+        if not indices:
+            raise ValueError("merge requires at least one slot")
+        for index in indices:
+            self._require_valid(index)
+        target = max(indices, key=lambda index: float(self.importance[index]))
+        merged = self._value(value) if value is not None else self.values[list(indices)].float().mean(0).to(self.config.dtype)
+        self.values[target].copy_(merged)
+        if confidence is None:
+            confidence = max(float(self.confidence[index]) for index in indices)
+        self._validate_score("confidence", confidence)
+        self.confidence[target] = confidence
+        self.importance[target] = max(float(self.importance[index]) for index in indices)
+        self.freshness[target] = int(Freshness.FRESH)
+        self.source[target] = int(source)
+        self.last_updated[target] = self._tick()
+        for index in indices:
+            if index != target:
+                self.invalidate(index)
+        return target
+
+    def invalidate(self, index: int) -> int:
+        self._require_valid(index)
+        self.valid[index] = False
+        self.values[index].zero_()
+        self.labels[index] = None
+        self.last_updated[index] = self._tick()
+        return index
+
+    def apply(self, operation: StateOperation, **kwargs):
+        if operation == StateOperation.KEEP:
+            return self.keep(**kwargs)
+        if operation == StateOperation.CREATE:
+            return self.create(**kwargs)
+        if operation == StateOperation.MODIFY:
+            return self.modify(**kwargs)
+        if operation == StateOperation.MERGE:
+            return self.merge(**kwargs)
+        if operation == StateOperation.INVALIDATE:
+            return self.invalidate(**kwargs)
+        if operation == StateOperation.IGNORE:
+            return None
+        raise ValueError(f"unsupported planner operation: {operation}")