parity: every growth_delta kernel ported name-preserving into the
cognition_core broker — _parse_json (fence strip, brace extraction, the
_parse_error degrade), _load_deltas/_save_deltas (parse-or-default, the
exact json.dump indent=2 bytes), _apply_profile (first-near-dup replace,
distinct append), _apply_one (200-char evidence, now-as-argument),
reflect's gate pipeline ([:3] slice, 12-char floor, behavioural-only,
0.6 gate), apply's validation (invalid-json/short/wrong-target/low-conf
branches), handle_hook passthrough, _llm's exact Ollama payload,
_write_store's memory_store argv, _ctx_budget's #28 arithmetic, and the
dict-aware py_near_dup.
fix-first: the facade's _near_dup fed DICTS into the string-only
growth_near_dup kernel, which answered False for every dict pair — live
core and pinned fallback DISAGREED (test_growth_delta_error_paths only
ran pinned, masking it). The new cc_py_near_dup kernel takes dicts-or-
strings; both pins now agree and the previously-masked assertion holds
live.
doc-envelope FFI via cc_free_string (never re-exported); cc_loader pins
argtypes+restype for all 12 new symbols; facade delegation with the
RUNE_COGNITION_CORE=python pin. Battery: 9 tests replay 24 pure +
22 state frozen-oracle cases VERBATIM (include_str!). Live parity 86/86
facade checks both pins; freeze_truth --verify byte-identical both pins.
clippy --all-targets -D warnings 0 (incl. two pre-existing lints the new
toolchain gates: branch_battery module inception, parse_probe format!).
Audit: growth_delta 5/20 → 17/20; the 3 remaining (_store_db env-path,
_cc_core loader probe, _py_growth_profile fallback oracle) stay Python
by law, same calibration as drift_cache.
Language verdict: RUST per docs/language-dichotomy-ledger.md (Law 4 —
deterministic trigger evaluation; the wall CLOCK is host-side by nature
(now passed per op, never null across FFI)).
- me_should_fire/me_fire_due/me_mark_fired doc-envelope FFI (me_*
symbols; free via capability_scoring cs_free_string — no free
re-export); me_loader mirroring broker_loader.py.
- Facade delegation with RUNE_ME_CORE=python pin; kernel floor on any
kernel error; INT now keeps the Python floor in mark_fired (the
oracle stores the value as-is; the kernel wire is float).
- Python laws replicated exactly: decision ordering (unknown → stop →
absent → rate → fires), state truthiness (0/''/null are absent),
falsy last_fired → 0, STRICTLY-LESS rate gate (equal fires),
Python int() truncation toward zero INSIDE the reason string,
fire_due in table (insertion) order, mark_fired shallow-copy with
unknown-trigger recording.
- 96-case frozen oracle truth (RUNE_ME_CORE=python pinned, deep-copied
inputs, every trigger class × every branch, truncation + boundary +
future-last cases) embedded in the crate and replayed VERBATIM by the
branch battery; live parity 1296/1296 (96 frozen + 1200 fuzz, seed
2479); pytest 56 passed (kernel auto) and 32 per pin BOTH ways;
clippy -D warnings clean.
Port the 12 audit-missing fns of src/rune/build_mode.py name-preserving
into the existing Go impl (contract BUILDER-2026-10-13T02:02:02Z-dad27f-
factory-gap-bm): _load_state/_save_state (ledger IO seam, buildsDir
injected), assess_complexity, and the full start_* phase-transition
family — the build-pipeline state machine frozen transition-by-transition
in declaration order via the SHARED freeze_truth harness (extended
backward-compatibly: dotted fn resolution + recv receiver rebuild for
class-based modules + the pinned clock its docstring promised, envelope
files carry frozen_now so --verify needs no env).
43 frozen cases byte-identical against the live oracle; _save_state byte
contract pinned by ledger_load_fixture.json (Python json.dump(asdict,
indent=2), phases in dict-insertion order via ledger first-occurrence);
_load_state error text pinned. Coverage 20/33 → 33/33 (audit-named).
LEDGER VERDICT: GO (docs/language-dichotomy-ledger.md) — the journal
write is I/O-bound file IO (decision tree: I/O-bound → Go) and the
census is simple counting over a static table (Laws 3/7: simple
operations stay in the caller's language; FFI overhead would exceed
the compute benefit — the census_report fold is ~16 increments).
parity: every public function of inference_paths ported — the CENSUS
table (all 16 call sites, insertion order preserved, notes verbatim),
trace_side_path's record shape (schema_version 1, kind side_path,
module/function/model/task_id/duration_ms, at) with the no-clock law
(`at` is a kernel argument — the oracle renders it via
time.strftime('%Y-%m-%dT%H:%M:%SZ', time.gmtime()); the freeze pins
time.gmtime), and census_report (total / by_kind fold / the EXCLUDED
list with documented reasons). Boundary law: the JOURNAL attempt
(rune.inference_trace import + record_trace + the journaled flag)
stays in the Python facade — the Go kernel owns the record shape and
the report. ORACLE DIVERGENCE NOTE (observable behavior pinned, not
fixed): the oracle's journal path is currently dead — InferenceTrace's
signature drifted (requires resolved_context_window/input_budget/
model_calls; the oracle passes prompt_tokens/output_tokens/cost), so
trace_side_path ALWAYS returns journaled=False via the except branch.
The frozen truth records that faithfully; the facade keeps its own
float duration_ms (Python renders 0.0 where Go marshals 0 — the
battery compares semantically). Journal attempts in the battery write
to throwaway temp dirs, never the real journal. gen_inference_paths_
truth.py freezes 7 cases (record defaults/full/zero/float/empty +
journal-failure branch + full census report); replay mode re-verifies
the live oracle 7/7. Go battery: go test replays truth.json VERBATIM +
the `inference-paths replay` CLI — 7/7; gofmt clean, go vet clean;
test_inference_paths.py 6/6 (no Python-side delegation pin — Go ports
are standalone per recall-uplift precedent).
Port the 18 missing sleep_time.py functions name-preserving to
src/go/sleep-time (kernels.go + kernel_dispatch.go) under the pure/IO
split law: deterministic cores in Go, IO (db, files, subprocess, http,
flock) behind injectable seams. 38-case branch truth (truth_gaps.json)
frozen from the live oracle with a pinned clock and deep-copied inputs,
replayed as a hard Go gate (truth_gaps_test.go) — 100% live parity on
the new fns. Wire live RUNE_SLEEP_TIME_CORE delegation in the facade
(_go_kernel JSON surface, 8 kernel call sites) with the python pin and
binary-missing fallbacks; both modes green (pytest, both ways). Go fn
coverage 8/26 -> 26/27 (the 27th is _go_kernel, the delegation glue
itself).
Contract BUILDER-2026-10-13T02:44:35Z-411615-factory-gap-mc. The 12
audit-named missing fns ported name-preserving into
src/go/memory-consolidation (ConsolidationNow, ConsolidationMemoryOracle,
ConsolidationNeuronOracle, LoadKnowledge/SaveKnowledge/LoadLessons/
SaveLessons/LoadConnections/SaveConnections, consolidateNeuron,
consolidateMemory, getRelevantKnowledge) plus the remaining 4 stragglers
(getRelevantLessons, getRelevantConnections, formatKnowledgeForPrompt,
getStatus) — 23/23 fn coverage, audit FULL. Logic 1:1 with the Python
oracle; IO and non-portables behind injectable seams (Clock, Compressor,
EntryLookup, store paths). Truth frozen through the SHARED harness
(scripts/freeze_truth.py + scripts/mc_freeze_seams/sitecustomize.py rig:
RUNE_COGNITION_CORE/RUNE_MEMORY_CORE pinned python, frozen clock,
hermetic MC_FREEZE_HOME, module-level seam bindings so the harness can
getattr the class methods) — 41 rows, byte-identical --verify vs the
live oracle, embedded VERBATIM and replayed by the go test battery and
the binary replay gate (PARITY OK 41/41; fresh re-freeze byte-identical
= live parity 100%). gofmt/vet clean; delegation tests green live
(CC_RUST_LIB kernel, 7/7) and oracle-pinned (RUNE_COGNITION_CORE=python).
Divergence, documented: Python hash() ids are process-randomized — the
entry-none branch pins the established id_prefix/entry_none shape
(truth_constructors.json precedent) instead of a non-portable hash.
Bare 'find . -name A -o -name B' without parens skips matches
unexpectedly; pane_authority's truth file (frozen_truth.json, 26 rows)
was missed by the ungrouped expression and missing name variant.
Language verdict: RUST per docs/language-dichotomy-ledger.md (Law 4 —
deterministic hashing/assembly law; the replay CALLABLE is host-side by
nature and stays in the facade).
- sk_sequence_id/sk_candidate_skill/sk_default_step_check/sk_sandbox_
gate/sk_promote doc-envelope FFI (sk_* symbols; free via
capability_scoring cs_free_string — no free re-export); sk_loader
mirroring broker_loader.py.
- Facade delegation with RUNE_SKC_CORE=python pin; kernel floor on any
kernel error.
- Python laws replicated exactly: json.dumps(steps, sort_keys=True)
BYTE law via pyjson::dumps_sorted + sha256[:12] (unicode, quotes,
nested structures verified); 'evidence or {}' falsy chain; default
shape check ('shape-ok'/'missing action'); passed=all with Python
truthiness and VACUOUS-TRUE empty steps (missing steps key too);
promote truthiness gate (missing/empty sandbox and passed=False all
block).
- 33-case frozen oracle truth (RUNE_SKC_CORE=python pinned, deep-copied
inputs, every public function + branch) embedded in the crate and
replayed VERBATIM by the branch battery; live parity 1624/1624 (24
frozen + 1600 fuzz, seed 2479); pytest 21 passed BOTH ways
(RUNE_SKC_CORE=python and auto); clippy -D warnings clean.
- Documented edge (not in corpus): integral float step values round-
trip as '3' through pyjson where Python would hash '3.0' — replay
scripts carry dict/list/str/int by construction.
Headline is now module-based: FULL/total (22% — 43/192), function-level
demoted to secondary detail. Mixing complete and in-flight work in one
number flatters progress; FULL is the only honest denominator.
PARTIAL rising is the funnel filling (NOT TOUCHED -> PARTIAL on landing),
not completion stalling — FULL went 42->44 in the same window.
Language verdict: RUST per docs/language-dichotomy-ledger.md (Law 4 —
pure deterministic classification/apply law; no I/O, no clock, the
whole module crosses FFI).
- pa_classify_utterance/pa_apply_to_task doc-envelope FFI (pa_* symbols;
free via capability_scoring cs_free_string — no free re-export);
pa_loader mirroring broker_loader.py.
- Facade delegation with RUNE_PA_CORE=python pin; kernel floor on any
kernel error.
- Python laws replicated exactly: (text or "") null law, control
first-word OR '{verb} the task'/'{verb} everything' substring law,
phrase-match verb="stop" law (even when the phrase matched a
different control word), status = verb+"ped" unless pause (the
oracle's 'cancelped' quirk frozen verbatim, not corrected), CHAT
amendment promotes visibly (needs_confirm=True), WORK amendment sets
directive, dict(task) shallow-copy semantics.
- 26-case frozen oracle truth (RUNE_PA_CORE=python pinned, deep-copied
inputs, every public function + branch) embedded in the crate and
replayed VERBATIM by the branch battery; live parity 826/826 (26
frozen + 800 fuzz, seed 2479); pytest 19 passed BOTH ways
(RUNE_PA_CORE=python and auto); clippy -D warnings clean.
- 7a/7b language-dependent: Rust = ctypes loader exists per facade import
(abbreviated stems: subsystem_health -> sh_loader); Go = go build +
exec/service connection (Go kernels are services by verdict, no .so).
- 7c: battery must reference the truth FILE (catches self-generated truth).
- 7d: CI gate presence check.
- WARN is now neutral (was incrementing FAIL — a pre-existing bug).
Verified green on both a known-good Rust landing (subsystem_health 8 PASS)
and Go landing (forge 7 PASS).
Language verdict: RUST per docs/language-dichotomy-ledger.md (W6 law —
deterministic record assembly with many fields; the journal FILE I/O
stays host-side per Law 7, the parse + receipt-assembly laws cross FFI).
- et_read_outcome_events/et_build_receipt/et_trace_task doc-envelope FFI
(et_* symbols; free via capability_scoring cs_free_string — no free
re-export); et_loader mirroring broker_loader.py.
- Facade delegation with RUNE_ET_CORE=python pin; kernel floor on any
kernel error.
- Python laws replicated: malformed-line skip, falsy task_id skip,
duplicate task_id last-wins, assigned_model→payload.model falsy
chain, payload-status-key-present (even null) law, completed_at
fallback, task_record or {task_id} falsy replacement, None-None→null.
- Fuzz divergence caught pre-landing: the oracle CRASHES (AttributeError)
on non-object journal lines ([1,2], 5, "x") — kernel now errors
(AttributeError envelope) so the facade reproduces the oracle crash
identically instead of silently skipping.
- 20-case frozen oracle truth (RUNE_ET_CORE=python pinned, deep-copied
inputs, every public function + branch) embedded in the crate and
replayed VERBATIM by the branch battery; live parity 820/820 (20
frozen + 800 fuzz, seed 2479); pytest 24 passed BOTH ways
(RUNE_ET_CORE=python and auto); clippy -D warnings clean.
parity: every public function of drift_resume ported branch-for-branch —
classify_drift (the 'matches is True' / 'matches is None' IDENTITY
checks — truthy non-True falls through to reality-differs; missing key
and explicit null both mean unverifiable), the stale_ok/user_locked
truthiness lattice, Python str() evidence renderings (str(None)='None',
str(True)='True', ints bare) with dict.get defaults applying ONLY on a
missing key (present-empty renders verbatim, present-null renders
'None'); reconcile (observer stays in the Python facade — the kernel
receives the observations; blocking-class filter preserves drift order,
resume = no blocking); detect_structural_drift (§18H: component filter,
the ext→identities falsy-source or-chain, identities.user_locked 'is
True' lock — truthy non-True is NOT locked, the exists check treats a
DIRECTORY source as present, moved-twin = first basename match over the
facade's sorted relative-path listing — unique-basename scenarios make
the oracle's rglob-first-match order-independent, evidence +
reconciliation strings exact). Replaces the old 11-line resume_state
stub crate (no consumers). Boundary law: the observer callable and the
filesystem walk stay in the facade; the kernel is a pure function of
their results. dr_loader mirrors dc_loader (doc-envelope FFI,
cs_free_string, DR_RUST_LIB override); facade delegation with
RUNE_DR_CORE=python pin. Battery: 3 tests replay 35 frozen-oracle cases
VERBATIM (include_str!). Live parity 35/35 facade + 35/35 kernel;
clippy 0; test_drift_resume + the §18H held-out suites green live AND
pinned (the one pre-existing failure on master, evidence_provenance
ep_loader FileNotFoundError, is unrelated to this module).
Pinned-core, no-clock, deep-copy, verbatim-embedding conventions in ONE
place. Includes --verify mode: re-freeze from live oracle and byte-compare
against the frozen file (catches self-consistent misreads at tick time).
Smoke-tested against rune.work_manager.
- verification_layer was miscounted NOT TOUCHED: the Rust stub crate
shadowed the full Go port in the corpus. Concatenate both sides.
- The *_loader family is the programme's own ctypes delegation glue
(strangler-fig stage-3 burn, same category as dunders) — machinery,
not port surface. ffi_query_memory_smoke is a smoke harness (TEST).
- Honest counts: 46% (1083/2366) | 40 FULL | 98 PARTIAL | 54 NOT TOUCHED.
Nick