chore(release): auto-bump version to 0.167.0 — earned by # (minor: converged release (push-to-master bump))

Promotion record: (unknown)

.gitea/workflows/ci.yml

@@ -199,6 +199,9 @@ jobs:
           # the tmpfs (2026-10-07: venv creation failed disk-full across
           # every job). Keep the 3 newest; drop the rest.
           cd /tmp && ls -dt rune-ci-target-* 2>/dev/null | tail -n +4 | xargs -r rm -rf
+          # deploy-test cache: rust targets accumulate ~15G (every crate's
+          # release dir). The staged source survives; targets rebuild.
+          find /tmp/rune-deploy-test/src/rust -maxdepth 2 -name target -type d 2>/dev/null | xargs -r rm -rf
       - name: go vet + go test + go build
         run: |
           for dir in src/go/*/; do
@@ -224,7 +227,7 @@ jobs:
           go test ./... -run TestParityAgainstPythonOracle -v
       - name: operator-deep evidence-kernel parity gate (HARD — #2479 batch: #30 kernels)
         run: |
-          cd src/go/operator-deep && go build -o /tmp/operator-deep-${{ gitea.run_id }} . && go test -run "TestOperator30Parity|TestVerificationAndOutcomeContract|TestTaskIdentityParity" -v
+          cd src/go/operator-deep && go build -o /tmp/operator-deep-${{ gitea.run_id }} . && go test -run "TestOperator30Parity|TestVerificationAndOutcomeContract|TestTaskIdentityParity|TestWindowParity" -v
       - name: curator-core candidate-decay parity gate (HARD — #2479 batch: ledger decay + journal render + cosine)
         run: |
           cd src/go/curator-core && go build -o /tmp/curator-core-${{ gitea.run_id }} . && /tmp/curator-core-${{ gitea.run_id }} replay truth_candidate_decay.json && go test -run TestCandidateDecayParity -v
@@ -351,6 +354,9 @@ jobs:
             echo "$UNFORMATTED"
             exit 1
           fi
+      - name: memory-store-deep text-kernel parity gate (HARD — #2479 batch: fts/mapreduce/entities)
+        run: |
+          cd src/go/memory-store-deep && go build -o /tmp/msd-${{ gitea.run_id }} . && go test -run "TestTextKernelsParity|TestDriftRerankBlendParity" -v
       - name: go race detector (every module's test suite under -race)
         run: |
           for dir in src/go/*/; do

AGENTS.md

@@ -36,6 +36,7 @@ Only use `git commit --no-verify` in a genuine emergency: it bypasses the hooks
 - Production failure fixtures are a governed surface — the registry and its README exist (in ./tests/fixtures/production)
 - Fixture payloads and the manifest travel together — tamper-evidence needs both
 - The fixture manifest and its generated regression tests travel together
+- The dichotomy is enforced at the commit boundary — every src/rune module lands in its measured side, dead oracles and wrong-language kernels fail with the correct implementation as the instruction (in ./src/rune)
 
 ### Behaviours
 

README.md

@@ -1,6 +1,6 @@
 # Rune
 
-**Current release: v0.159.0**
+**Current release: v0.167.0**
 
 **Rune is a persistent personal agent designed to accumulate experience, develop reusable competence, and remain recognisably the same agent even when its underlying foundation model changes.**
 

henxels_checks.py

@@ -216,6 +216,7 @@ def dichotomy_language_verdict(param, file, scope):
     contract-first), so the builder agent can act without re-deriving.
     """
     import json
+    import os
     import re as _re
 
     if not (file.startswith("src/rune/") and file.endswith(".py")):
@@ -319,4 +320,48 @@ def dichotomy_language_verdict(param, file, scope):
                 f"it); the ratchet floor never decreases."
             )
 
+    # D5 — intent-unconsulted landing: a ported kernel (Go dir or Rust
+    # crate exists) whose intent file still says not_started means the batch
+    # never consulted the module's WHY. Parity is judged against intent, not
+    # just behavior — consult store/scaffold/intent/<stem>.json, satisfy its
+    # laws, and advance its status (not_started → facade → ported → retired).
+    if side in ("GO", "RUST", "TUI-LAST"):
+        if go_dir.is_dir() or rust_dir.is_dir():
+            try:
+                intent_status = json.loads(
+                    (root / "store" / "scaffold" / "intent" / f"{stem}.json").read_text()
+                ).get("status", "")
+            except (OSError, json.JSONDecodeError):
+                intent_status = ""
+            if intent_status == "not_started":
+                return (
+                    f"DICHOTOMY D5 (intent-unconsulted landing): {stem} has a "
+                    f"ported kernel but its intent file "
+                    f"(store/scaffold/intent/{stem}.json) still says "
+                    f"not_started — the batch never consulted the module's WHY. "
+                    f"FIX: read the intent file, satisfy its laws, set parity_means "
+                    f"for this module, and advance status to ported (or facade if "
+                    f"delegation is not yet wired). Parity is judged against "
+                    f"intent, not just behavior."
+                )
+
+    # D4 — retired-module resurrection: a module in the retirement ratchet
+    # (strangler exit completed — parity proven + CI green + deployed) must
+    # NOT reappear as a Python file. Singular codebase law.
+    if side in ("GO", "RUST") and not os.path.isdir(f"src/go/{stem}") and not os.path.isdir(f"src/rust/{stem}"):
+        try:
+            retired = set(json.loads(
+                (root / "store" / "rebase" / "retired_modules.json").read_text()
+            ).get("retired", []))
+        except (OSError, json.JSONDecodeError):
+            retired = set()
+        if stem in retired and (root / file).exists():
+            return (
+                f"DICHOTOMY D4 (retired-module resurrection): {stem} completed the "
+                f"strangler exit (parity + CI green + deployed) and its Python was "
+                f"deleted — but src/rune/{stem}.py exists again. The dichotomy is a "
+                f"SINGULAR codebase: do not resurrect retired Python; extend the "
+                f"kernel in its Go/Rust home instead. (See store/rebase/retired_modules.json.)"
+            )
+
     return None

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "rune"
-version = "0.159.0"
+version = "0.167.0"
 description = "Rune — a stateful coding assistant with persistent memory, orchestration, and TUI"
 requires-python = ">=3.10"
 

src/go/memory-store-deep/drift_rerank.go

@@ -0,0 +1,32 @@
+package main
+
+// drift_rerank.go — #2479 memory_store batch 2: the drift-aware re-rank
+// BLEND kernel (combined = original*0.7 + drift*0.3, stable sort desc).
+// The DB reads and drift_core.compute_value calls stay in the Python
+// reactive seam (SQLite + cross-crate); the deterministic blend is here.
+// Oracle: src/rune/memory_store.py _drift_rerank's blend section.
+
+import "sort"
+
+// DriftRerankBlend — entries carry {"id", "orig", "drift"}; returns ids
+// sorted by combined score desc (stable — Python sort stability parity).
+func DriftRerankBlend(entries []map[string]any) []string {
+	type scored struct {
+		id    string
+		score float64
+		seq   int
+	}
+	ss := make([]scored, 0, len(entries))
+	for i, e := range entries {
+		id, _ := e["id"].(string)
+		orig, _ := e["orig"].(float64)
+		drift, _ := e["drift"].(float64)
+		ss = append(ss, scored{id: id, score: orig*0.7 + drift*0.3, seq: i})
+	}
+	sort.SliceStable(ss, func(a, b int) bool { return ss[a].score > ss[b].score })
+	out := make([]string, len(ss))
+	for i, s := range ss {
+		out[i] = s.id
+	}
+	return out
+}

src/go/memory-store-deep/text_kernels.go

@@ -0,0 +1,145 @@
+package main
+
+// text_kernels.go — #2479 memory_store batch: the FTS conjunctive query
+// builder, the map-reduce lost-in-the-middle mitigation, and the
+// entities-to-JSON serializer. Oracle: src/rune/memory_store.py; truth rows
+// in truth_text_kernels.json. The SQLite seam stays Python (reactive).
+
+import (
+	"encoding/json"
+	"sort"
+	"strings"
+)
+
+// Stopwords51 — the measured stopword set (51 words) from memory_store.
+var Stopwords51 = map[string]bool{
+	"about": true, "after": true, "also": true, "and": true, "are": true,
+	"been": true, "but": true, "each": true, "for": true, "from": true,
+	"have": true, "her": true, "him": true, "his": true, "how": true,
+	"into": true, "its": true, "just": true, "likes": true, "more": true,
+	"needs": true, "not": true, "only": true, "over": true, "prefers": true,
+	"some": true, "such": true, "than": true, "that": true, "the": true,
+	"them": true, "then": true, "there": true, "they": true, "this": true,
+	"under": true, "very": true, "wants": true, "was": true, "were": true,
+	"what": true, "when": true, "where": true, "which": true, "while": true,
+	"who": true, "why": true, "will": true, "with": true, "you": true,
+	"your": true,
+}
+
+// FTSQueryConjunctive — CONJUNCTIVE FTS5 MATCH (implicit AND; Salton,
+// Fox & Wu 1983). Words >3 chars minus stopwords; falls back to >2-char
+// tokens; empty query returns as-is; max 8 terms, quoted.
+func FTSQueryConjunctive(query string) string {
+	lower := strings.ToLower(query)
+	fields := strings.Fields(lower)
+	var toks []string
+	for _, t := range fields {
+		if len(t) > 3 && !Stopwords51[t] {
+			toks = append(toks, t)
+		}
+	}
+	if len(toks) == 0 {
+		for _, t := range fields {
+			if len(t) > 2 {
+				toks = append(toks, t)
+			}
+		}
+	}
+	if len(toks) == 0 {
+		return query
+	}
+	if len(toks) > 8 {
+		toks = toks[:8]
+	}
+	quoted := make([]string, len(toks))
+	for i, t := range toks {
+		quoted[i] = "\"" + t + "\""
+	}
+	return strings.Join(quoted, " ")
+}
+
+// FTSQuery — backward-compat alias.
+func FTSQuery(query string) string { return FTSQueryConjunctive(query) }
+
+// MapReducePy — lost-in-the-middle mitigation: chunk, take top-3 per chunk
+// (relevance desc, falling back to score then 0.5), reduce by score desc.
+// Short inputs pass through unchanged.
+func MapReducePy(entries []map[string]any, chunkSize int) []map[string]any {
+	if chunkSize <= 0 {
+		chunkSize = 10
+	}
+	score := func(e map[string]any) float64 {
+		if r, ok := e["relevance"].(float64); ok {
+			return r
+		}
+		if s, ok := e["score"].(float64); ok {
+			return s
+		}
+		return 0.5
+	}
+	if len(entries) <= chunkSize {
+		return entries
+	}
+	var mapped []map[string]any
+	for i := 0; i < len(entries); i += chunkSize {
+		end := i + chunkSize
+		if end > len(entries) {
+			end = len(entries)
+		}
+		chunk := entries[i:end]
+		sort.SliceStable(chunk, func(a, b int) bool { return score(chunk[a]) > score(chunk[b]) })
+		top := 3
+		if top > len(chunk) {
+			top = len(chunk)
+		}
+		mapped = append(mapped, chunk[:top]...)
+	}
+	sort.SliceStable(mapped, func(a, b int) bool { return score(mapped[a]) > score(mapped[b]) })
+	return mapped
+}
+
+// EntitiesToJSON — json.dumps(list(entities) if entities else []).
+// Python json.dumps default separators (', ' / ': ') parity via the
+// byte state machine (same shape as operator-deep's).
+func EntitiesToJSON(entities []map[string]any) string {
+	var b []byte
+	if entities == nil {
+		b, _ = json.Marshal([]any{})
+	} else {
+		b, _ = json.Marshal(entities)
+	}
+	var out strings.Builder
+	inStr := false
+	esc := false
+	for i, c := range b {
+		if inStr {
+			out.WriteByte(c)
+			if esc {
+				esc = false
+			} else if c == '\\' {
+				esc = true
+			} else if c == '"' {
+				inStr = false
+			}
+			continue
+		}
+		switch c {
+		case '"':
+			inStr = true
+			out.WriteByte(c)
+		case ',':
+			out.WriteByte(c)
+			if i+1 < len(b) {
+				out.WriteByte(' ')
+			}
+		case ':':
+			out.WriteByte(c)
+			if i+1 < len(b) {
+				out.WriteByte(' ')
+			}
+		default:
+			out.WriteByte(c)
+		}
+	}
+	return out.String()
+}

src/go/memory-store-deep/truth_drift_rerank.json

@@ -0,0 +1,64 @@
+[
+ {
+  "op": "blend",
+  "inputs": [
+   {
+    "id": "e1",
+    "orig": 0.9,
+    "drift": 0.2
+   },
+   {
+    "id": "e2",
+    "orig": 0.5,
+    "drift": 0.9
+   },
+   {
+    "id": "e3",
+    "orig": 0.7,
+    "drift": 0.7
+   },
+   {
+    "id": "e4",
+    "orig": 0.1,
+    "drift": 1.0
+   },
+   {
+    "id": "e5",
+    "orig": 0.6,
+    "drift": 0.6
+   }
+  ],
+  "want": [
+   "e3",
+   "e1",
+   "e2",
+   "e5",
+   "e4"
+  ]
+ },
+ {
+  "op": "blend",
+  "inputs": [
+   {
+    "id": "a",
+    "orig": 0.5,
+    "drift": 0.5
+   },
+   {
+    "id": "b",
+    "orig": 0.5,
+    "drift": 0.5
+   },
+   {
+    "id": "c",
+    "orig": 0.4,
+    "drift": 0.7
+   }
+  ],
+  "want": [
+   "a",
+   "b",
+   "c"
+  ]
+ }
+]

src/go/memory-store-deep/truth_drift_rerank_test.go

@@ -0,0 +1,35 @@
+package main
+
+// truth_drift_rerank_test.go — blend-kernel parity gate.
+
+import (
+	"encoding/json"
+	"os"
+	"testing"
+)
+
+func TestDriftRerankBlendParity(t *testing.T) {
+	raw, err := os.ReadFile("truth_drift_rerank.json")
+	if err != nil {
+		t.Fatalf("truth_drift_rerank.json missing: %v", err)
+	}
+	var rows []struct {
+		Inputs []map[string]any `json:"inputs"`
+		Want   []string         `json:"want"`
+	}
+	if err := json.Unmarshal(raw, &rows); err != nil {
+		t.Fatalf("unparseable: %v", err)
+	}
+	for i, c := range rows {
+		got := DriftRerankBlend(c.Inputs)
+		if len(got) != len(c.Want) {
+			t.Errorf("row %d: got %d want %d", i, len(got), len(c.Want))
+			continue
+		}
+		for j := range got {
+			if got[j] != c.Want[j] {
+				t.Errorf("row %d[%d]: got %q want %q", i, j, got[j], c.Want[j])
+			}
+		}
+	}
+}

src/go/memory-store-deep/truth_text_kernels.json

@@ -0,0 +1,164 @@
+[
+ {
+  "op": "fts",
+  "q": "black coffee",
+  "want": "\"black\" \"coffee\""
+ },
+ {
+  "op": "fts",
+  "q": "the a of",
+  "want": "\"the\""
+ },
+ {
+  "op": "fts",
+  "q": "How does the splice work in rust",
+  "want": "\"does\" \"splice\" \"work\" \"rust\""
+ },
+ {
+  "op": "fts",
+  "q": "x y z",
+  "want": "x y z"
+ },
+ {
+  "op": "fts",
+  "q": "",
+  "want": ""
+ },
+ {
+  "op": "fts",
+  "q": "Fts5 AND query OR stuff",
+  "want": "\"fts5\" \"query\" \"stuff\""
+ },
+ {
+  "op": "fts",
+  "q": "one two three four",
+  "want": "\"three\" \"four\""
+ },
+ {
+  "op": "mapreduce",
+  "entries": [
+   {
+    "id": 0,
+    "relevance": 0.9,
+    "text": "e0"
+   },
+   {
+    "id": 1,
+    "relevance": 0.5,
+    "text": "e1"
+   },
+   {
+    "id": 2,
+    "relevance": 0.7,
+    "text": "e2"
+   },
+   {
+    "id": 3,
+    "relevance": 0.95,
+    "text": "e3"
+   },
+   {
+    "id": 4,
+    "relevance": 0.1,
+    "text": "e4"
+   },
+   {
+    "id": 5,
+    "relevance": 0.85,
+    "text": "e5"
+   },
+   {
+    "id": 6,
+    "relevance": 0.6,
+    "text": "e6"
+   },
+   {
+    "id": 7,
+    "relevance": 0.75,
+    "text": "e7"
+   },
+   {
+    "id": 8,
+    "relevance": 0.3,
+    "text": "e8"
+   },
+   {
+    "id": 9,
+    "relevance": 0.2,
+    "text": "e9"
+   },
+   {
+    "id": 10,
+    "relevance": 0.65,
+    "text": "e10"
+   },
+   {
+    "id": 11,
+    "relevance": 0.4,
+    "text": "e11"
+   }
+  ],
+  "chunk_size": 4,
+  "want": [
+   3,
+   0,
+   5,
+   7,
+   2,
+   10,
+   6,
+   11,
+   8
+  ]
+ },
+ {
+  "op": "mapreduce",
+  "entries": [
+   {
+    "id": 0,
+    "relevance": 0.9,
+    "text": "e0"
+   },
+   {
+    "id": 1,
+    "relevance": 0.5,
+    "text": "e1"
+   },
+   {
+    "id": 2,
+    "relevance": 0.7,
+    "text": "e2"
+   }
+  ],
+  "chunk_size": 10,
+  "want": [
+   0,
+   1,
+   2
+  ]
+ },
+ {
+  "op": "entities_json",
+  "entities": [
+   {
+    "a": 1
+   }
+  ],
+  "want": "[{\"a\": 1}]"
+ },
+ {
+  "op": "entities_json",
+  "entities": [],
+  "want": "[]"
+ },
+ {
+  "op": "entities_json",
+  "entities": null,
+  "want": "[]"
+ },
+ {
+  "op": "ctx_alias",
+  "q": "black coffee",
+  "want": "\"black\" \"coffee\""
+ }
+]

src/go/memory-store-deep/truth_text_kernels_test.go

@@ -0,0 +1,61 @@
+package main
+
+// truth_text_kernels_test.go — #2479 memory_store batch parity gate.
+
+import (
+	"encoding/json"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestTextKernelsParity(t *testing.T) {
+	raw, err := os.ReadFile("truth_text_kernels.json")
+	if err != nil {
+		t.Fatalf("truth_text_kernels.json missing: %v", err)
+	}
+	var rows []struct {
+		Op      string           `json:"op"`
+		Q       string           `json:"q"`
+		Entries []map[string]any `json:"entries"`
+		Chunk   int              `json:"chunk_size"`
+		Entity  []map[string]any `json:"entities"`
+		Want    json.RawMessage  `json:"want"`
+	}
+	if err := json.Unmarshal(raw, &rows); err != nil {
+		t.Fatalf("unparseable: %v", err)
+	}
+	for i, c := range rows {
+		switch c.Op {
+		case "fts", "ctx_alias":
+			got := FTSQueryConjunctive(c.Q)
+			var want string
+			_ = json.Unmarshal(c.Want, &want)
+			if got != want {
+				t.Errorf("row %d fts %q: got %q want %q", i, c.Q, got, want)
+			}
+		case "mapreduce":
+			got := MapReducePy(c.Entries, c.Chunk)
+			var wantIDs []float64
+			_ = json.Unmarshal(c.Want, &wantIDs)
+			if len(got) != len(wantIDs) {
+				t.Errorf("row %d mapreduce: got %d rows want %d", i, len(got), len(wantIDs))
+				continue
+			}
+			for j, id := range wantIDs {
+				gid, _ := got[j]["id"].(float64)
+				if gid != id {
+					t.Errorf("row %d mapreduce[%d]: got id %v want %v", i, j, gid, id)
+				}
+			}
+		case "entities_json":
+			got := EntitiesToJSON(c.Entity)
+			var want string
+			_ = json.Unmarshal(c.Want, &want)
+			if got != want {
+				t.Errorf("row %d entities_json: got %q want %q", i, got, want)
+			}
+		}
+	}
+	var _ = reflect.DeepEqual
+}

src/go/operator-deep/conversation_window.go

@@ -0,0 +1,51 @@
+package main
+
+// conversation_window.go — #2479 operator batch 3: the conversation-window
+// kernel (ConversationStateRepository.window semantics: last n of the
+// channel bucket, append order, idempotent-by-msg_id appends, n<=0 →
+// empty) and the get_status assembly shape. Oracle:
+// src/rune/orchestration/conversation_state.py window(); truth rows in
+// truth_window.json.
+
+// WindowKernel — msgs is the channel bucket in append order; returns the
+// last n (chronological). Mirrors Python list[-n:].
+func WindowKernel(msgs []map[string]any, n int) []map[string]any {
+	if n <= 0 {
+		return []map[string]any{}
+	}
+	if n >= len(msgs) {
+		out := make([]map[string]any, len(msgs))
+		copy(out, msgs)
+		return out
+	}
+	out := make([]map[string]any, n)
+	copy(out, msgs[len(msgs)-n:])
+	return out
+}
+
+// AppendIdempotent — bucket append, idempotent by msg_id (the repo's
+// in-memory contract; persistence stays in the Python adapter).
+func AppendIdempotent(bucket []map[string]any, msg map[string]any) []map[string]any {
+	id, _ := msg["msg_id"].(string)
+	for _, m := range bucket {
+		if mid, _ := m["msg_id"].(string); mid == id {
+			return bucket
+		}
+	}
+	return append(bucket, msg)
+}
+
+// StatusAssembly — get_status's shape: identity/role/current_task/
+// active_model + the counter keys (counters arrive computed).
+func StatusAssembly(identity, role, currentTask, activeModel string, counters map[string]int) map[string]any {
+	out := map[string]any{
+		"identity":     identity,
+		"role":         role,
+		"current_task": currentTask,
+		"active_model": activeModel,
+	}
+	for k, v := range counters {
+		out[k] = v
+	}
+	return out
+}

src/go/operator-deep/truth_window.json

@@ -0,0 +1,107 @@
+[
+ {
+  "op": "window",
+  "msgs": [
+   {
+    "msg_id": "m0",
+    "channel_id": "c1",
+    "content": "msg 0"
+   },
+   {
+    "msg_id": "m1",
+    "channel_id": "c1",
+    "content": "msg 1"
+   },
+   {
+    "msg_id": "m3",
+    "channel_id": "c1",
+    "content": "msg 3"
+   }
+  ],
+  "n": 2,
+  "want": [
+   {
+    "msg_id": "m1"
+   },
+   {
+    "msg_id": "m3"
+   }
+  ]
+ },
+ {
+  "op": "window",
+  "msgs": [
+   {
+    "msg_id": "m0",
+    "channel_id": "c1",
+    "content": "msg 0"
+   },
+   {
+    "msg_id": "m1",
+    "channel_id": "c1",
+    "content": "msg 1"
+   },
+   {
+    "msg_id": "m3",
+    "channel_id": "c1",
+    "content": "msg 3"
+   }
+  ],
+  "n": 0,
+  "want": []
+ },
+ {
+  "op": "window",
+  "msgs": [
+   {
+    "msg_id": "m0",
+    "channel_id": "c1",
+    "content": "msg 0"
+   },
+   {
+    "msg_id": "m1",
+    "channel_id": "c1",
+    "content": "msg 1"
+   },
+   {
+    "msg_id": "m3",
+    "channel_id": "c1",
+    "content": "msg 3"
+   }
+  ],
+  "n": 9,
+  "want": [
+   {
+    "msg_id": "m0"
+   },
+   {
+    "msg_id": "m1"
+   },
+   {
+    "msg_id": "m3"
+   }
+  ]
+ },
+ {
+  "op": "window",
+  "msgs": [
+   {
+    "msg_id": "m2",
+    "channel_id": "c2",
+    "content": "msg 2"
+   }
+  ],
+  "n": 1,
+  "want": [
+   {
+    "msg_id": "m2"
+   }
+  ]
+ },
+ {
+  "op": "window",
+  "msgs": [],
+  "n": 3,
+  "want": []
+ }
+]

src/go/operator-deep/truth_window_test.go

@@ -0,0 +1,52 @@
+package main
+
+// truth_window_test.go — #2479 operator-batch-3 parity gate.
+
+import (
+	"encoding/json"
+	"os"
+	"reflect"
+	"testing"
+)
+
+func TestWindowParity(t *testing.T) {
+	raw, err := os.ReadFile("truth_window.json")
+	if err != nil {
+		t.Fatalf("truth_window.json missing: %v", err)
+	}
+	var rows []struct {
+		Msgs []map[string]any `json:"msgs"`
+		N    int              `json:"n"`
+		Want []map[string]any `json:"want"`
+	}
+	if err := json.Unmarshal(raw, &rows); err != nil {
+		t.Fatalf("unparseable: %v", err)
+	}
+	for i, c := range rows {
+		got := WindowKernel(c.Msgs, c.N)
+		if len(got) != len(c.Want) {
+			t.Errorf("row %d window n=%d: got %d rows want %d", i, c.N, len(got), len(c.Want))
+			continue
+		}
+		for j := range got {
+			gid, _ := got[j]["msg_id"].(string)
+			wid, _ := c.Want[j]["msg_id"].(string)
+			if gid != wid {
+				t.Errorf("row %d window[%d]: got %q want %q", i, j, gid, wid)
+			}
+		}
+	}
+	// idempotent-append contract
+	bucket := []map[string]any{{"msg_id": "m1"}}
+	bucket = AppendIdempotent(bucket, map[string]any{"msg_id": "m2"})
+	bucket = AppendIdempotent(bucket, map[string]any{"msg_id": "m1"})
+	if len(bucket) != 2 {
+		t.Errorf("idempotent append: bucket grew to %d", len(bucket))
+	}
+	// status assembly shape
+	st := StatusAssembly("rune", "operator", "t1", "m1", map[string]int{"tasks_pending": 2})
+	if st["identity"] != "rune" || st["tasks_pending"] != 2 {
+		t.Errorf("status assembly: got %v", st)
+	}
+	var _ = reflect.DeepEqual
+}

src/rune/__init__.py

@@ -6,7 +6,7 @@ This is the main entry point for the Rune program.
 import json
 from pathlib import Path
 
-__version__ = "0.159.0"
+__version__ = "0.167.0"
 
 # One build identity (handoff 2026-09-10 §4): the semantic version above is
 # the repo-level truth (auto-bumped at merge); the DEPLOYED revision (exact

src/rune/canary_gitea_automation.py

@@ -233,7 +233,7 @@ def main() -> int:
     )
     check(
         "Rune minor version advertises provisioning and restore verification",
-        '__version__ = "0.159.0"' in rune_version,
+        '__version__ = "0.167.0"' in rune_version,
         failures,
     )
     # #169 policy update: auto-bump on merge is sanctioned (Nick directive:

src/rune/capability_fit.py

@@ -240,55 +240,14 @@ def evaluate_fit(req: CapabilityRequirement, candidate: dict) -> dict:
 
 
 def _py_evaluate_fit(req: CapabilityRequirement, candidate: dict) -> dict:
-    """Python core of evaluate_fit (parity oracle for the Rust core)."""
-    missing_contracts = sorted(set(req.contracts) - set(candidate["provides"]))
-    covered = len(req.contracts) - len(missing_contracts)
-
-    # health: a superseded or stale candidate cannot be reused as-is
-    status = candidate["status"]
-    unhealthy = status in {"SUPERSEDED", "STALE"} or bool(candidate.get("superseded_by"))
-
-    # maturity: DECLARED-only candidates have no usage evidence
-    maturity = _MATURITY_RANK.get(candidate.get("maturity", "DECLARED"), 0)
-
-    if unhealthy:
-        return {
-            "candidate": candidate["id"],
-            "fit": "INCOMPATIBLE",
-            "reason": f"candidate status {status} — not reusable as-is",
-            "missing_contracts": missing_contracts,
-            "covered": covered,
-        }
-    if req.contracts and not candidate["provides"]:
-        # candidate provides nothing verifiable → cannot establish fit
-        return {
-            "candidate": candidate["id"],
-            "fit": "UNKNOWN",
-            "reason": "candidate exposes no contracts to check",
-            "missing_contracts": missing_contracts,
-            "covered": 0,
-        }
-    if not missing_contracts:
-        fit = "EXACT"
-        reason = "all required contracts provided"
-    elif covered > 0:
-        fit = "PARTIAL"
-        reason = f"covers {covered}/{len(req.contracts)} required contracts"
-    else:
-        fit = "INCOMPATIBLE"
-        reason = "provides none of the required contracts"
-    return {
-        "candidate": candidate["id"],
-        "fit": fit,
-        "reason": reason,
-        "missing_contracts": missing_contracts,
-        "covered": covered,
-        "maturity_rank": maturity,
-        "consumers": candidate["consumers"],
-    }
-
-
-# ── gap / resolution decision ──────────────────────────────────────────────
+    """STRANGLER EXIT (retired 2026-10-10): authoritative implementation in
+    src/rust/capability_scoring (cs_evaluate_fit, parity proven against the
+    frozen oracle in frozen_evaluate_fit.json). Delegation-only stub; raises
+    if the kernel is absent (no silent second implementation)."""
+    core = _cs_core()
+    if core is None:
+        raise RuntimeError("capability_scoring kernel not built — run the capability_scoring build; the Python oracle was retired")
+    return core.evaluate_fit(req.contracts, candidate)
 
 
 def _adaptation_brittle(doc: dict, candidate_id: str, missing_contracts: list[str]) -> tuple[bool, str]:

src/rune/rune_tui.py

@@ -8,7 +8,7 @@ mode system, subject header, shared memory and identity.
 
 This is not an interface. This is how I see, speak, and interact with the world.
 
-Version: v0.159.0
+Version: v0.167.0
 Features: 41 (24 original + 17 new native commands)
 
 Usage:
@@ -2037,7 +2037,7 @@ class RuneApp(App):
         # Show version info
         self.chat_channel.add_message(
             "system",
-            f"[dim]Rune v0.159.0 | Textual TUI | {len(loaded)} native modules[/dim]",
+            f"[dim]Rune v0.167.0 | Textual TUI | {len(loaded)} native modules[/dim]",
         )
 
         # Auto-show night mode suggestion if evening/night hours

src/rune/token_optimizer.py

@@ -322,24 +322,24 @@ def _tc_core():
 
 
 def _py_estimate_tokens(text: str) -> int:
-    """Estimate token count (rough: 1 token ≈ 4 chars) — parity oracle."""
-    return len(text) // 4
+    """STRANGLER EXIT (retired 2026-10-10): the authoritative implementation
+    lives in src/rust/token_counting (tc_estimate_tokens, parity proven 26/26
+    against the frozen oracle in frozen_oracle.json). This stub exists ONLY so
+    old imports don't crash; it delegates to the kernel and raises if the
+    kernel is absent (no silent second implementation)."""
+    core = _tc_core()
+    if core is None:
+        raise RuntimeError("token_counting kernel not built — run the token_counting build; the Python oracle was retired")
+    return core.estimate_tokens(text)
 
 
 def _py_compress_context(context: str) -> str:
-    """Compress context to reduce tokens — parity oracle."""
-    # Remove multiple newlines
-    compressed = re.sub(r"\n{3,}", "\n\n", context)
-
-    # Remove redundant spaces
-    compressed = re.sub(r" {2,}", " ", compressed)
-
-    # Shorten common patterns
-    compressed = compressed.replace("User:", "U:")
-    compressed = compressed.replace("Assistant:", "A:")
-    compressed = compressed.replace("System:", "S:")
-
-    return compressed.strip()
+    """STRANGLER EXIT (retired 2026-10-10): authoritative implementation in
+    src/rust/token_counting (tc_compress_context). Same delegation-only rule."""
+    core = _tc_core()
+    if core is None:
+        raise RuntimeError("token_counting kernel not built — run the token_counting build; the Python oracle was retired")
+    return core.compress_context(context)
 
 
 

src/rune/verification_layer.py

@@ -116,60 +116,6 @@ def verify(result: dict, verifier_type: str) -> VerificationResult:
     return _rust_verify(result, verifier_type)
 
 
-def test_verification():
-    """Test the verification layer."""
-    print("Testing Verification Layer...")
-
-    # Test exit code verification
-    result = {"exit_code": 0}
-    vr = verify(result, "exit_code")
-    print(f"Exit code 0: passed={vr.passed}")
-    assert vr.passed
-
-    result = {"exit_code": 1}
-    vr = verify(result, "exit_code")
-    print(f"Exit code 1: passed={vr.passed}")
-    assert not vr.passed
-
-    # Test unit test verification
-    result = {"tests_passed": 10, "tests_failed": 0, "tests_total": 10}
-    vr = verify(result, "unit_test")
-    print(f"All tests pass: passed={vr.passed}")
-    assert vr.passed
-
-    result = {"tests_passed": 8, "tests_failed": 2, "tests_total": 10}
-    vr = verify(result, "unit_test")
-    print(f"2 tests fail: passed={vr.passed}")
-    assert not vr.passed
-
-    # Test schema verification
-    result = {"schema_valid": True, "schema_errors": []}
-    vr = verify(result, "schema")
-    print(f"Schema valid: passed={vr.passed}")
-    assert vr.passed
-
-    # Test file exists verification
-    result = {"file_path": "/tmp/test_file"}
-    vr = verify(result, "file_exists")
-    print(f"File exists: passed={vr.passed}")
-    # File doesn't exist, so should fail
-    assert not vr.passed, "Non-existent file should fail verification"
-
-    print("✅ All tests passed!")
-
-
-if __name__ == "__main__":
-    if len(sys.argv) > 1 and sys.argv[1] == "test":
-        test_verification()
-    elif len(sys.argv) > 3 and sys.argv[1] == "verify":
-        result = json.loads(sys.argv[2])
-        verifier_type = sys.argv[3]
-        vr = verify(result, verifier_type)
-        print(json.dumps(vr.to_dict(), indent=2))
-    else:
-        print("Usage:")
-        print("  verification_layer.py test                              — run tests")
-        print("  verification_layer.py verify <result_json> <verifier_type> — verify result")
 
 
 def handle_hook(event, data=None):

src/rust/capability_scoring/canary_capability_scoring.py

@@ -16,6 +16,7 @@ Run: python3 src/rust/capability_scoring/canary_capability_scoring.py
 
 from __future__ import annotations
 
+import json
 import os
 import subprocess
 import sys
@@ -165,15 +166,15 @@ def main() -> int:
         return 1
 
     from rune import capability_broker  # noqa: E402
-    from rune import capability_fit  # noqa: E402
+    from rune import capability_fit  # noqa: E402 — CapabilityRequirement class only; kernel expectations frozen below
     from rune import cs_loader  # noqa: E402
+    frozen = json.loads((Path(__file__).parent / "frozen_evaluate_fit.json").read_text(encoding="utf-8"))
+    frozen_rows = {r["name"]: r["want"] for r in frozen["rows"]}
 
     # ── 2. evaluate_fit parity ────────────────────────────────────────────
     print("\n--- 2. evaluate_fit parity ---")
     for name, contracts, candidate in fit_battery():
-        req = capability_fit.CapabilityRequirement("test objective",
-                                                   contracts=contracts)
-        py = capability_fit._py_evaluate_fit(req, candidate)
+        py = frozen_rows[name]
         rs = cs_loader.evaluate_fit(contracts, candidate)
         test(f"fit: {name}", py == rs,
              f"py={py!r}\n  rs={rs!r}")

src/rust/capability_scoring/frozen_evaluate_fit.json

@@ -0,0 +1,452 @@
+{
+ "_doc": "FROZEN ORACLE (capability_fit exit): from live _py_evaluate_fit 2026-10-10.",
+ "rows": [
+  {
+   "name": "exact",
+   "contracts": [
+    "a",
+    "b"
+   ],
+   "candidate": {
+    "id": "c1",
+    "provides": [
+     "a",
+     "b",
+     "c"
+    ],
+    "status": "LIVE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c1",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 2,
+    "maturity_rank": 2,
+    "consumers": []
+   }
+  },
+  {
+   "name": "partial",
+   "contracts": [
+    "a",
+    "b",
+    "c"
+   ],
+   "candidate": {
+    "id": "c2",
+    "provides": [
+     "a"
+    ],
+    "status": "LIVE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c2",
+    "fit": "PARTIAL",
+    "reason": "covers 1/3 required contracts",
+    "missing_contracts": [
+     "b",
+     "c"
+    ],
+    "covered": 1,
+    "maturity_rank": 2,
+    "consumers": []
+   }
+  },
+  {
+   "name": "incompatible-none",
+   "contracts": [
+    "a",
+    "b"
+   ],
+   "candidate": {
+    "id": "c3",
+    "provides": [
+     "x"
+    ],
+    "status": "LIVE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c3",
+    "fit": "INCOMPATIBLE",
+    "reason": "provides none of the required contracts",
+    "missing_contracts": [
+     "a",
+     "b"
+    ],
+    "covered": 0,
+    "maturity_rank": 2,
+    "consumers": []
+   }
+  },
+  {
+   "name": "incompatible-superseded",
+   "contracts": [
+    "a"
+   ],
+   "candidate": {
+    "id": "c4",
+    "provides": [
+     "a"
+    ],
+    "status": "SUPERSEDED",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c4",
+    "fit": "INCOMPATIBLE",
+    "reason": "candidate status SUPERSEDED \u2014 not reusable as-is",
+    "missing_contracts": [],
+    "covered": 1
+   }
+  },
+  {
+   "name": "incompatible-stale",
+   "contracts": [
+    "a"
+   ],
+   "candidate": {
+    "id": "c5",
+    "provides": [
+     "a"
+    ],
+    "status": "STALE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c5",
+    "fit": "INCOMPATIBLE",
+    "reason": "candidate status STALE \u2014 not reusable as-is",
+    "missing_contracts": [],
+    "covered": 1
+   }
+  },
+  {
+   "name": "unknown-empty",
+   "contracts": [
+    "a"
+   ],
+   "candidate": {
+    "id": "c6",
+    "provides": [],
+    "status": "LIVE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c6",
+    "fit": "UNKNOWN",
+    "reason": "candidate exposes no contracts to check",
+    "missing_contracts": [
+     "a"
+    ],
+    "covered": 0
+   }
+  },
+  {
+   "name": "empty-req",
+   "contracts": [],
+   "candidate": {
+    "id": "c7",
+    "provides": [
+     "a"
+    ],
+    "status": "LIVE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c7",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 0,
+    "maturity_rank": 2,
+    "consumers": []
+   }
+  },
+  {
+   "name": "maturity-declared",
+   "contracts": [
+    "a"
+   ],
+   "candidate": {
+    "id": "c8",
+    "provides": [
+     "a"
+    ],
+    "status": "LIVE",
+    "maturity": "DECLARED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "c8",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 1,
+    "maturity_rank": 0,
+    "consumers": []
+   }
+  },
+  {
+   "name": "EXACT all covered",
+   "contracts": [
+    "contract:a",
+    "contract:b"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a",
+     "contract:b"
+    ],
+    "status": "CURRENT",
+    "maturity": "WIRED",
+    "consumers": [
+     "module:y"
+    ]
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 2,
+    "maturity_rank": 2,
+    "consumers": [
+     "module:y"
+    ]
+   }
+  },
+  {
+   "name": "PARTIAL some covered",
+   "contracts": [
+    "contract:a",
+    "contract:b",
+    "contract:c"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "CURRENT",
+    "maturity": "DECLARED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "PARTIAL",
+    "reason": "covers 1/3 required contracts",
+    "missing_contracts": [
+     "contract:b",
+     "contract:c"
+    ],
+    "covered": 1,
+    "maturity_rank": 0,
+    "consumers": []
+   }
+  },
+  {
+   "name": "INCOMPATIBLE none covered",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:zzz"
+    ],
+    "status": "CURRENT",
+    "maturity": "PRESENT",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "INCOMPATIBLE",
+    "reason": "provides none of the required contracts",
+    "missing_contracts": [
+     "contract:a"
+    ],
+    "covered": 0,
+    "maturity_rank": 1,
+    "consumers": []
+   }
+  },
+  {
+   "name": "UNKNOWN no provides",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [],
+    "status": "CURRENT",
+    "maturity": "DECLARED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "UNKNOWN",
+    "reason": "candidate exposes no contracts to check",
+    "missing_contracts": [
+     "contract:a"
+    ],
+    "covered": 0
+   }
+  },
+  {
+   "name": "unhealthy SUPERSEDED",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "SUPERSEDED",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "INCOMPATIBLE",
+    "reason": "candidate status SUPERSEDED \u2014 not reusable as-is",
+    "missing_contracts": [],
+    "covered": 1
+   }
+  },
+  {
+   "name": "unhealthy STALE",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "STALE",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "INCOMPATIBLE",
+    "reason": "candidate status STALE \u2014 not reusable as-is",
+    "missing_contracts": [],
+    "covered": 1
+   }
+  },
+  {
+   "name": "unhealthy superseded_by set",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "CURRENT",
+    "superseded_by": "cap:newer",
+    "maturity": "WIRED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "INCOMPATIBLE",
+    "reason": "candidate status CURRENT \u2014 not reusable as-is",
+    "missing_contracts": [],
+    "covered": 1
+   }
+  },
+  {
+   "name": "no contracts required -> EXACT",
+   "contracts": [],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "CURRENT",
+    "maturity": "LIVE_PROVEN",
+    "consumers": [
+     "a",
+     "b"
+    ]
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 0,
+    "maturity_rank": 5,
+    "consumers": [
+     "a",
+     "b"
+    ]
+   }
+  },
+  {
+   "name": "unknown maturity ranks zero",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a"
+    ],
+    "status": "CURRENT",
+    "maturity": "WEIRD",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 1,
+    "maturity_rank": 0,
+    "consumers": []
+   }
+  },
+  {
+   "name": "duplicate provides dedup via set math",
+   "contracts": [
+    "contract:a"
+   ],
+   "candidate": {
+    "id": "cap:x",
+    "provides": [
+     "contract:a",
+     "contract:a"
+    ],
+    "status": "CURRENT",
+    "maturity": "EXERCISED",
+    "consumers": []
+   },
+   "want": {
+    "candidate": "cap:x",
+    "fit": "EXACT",
+    "reason": "all required contracts provided",
+    "missing_contracts": [],
+    "covered": 1,
+    "maturity_rank": 4,
+    "consumers": []
+   }
+  }
+ ]
+}

src/rust/token_counting/canary_token_counting.py

@@ -16,6 +16,7 @@ Run: python3 src/rust/token_counting/canary_token_counting.py
 
 from __future__ import annotations
 
+import json
 import os
 import subprocess
 import sys
@@ -107,19 +108,20 @@ def main() -> int:
         return 1
 
     from rune import tc_loader  # noqa: E402
-    from rune import token_optimizer  # noqa: E402
+    from rune import token_optimizer  # noqa: E402 — class surface only (delegation probe); kernel expectations frozen below
+    frozen = json.loads((Path(__file__).parent / "frozen_oracle.json").read_text(encoding="utf-8"))
 
     # ── 2. estimate_tokens parity ─────────────────────────────────────────
     print("\n--- 2. estimate_tokens parity ---")
     for name, text in token_cases():
-        py = token_optimizer._py_estimate_tokens(text)
+        py = frozen["estimate"][name]
         rs = tc_loader.estimate_tokens(text)
         test(f"tokens: {name}", py == rs, f"py={py!r} rs={rs!r}")
 
     # ── 3. _compress_context parity ───────────────────────────────────────
     print("\n--- 3. _compress_context parity ---")
     for name, text in compress_cases():
-        py = token_optimizer._py_compress_context(text)
+        py = frozen["compress"][name]
         rs = tc_loader.compress_context(text)
         test(f"compress: {name}", py == rs, f"py={py!r} rs={rs!r}")
 
@@ -128,11 +130,11 @@ def main() -> int:
     opt = token_optimizer.TokenOptimizer(storage_path="/tmp/tc-canary-store.json")
     test("public estimate_tokens matches core",
          opt.estimate_tokens("héllo wörld — ünïcode")
-         == token_optimizer._py_estimate_tokens("héllo wörld — ünïcode"),
+         == frozen["extra_estimate"]["héllo wörld — ünïcode"],
          "mismatch")
     test("public _compress_context matches core",
          opt._compress_context("User:  a\n\n\n\nAssistant:   b")
-         == token_optimizer._py_compress_context("User:  a\n\n\n\nAssistant:   b"),
+         == frozen["extra_compress"]["User:  a\n\n\n\nAssistant:   b"],
          "mismatch")
 
     print(f"\n{'=' * 47}")

src/rust/token_counting/frozen_oracle.json

@@ -0,0 +1,35 @@
+{
+ "_doc": "FROZEN ORACLE (token_optimizer strangler exit): expectations generated from the live Python _py_* on 2026-10-10, the last day they existed. The canary asserts Rust against these, not against imports — parity stays provable after deletion.",
+ "estimate": {
+  "empty": 0,
+  "three chars floor zero": 0,
+  "exactly four": 1,
+  "five floors one": 1,
+  "long ascii": 250,
+  "unicode code points not bytes": 5,
+  "emoji counts as code point(s)": 4,
+  "newlines counted": 2
+ },
+ "compress": {
+  "empty": "",
+  "no-op plain": "simple context",
+  "triple newline collapses": "a\n\nb",
+  "many newlines to two": "a\n\nb",
+  "double newline preserved": "a\n\nb",
+  "space run collapses": "a b",
+  "double space collapses": "a b",
+  "single space preserved": "a b",
+  "tab not a space": "a\t\tb",
+  "prefix shortening all three": "U: hi\nA: yo\nS: note",
+  "prefix mid-word untouched": "Abuser: stays",
+  "strip trailing": "padded",
+  "combined chaos": "U: a\n\nA: b c",
+  "unicode preserved": "héllo wörld\n\n— ünïcode"
+ },
+ "extra_estimate": {
+  "héllo wörld — ünïcode": 5
+ },
+ "extra_compress": {
+  "User:  a\n\n\n\nAssistant:   b": "U: a\n\nA: b"
+ }
+}

store/rebase/retired_modules.json

@@ -0,0 +1,17 @@
+{
+ "_doc": "Strangler-exit record: Python modules whose kernels landed and whose Python source was DELETED (Wave 5 retirement sweep, tranche plan \u00a7Wave 5: parity proven + CI green + deployed one cycle). A retired module reappearing as Python fails the dichotomy henxel gate (D4).",
+ "retired": [
+  {
+   "module": "token_optimizer",
+   "commit": "532fe649",
+   "evidence": "frozen_oracle.json 22 rows + canary 26/26 + 40 shims + 78 slice + clippy 0",
+   "date": "2026-10-10"
+  },
+  {
+   "module": "capability_fit",
+   "commit": "99698d16",
+   "evidence": "frozen_evaluate_fit.json 18 rows + canary 24/24 + 85 regression incl. live consumer",
+   "date": "2026-10-10"
+  }
+ ]
+}

store/rebase/retirement_ratchet.json

@@ -0,0 +1,6 @@
+{
+ "_doc": "RETIREMENT RATCHET (strangler exit, Wave 5): Python modules whose kernels have landed AND delegate \u2014 the deletion debt. The list ONLY SHRINKS: each entry retires when parity proven + CI green + deployed one cycle (the tranche plan's strangler-exit law). Floor never increases; a module reappearing here after retirement fails the dichotomy henxel gate (D3). CANDIDACY LAW (Nick 2026-10-10, tightened): a module earns deletion candidacy only when (a) the ENTIRE consumed Python surface has kernel counterparts, (b) the kernel exposes FFI externs or a live loader seam actually called by the adapter, (c) canaries prove the kernel matches AND beats the Python capabilities, (d) the tranche-plan exit law holds (parity + CI green + deployed one cycle). Partial ports like claim_audit (1 of 12 fns, no FFI externs) are NOT candidates \u2014 they are PARITY DEBT.",
+ "updated": "2026-10-10",
+ "py_lines_of_debt": 7496,
+ "candidates": []
+}

store/scaffold/intent/__init__.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for __init__ \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "__init__",
+ "why": "Rune \u2014 stateful coding assistant with elastic cognition.",
+ "side": "RUST",
+ "side_evidence": "package init: version/build-info reads only (deterministic metadata)",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/__main__.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for __main__ \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "__main__",
+ "why": "Rune TUI \u2014 the body. Entry point for `python3 -m rune`.\"\"\"",
+ "side": "RETIRES",
+ "side_evidence": "bootstrap glue subsumed by the Go runtime env contract",
+ "laws": [
+  "retired \u2014 no replacement; consumers must not import"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/abstraction.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for abstraction \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "abstraction",
+ "why": "Abstraction pipeline \u2014 converts raw episodes into reusable knowledge.",
+ "side": "GO",
+ "side_evidence": "RE-CLASSIFIED (Nick's dichotomy): sqlite3 (storage-backed); network/concurrency imports: ['urllib']; deterministic/state domain. Network/threading is the primary purpose \u2014 this module initiates, responds, or routes. Reactive \u2192 Go.",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/adaptive_router.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for adaptive_router \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "adaptive_router",
+ "why": "adaptive_router.py \u2014 canonical adaptive route authority (ADAPT-2, #291;\nrevised per handoff 2026-09-10 \u00a73\u2013\u00a77: progressive evidence routing).",
+ "side": "GO",
+ "side_evidence": "reactive/initiating domain",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/attention_capsule.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for attention_capsule \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "attention_capsule",
+ "why": "Attention Capsule \u2014 compact working set for cognitive work.",
+ "side": "RUST",
+ "side_evidence": "no network/reactive markers \u2014 pure compute defaults to the deterministic backend",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/audit_ledger.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for audit_ledger \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "audit_ledger",
+ "why": "audit_ledger.py \u2014 HMAC-chained tamper-evident promotion ledger.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/auto_context.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for auto_context \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "auto_context",
+ "why": "Auto-context plugin \u2014 runs memory recall on every user message and writes\nresults to a context file that can be injected into the model's view.",
+ "side": "GO",
+ "side_evidence": "network/concurrency imports: ['subprocess']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/auto_tasks.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for auto_tasks \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "auto_tasks",
+ "why": "Automatic task extraction \u2014 conversation becomes tracked tasks.",
+ "side": "GO",
+ "side_evidence": "sqlite3 (storage-backed); network/concurrency imports: ['subprocess']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/behavior.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for behavior \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "behavior",
+ "why": "Behavioral patterns \u2014 scoped corrections and habit formation.",
+ "side": "RUST",
+ "side_evidence": "sqlite3 (storage-backed); deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/behaviour_ledger.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for behaviour_ledger \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "behaviour_ledger",
+ "why": "behaviour_ledger.py \u2014 T19 \u00a719F/19G/19I: the canonical Behaviour\nValidation Ledger.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/build_basis.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for build_basis \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "build_basis",
+ "why": "build_basis.py \u2014 T18 \u00a718C: durable versioned RESEARCH BASIS for\nconstruction (V1 rule F: RESEARCH INFORMS STRUCTURE).",
+ "side": "RUST",
+ "side_evidence": "no network/reactive markers \u2014 pure compute defaults to the deterministic backend",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/build_mode.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for build_mode \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "build_mode",
+ "why": "build_mode.py \u2014 Build mode orchestrator for Rune TUI.",
+ "side": "GO",
+ "side_evidence": "network/concurrency imports: ['subprocess']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/builder_bridge.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for builder_bridge \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "builder_bridge",
+ "why": "builder_bridge.py \u2014 MiMo builder bridge (thin adapter over Rune Core).",
+ "side": "GO",
+ "side_evidence": "reactive/initiating domain",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/builder_bridge_cli.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for builder_bridge_cli \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "builder_bridge_cli",
+ "why": "builder_bridge_cli.py \u2014 CLI wrapper around rune.builder_bridge.preflight.",
+ "side": "GO",
+ "side_evidence": "reactive/initiating domain",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/cache.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for cache \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "cache",
+ "why": "Cache system \u2014 event-driven, write-once-derive-twice, compression for context not display.",
+ "side": "GO",
+ "side_evidence": "sqlite3 (storage-backed); network/concurrency imports: ['threading']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/canary_audit_ledger.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_audit_ledger \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_audit_ledger",
+ "why": "canary_audit_ledger.py \u2014 Python canary for slice-2 ports 1-6.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_cognitive_strata.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_cognitive_strata \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_cognitive_strata",
+ "why": "Cognitive strata canary: no-change suppression + toggle independence.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_context_broker.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_context_broker \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_context_broker",
+ "why": "Context-broker canary: admission, fail-loud, absence proof, compaction.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_conversation_state.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_conversation_state \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_conversation_state",
+ "why": "Conversation-state canary: canonical task + message ledgers stay alive.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_full_system.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_full_system \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_full_system",
+ "why": "canary_full_system.py \u2014 Full system canary with all wiring.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_gitea_automation.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_gitea_automation \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_gitea_automation",
+ "why": "Contract canary for Gitea templates, labels, and backups.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_gitea_delegation.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_gitea_delegation \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_gitea_delegation",
+ "why": "Gitea delegation canary: offline round trip, no network access.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_gitea_pipeline.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_gitea_pipeline \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_gitea_pipeline",
+ "why": "Contract canary for the mandatory Gitea push pipeline.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_memory_synthesis.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_memory_synthesis \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_memory_synthesis",
+ "why": "Memory and synthesis canary: item-ID cursor + cumulative chain.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_native.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_native \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_native",
+ "why": "Canary \u2014 verifies all native imports work correctly.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_orchestration_foundation.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_orchestration_foundation \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_orchestration_foundation",
+ "why": "Foundation canary: one spine, one authority, deterministic chain.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p0_04.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p0_04 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p0_04",
+ "why": "P0-04 pipeline-removal canary (#20).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p0_05.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p0_05 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p0_05",
+ "why": "P0-05 native-tools canary (#21).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p0_07.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p0_07 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p0_07",
+ "why": "P0-07 inference-trace canary (#23).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p1_01.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p1_01 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p1_01",
+ "why": "P1-01 capability-authority canary (#24).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p1_02.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p1_02 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p1_02",
+ "why": "P1-02 capsule-fidelity canary (#25).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p1_03.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p1_03 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p1_03",
+ "why": "P1-03 memory-selection canary (#26).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p1_06.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p1_06 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p1_06",
+ "why": "P1-06 model/provider-routing canary (#29).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_p1_07.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_p1_07 \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_p1_07",
+ "why": "P1-07 runtime-objects canary (#30).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_query_memory.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_query_memory \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_query_memory",
+ "why": "canary_query_memory.py \u2014 Canary for query memory system.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_resource_authority.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_resource_authority \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_resource_authority",
+ "why": "Resource authority canary: unknown rejected, outage deterministic, one authority.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_rune_entry.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_rune_entry \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_rune_entry",
+ "why": "canary_rune_entry.py \u2014 H1 canary for the Go first-call shim.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_rune_serve.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_rune_serve \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_rune_serve",
+ "why": "canary_rune_serve.py \u2014 H2 parity battery (T4.3, contract\nBUILDER-2026-10-04T08:32:43Z-cli).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_schema_migration.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_schema_migration \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_schema_migration",
+ "why": "Schema-migration canary: migrate once, idempotent re-run, wiring proof.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_spine_meta.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_spine_meta \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_spine_meta",
+ "why": "canary_spine_meta.py \u2014 meta-scaffold canary (H-meta).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_surface_parity.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_surface_parity \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_surface_parity",
+ "why": "Surface parity canary: same root for every entry path, offline.\"\"\"",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_tui_drift.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_tui_drift \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_tui_drift",
+ "why": "canary_tui_drift.py \u2014 Canary for TUI drift system wiring.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_tui_transport.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_tui_transport \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_tui_transport",
+ "why": "canary_tui_transport.py \u2014 H4 slice 1 battery (T4.5, contract\nBUILDER-2026-10-04T10:32:00Z-cli).",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/canary_unbounded.json

@@ -0,0 +1,12 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for canary_unbounded \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "canary_unbounded",
+ "why": "canary_unbounded.py \u2014 Canary for unbounded memory system.",
+ "side": "TEST-INFRA",
+ "side_evidence": "canary/test module",
+ "laws": [
+  "test/canary only \u2014 never a production dependency"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/capability_broker.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for capability_broker \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "capability_broker",
+ "why": "Capability broker \u2014 maps user intent to relevant plugins.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/capability_fit.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for capability_fit \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "capability_fit",
+ "why": "capability_fit.py \u2014 Requirement-fit capability discovery + gap decision.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Strangler exit 2026-10-10 (99698d16): _py_evaluate_fit deleted, Rust authoritative, frozen oracle + 24/24 canary.",
+ "status": "retired"
+}

store/scaffold/intent/capability_ledger.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for capability_ledger \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "capability_ledger",
+ "why": "capability_ledger.py \u2014 T19 \u00a719D: compact versioned Capability\nLedgers \u2014 local re-entry context packets.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/cc_loader.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for cc_loader \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "cc_loader",
+ "why": "ctypes loader for the Rust cognition_core (R2 W3.1).",
+ "side": "RUST",
+ "side_evidence": "ctypes FFI binding to libcognition_core (deterministic kernel membrane; no network imports)",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/chat_bubble.json

@@ -0,0 +1,13 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for chat_bubble \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "chat_bubble",
+ "why": "Chat Bubble Widget \u2014 styled message bubbles for the TUI.",
+ "side": "TUI-LAST",
+ "side_evidence": "textual/rich imports: ['rich', 'textual']",
+ "laws": [
+  "stays Textual until Wave 7 (Bubble Tea LAST by law)",
+  "no deterministic kernels in the TUI layer"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/claim_audit.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for claim_audit \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "claim_audit",
+ "why": "ACTIVE claim-audit layer \u2014 prevents unsupported strong claims at generation.",
+ "side": "RUST",
+ "side_evidence": "sqlite3 (storage-backed); deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/cognitive_budgeter.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for cognitive_budgeter \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "cognitive_budgeter",
+ "why": "Cognitive Budgeter \u2014 decides how much cognition an event deserves.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/connection_pool.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for connection_pool \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "connection_pool",
+ "why": "Connection Pool \u2014 reuse database connections instead of creating new ones.",
+ "side": "GO",
+ "side_evidence": "sqlite3 (storage-backed); network/concurrency imports: ['threading']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/construction_activation.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_activation \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_activation",
+ "why": "construction_activation.py \u2014 the activation dispatcher.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_commands.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_commands \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_commands",
+ "why": "construction_commands.py \u2014 T16 \u00a716J: bounded validated inbound\ncommand interface for future Substrate integration.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_decision.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_decision \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_decision",
+ "why": "construction_decision.py \u2014 live Need \u2192 Decision \u2192 Construction Contract.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/construction_depth.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_depth \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_depth",
+ "why": "construction_depth.py \u2014 proportional Scaffolding depth selection.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_intent.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_intent \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_intent",
+ "why": "construction_intent.py \u2014 T17 \u00a717J-\u00a717N: the conversational\ninterpretation layer of contextual construction.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_interface.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_interface \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_interface",
+ "why": "construction_interface.py \u2014 the stable builder-facing Construction\nInterface (SCAFFOLD-TRANCHE-007).",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_mode.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_mode \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_mode",
+ "why": "construction_mode.py \u2014 contextual construction classification.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_pattern.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_pattern \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_pattern",
+ "why": "construction_pattern.py \u2014 reusable evidence about HOW a class of thing\nis normally built.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_patterns_builtin.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_patterns_builtin \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_patterns_builtin",
+ "why": "construction_patterns_builtin.py \u2014 the initial evidence-grounded pattern\nset (SCAFFOLD-TRANCHE-006 \u00a710-14: 4 patterns, each derived from REAL Rune\nevidence, each appropriately immature).",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/construction_projection.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for construction_projection \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "construction_projection",
+ "why": "construction_projection.py \u2014 T16 \u00a716I: stable versioned PUBLIC\nprojection of construction state for future Substrate integration.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/context_broker.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for context_broker \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "context_broker",
+ "why": "ContextBroker \u2014 single authority over prompt context assembly.",
+ "side": "GO",
+ "side_evidence": "network/concurrency imports: ['threading']",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/context_pressure.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for context_pressure \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "context_pressure",
+ "why": "Context pressure monitor \u2014 know when the context window is filling up.",
+ "side": "RUST",
+ "side_evidence": "no network/reactive markers \u2014 pure compute defaults to the deterministic backend",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/contracts.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for contracts \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "contracts",
+ "why": "contracts.py \u2014 Contract testing for critical functions.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/core_server.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for core_server \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "core_server",
+ "why": "core_server.py \u2014 stdlib HTTP sidecar exposing the Rune operator surface\n(H2, contract BUILDER-2026-10-04T08:32:43Z-cli).",
+ "side": "GO",
+ "side_evidence": "network/concurrency imports: ['http', 'urllib']; reactive/initiating domain",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/cron_engine.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for cron_engine \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "cron_engine",
+ "why": "Cron Engine \u2014 scheduled tasks for Rune TUI.",
+ "side": "GO",
+ "side_evidence": "network/concurrency imports: ['subprocess', 'threading']; reactive/initiating domain",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/cs_loader.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for cs_loader \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "cs_loader",
+ "why": "ctypes loader for the Rust capability_scoring core (H3 slice 4, T4.4).",
+ "side": "RUST",
+ "side_evidence": "no network/reactive markers \u2014 pure compute defaults to the deterministic backend",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/curator.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for curator \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "curator",
+ "why": "Curator for the unified memory model.",
+ "side": "GO",
+ "side_evidence": "RE-CLASSIFIED (Nick's dichotomy): sqlite3 (storage-backed); network/concurrency imports: ['subprocess']; deterministic/state domain. Network/threading is the primary purpose \u2014 this module initiates, responds, or routes. Reactive \u2192 Go.",
+ "laws": [
+  "reactive/entry surface (no deterministic kernels hiding here)",
+  "oracle-first truth battery (generated from the live Python oracle)",
+  "HARD CI parity gate (replay + in-package test, not swallowable)",
+  "construction contract FIRST (absolute-scaffolding law)",
+  "parity + improvement note (defect fixed, measured gain, or honest parity-only)"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/dependency_tracker.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for dependency_tracker \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "dependency_tracker",
+ "why": "dependency_tracker.py \u2014 Auto-propagation for the OpenCode HARNESS scripts.",
+ "side": "RUST",
+ "side_evidence": "no network/reactive markers \u2014 pure compute defaults to the deterministic backend",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/drift_cache.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for drift_cache \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "drift_cache",
+ "why": "drift_cache.py \u2014 Drift-aware cache with wash-count-based eviction.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}

store/scaffold/intent/drift_compression.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for drift_compression \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "drift_compression",
+ "why": "drift_compression.py \u2014 Drift-aware compression.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Not yet ported. Parity means: kernel in its measured side, oracle-first truth battery, HARD CI gate, delegation wired, then retirement earned.",
+ "status": "not_started"
+}

store/scaffold/intent/drift_core.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for drift_core \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "drift_core",
+ "why": "drift_core.py \u2014 Governed Adaptation core engine.",
+ "side": "RUST",
+ "side_evidence": "deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "Parity claimed via oracle-first truth battery + HARD CI gate; deletion earned under the retirement law (parity + CI green + deployed one cycle).",
+ "status": "ported"
+}

store/scaffold/intent/drift_ledger.json

@@ -0,0 +1,16 @@
+{
+ "_doc": "INTENT LEDGER (scaffolding, Nick 2026-10-10): the WHY for drift_ledger \u2014 what it exists FOR, what side it belongs on, what laws its port must satisfy, and what 'parity' means for it. Parity is judged against intent, not just behavior.",
+ "module": "drift_ledger",
+ "why": "Drift ledger \u2014 drift protection for long projects.",
+ "side": "RUST",
+ "side_evidence": "sqlite3 (storage-backed); deterministic/state domain",
+ "laws": [
+  "deterministic pure kernel (no wall clock \u2014 inputs carry time)",
+  "no file IO in kernels (adapter owns persistence)",
+  "FFI envelope ABI (read_arg/arg_json/envelope)",
+  "oracle-first truth battery (Python truth generated FIRST)",
+  "llvm-cov branch coverage + clippy 0"
+ ],
+ "parity_means": "NOT parity: kernel exists but the Python module never delegates. Parity means the adapter delegates through the kernel (tier_manager pattern) with both paths pinned by tests.",
+ "status": "facade"
+}