339 Commits

Include renames

Author	SHA1	Message	Date
Nick	38497a61d0	feat(release_notes): port to FULL Go — dichotomy wave ... Full name-preserving port of src/rune/release_notes.py to src/go/release-notes (GO verdict, #2479 dichotomy tranche — 16/16 fns, dichotomy audit now FULL): - ReleaseNote record: __init__ sort-never-dedup semantics, to_dict insertion-order, from_dict; unicode codepoint sorts byte-parity - render_markdown: short-SHA [:12] clamping (rune-safe pySlice), empty section omission, backfill/provenance footers, unicode rstrip - extract_evidence_facts: closed-contract references + correctly_predicted proven, maintenance resolved/open, TUI projection decisions, release_evidence final_deployed/deployed_identity variants, sorted-set dedup; nested _clean echo for the §24F unsupported-claim filter - build_note: extras merged per key through the SAME exclude filter - summary_from_body: Python splitlines() full separator set (\v \f \x1c-\x1e \x85 \u2028 \u2029), H1-skip, heading/italic/item breaks, blank-gap stop, em-dash fallback - sha_from_body: (?i) tag/deployed markup regexes - Gitea surface: _api (HTTPError-before-OSError order, JSON/"_raw"/"_error" degrades with [:200] truncation), fetch_release, publish_release (create/update/idempotent, ordered POST payload, failed-dict shape) — HTTP behind the injectable Transport seam with request capture - converged_deployed_sha + os_readlink behind the FileSystem seam (RUNE_DEPLOY_ROOT default preserved) - auto_initial_note / convergence_refresh / build_from_deployment: store-missing/corrupt degrades, provenance defaults, tag-SHA-never- changes convergence truth - truth.json: 78 frozen rows from the live oracle (scripts/ gen_release_notes_truth.py) covering EVERY public function and branch — incl. scripted-transport request capture (method/url/headers/body byte-parity), 200+ char truncation, non-ascii escapes; replay 78/78 exact-equal, live-regenerated and re-verified; go test green; gofmt+vet clean - CI: release-notes gate upgraded to the HARD FULL-port parity gate (replay + TestTruthParity) - release_notes.py untouched (Python oracle remains the parity authority) Contract: BUILDER-2026-10-11T15:00:35Z-e67406-factory-wave (draft; phase walk + closure with both SHAs in the Phase B commit). Dichotomy audit: release_notes 16/16 → FULL.	2026-10-11 17:09:07 +01:00
Nick	180d2bb8b4	feat(abstraction): port to FULL Go — dichotomy wave ... Full name-preserving port of src/rune/abstraction.py to src/go/abstraction (GO verdict, #2479 dichotomy tranche — 17/17 fns, dichotomy audit now FULL): - ExtractFacts: Hindsight what/when/where/who/why prompt byte-parity (incl. existing-facts context), Mem0 ADD/NOOP via sha256[:80-lower][:16] content-hash dedup, entity upsert/linking with fact_count, HippoRAG who+first-3-words triples, LLM-array extraction (first '[' to last ']', JSONDecodeError -> []), deterministic kernel fallback seam (cc_abstraction_extract_facts with sorted stopword table + min_len=10, blank items skipped, text/words/content_words -> experience fact with kernel:true), silent kernel-failure degrade, raw[:200] error row - SynthesizeObservations: >=3-fact gate, facts_text [type] lines, DESC created_at source_fact_ids, confidence default 0.7, observation_count update; ListBeliefs/Rules/Skills (confidence/success_count DESC + limit); RunLifecycle (30-day/access_count/confidence<0.5 gates + superseded observations, changes() accumulation); PipelineStats (7 tables, active<=state tables); HandleHook - CtxBudget over frozen DEFAULT_PROFILES snapshot; Now() Python isoformat semantics (microseconds only when nonzero); cc_loader_pin env pin + kernel probe seam; connect() schema 1:1 (WAL, 8 tables, 8 indexes) - LLM payload byte-parity (temperature 0.3, num_predict, num_ctx via CtxBudget); OLLAMA_URL seam; transport failure -> logged + "" - RunCLI: main() exact stdout incl. argparse usage/help/error text frozen from the oracle (COLUMNS=80), --json via Python json.dumps(indent=2) byte-parity encoder (pyjson.go, ensure_ascii=True, compact + indented) - truth.json: 77 frozen rows from the live oracle covering EVERY public function and every branch (LLM valid/prose-wrapped/unterminated/empty/ dedup/short/hash-80-truncation, kernel fallback/raise/none, prompt-bytes captures, payload captures, lifecycle gate matrix, CLI branches incl. help/bad-choice/usage) — replay 77/77 exact-equal, live-regenerated and re-verified (frozen == live); go test green; gofmt+vet clean - IO (sqlite via modernc.org/sqlite, LLM transport, clock, env, kernel) behind injectable seams; scripts/gen_abstraction_truth.py committed - CI: HARD abstraction FULL-port parity gate (replay + test, not swallowable) - abstraction.py untouched (Python oracle remains the parity authority); stale batch-28 extractor skeleton superseded by the full port Dichotomy audit: abstraction 17/17 → FULL (27%→28% function-level). Contract: BUILDER-2026-10-11T13:36:04Z-c0db01-factory-wave (phase A of factory protocol v2; improvement commit follows before closure).	2026-10-11 15:43:11 +01:00
Nick	2016fe0433	refactor(system_registry): language-advantage pass — Category enum lattice, encode_utf16 escaping, iterator report grouping ... language advantage: Category enum with exhaustive match replaces string comparison chains (for_scripts_ext/for_systemd_name constructors); char encode_utf16 replaces manual surrogate-pair bit math; iterator filter/collect replaces by_cat Vec-find grouping; writeln! replaces format!+push_str churn. Battery green (4/4), clippy 0, live parity 33/33.	2026-10-11 15:27:49 +01:00
Nick	08757105e7	feat(construction_intent): port to FULL Rust — dichotomy wave	2026-10-11 14:48:20 +01:00
Nick	55ad089c3f	feat(spine): port to FULL Rust — dichotomy wave ... Facade kernels ported to the rune_spine Rust core (RUST verdict, issue #2479 tranche, contract BUILDER-2026-10-11T08:06:21Z-1a7a76-factory-wave): - sf_sorted/sf_save_text/sf_entity/sf_declared_surfaces/ sf_project_meta_surfaces/sf_ingest_umbrellas_data FFI via doc-envelope - facade delegation wired (RUNE_SPINE_CORE=python pins the strangler fallback; entity returns the live dict to preserve mutation semantics) - REAL divergence fixed pre-wiring: the Rust ingest refusal message was missing the oracle's exact text; battery caught the save redaction boundary (spine.save does NOT redact — that is structural_store.save) - battery: 26 frozen-oracle cases replayed verbatim in-crate (45/45 crate tests, clippy clean); live parity 26/26 vs the Python oracle - 135 spine-adjacent Python tests green (delegation live); pinned fallback mode identical to pre-batch behavior - dichotomy audit: spine 5/30 -> 20/35 functions matched (rune_spine crate registered in the alias table) Dichotomy verdict: spine PARTIAL — pure kernels Rust-authoritative; gather/IO and _py_* fallback oracles stay Python by the zero-dep split law.	2026-10-11 10:17:46 +01:00
Nick	a95c6ce129	feat(curator): port to FULL Go — dichotomy wave ... DICHOTOMY VERDICT: GO (reactive/entry surface — the port completes the GO-side deterministic core; store/journal/embed/graph IO stays on the Python adapter seams by design, not by omission). Ported (name-preserving, src/go/curator-core/wave.go): - IsTopicFact (topic-neuron heuristic, 21-word domain table) - SemanticCandidateKey (cosine >= 0.62 accumulation, insertion-order tie-break; embed seam adapter-injected) - GraphTriple/GraphWrite (ordered verb map, prep/punct object trim, subject guard; graph_memory.py subprocess stays a seam) - AuthorSkillBody/AuthorSkill (SKILL.md doc-build, Evidence-section rule) - ApplyOp (full write-path surgery: PROPOSE journaling, SKIP-DUPLICATE body+store dedup, SKIP-CONSTITUTION belt-and-braces, UPDATE supersede transition, DELETE line+meta removal, skill routing, unknown-label journal passthrough) - HandleHook Excluded (fallback/adapter by design): _aaak, _embed ollama IO, coherence_check corpus/session IO, read_block/write_block/store_has sqlite seams, apply_warm warm-router IO, run_plan drift-ledger IO — these are the Python strangler surface, not ported per the scaffolding law. Truth: scripts/gen_curator_wave_truth.py freezes 38 cases from the live oracle (truth_curator_wave.json embedded verbatim); battery 38/38 + live re-verified 38/38. Full curator-core suite green; Python surface tests green (no facade delegation — Python oracle untouched).	2026-10-11 09:44:03 +01:00
Nick	1619cbe6b1	fix(SRE): CI failure triage — the whole local suite is GREEN again (#2479 sidequest, SRE hat) ... The SRE question was: are the Actions runs finding real issues or wasting submissions? Answer: BOTH — the failures are REAL, and they were mine: 1. cargo fmt --check: 19 crates with pre-existing drift (batches 55-79 never ran fmt) — fixed, all tests still green. 2. canary scripted-run: 7 stale 'assemble=lambda task, session, model_id' lambdas — send_task grew the session_id kwarg (#141); lambdas now **kwargs. 168 tests in the affected suites green. 3. type-check pyright ratchet 117->121 — addressed with the fixture fixes. 4. umbrella gate: message_graph (#13) was never spine-registered — registered in subsystem:memory, view regenerated (spine-authoritative). 5. scaffolding gate: auto-detect + forge-client retro-adopted (absolute law honored: explicit contracts BUILDER-...-504272 / 5bc1c7). 6. lint-contract test: ruff discovery failed outside CI venv — fallback to PATH + bite-test PATH fix. 7. test_p3 shadowing: scripts/growth_delta collided with rune.growth_delta in the full run — explicit-path loading. FULL LOCAL SUITE: 2618 passed, 0 failed (was 7 failed / 18 failed / more). The CI backlog was draining against genuinely red commits — every failure was a real signal, never noise.	2026-10-10 03:41:26 +01:00
Nick	f170a01b1e	chore: audit doc refresh + store docs (batch 174)	2026-10-10 01:45:56 +01:00
Nick	1ecaa76e4a	feat(research): harness invariants — the R1 repair classes as deterministic checks (#411, contract BUILDER-2026-10-08T18:49:19Z-7236d8) ... - scripts/research_harness_invariants.py: 6 invariants (I1 schema-shape, I2 outward-evidence, I3 innovation-ground, I4 synthesis-qualify, I5 ledger-validity, I6 no-phantom-paths) + one-call check() every harness entry point can run + CLI. - tests/test_research_harness_invariants.py 7/7: each fixture IS a repair family (the bad shapes that caused the R1 repairs), pinned as regression. - Language verdict (dichotomy law): Python — deterministic validation over in-process harness artifacts (batch/tooling, not runtime backend state).	2026-10-08 19:50:11 +01:00
Nick	570e7d10e2	fix(lint): polyglot gate path normalization + go/rust formatting debt — fault-watch fix (contract BUILDER-2026-10-08T15:15:16Z-6a78f4) ... - ROOT CAUSE: lint_rust called Path(f).relative_to(REPO) on already-relative paths — ValueError on every all-rust changed set since the relative-path change; the gate has been silently dead for rust whenever changed-only mode collected rust files. Normalized via os.path.isabs. - gofmt: 8 Go files carried pre-existing formatting debt (surfaced only now that the gate can actually see them) — formatted. - rustfmt: branch_battery.rs formatted. - Verified: polyglot clean (468 changed → 169/165/107), rust shims 40/40, cargo 34/34, ratchet PASS.	2026-10-08 16:16:19 +01:00
Nick	33ff9ec4e0	feat(phase-g): #2447 remaining — CI qualification + fresh shadow evidence for the query_memory authority switch (contract BUILDER-2026-10-08T13:52:55Z-b0fc70) ... - ci.yml: query_memory in ALL THREE rust build lists + a shadow step. - scripts/qm_shadow.py: the honest shadow — the TRUE pre-shim Python oracle (recovered from git history 6f44a87~1 — the parity harness pointed at the superseded src/rune/query_memory.py, comparing Rust against Rust) vs the Rust CLI on the frozen 24-command sequence in isolated HOMEs. - Fresh evidence: 24/24 commands exact-equal, history.jsonl + topic_stats.json byte-parity. The authority switch itself was already landed (shared/query_memory.py = AUTHORITY-SWITCHED shim, verification wall green).	2026-10-08 14:59:52 +01:00
Nick	8f2ec34bc4	fix(lint): annotate the board fetcher's intentional silence — BLE001 baseline (fault-watch fix, completes c73d249)	2026-10-08 14:48:58 +01:00
Nick	c73d24975b	fix(lint): annotate the rust-deploy terminal reporter — BLE001 ratchet at 47/47 baseline (fault-watch fix)	2026-10-08 14:27:57 +01:00
Nick	853468783d	feat(finance): stdlib-only finance tracker — #3 (contract BUILDER-2026-10-08T13:22:02Z-af7a8b) ... - scripts/finance_tracker.py: CSV ledger (~/.rune/finance/, human-readable, portable), add/budget/report commands, month + week filters, per-category totals vs budgets with over-by flags, income/net, and recurring-payment detection (3+ same-note ~monthly payments) that surfaces subscription cancellation candidates — the exact 'flags subscriptions worth cancelling' acceptance. - tests/test_finance_tracker.py 6/6: sign→kind, budget over-flag, net, week filter, monthly-subscription detection, one-off not flagged.	2026-10-08 14:24:29 +01:00
Nick	e80ba65e8c	feat(deploy): Rust cores ship as BINARIES into the deployed revision (#2455, contract BUILDER-2026-10-08T13:01:13Z-0cb00d) ... - scripts/deploy_rust_build.py: builds all 11 crates CI builds INTO the staged tree (in-tree target/release — the loaders' default path), then FFI-smokes each: CDLL + loader entry symbol per crate, PLUS a real FFI call (token_counting tc_estimate_tokens {"text":...} -> int) through the exact loader convention (argtypes c_char_p, restype c_void_p, tc_free_string). - deploy_stage.py: the Rust phase runs AFTER staged-verify, BEFORE the TUI canary and promotion — a revision whose cores don't build or smoke never becomes current. RUNE_DEPLOY_SKIP_RUST=1 is the documented emergency bypass. - Live proof: 11/11 built + 11/11 smoked on a real staged tree, bare exit 0.	2026-10-08 14:01:46 +01:00
Nick	7e1a5b84b6	feat(umbrellas): forge board + umbrella closure proofs — #204/#125/#284 (contracts BUILDER-2026-10-08T12:31/32/33) ... - #204: scripts/forge_board.py — the forge as the single pipeline state machine. Derives the next action per open issue from forge state alone (labels + CI verdict): FIX FIRST / WAITING / BLOCKED / REVIEW / CONTINUE CONTRACT / OPEN CONTRACT. Deterministic, zero tokens, injectable fetcher; live read returns the full board. - #125: tests/test_epic_umbrellas.py::Test125 — the decomposition's migrate-adapter end state proven: ContextBroker contributors own model-facing context (operator registers adapters only), archive-candidate mechanisms removed, model resolution delegates; adapter block <200 lines. - #284: instruments end-to-end (scorecard, wiring status, route acceptance) — all ADAPT children #294-#301 CLOSED.	2026-10-08 13:38:57 +01:00
Nick	73134a3122	feat(adapt): ACCEPTANCE TRIO CLOSED — route acceptance, scorecard, wiring report (contract BUILDER-2026-10-08T12:24:58Z-472dfe) ... - test_route_acceptance.py (#300): fixes stay light, uncertainty escalates via the production sufficiency path, provenance never lost, floor-protected downgrade raises — 4/4 - adapt_scorecard.py (#301): 6-job fixture set, 6/6 route accuracy, elapsed + avoided-waste reported - wiring_status.py (#315): 202 modules mapped to wiring + authority-map coverage, unwired list, largest-first 10/10 green. #300/#301/#315 closed with evidence.	2026-10-08 13:30:14 +01:00
Nick	3889d1d0e8	feat(adapt): ADAPT QUARTET CLOSED — budgets, capsules, consolidation, legibility (contract BUILDER-2026-10-08T12:20:44Z-2c1a18) ... - research_budget.py (#294): query/tool budgets with overrun refusal + explicit stops - evidence_capsule.py (#295): fixed-size capsules (5/3/3) with truncation accounting + raw-evidence pointer - design consolidation (#296): the A/B experiment recorded — standard jobs merge (applicability checks are the rail), high-uncertainty keeps the separate step - harness_audit.py (#299): legibility scorer (owner/tests/contracts discoverability) + repo report 10/10 green. #294/#295/#296/#299 closed with evidence.	2026-10-08 13:23:26 +01:00
Nick	03070830b6	feat(bench): #45/#46/#47 CLOSED — warm ablation, growth delta, transfer experiment (contracts 197587/a78c0a/31d506) ... - warm_ablation.py: 4-condition matrix (lexical/hybrid/hybrid+warm/ hybrid+outcome) with the KEEP-vs-SIMPLIFY verdict rule - growth_delta.py: 8 behavioural metrics with advantage deltas (NOT database growth) - transfer_experiment.py: the both-models-must-clear protocol for the core research hypothesis (one-model wins don't count) - 9/9 green	2026-10-08 12:32:03 +01:00
Nick	8e5e8ca331	feat(bench): #44 CLOSED — RuneBench v0.1 (contract BUILDER-2026-10-08T11:25:21Z-1497c5) ... 8 task families × 4 conditions (fresh model / fresh Rune / experienced Rune / experienced-no-memory), offline fixtures for the CI gate + live Ollama mode for real measurement. Deltas (not vibes): C−B experience advantage, C−D memory contribution. #45/#46/#47 unblocked. 6/6 green.	2026-10-08 12:27:45 +01:00
Nick	91a91e8e36	feat(graph): #42 CLOSED — live graph-health instrument + supersession pins (contract BUILDER-2026-10-08T10:58:57Z-019b73) ... - graph_health_report.py: superseded/active/expired ratios, orphan + dangling counts, normalization behavior — against ANY store path. Empty graphs report no-data (ratios undefined, not 0%), missing stores report no-store. The dossier statistic is replaced by a live instrument anyone can run. - supersession state machine pinned: old edge marked (never deleted), new edge wins, superseded_by chain intact.	2026-10-08 12:02:37 +01:00
Nick	f9f83e0c35	feat(review): reviewer P0 trio CLOSED — rubric + calibration + first-pass agent (contract BUILDER-2026-10-08T10:27:52Z-a8b4ae) ... - #129: dimensional review rubric folded into the dispatch template (correctness/design/test-quality/observability/security, forced-choice verdicts; missing dimension = incomplete review) - #130: calibration harness (scripts/reviewer_calibration.py) — 5 known defects from the ledger + 1 clean control, 6/6 caught (100%, CALIBRATED). The pagination pattern needed widening for dotted receivers (self._rows[:50]) — the harness caught its own blind spot. - #131: local-model first-pass reviewer — Gitea workflow (local-review.yml) + agent script (local_firstpass_review.py, Ollama + review-lessons + #129 rubric). Fail-open by design: Ollama unreachable → skip with a note; findings are advisory PR comments, never gates.	2026-10-08 11:32:09 +01:00
Nick	82abd1b3ab	feat(pipeline): EXIT-NOTE TEMPLATE — plain-English version history (contract BUILDER-2026-10-08T02:04:24Z-a129fb) ... Nick's directive: when the pipeline earns a new version, the release body must carry a plain-English summary of what was worked on and submitted — the counterpart of the issue-entry template, part of the Gitea Actions pipeline (auto-version.yml), not a manual step. - scripts/release_exit_note.py: renders the exit note from the push range (git log v<last>..HEAD, chore(release) excluded) — conventional- commit prefix → kind classification (added/fixed/improved), reader- facing translation (contract refs, parity language, truth batteries), aggregate headline + per-item bullets + verification summary - auto-version.yml: wired into the release step (LAST_TAG → release_exit_note.py → --exit-note flag on release_history_cli init) - release_history_cli.py: consumes --exit-note, parses the markdown into structured extras (headline + items) passed to auto_initial_note(extra=...) - release_notes.py: auto_initial_note accepts extra (merged into improved/added/fixed after fact extraction, deduped) - scripts/backfill_exit_notes.py: retroactive backfill for the 27 pre-template releases (executed — all patched) The exit note is now a first-class pipeline citizen: every earned version carries the human narrative alongside the governed evidence.	2026-10-08 03:19:27 +01:00
Nick	6d2fb5edea	feat(go): factory batch 12 — FAMA scoring (contract BUILDER-2026-10-08T02:01:32Z-236bbf-unknown) ... Forgetting-Aware Memory Accuracy ported to drift-core: valid = active AND (wash>0 OR rock/established); missing rows skipped; empty = 0.0. 5-case battery from the live oracle incl. the missing-row path. First-run green.	2026-10-08 03:01:43 +01:00
Nick	1568d571ea	feat(go): factory batch 11 — sleep-time transcript surfaces (contract BUILDER-2026-10-08T01:44:30Z-b7985f-unknown) ... ExtractTodos (latest-todowrite filter, malformed rows skipped) and WriteTranscript (byte format, injected clock, title sanitization) ported to sleep-time. SQL stays reactive. 5-case battery. Oracle quirks pinned: SQL json_extract crashes on malformed JSON rows; write_transcript relies on _ensure_dirs pre-running.	2026-10-08 02:44:40 +01:00
Nick	32dda3d3bd	feat(go): factory batch 10 — drift value mechanics (contract BUILDER-2026-10-08T01:27:57Z-743b1c-unknown) ... ComputeValue (5-factor weighted score: log1p proven, recency half-life 30d with floors + bad-ts degrade, reliability, goal relevance) and CheckPromotionEligibility (rock short-circuit, threshold gate, 0.6 minimum, exact reason texts) ported to drift-core. Constants verbatim, clock injected. 13-case battery incl. degrade paths — first-run green.	2026-10-08 02:28:08 +01:00
Nick	ce638de74e	feat(go): factory batch 9 — event-bus content hash (contract BUILDER-2026-10-08T00:06:39Z-8c023f-unknown) ... _content_hash ported with FULL python json.dumps byte semantics: nested sort_keys recursion, ensure_ascii escaping, and the int-vs-float literal distinction preserved via json.Number decoding (the oracle distinguishes 1 from 1.0; the hash of an int-carrying payload differs from the float-carrying one). 6-case battery — the oracle corrected two assumptions before the design was pinned.	2026-10-08 01:06:50 +01:00
Nick	4c7ee39f61	feat(go): factory batch 8 — microkernel registry primitives (contract BUILDER-2026-10-07T23:35:52Z-see-contract) ... Register/Unregister/Resolve ported to microkernel, integrated with the committed main.go shapes (PluginManifest typed struct; Hooks widened to map[string]interface{} for oracle parity — the manifest carries bool enabled flags). Resolve: priority ladder (lower = higher), active-only filter, stable tie order. 6-case battery from the live oracle with a tmp-REGISTRY_DB seam (the reactive store isolated). The oracle fixtures corrected my snapshot approach: the registry is PERSISTED per-op, so the truth reloads from the store rather than trusting a stale in-memory object.	2026-10-08 00:41:51 +01:00
Nick	c1d9e424eb	feat(go): factory batch 7 — cache mechanical compression (contract BUILDER-2026-10-07T23:29:49Z-a1fb0d-unknown) ... Compress ported verbatim: drop empty/comment/decorative/citation/short lines, join, 797+... truncate past 800. 9-case battery (4 hash + 5 compress) from the live oracle. First-run green.	2026-10-08 00:30:00 +01:00
Nick	d980aeba43	feat(go): factory batch 6 — cache content-hash (contract BUILDER-2026-10-07T23:23:32Z-8265ae-unknown) ... ContentHash sha256[:16] ported to cache/ — the change-detection hash. 4-case battery from the live oracle. sqlite layer stays reactive.	2026-10-08 00:23:43 +01:00
Nick	76430ca71f	feat(go): factory batch 5 — provider tool-format adapters (contract BUILDER-2026-10-07T23:14:45Z-635b00) ... FormatToolsOI/FormatToolsAnthropic ported: the provider-facing shape transforms with default-parameters fallback. 2-case battery from the live oracle (with and without the parameters key). The [OI] in the original name was literal Go generic syntax — invalid; renamed to OI.	2026-10-08 00:20:44 +01:00
Nick	4c1b13e61a	feat(go): factory batch 4 — hook placement mechanics (contract BUILDER-2026-10-07T23:06:18Z-ec6208-unknown) ... RecommendPlacement ported verbatim to hook-engine: the decision table (hook points with append-order shape, the frequency ladder, cache scopes, concurrency, failure modes, context budget) + the HOOK_*/FREQ_*/SCOPE_* constants. 14-case factor-matrix battery from the live oracle — first-run green. The factory continues.	2026-10-08 00:09:18 +01:00
Nick	4032c753f3	feat(go): factory batch 1 — tool-protocol validation core (contract BUILDER-2026-10-07T22:11:52Z-9ffb73) ... The model→tool boundary ported to tool-protocol: - ValidateToolRequest: alias canonicalization BEFORE schema (grep→ grep_files, bash→run_command — bash never bypasses run_command's approval boundary), exact Python error texts (unknown tool / required argument missing / unknown argument / must be <type>), array item type checks, deterministic arg iteration for error stability - schemas from the FROZEN tools_registry.json (shared with tool-executor — the set-equality authority) - NormalizeOllamaToolCalls: native envelope + string-arguments JSON decode, malformed-shape errors - ContainsInternalProtocol: result/error markers + xml tool_call spans - ToolRequest dataclass aligned to the Python shape (Arguments field) - 17-case truth battery from the live oracle; span-surgery surfaces (extract_visible_text, text-fallback parse) pinned for batch 2	2026-10-07 23:48:24 +01:00
Nick	eef7768501	feat(pipeline): the POLYGLOT LINT GATE — language-aware dynamic linting + fuzz + property invariants (contract BUILDER-2026-10-07T20:01:40Z-ac6140-unknown) ... Nick's directive: linting must apply DYNAMICALLY on the right language — Go/Rust/anything gets the correct linter — plus fuzzy tests and useful bug-catchers, wired into the Gitea pipeline. THE GAPS (confirmed by inspection): Rust had ZERO linting (crates built, never clippy); Go had vet only (gofmt drifted across 41 files); no fuzzing anywhere; no property-based tests. NEW: - scripts/polyglot_lint.py: detects changed files vs the push range, groups by language (extension + path prefixes), runs ruff / go vet + gofmt -l / cargo clippy + cargo fmt --check per language; unknown extensions skipped with a note; exit non-zero on any finding - CI: gofmt gate (formatting is a gate), go test -race sweep, go fuzz smoke (15s per target), and a NEW rust-surface job: rustfmt --check + clippy -- -D warnings + cargo test (currently trivial — the crates carry no #[test] yet; this lights up the moment the first lands) - GO FUZZ TARGETS on the byte-parity surfaces: canonicalJSON (round-trip), Norm (deterministic + charset), Stem (no-grow/no-empty — idempotence deliberately NOT asserted: the oracle folds retroactively → retroactive → retroactiv, verified), FtsQueryConjunctive, Overlap (symmetry + [0,1]) - PYTHON property invariants (hypothesis, pinned 6.168.5 in dev extras + requirements-ci.txt): the same mathematical properties, mirrored FOUND BY THE FUZZER ON FIRST LIGHT: - canonicalJSON passed control bytes (<0x20) through RAW — Python json.dumps escapes them \uXXXX even with ensure_ascii=False. The Go digest DIVERGED from the oracle on adversarial payloads. FIXED (jsonEsc now emits \u00XX); the approval-digest surface is byte-stable again - the FTS builder never escapes embedded quotes (oracle-verified: Python does the same) — pinned as oracle truth; FTS5 hardening filed separately Also: gofmt -w across the tree (the 41-file drift converged; every module builds), clippy --fix + cargo fmt across all 80 crates (warnings ~110 → 59 mechanical-fixed, remainder are stylistic and now GATED so debt cannot grow). THE PIPE-MASK hit my own verification twice more this session — the gate script itself exits 1 correctly (verified bare).	2026-10-07 21:31:23 +01:00
Nick	de9dee7dd9	feat(go): memory-store batch 4 — the dense-side meta-judgement (contract BUILDER-2026-10-07T19:47:37Z-1cf1dc-unknown) ... The recall() gate ported to memory-store-deep: - DenseGate: vector proximity is not a relation — a dense hit (cos = 1 - distance/2) is kept iff it shares a DISTINCTIVE content word with the entry (df/total < 0.05 via LIKE-substring counts); fallback keeps no-content-word queries or strong matches (cos >= 0.80). The black-coffee/black-holes fix, now deterministic-side. - QueryContent (len>3 non-stop, first-occurrence order) - RankFusionEntries: verified IDENTICAL to the chunk-side fusion (same code, :1297 vs the batch-2 port) — wrapper pins the parity for the recall() call shape; the docstring's raw-BM25 claim is stale, the CODE min-max normalizes in all modes (code is the oracle) - the abstain constants: RECALL_BUDGET=8, RECALL_MIN_SCORE=0.42 PARITY: truth_gate.json — 6 cases from the live oracle against a fixture store (distinctive/common/strong-cos/no-content branches + fusion identity + constants). Embedding/vec0 SQL and the cache stay reactive.	2026-10-07 20:52:25 +01:00
Nick	ee7da6d080	feat(go): warm-router deep batch — the always-on digest core (contract BUILDER-2026-10-07T19:35:07Z-4d6b4c-unknown) ... The digest selection machinery ported to warm-router: - LexicalSignal (punctuation-strip, len>3, _DIGEST_STOP 64 words extracted verbatim), LexicalOverlap (Jaccard) - Universality: the rule-vs-record classifier (date regex → 0, dated markers 2+ → 0 / 1 → 0.25, directive markers capped +0.25, terse 40/90 ±0.15/-0.2, clamp) - DigestSelect: the pure core — topic_rank slug ordering, 5-key stable sort (topic, -universality, always_on, -importance, -lexical density), junk skip (<12 chars / no triggers), universality gate, lexical gate, Jaccard dedup >=0.45, token sizing (len/4), oversized skip, budget fit PARITY: truth_digest.json — 9 cases. The oracle corrected MY expectation in the fixture: operating-gates-copy (importance 0.8) outranks the original (0.7) on the importance tiebreak — fixture honesty, again. DB I/O stays reactive. First-run green on the port itself.	2026-10-07 20:39:13 +01:00
Nick	5dea803e92	fix(tools): SECURITY-ADJACENT parity repair — the approval boundary (contract BUILDER-2026-10-07T19:10:38Z-cc6be2-unknown) ... src/go/tool-executor readOnlyTools diverged from the Python oracle in BOTH directions: - it wrongly ADDED run_command — a mutating tool the oracle routes through operator approval; the Go port would execute it read-only (the dangerous direction: approval bypass) - it MISSED 8 of the 12 oracle read-only tools (git_diff, git_log, repo_map, read_persona, query_memory, check_growth, diagnose_behavior, find_capability) Fixed to the exact 12-tool set, and pinned by a FROZEN truth battery (gen_tool_executor_auth_truth.py → truth_auth.json) asserting set equality both ways forever — the test's failure message says it plainly: THE APPROVAL BOUNDARY HAS DRIFTED. Per-wave routine held (gates bare, spine rebuilt, both snapshots shipped).	2026-10-07 20:13:13 +01:00
Nick	df9290fcff	feat(go): memory-store batch 3 — the scoring/abstention kernel (contract BUILDER-2026-10-07T18:57:06Z-c2429c-unknown) ... The recall scoring kernel ported to memory-store-deep: - ScoreRecallRows: rank-ordered metadata scoring — confidence (0.7 default) x temperature (1.0 default) x recency (half-life 30.0, hl/(hl+days) on non-negative days, timestamp failures degrade to 1.0); dense base vs lexical base+5.0; the exact round discipline (rrf/conf/temp 4-4-2-2) - PositionAware: the lost-in-the-middle re-rank — best item FIRST, second-best LAST, same items, order-only (no-op < 3) - the FULL abstention ladder verbatim: neither → []; lexical-only max-relevance gate; dense-only min_score → >=0.74 position-aware → >=2 rows with 0.08 gap → gap-abstain → position-aware(map_reduce); hybrid min_score then position-aware(map_reduce) PARITY: truth_score.json — 6 cases covering every abstention branch (hybrid 3, dense-only high-conf/gap-abstain/min-score, lexical gate, neither). First-run green — the oracle's fixture honesty paid forward.	2026-10-07 20:00:56 +01:00
Nick	3f440693de	feat(go): scaffold batch 3 — the closure mechanics (contract BUILDER-2026-10-07T18:42:38Z-52829e-unknown) ... CloseContract ported to Go: - CloseQuality: the pure bucket math verbatim — pred_existing from affected_entities + the frontier's 4 keys, correctly_predicted / predicted_but_unaffected / expected_new_observed / expected_new_missing, expected_runtime prefix-matching (both directions), genuinely_unexpected_new, legacy missed/needless aliases, candidate_corrections, evidence_sources - RecordObservedImpact: observations append (detail[:300]), sorted implicated, evidence_count — INDEPENDENTLY SOURCED, never re-derives the prediction (the §17 invariant) - CloseContract: superseding/verifying phase gate (exact error text), inputs assembly, quality stamping, optional scope_check, checkpoint append, phase/status/next_action/observed_at mutation - ContractEntity gains Ext (the ext dict the lifecycle carries) PARITY: truth_close.json — 4 cases (edge-covering bucket math, full lifecycle close with scope_check, both gate errors). The ratchet stopped the first commit attempt (2 new generator handlers) — annotated with intentional-silence reasons, re-landed. Per-wave routine: gates BARE, spine rebuilt, both snapshots shipped.	2026-10-07 19:50:33 +01:00
Nick	61432632f7	feat(go): build-mode batch 2 — worktree git operations, plan/exec split (contract BUILDER-2026-10-07T18:26:40Z-8be89a-unknown) ... The worktree lifecycle ported to build-mode with a TESTABILITY split: - the PLAN layer is pure and oracle-batteried: WorktreePlan / DeletePlan (two bare steps, no short-circuit — parity with the Python's separate subprocess calls) / MergePlan (exact message format 'Build {id}: {desc}') - the EXEC is reactive and fixture-proven: a REAL tmp git repo round-trip (create → commit on the branch → merge lands the file in the repo root → delete clears worktree+branch), plus the duplicate-create and conflicting-merge failure texts (the wrapper 'Failed to merge worktree:' is the stable contract; git's own message varies by version — the ORACLE's fixture text pinned the shape, the live git pinned the variance) - state transitions verified: worktree_path set on create, cleared by merge-follows-delete PARITY: truth_worktree.json — 6 cases (3 argv plans, state round-trip, both error texts) from the live BuildManager driving real git with the clock frozen. Per-wave routine held: gates BARE, spine rebuilt, both store snapshots shipped.	2026-10-07 19:35:04 +01:00
Nick	d12fbab06a	feat(go): memory-store batch 2 — the deterministic read-path (contract BUILDER-2026-10-07T18:05:47Z-152c16-unknown) ... Read-path mechanics of memory_store.py ported to memory-store-deep: - FtsQueryConjunctive: extended-Boolean AND (len>3 non-stop terms, len>2 fallback, quoted, first 8, space-joined) — msStopwords extracted verbatim from the live module - ChunkText: paragraph recombination + 1.5x hard-split - RankFusion: RRF k=15, three modes (hybrid/dense-only/lexical-only with min-max bm25 normalize), insertion-ordered ranks, NUMERIC ids out (Python int ids; the string map is internal) - ProjectChunkRows: -rrf sorted, text[:400], rrf round 4, budget cap - MapReduce: top-3 per chunk + the REDUCE pass (all mapped re-sorted by score) — the oracle caught my chunk-order-only first read - FuseResults: NormKey (lowercase whitespace-collapse) dedup, exact field shape, kind-wise min-max scale-alignment (the audit fix), final sort PARITY: truth_recall.json — 17 cases from the _py_* oracles; fixtures SHIP in the inputs. Embed surfaces stay Python-side (model-coupled).	2026-10-07 19:13:55 +01:00
Nick	5dda590588	feat(go): scaffold batch 2 — the transactional store layer (contract BUILDER-2026-10-07T17:47:00Z-960f12) ... The §21 transactional boundary ported to Go: - CanonicalDigest: sha256 of the sorted+redacted semantic payload (byte parity with json.dumps(sort_keys=True): Python default separators, ensure_ascii escaping) — the §12B real commit semantics - RedactSecrets (exact names + credential substrings), SortedNorm (recursive; lists sort by their dumps repr) - Commit (intended-vs-on-disk digest readback), VerifyOnDisk (the forgotten-save lie detector), SaveVerified — exact Python assertion texts including the %r single-quote form - SaveDoc: schema guard + indent=1 sort_keys write (the disk format) - ImpactFrontier: the bounded Spine-edges-only walk — change_kind inference, NON_OBLIGATION/STALE/CANDIDATE skips, contract expansion (implements/consumes); the ORACLE corrected my inverted party computation (c==b → party=a) - SnapshotPredictedFrontier + SpineBridgeEntity (identity-only bridge) PARITY: truth_store.json — 10 cases incl. digest key-order stability, secret redaction shape, forgotten-save detection with exact text, three frontier modes. Frontier docs SHIP in the truth inputs (batch-1 lesson). The ratchet blocked the first commit attempt (new generator handler) — the bare-command law held; annotated and re-landed.	2026-10-07 18:56:17 +01:00
Nick	9fd3d8b15d	fix(lint): scaffold truth generator — intentional oracle-error handler annotated (ratchet back to 345/75; the pipe-mask that let the violation commit is the recurring lesson, re-learned)	2026-10-07 18:42:22 +01:00
Nick	64f77e82ff	feat(go): scaffold batch 1 — the contract-lifecycle core (contract BUILDER-2026-10-07T17:27:25Z-6bc737-unknown) ... Deterministic core of scaffold.py ported to src/go/scaffold (integrated with the existing W5c classify/status CLI, not replacing it): - the 9-phase STORE machine (22 legal edges incl. migrating/superseding/ failed-retry) — DISTINCT from the 16-edge contract machine frozen in the Rust membrane; two layers, each authoritative at its own boundary - TerminalPhases DERIVED from the map (single authority) - NewContract (identity defaults, sorted-list discipline, doc mutation via add_entity parity, duplicate error), TransitionContract (exact error texts incl. Python list-repr quoting, checkpoint note[:200], status updates, next_action, observed_at) - CheckScope (equality/prefix/substring; UNKNOWN on unscoped — never silently green), LayoutObligations (FLEXIBLE vs USER-LOCKED texts), JsonFrontier (Python json.dumps byte form: insertion-ordered keys, ', '/': ' separators, ensure_ascii escaping) PARITY: truth_scaffold.json — 19 cases from the live Scaffold oracle (now frozen); the generator SHIPS scope+doc in the inputs so the Go replay needs no oracle-side state. Governance note: the completeness gate required constraints={'contracts': ['contract:construction_contract_lifecycle']} — full spine id, prose never counts.	2026-10-07 18:41:07 +01:00
Nick	c5ecbacf98	feat(go): build-mode batch 1 — the phase machine + ledger mechanics (contract BUILDER-2026-10-07T17:08:00Z-6e177d-unknown) ... Deterministic core of build_mode.py ported to src/go/build-mode: - the 11-phase machine in declaration order + PhaseStatus/BuildPhase/ VerificationTier constants - LogPhase + the named completion functions, clock INJECTED (date-time-bomb law); side effects pinned: complete_plan assigns batches, start_correct increments corrections - ResumePoint (reversed declaration-order scan) + the pinned quirk: complete_verify(false) records status 'complete' with the failure in DETAILS — the resume scan never fires on it - BuildStatus shape; build_id %Y%m%d-%H%M%S from the injected clock - module-family CLI (curator-core convention); worktree git ops stay reactive (batch 2) PARITY: truth_buildmode.json — 5 flow cases with RECORDED CALLS replayed through the ported functions; the oracle's ledger pinned two subtleties my first read missed (complete_feasible's nested details key; assess/research log their parameter dicts, not kwargs maps). Comparisons are canonical-JSON (Go []string vs decoded []interface{} differ in type, not bytes).	2026-10-07 18:18:07 +01:00
Nick	a7b13099aa	feat(go): curator-core batch 2 — the REAL lexicon semantics (contract BUILDER-2026-10-07T16:31:17Z-997c9d) ... The batch-1 LePromoteEligible encoded the LEXICON DEGRADE — the phantom's shadow ('lexicon module unavailable — strength gate only'). With the phantom recovered from provenance (5749029), the live oracle returns real verdicts and the port was behind it. This batch closes that gap: - lexicon.go: verbatim port of the recovered lexicon_evolution.py — ContentWords, Stem (ordered suffix rules + y->i fold), DistinctiveTerms (stem-aware df, max(total*0.05, 1.5)), SharedDistinctive, Coherence (conflict/consistent/novel), GroundedLex, PromoteEligible — including the Python list-repr byte format in the shared-terms reason - LePromoteEligible upgraded to the real semantics (wash-adjusted threshold preserved; degrade path kept as LePromoteEligibleDegrade for the record) - truth.json le_promote_eligible cases REGENERATED against the live oracle (degrade shadow gone); truth_lexicon.json: 14 new direct cases — coherence (incl. common-word-is-not-a-relation), grounded (stem-aware, invented-token parking), distinctive terms, all four promote verdicts - scripts/gen_curator_lexicon_truth.py: the committed generator Also discovered during this batch: the 12:52 checkpoint was 45 min stale — batches 2-4 (candidates/coherence/decay+compress) had already landed (9ccb331..38fd578); duplicate work discarded, committed batches kept.	2026-10-07 17:45:20 +01:00
Nick	df6f52e652	fix(tools): repair wave — master red closed (contract BUILDER-2026-10-07T16:11:35Z-70ca24) ... - tool-executor batch 6: jsonUnmarshal/paramOrder/rawKeyOrder moved from truth_prompt_test.go into json_order.go — the non-test build failed with undefined symbols (go-surface run 19792 job 56712) - truth batteries regenerated HERMETICALLY via the committed live-oracle generator (scripts/gen_tool_executor_truth.py): {{TMP}}/{{WROOT}} placeholders replace the generation host's /mnt/workdrive/tmp* paths in inputs AND expectations; fixtures manifest carried in each truth file; tests recreate fixtures under their own allowed roots (truth_harness_test.go) - list_dir comparison now exact (both sides sort); grep compares sorted line sets (oracle os.walk order is OS-dependent, not a parity property); truncation marker pinned by a new hermetic test - construction_decision lib.rs: the 'rune dichotomy:' rule-string parity half committed (Python half landed in 6d63034; strings verified identical) - stale in-tree binaries rebuilt from current source	2026-10-07 17:23:15 +01:00
Nick	9ccb331a41	fix(governance): scaffold-membrane retro-adopted (the gate caught its own author) + curator-core CLI entry ... Two finds from the newest tip: (1) the absolute-scaffolding gate flagged scaffold-membrane because I committed it before extending the adoption record — the law working as designed; contract opened, walked draft→closed, record extended. (2) curator-core is a main-package family member but lacked main() — CLI entry added (one JSON op per invocation, module-family contract).	2026-10-07 13:06:39 +01:00
Nick	e44ee897db	feat(governance): ABSOLUTE SCAFFOLDING LAW — CI gate verifies every Go/Rust unit has a construction contract ... Nick's directive: scaffolding is not optional. New CI step (scaffolding_coverage.py) fails the build when any src/go or src/rust unit lacks a construction contract mapping; retro-adoption record carries the pre-law units (120) with their BUILDER-2026-10-07T11:3x contract ids; the 13 contract-scoped units verify against live store/scaffold/ JSON. Frozen tests prove the gate catches uncovered units AND accepts adopted ones. From now on: contract opens BEFORE the commit lands, never after.	2026-10-07 12:38:09 +01:00
Nick	85c0f1eafa	feat(go): adaptive-router — DEEP PARITY PORT of the route authority (W5b) ... Full port of adaptive_router.py (625 lines, 19 fns): classify_route (legacy + provenance paths, LOCAL_FIX defect-doctrine, deep-research floor), floor predicates, escalation/downgrade with FloorViolation, verification-failure hook, append-only route events, research dispatch, derive_sufficiency (Option C with mechanism-uncertainty, test-surface, external-ref, scope-novelty, action-verb semantics). Survivor hybrid: detect_flags = Rust rrf_detect staticlib (live-probe proves the membrane returns real flags, no silent nil). PARITY: 24 Python-oracle truth cases WITH inputs committed; Go test replays every case — all pass. scripts/gen_adaptive_router_truth.py regenerates the battery from the Python oracle.	2026-10-07 10:52:49 +01:00