The sweep converted the panic-only trust test to a bounded-width
assertion and it caught a REAL defect: trust strips (and inner lines)
overflowed the face width at tiny sizes (0x0, 1x1, 20x4) — the exact
class the Layer Law forbids. Fixed: floor-clipped strips AND inner
lines. This is the answer to 'are tests ceremony': the conversion
paid for itself on its first run.
Measured diagnosis: tui/cmd/rune-tui eats 600 of 694 Go-check seconds
— the boot smoke test hangs in an unbounded terminal read past its own
deadlines (pre-existing on HEAD, repro'd on clean checkout). Race
detector measured innocent (1.6x, not 2-10x); Go's built-in test cache
already IS the content-keyed cache; all three sharding options
rejected on the numbers.
Landed instead: boundary_corpus_go scoped from the full tui suite to
its sole corpus consumer (70-84s → 0.1s, verified end-to-end GREEN);
explicit race-command timeout; honest 'not sharded' manifest notes
with measured reasons. The boot-smoke watchdog fix is named for its
own bounded repair wave (fix sketched in the receipt).
closes#2508
CONSENT BRIDGE (queue 2a): chat detects work-shaped messages
(deterministic tiers 0-1, spec-interview-first per owner correction),
opens the gold y/n card (default No, typing never answers, lapse to
the hold queue); on y the BriefRecord freezes AT CONSENT (verbatim +
message id + context refs) and the task enqueues through the queue's
admission — never interrupting a running turn. Tier 2 (model
self-report) is phase 2 per the research's kill tests.
WATCHING-HER-WORK (queue 2b): the tasks pane leads with a live work
block per running task — thinking (collapsed, e expands, ◆), the
newest observed tool activity as the current line, honest progress
(observed counts + live elapsed; no step feed = named gap, never
fabricated). /tree palette command added (the tree had no opener);
queue rows finally wired into the pane.
CORE WIRE FIX: the queued answer carries queued:true + entry_id
(consent-wave finding — consumers saw 'no verdict' on the
queue-behind path).
closes#2504, #2505
The killer was never the tag step: the bump step's FIRST LINE
(git tag --sort | head -1 under pipefail) died with SIGPIPE/exit-141
once the repo passed ~250 tags — zero step output, so every fallback
looked like it never ran. 40+ runs failed this way (0.312/0.313/0.314
among them). Second bug: GITEA_REF_NAME resolves empty on this runner,
so even repaired tags never fired TUI releases.
Fixed at source: scripts/tag_repair.py (one tested authority —
SIGPIPE-safe latest-tag, idempotent ensure, deadlock self-heal),
red-first 12-test battery pinning the disease as exit-141; both pipes
removed from all three workflows; tui-release tag resolution falls
back GITEA_REF_NAME → GITHUB_REF_NAME → git describe.
PROOF on a live runner: two full cycles auto-bumped AND auto-tagged
(v0.401.0/tui-v0.401.0, v0.401.1/tui-v0.401.1); the exact deadlock
state self-healed on the next push (v0.402.0 created+pushed
automatically). The pipeline never needs manual tag repair again.
closes#2503
model-routing: 8 importers mapped — rune_tui/rune_operator/composition
rank through the Go engine (47-test battery live); capability_broker/
model_connect/work_manager were metadata-only. event-bus: operator
emits, health events, TUI stats, canary probes route through the Go
journal engine. Fail-loud (no silent Python fallback); deliberate
opt-out via RUNE_MODEL_ROUTING_ENGINE=python / RUNE_EVENT_BUS_ENGINE=python.
Integration receipts recorded; binaries rebuilt+re-attested; zero
deletions (the owner's PORT→INTEGRATE→REMOVE law: integration must
prove live before removal). Named blocker for removal: reconcile_tools_support.
At each task-turn boundary the lane takes the OLDEST pending entry and
dispatches it through the normal task-create path (send_task, channel
task); the queue file updates atomically, rows re-number, the pane
follows on its next poll. selectNextQueueEntry is the D36
'Rune intelligently decides' seam (phase 1 = FIFO oldest-first);
failed dispatches re-queue at the FRONT (order-preserving, never
silently dropped) with a typed journal event. Race-proofed (one
critical section, dispatch outside the lock, settle path for
fast tasks) — six consecutive -race suite runs green; live proof:
two queued demands drained FIFO through a real rune serve.
closes#2501
- local timestamps, opposite side, demphasised; direction-aware sides
(user LEFT for LTR, inverted for RTL locales — one decision function)
- one thinking stream (claim law hardened, 4 frozen no-dupe tripwires);
thinking clickable at the rendered row; stays in chat
- solid pink borders everywhere (the confirm card's gold outline was
the defect); composer always lit; selected pane pink/unselected grey
- info bar: 'rune <semver> · ctx <used>/<limit>' (engine reports
per-turn window tokens vs the registry's model limit); status/focus/
rail/seq/lib noise stripped from the bottom
- thinking line: hint before the walk; walk capped at 3 glyphs
- ghost placeholder + anchored blinking cursor
- fading scrollbars in BOTH panes (independent layers, visible-on-
activity, fade over 4 ticks)
- THE LAYER LAW live: the composer is a composed scaffold — border/
content/cursor layers, each with isolation tests including the
cursor-punches-the-border regression pin; layers registered as
project citizens (visual-system domain); ownership header
- arbitration live: rail cluster still while thinking animates
- chat send proven live on PTY (the earlier report was a model
timeout — the honest error path surfaced)
47 packages green under -race; PTY-proven on the real home.
closes#2500
Every mutating tool call (subagent or main session) is scope-checked
against the active construction contract through the installed hook:
in-scope edits allowed, out-of-scope blocked naming the contract; the
durable lock fails closed across fresh processes (ACTIVE/UNREADABLE
both stop, ABSENT allows ordinary work); shell escapes (clobber/tee/
--output/touch) caught; supervisory acts refused; violations recorded
and self-clear on remediation. 67/67 drills + authority tests green;
hook installed hash-verified; activation front door ported (the one
design decision per the map) with the introduce-verb fix for rune's
Rust-core delegation.
closes#2499
- ImportLegacyHotStore: one-time boot import of the Python-era store
(~/.rune/hot/conversation_messages.json + K25 tail) into the Go
store — msg_id-deduped, chronological, crash-resumable (proven in
the wild: 116/512 mid-kill, resume completed zero-dupes)
- thinking rides the conversation wire → history renders collapsed
thinking bubbles (clickable), claim-law dedupes the live one
- user bubbles: rune-count width math (byte-length was the defect),
timestamp-aware cap, four rows one alignment, stamp hangs outside
the corner — the full box the owner expected
- D41 addendum 3 live: no text prefixes; ◆ leads all rune bubbles
closes#2498
Three cloud ModelClients ([OI]-compat, anthropic, gemini) with vault
key resolution at call time (secret-tool, key value never persisted),
per-provider routing from the record's Provider (table + registry,
source_base_url preferred), typed errors (503 provider_key_missing
when the vault fails, 502 provider_error carrying the provider's own
envelope). 67 tests hermetic under -race; the live token-spending leg
gated behind RUNE_CLOUD_PARITY_LIVE=1 for the owner to run explicitly.
A cloud default now works end to end: wizard pick → vault key → the
right wire → the reply, all in Go.
- rounded chat bubbles (cyan you right / green rune left), dim stamps,
pink outline accent on the focused pane + input box, breathing
thinking marker (3 pink phases, ≥4.5:1)
- one-cell purple diamond beside rune's markers
- the dots-walk thinking animation: '◆ thinking' + dots appearing
left-to-right, each a glyph from the instance's SHUFFLED 15-glyph
vocabulary (10 futhark + 5 cthulian, owner-verified set), row-fill
restarts the walk; expandable WHILE thinking (click + ctrl+t)
- /style cycles live: amalgamation → quiet typeset → full futhark
- gauges window: ctrl+g or /progress, honest bars (indeterminate
sweeps, never fabricated percentages), never paints over input
- mode token + live turn duration (mm:ss) on the identity line
- task pane sectioned (work stream / entry signage); sub-agent rail
cluster animates on the SetWaves state; thick-gold confirms
- placeholder 'type in chat'; generous 2-row input box
- reduced-motion: one static glyph, zero ticks (PTY-proven)
- all 15 glyphs byte-verified in raw PTY (detect-then-render law)
9 packages green under -race; PTY-proven end to end.
- catalog reordered: vault-keyed clouds lead (moonshot/xiaomi/openai/
google/ollama-cloud), keyless clouds, locals after (ollama demoted
to a row among equals), custom hatch last; the drift-gated trio
byte-proven (--check identical, 66 cases)
- wizard starts on NOTHING (cursor −1, no pre-selection); cloud rows
lead; cloud picks walk the vault (SecretToolReader, endpoint+key
probe per wire) — a cloud default is a fully supported outcome
- engine faithfulness: the record's provider owns the route — a
cloud-naming record gets typed 503 provider_unrouted (never the
silent localhost misroute); last-chosen unavailable renders the
honest 'pick another' state, never a fallback
- last-used memory verified: one record, atomic writers, boot loads
it, the engine reads it fresh per turn — no divergence path
Every task initiation creates a markdown file (title, initiated time,
brief, append-only log) — resumable, recorded, crash-safe (atomic
writes). Completion crosses off the title, flips DONE with a
timestamp, and retires the file to tasks/done/<calendar-day>/ — a day
with no completions never gets a folder. /v1/tasks-open serves the
ledger as the source-of-truth listing. Wired to reality: creation
reconciles from the core's checkpoint at real creation times (task
creation has exactly one path — send_task create); completion hooks
both writers (Python lifecycle reconciliation + Go complete command
synchronous retire). Ledger is best-effort — the checkpoint stays
authoritative; the seam has no zero-value fallback so hermetic tests
stay hermetic.
The chat face per owner rulings (boundary-law.md §D34-D36):
- stable bordered input BOX (1 row at rest, grows to 3) with the
old-TUI placeholder; its own region outside the selectable pane
- backspace fixed at the naming layer (real keys now arrive named:
backspace/delete/home/end/left/right/pgup/pgdown — the gap was
inserting invisible DEL chars into sent messages)
- bracketed paste wired (was silently dropped)
- input history recall (up/down, draft-save, dedup — the old
HistoryInput contract, now the live composer via Input3)
- boot history restore: last conversation window (8 rows, newest
visible) — enabled by the serve-child query-string fix
(surface.go: fetchCore dropped r.URL.RawQuery — every query-carrying
GET proxied parameterless; red-first regression test added)
- thinking: animated diamond in the identity line + live thinking
bubble carrying the core's real thinking text; expandable via
click on the purple runic glyph ᚱ (Raido — Rune's identity mark)
- dim HH:MM timestamps on every transcript message
- command surface: / slash-overlay autocomplete (filtered as you
type) + ctrl+p searchable palette, one vocabulary (/model /theme
/night /help /quit)
- model menu (send-without-provider / ctrl+m) rides above the box
All green: 42 TUI packages, rune-entry serial; race-clean; PTY-proven
against the live core (typing, wrapping, dispatch, reply, slash
overlay, boot restore).
The 0.312.0 bump commit (0c736b7e) landed without its tag; every
subsequent push then hit the 'version > tag = bump rode the PR' skip
and the pipeline self-deadlocked (no bumps, no tags, no releases for
~56 commits). Tags v0.312.0 + tui-v0.312.0 now exist on the bump
commit; this trigger commit re-arms the convergence so the outstanding
work warrants the next bump normally. Drift issue #193-class: filed by
release-drift-reconciliation, auto-closes when lineage matches.
- the composer prompt renders from the FIRST frame (was: invisible
until first keypress — the do-while trap the owner hit)
- model selection is a MENU at the chat line (digits/arrows/enter,
esc closes, ctrl+m opens directly) — never a gate card, never a
chat message in the transcript
- a send with no provider opens the menu and stays pending; the pick
persists the selection and dispatches the pending message
- plain printable runes TYPE while the chat composer is active
(h/j/k/m/y letter-stealing fixed; single-letter face actions stay
live in the tasks lane, modals, and chrome)
- dead first-run card + selectorDigit gate removed; tests rewritten
to the new law; PTY-proven: type → menu → pick → dispatch
CRITICAL: chat-originated tool dispatch (Python local_tool_runtime.py)
had ZERO mode awareness — a chat write_file in CHAT mode executed
ungated (the Go serve surface gated but the chat path never touched
it). Closed: mode authorization at request intake in local_tool_
runtime, authorize seam in tool_protocol dispatch, approve() resume
door gated, hatch-exposure filtered. Typed ModeRefusal feeds the model
as tool-error data; failure breaker trips on repeat.
T1: ONE mode matrix artifact (schemas/mode/v1/mode_matrix.json) read
by BOTH Go (embed, byte-identical, 16-case battery) and Python
(mode_gate.py, per-dispatch read 0.011ms, RUNE_MODE env wins).
T2: model only SEES mode-allowed tools at capability selection.
T3: per-dispatch mode re-check (mid-loop switch pinned).
T4: tool events persist as channel-scoped role=tool conversation
records — results land in the chat lane through the bridge poll.
Main-session verify: mode dispatch gate + tool authority suites green
own runs. 31/31 + 3438/0 new-mode-gating failures.
New modules: secret_store.py (memory/SecretService/encrypted-fallback,
secrets never in argv/registry/UI/logs), provider_registry.py (per-
provider connections, api_key_ref resolution at call time, config-over-
auth precedence). scripts/migrate_api_keys.py: scanned 5 stores
(mimocode.jsonc, auth.json, opencode.json+jsonc+secrets, rune model_
state), found 16 connections / 15 distinct secrets, migrated all 15
into org.freedesktop.secrets (ksecretd), verified independently by
fingerprint against fresh scan, counts match, idempotent.
mimo finding: provider store masks keys as '***' on save — keys
silently lost every restart (the secret-ref pattern fixes this class
permanently). Provider store stores REFS only + chmod 0600; no
plaintext anywhere. 2 placeholders skipped (URL-shaped, not creds);
7 connections endpoint_unknown flagged (no URLs guessed). Chat works
with 15/15 keys live through provider_registry. Main-session verify:
30/30 green own runs.
PTY PROOF: clean RUNE_HOME -> gate card (no provider configured) ->
model list -> digit selects (record persisted) -> typed message -> real
Ollama reply lands complete in the lane -> checkpoint holds user+
assistant msg_ids. The face talks.
F1-F4 + mutex: channel honoring (chat lands in chat, not task), stale
canary stub killed + supervised real core on 8376 (ensure_core.py,
identity sanity), timeout budget >=330s all three legs, bridge polls
channel chat beside task. Thread-safety: dispatch_lock mutex (canary
overlap probe was RED pre-fix, 35/0 post, 4-way concurrency pytest,
rogue-mutant teeth).
8-role bubble structure per the design-intent contracts: user right/
assistant left, thinking collapsed, dark bg. Fresh-state: gate card
with real model list, no default, record persisted, chat gated until
selection. Full module green (32 pkgs + 4 with new content), race-
clean. Identity line: runtime lib:connected.
KNOWN: chatpane contrast fails WCAG on the dark bg (1.35:1 assistant
invisible) — visual round build wave lifts every role to >=4.5:1 per
direction; identity line clips chat token at 100 cols; ordinary
sentences can't be typed on the chat pane while chain keys r/t/p/y/
route to chrome — the selection law's pending-input surfaces need
unbinding in the visual round. These are DESIGN findings, not defects.
- tui/factory: read-only projection — waves as threads in the task tree
([r] RESEARCH/[b] BUILD/[d] LANDED + receipt leaves + rung/pin line),
contracts readable, receipts live, fold into the face's live derivation
- seam socket: factory-orchestration registered (v1.1.0, three current
consumers, deletion test trips, compat passes, registry GREEN)
- real queue wiring: reconcile kernel spawns real waves from
docs/factory/spawn-queue.md (mechanical grammar: priority groups
spawn, deferred blocks on owner, in-flight skipped); proven live via
CLI; live migration is a main-session actuation
- domain row: factory-protocol registered in domains.json
tui/firstrun: fresh-state detection (no provider record + no checkpoint
= first boot); stage machine (welcome -> provider catalog -> model list
-> connection test -> done) through lib.ModelLister (off-thread, pending/
answer protocol); no-default gate (chat refused until explicit selection
recorded in provider_selection.json, atomic write); scrubbed record
re-gates (leaving configured state re-triggers first-run). 7/7 frozen
red-first green. Main-session verify: green own run. Face wiring deferred
(main.go owned by chat-live wave).
Three grounded directions on the shared isomorphism base:
V-A 'Set Line' (D31 pole: box-free typeset, hanging indents, strongest
fallbacks) / V-B 'Rune Classic' (owner's captured Textual design
rebuilt native: exact CB-05 color table, rounded bubbles, the purple
diamond spinner, 10-token live editor) / V-C 'Instrument'
(observability-forward: edge-railed chat, instrument-panel task lane,
dense telemetry rail, 3D slot reserved).
Portrayal tooling shipped: render_frames.py renders each direction as
.ansi truth frames (owner's terminal decodes real truecolor), .txt
zero-ANSI twins, .png records, diamond motion strip. Build wave spawns
after the owner's recorded pick.
CRITICAL FINDING: current chatpane fills all fail WCAG AA on the
owner's base (assistant at 1.35:1 = invisible); old fill design
measured 8.15-13.59:1. Build wave must lift every role to >=4.5:1.
factory_worktree.py: create (git worktree add rune-wave-<hash>),
enter, land (merge inside throwaway rune-merge worktree, run
unified_check.py + check_landing.py against the MERGED tree, green =
CLEARED TO LAND), cleanup. No subcommand writes files or moves refs
in the main tree (update-ref ref-surgery rejected — phantom-dirty +
silent no-op, probe-proven). 8 frozen tests red-first. Landing gate
catches breakage at merge: unbuildable Go module, RED manifest,
missing manifest. Main-session verify: own runs green.
scripts/rune-launcher.sh: boot ladder — deployed binary
(~/.local/share/rune/bin/rune-tui, the update-apply swap target) ->
last paired build (verification/build-id/rune-tui) -> build via
build_paired.sh -> Python-era launcher with spoken fallback notice.
install_rune_launcher.sh + make install-launcher: installs to
~/.local/bin/rune (old launcher backed up as rune.python-era), stages
the paired build. 7/7 frozen tests red-first green; live verified:
rune --build-id shows the stamped paired build id. The old Textual
TUI is accessible as rune.python-era.
CRITICAL FINDING: two-door mode bypass — chat tool dispatch (Python
local_tool_runtime.py) has ZERO mode awareness; only the Go serve
surface (/v1/tools/call) gates. A chat-originated write_file in CHAT
mode would execute ungated. Escalation-class; first red-first test.
What exists: the agentic loop ALREADY runs (model emits tool calls,
iteration budget, circuit breaker, approval pause with restart-safe
pending_state, resume/approve/reject); the approval machinery is
fully built (single-use tokens, digest revalidation); the chat rune
block already carries tool_events + pending_approval end-to-end;
the TUI decodes it and consumes none of it. Tools-live is WIRING,
not construction.
6 slices: T1 mode matrix as shared JSON; T2 model SEES only mode-
allowed tools; T3 dispatch-time re-check (gate twice); T4 tool
events persist as conversation records (results land in the chat
lane through existing bridge poll); T5 TUI approval card; T6
adversarial battery. Plus: fix the two-door bypass first.
~70% built already (the hard live part is proven). Key findings:
- mimo auth.json: 12 entries (static keys + EXPIRING OAuth + typo dupes)
- mimocode.jsonc: inline keys + custom models with hard-won context/
output limits (migrating without limits loses data)
- Three wire families cover everything: [OI]-compat, Anthropic, Gemini
- libsecret/go-keyring is the OS-store route (registry.go writes
api_key in PLAINTEXT today — the vault is load-bearing before
migration)
- opencode's /connect pattern is the design reference AND the
migration source's own spec
- P1: extend STANDARD_PROVIDERS to full list + custom escape hatch
- P2: secrets vault BEFORE the importer; lossless migration by
baseURL+wire mapping; real cloud adapters behind the unchanged
protocol
- P3: budget/rotation; live proofs: free models-list at connect;
paid proofs owner-gated (D-PROV-1/2/3 to owner)
Real hooks: sleep-kind 'consolidate' execs the Go sleep-time
consolidation binary; night-kind 'night-report' execs the report;
K17 gate never widens inside the hooks. Night-mode's sleep phase now
execs Go (Python sleep_time retired for this path); /v1/night serve
surface (GET status, POST start/stop/toggle); tui/night two-state
display toggle. All suites green real-tree + race. Main-session
verify: all modules green own runs.
G3 outside-network refusal (typed, effect never runs), G2 consequential
hard-ask (held, renders, commits via revalidated one-use token), visible-
but-blocked records, G1/G4/G5. Doors: RunTrusted (toolexec), EmitTrusted
(eventbus), RankTrusted (modelrouting), ClearWorkTrusted/CompleteBatchTrusted
(workmanager), MediateTaskCommand + serve 403s (entry). Red-first on all
five; all suites green x5 + -race. The trust surface is no longer UI-only
— the libraries refuse at their own boundaries. Main-session verify:
all five green own runs.
tui/changes: side-by-side/unified/auto layout (SplitMinWidth=83, s
cycles, manual survives resize); runtime wiring drives the restore-
points engine via its public CLI (separate module, internal by law);
selective external-file restore (overwrite preview per file, sha-
compared, WILL RESTORE/WILL OVERWRITE, J/K + space toggle, v restores
ONLY selected); one-command revert through the REAL engine (tests build
the actual binary); dirty-tree protection live (blocked-dirty before
any engine call). Engine: additive RewindFiles + --file (unknown path
refuses whole; 3.1 semantics byte-identical). 8 stub failures red-first;
all frozen suites green incl -race, -count=3. Main-session verify:
changes green + race own run.
Live crash-recovery (not fixtures — the REAL serve process): 300-step
irreversible task over /v1, SIGSTOP-frozen journal observed, SIGKILL,
restart on same home: epoch 2, task resumed, drained live, every
irreversible effect exactly once across both generations; a kill inside
one effect fails closed as ambiguous. Real defect found + fixed: K9's
recovery epoch derived from checkpoint-only truth — crash leaves no
checkpoint, every crash-restart reported epoch 1; now generation =
max(checkpoint, journal) + 1 (journal-truth counting, crash-proof).
Plan document store: durable plans under <home>/plans, atomic
tmp+fsync+rename, append-only revisions, traversal-proof IDs; serve
surface /v1/plans create/list/fetch/revisions; restart byte-identical
recall. Red-first; race-clean. Main-session verify: green own runs.
paths is a pure library (Python-parity port, imported by siblings) but
shipped as package main without main() — the compile-first build law
correctly refused it (first module to fail the law, proving the gate
works). Thin shell added. Battery green.
toolExecutorBin() fell through to a repo-root walk when the pinned
RUNE_TOOL_EXEC_BIN didn't resolve, silently substituting a stale
October-10 tool-executor binary — the call 'succeeded' as 200-with-
error-body, fabricating reachability. Law: explicit config failing
is UNRESOLVED, not 'try something else'. Now: set-but-missing env =
typed 503 authority_unavailable naming tool-executor; full entry
suite green incl. the honesty test. Flagged: stale built binary at
src/go/tool-executor/tool-executor (gitignore candidate).
GET /v1/delegation over the real records: every parent_task_id task
joined with journal evidence; chain (cycle-safe, true depth, bounded
tail with count+truncation flags), action, evidence (event ids),
waits (awaiting_approval/research_required), blocks (failed), history.
Orphans served with chain_break named. Honesty: absent checkpoint =
available:false; missing journal = journal_available:false.
TUI: DelegationSource lib seam; tasks deriveDelegations (enrich-or-nest
at parent, orphan dock, expansion on nodes, fingerprint gate); threads
fold chains into the one ancestry tree. No-hidden-delegation conformance
(exact set match both directions). Live: 3723 real children served;
3713-deep lineage bounded+flagged (O(depth²) fix). All frozen suites
red-first green. Main-session verify: delegation + threads green.
src/go/parity-harness: real task runs side-by-side — live Python oracle
vs attested native binary, both real subprocesses; parity unit =
authority-preserving action/receipt trace (widget vocabulary forbidden,
frozen); failure/restart/recovery at two breakpoints with duplicate-
irreversible-effect counts. 4/4 named mutants trip RED (key-scope,
receipt-origin, recovery-ordering, launcher-target). Found+fixed a real
divergence live (Go port mapped non-zero check exit to error path; the
oracle parses stdout — checks.go fixed + pinned). Task-management row
proved end-to-end: verification/parity/task-management.json GREEN
packet; retirement map row 12 PARTIAL (only 7.3 same-change Python
removal missing). migration_mutants member live. Main-session verify:
21s own run, all green.
rune run hosts the serve surface as the face-agnostic core: fsynced
append-only effects journal (replay truth), worker loop with zero faces
attached, exactly-once irreversible effects keyed by effect_id (committed
-> never re-executed; begun-uncommitted -> ambiguous fail-closed into
pending decisions, never silently re-run or dropped); atomic checkpoint
(active tasks, pending decisions, replay cursor, evidence pointers);
recovery with explicit gap status; runtime endpoints (attach/detach/
tasks/exit) over the unchanged front-door mux; SIGTERM/POST exit =
deliberate (checkpoint then stop — found in live smoke that exit didn't
stop the server); systemd user unit (Restart=on-failure, pinned) +
autostart CLI. 9 frozen tests red-first, race-clean. Main-session
verify: -race green own run. Pre-existing modegate failure unrelated
(authority-missing test, named).
Sole model-visible representation (every sent byte traces to admitted
broker blocks; hidden post-broker appenders fail closed); sole memory
contributor path (frozen six-contributor set, rogue emitters caught);
single selection API (source-tag allowlist, bypass + tamper fail
closed, abstention/degradation proven); no future-memory API reserved
(repository classes require named cross-module consumers); auto-detect
of new memory_/context_/graph_ modules. 20/20 red-first (rogue
contributor mutated 3 tests red, reverted clean). Flagged: K15's
continuity contributor is unwired — wiring wave amends the allowlist
with a named consumer.
The convergence hook created tui-v* tags via POST /repos/.../tags;
API-created tags emit NO push events, so tui-release.yml (on: push:
tags) never triggered — tui-v0.310.0 exists as an orphan with no
release. Fix: real git tag + git push from the runner (token via
extraheader, same mechanism as actions/checkout; fetches origin/master
first because the bump commit postdates checkout; idempotent via
ls-remote check; fails loud). Manual fallback + orphan recovery
documented in tui/version/README.md. Needs one real convergence event
to prove end-to-end (flagged).
token_counting end-to-end: 24/24 frozen-oracle parity; wasm 1.6-2.2x
slower than cgo but ~160x faster than IPC; trap isolation with symbolic
stack + file:line debug capture; zero porting cost; +6.9MB binary +
12.4MB vendor for wazero. ABI convention matters 23x (reserved-scratch).
Honest limits: does not beat cgo raw; heavy I/O crates would re-test
WASI limits. Verdict inputs recorded; architecture call per D30.
WASM via wazero = the standard Rust crossing (speed class + real
isolation + designed debug errors + no cross-compile pain); cgo
exception-only with named re-provable conditions; five libraries
in-process; crossings batched; prototype round gates the migration.
- semantic.CheckSelection walker: four clauses over every box-bearing
face — click selects + renders highlight token; shift+tab walks the
full declared ring reverse-wrapping; typed input fires ONLY on the lit
box; unlit boxes carry no token. Box inventories pinned per face —
new/vanished box = RED until deliberately added.
- All faces wired: lanes ring + row clicks, rail takeover, promote rows,
tasks tree rows, threads nodes + clicks; nested chains comply; the
144-state fixture + receipt pins HELD (ring reuses existing action
IDs); shift-tab golden path regoldened in.
- Mutants: shift+tab-blind wrapper, always-lit, rogue-probe, dead-click,
untokened — all trip RED. The law has teeth.
- 33 packages green incl -race + gofmt. Main-session verify: 33/33 own
run; live pty shows tab cycle + task rows.
- tui/selection: 12 configurations + both projections, frozen.
- Seam: tui/runtime/lib — library-binary child processes (entry serve
ephemeral port; event-bus log --json), built from source at boot,
GOPROXY=off; go.work/in-process honestly impossible (internal/ blocks
cross-module; go.mod generator-owned) — shelling the LIBRARY binaries
is the honest seam. Zero changes inside the five libraries.
- Question-rooted trees per D28: newest unresolved question roots the
live tree (real task IDs, parent_task_id nesting, journal events as
sub-trees via parent_id ancestry); resolved questions close to one-line
history; no open question = honest runtime-activity root. Statuses
roll on fingerprint-gated re-derivation. Controls carry real IDs,
footer honestly marks render-only (command paths = next wave).
- Identity: runtime lib:connected vs serve: fallback.
- 32 packages green incl -race + gofmt (go_suite GREEN); 21 new tests;
env-gated live test verified. Main-session verify: 32/32 own run;
live pty shows question tree + lib:connected.
- Sibling-mid-flight churn (spine, uv.lock, diff.go) left for their
waves.
PROVEN 0 / PARTIAL 16 / UNPROVEN 1 / NOT-STARTED 2. Every cited artifact
path programmatically confirmed; cross-checked by live suite runs.
Honest gaps named: no capability meets the retirement bar yet (module
proofs != capability proofs); the mutant-hardened parity harness (7.2)
blocks all PROVEN promotions; Python remains authoritative; seam-registry
enforcement gate red at map time (new python failures — investigating at
landing). cmd/rune-tui build red is I3 mid-flight (expected).
New module model-acquisition: configured-local reuse FIRST (no discovery
no consent); read-only HuggingFace discovery with computed explanations
(fit/hardware/storage/license cite the numbers, golden fixture); consent
recorded + pinned (size+digest) before any byte; download streams
sha256, verifies per-file + aggregate against the pin, mismatch refuses
with partials discarded + refusal logged; verified landings carry
provenance. Hub client injectable — CI drives a fake only; real client
pinned GET-only. 9/9 red-first; race-clean. Main-session verify: green
own run.
Sentinel-ized pinned messages byte-identically (ErrCanonicalBridgeUnavailable,
ErrPathRequired); %w wraps where an underlying err exists (event journal
append, scaffold core call); errors.Is/As proof tests per touched
subsystem. Judgment calls: model-routing + work-manager construct zero
errors (nothing to wrap); remaining fmt.Errorf are pinned parity texts
with no underlying err — kept as-is. Batteries green all five.
Main-session verify: green own runs.
New module webfeed (library + thin shell): snapshot over real on-disk
sources (task checkpoint, event journal, commands store) — absent/corrupt
render available:false + reason, never fabricated; every item carries a
resolvable evidence link; committed/pending on everything; paired-command
ordering by authenticated arrival (unpaired/replayed render as refusals);
GET-only (mutating methods 405 read_only on every route); SSE replay +
live-tail handling BOTH envelope generations in the journal (id/type and
event_id/event_type — silent under-reporting otherwise). Red-first;
race-clean. Main-session verify: green own run.
New module extension-host (library + thin shell): strict manifests
(unknown fields rejected); ed25519 publisher identity/digest as admission
PRECONDITION (unknown/wrong-key/tampered all refuse, mint nothing);
atomic capability-index replacement (superseded capability resolving =
hard failure); update extra-scope quarantine pending fresh EXACT-scope
consent (laundering refused); disable/uninstall with verified /proc
process-tree termination, fail-closed orphans, rollback; slots pinned to
one command + one status card (approval/lane/identity/policy forbidden,
ESC-phishing render blocked); discovery mints no authority; every deny
path carries fast owner resolution. Real sh+sleep process trees in
tests. Red-first; race-clean. Main-session verify: green own run.
Truth fixtures baked a deleted worktree's absolute path into 4 rows (2
failing); surgical placeholder rewrite preserving all other frozen bytes
(no live re-freeze); loadTruth substitutes the runtime repo root; new
TestTruthHermetic guards host-root leaks; generator hermetic for future
freezes. 62/62 rows green plain+race; module REMOVED from the unified
baseline — src_go_suite now 87/87 capable. Main-session verify: green
own run. Flagged: float-rendering vintage drift in live re-freeze is a
separate bounded repair.
Seeds = full corpus; 30s run at ~412k exec/s across 32 workers;
coverage corpus 13 -> 534 interesting inputs; no crashers. Generated
code honors panic-freedom (malformed input returns error, never panics)
— generator untouched. Main-session verify: suite green + codegen gate
GREEN own runs.
- go_suite: go test -race on ALL tui packages (~5s, no split needed) +
gofmt -l gate (caught 10 files; generator now emits formatted Go —
fixed at source, codegen matcher whitespace-tolerant); staticcheck
detect-and-warn (absent here: honest skip, never gated)
- src_go_suite NEW: go test ./... in every src/go module — the 156
bypassed test files now inside the gate; 86/87 green, one named
baseline (verification_layer: stale absolute paths in truth fixtures,
pre-existing; bounded repair queued)
- Main-session verification: go_suite GREEN w/ race+gofmt own run;
src_go_suite AMBER 86/87 own run
- 35/35 gate tests; full sweep AMBER 0 new
event-bus, model-routing, tool-executor, work-manager, rune-entry: core
code in internal/*, 15-26 line main.go shells preserving exact CLI
behavior. Batteries green through the shells; byte-identical CLI
matrices pre/post (24-case event-bus, 16-case tool-executor, 6-case
work-manager replay, 7-case routing parity, 8-case entry).
Fixes riding the wave: tool-executor duplicate pyListRepr symbol (broken
on HEAD since 07c08c34), work-manager repoRoot depth, CI run-pattern +
fuzz + generator path repointing.
Main-session verification: all five build + test green by own run;
-race clean on event-bus. model-routing has no Go test files — its
battery IS the binary's replay mode, verified through the shell.
Tree spawns from a question, grows to resolution, then a new tree; threads
nest as trees-within-trees; always visible, fully live, fully workable
(A+C blend). Binding on task-lane live wiring.
- /v1/conversation: proxy-first; falls back to the canonical hot
checkpoint (6322 live msgs, every message msg_id+ts); never fabricates
- /v1/tasks: TaskStateRepository checkpoint — 3812 real tasks, status
filters, active pointer
- /v1/events: SSE over the event-bus journal (41,542 events) with
last-N replay + live tail; honest empty-if-quiet
- /v1/health: six live probes; unavailable subsystems render
available:false + reason (work_manager: no batch store on this host;
subsystem_health: no failure registry) — never zeros-that-look-alive
- Contract tests + honesty tests red-first; parity canary updated to
real record shape (28/28); main-session verify: tests green, health
endpoint answered live (event_bus true, work_manager false+honest)
- tui/bridge: live seam to the runtime serve surface (Go front door :8377
proxying the core sidecar :8376); polls /v1/status + /v1/conversation,
converts to boundary messages (status_snapshot added via the GENERATOR,
both sides regenerated), pure DeriveFrom renders; every display entry
names its source msg_id — deleting the source deletes the display
(no-sim tests)
- Identity line: honest runtime token (connecting/connected/feed/
disconnected/off); honest OFFLINE + serve_unreachable when the runtime
is down — verified live by main session
- Boundary protocol: 8 message types now; Rust crate round-trips green
- 26 tui packages green; 12 new bridge tests + 2 wiring, red-first
(caught: disconnected-seed mapping, post-shutdown poll append,
80-col identity clipping)
- Known-thin live surface (honest): status counters + role/content
window; no msg_ids from the running sidecar yet (older than the record
type), no events/tasks endpoints — next wave extends the serve side
- tui/update: read-only Gitea latest-check (tui-v* namespace-aware),
three states (UP-TO-DATE / BEHIND with +N / UNREACHABLE honest),
consent-gated offer card (y records consent, changes nothing else —
no download/write code exists), identity-line status token
- 22 frozen tests incl. D27 conformance; red-first; full module green
- Main-session verification: update suite green own run; live pty shows
the token resolving against the real feed
- Honest today: feed has zero tui-v releases yet (bootstrap tag only) —
every TUI truthfully reports feed-state until the first convergence
bump cuts a real release
Resolution ladder: ldflags injection (releases/paired, unchanged) ->
buildinfo VCS + cached git describe (exact tag / tag-distance-sha /
dirty / dev-sha when git absent) -> 0.0.0-dev. go run covered via a
guarded worktree probe (this toolchain skips vcs stamping for go run
actions; go build embeds it). Pure core, no network, git failure
degrades never errors. 12/12 tests.
Main-session verification: go test green own run; go run under pty
shows rune-tui 0.1.0 (HEAD exactly tui-v0.1.0).
- tui/version: build-time semver via ldflags (git tag / describe / dev
fallback ladder); face identity line shows the real version; unstamped
builds honestly say 0.0.0-dev
- .gitea/workflows/tui-release.yml: tag push tui-v* -> paired build
(GOPROXY=off, vendored, self-contained) -> Gitea release 'Rune TUI
<semver>' with single binary attached + commit-range body
- auto-version.yml convergence: version bump now also tags tui-v<version>
at the bump commit — one version event cuts both faces' releases
- build_paired.sh injects semver alongside the build stamp; live run:
tui semver 0.307.0-109-ga04113c5, attestation green
- Main-session verification: 24/24 tui packages green own run; built
with real git-describe and ran the face under pty, exit 0
- First live tui-v* tag push is the remaining proof (flagged)
- tui/skills (G14, LAST package): pattern proposals with consent-first
law (nothing drafted until explicit y), activation views with test
evidence, D10 self-transformation proposal-only truth (fixture walks
the whole keyboard proving no activation path), consent-drift guard
- G7 delta over mid-flight 5db2e249: SSH replay fixed to GREEN (setsid
controlling-tty, boot-ACK wait, burst-boundary parsing, JSON drain) —
main-session verified: 4/4 mutants RED, ssh GREEN, 21/21 pytest
- verification/slowest-target-slo/: schema + validated records; budgets
proposed-only (agreed=false per GAP-BT-05)
- 23/23 tui packages green by main-session own run (cmd/rune-tui
mid-write by wave H1 version wiring — excluded here, lands with H1)
Tag-driven semver injection through the paired-build stamp; tui-v* tag
pushes cut Gitea releases with the vendored binary attached; update
offers go through the self-transformation + migration rules (offer never
silent, consent + digest verify + restore point + honest post-restart
version; owner's Gitea only). Tasks 0.16-0.18. Strict-valid.
Additive exported methods for wrapper faces above promote: TakeoverOpen
distinct from Open (suggestion-region vs rail-takeover precedence) and
RecordFeed (mirror acts through the chain's own API, never a bypass).
Verified: promote + changes suites green.
Contract ADMIT-2026-10-16T03:00:15Z-2fa2c0-wave-e-rail-groundwork (headless
admission, user:wave-E-rail-groundwork dispatch).
- tui/rail/: one-line RAIL beneath lanes (focus, status, newest event with
source tag) + full-width ACTIVITY RAIL takeover (events one-line newest
last, lane-status footer, [x] marker); r opens, x/X/esc restores lanes
EXACTLY; takeover is an inspection boundary (swallows all keys incl.
quit, like a modal; never mutates semantic State — restore true by
construction)
- Feed entries carry source + ancestry strings from day one (SA-D1) — the
thread-tree view (2.10) gets its data free
- Wrapper-Face pattern: rail implements semantic.Face around the inner
face; only chrome keys in the wrapper — frozen 144/20 receipt pins
untouched (reusable for every later interactive surface)
- 77 module tests green (rail 10 + subtests, red-first proven); oracle
GREEN (rich vs zero-ANSI linear projections); 3 mutant canaries trip;
frozen fixture: 5 golden paths + 192-state/24-action walk pins
- Main-session verification: go test ./... all ok; own pty run showed
lanes + RAIL line with focus/source, exit 0
Contract ADMIT-2026-10-16T01:53:09Z-266009-wave-c-semantic-map (headless
admission, user:wave-C-semantic-map dispatch).
- tui/semantic/: renderer-free State + one Apply transition (no mode
branches); both renderers implement one Face interface; linear renderer
reference (zero-ANSI) + rich stub on the same action interface
- Oracle CheckIsomorphism: same 144-state space + 20-action vocabulary on
both; golden-path fingerprints equal per-step AND equal to frozen traces
(testdata/golden-paths.v1.json, receipt-SHAs pinned); focus restores
after modals under mouse perturbation; every mouse action keeps a
keyboard equivalent; announcements bounded at 5
- Red-then-green: lab mut-reorder-asym implanted -> frozen gate RED with
14 violations (matching lab receipt); reverted -> green. Four lab mutants
permanent canaries (each must trip oracle or pins, forever)
- Key-parse conformance: receipt byte strings replayed through the real
vendored parser (alt+q atomic vs split divergence, enter-confirms-modals)
- 27 semantic tests (42 module-wide) green; unified_check go member GREEN
- Fixed a linear-region Y off-by-one inherited from the lab (made the
perturbation probe vacuous there — now real in both projections)
- Main-session verification: go test ./... all ok; oracle + mutant +
keyparse tests watched passing with own hands
- README: plain-language — what the map is, why both renderers satisfy it,
how to add a golden path
Contract ADMIT-2026-10-16T00:49:38Z-71a0db-wave-b-foundation (headless
admission, user:wave-B-tui-foundation dispatch).
- tui/ real module: bubbletea v2.1.0 + bubbles v2.2.1 + lipgloss v2.0.6,
pinned through the GENERATOR (go.mod is generated territory — codegen
gate byte-diffs it; pins flow gen template -> regenerate -> tidy no-op
-> vendor), vendored into the repo (679 files, offline-proven with
GOPROXY=off; zero binary content; all committable)
- cmd/rune-tui: minimal honest face — Rune, version 0.0.0-dev, build line
(unset for unpaired dev builds; stamped builds show the paired id),
q/ctrl-c clean exit 0; no TTY -> clear error, never a hang; no fake
functionality (lanes/rail/threads are later waves per spec honesty)
- 15 Go tests green (quit keys, honest view, build-id stamp readback
through a probe-built binary, boundary round-trips)
- Wiring: unified runner go member GREEN (vendor auto-detected, no runner
change); paired build stamps both sides; attestation passes
- Main-session verification: go build/test green; face RUN under a real
pty (script) — boot + render + q -> exit 0
- Morning list section 4 filled; judgment log 6-7 (pins package law,
generated go.mod law)
Contract ADMIT-2026-10-15T22:10:31Z-4b1306-substrate-worker (headless
admission, user:phase-0C-substrate dispatch). Code enforces; spec records.
- 0.12 schemas/boundary/v1 (7 INITIAL message types) + gen_boundary_types.py
emitting BOTH sides (tui/boundary/gen + src/rust/boundary_types crate);
check_boundary_codegen.py gate — hand-edits RED, stale regen RED, corpus
corruption RED (all red-tested first)
- 0.13 unified_check.py (make check): 103 rust crates + pinned pytest suite +
go vet/build/test + corpus round-trip both sides + codegen gate + binary
gate; single exit; per-sha JSON manifest; partial green impossible (tested)
- 0.14 build_paired.sh one build id stamped both sides; build_attestation
verify_build_pairing() raises on mismatch (proven by live tampering)
- 0.15 check_landing.py — refuses landings lacking fresh green runner
evidence or committing binaries (6014 files swept: zero tracked binaries)
- First full verdict RED (correct): surfaced pre-existing prompt_sync
arithmetic-overflow (src/rust/prompt_sync/src/difflib.rs:107, 3 tests,
never swept before — reported, not fixed, queued for bounded repair).
Honest baselines recorded (verification/unified-baseline.json): 120
pytest + 1 crate known-sick; AMBER = baseline-only, 0 new; baseline-diff
comparison only (flaky edges 118-120 observed).
- Judgment calls (logged for owner): suite-refreshed store/spine/current.json
LEFT in place (restoring re-arms an order-dependent false RED; spine was
stale vs c8926ef8). 0.10/0.11 members declared as named SKIPs (fold next).
Owner ruling 2026-10-15: no two test worlds — the system is tested as one.
D26 makes the dichotomy's known failure modes structurally impossible:
generated boundary shapes (one schema source, both sides code-generated,
hand-written shared shapes gate-rejected), one unified runner (Rust + Go +
boundary round-trip corpus + verdict fixtures + mutants; partial green
impossible), paired builds with startup attestation (mismatch fails
closed; no committed compiled artifacts), and the landing rule (every
landing passes the unified runner). Phase 0C tasks 0.12-0.15 added before
construction begins. Strict-valid.
Contract ADMIT-2026-10-15T21:04:13Z-7ea89c-repair-worker (headless admission,
approval user:phase-0B-0.9(e) dispatch).
Root cause: fire() stamped dispatch start with an aware clock
(microkernel.py:364 datetime.now(timezone.utc)) then subtracted a naive
datetime.now() at :441 — TypeError killed every dispatch with a listener
(= all alert firing). Matches R2 evidence naming (verification.txt
'aware total_start ... subtracts naive datetime.now').
Discharge (finding -> test -> commit):
- test: test_fire_with_listener_completes_on_real_clock — RED with the
actual TypeError on unfixed code (real clock, no shim), GREEN after;
frozen forever
- fix: one line — both sides of the duration boundary use the file's
existing UTC-aware convention; no codebase datetime migration
- proof: 26/26 (2 new + 24/24 hardening untouched); 83/83 adjacent
consumers; end-to-end CLI fire verified ('Fired alert.requested: 1
hooks in 34.9ms'); ruff clean. Scope named; 116 pre-existing
full-suite failures unchanged.
Alerts are live again.
Contract ADMIT-2026-10-15T20:28:00Z-15eb44-repair-worker (headless admission,
approval user:phase-0B-0.9(c) dispatch). All four I-R2-023 holes closed:
Discharge (finding -> test -> commit):
- finding: I-R2-023 lifecycle_threat_matrix (research/tui-frontier-r2)
- install: closed-field typed manifest schema (unknown fields rejected) +
sha256 digest recorded at registration and verified before any hook runs
(swapped file -> digest_mismatch, never executes)
- update: stale-cap.old defect — old index rows now removed + buckets pruned;
registry written via temp-file + atomic rename (crash-mid-write safe)
- revoke: whole process GROUP killed (children included) with verified death
before completion + auditable receipt
- migration: migrate_registry() — export, checkpoint, migrate copy, validate,
atomic switch, rollback on failure
- test: tests/test_microkernel_lifecycle_hardening.py 24/24 green
(21 red / 3 pass on unfixed code — each hole reproduced before fixed);
consumers 96 passed; Go-twin parity sweep 24/24; ruff clean. Missing-name
check reported already-fixed on HEAD, not re-proven.
Known adjacent (separate repair): fire() aware/naive datetime crash = 0.9(e);
tests used the R2 clock shim to stay neutral. Dichotomy debt recorded: Go
parity twin lacks the new hardening gates (future wave).
First repair landed through the COMPLETE headless Scaffolding path:
contract ADMIT-2026-10-15T20:01:32Z-ec2794-repair-worker (classify ->
activate -> admit -> building, approval user:phase-0B-0.9(b) dispatch).
Root cause: LocalToolRuntime.run asked Ollama directly and believed
whatever it advertised; CAPABILITY_FLOOR (model_routing.py:308) says
otherwise for some models (qwen2.5:3b) — nothing compared the two or
recorded disagreement (R2 probe 'truth_drift').
Discharge (finding -> test -> commit):
- finding: I-R2-022 truth_drift probe (research/tui-frontier-r2)
- test: 2 new fixtures (routing seam + drift record) — RED on unfixed
code, GREEN after; frozen forever
- fix: reconcile_tools_support checks every provider-reported tool claim
against CAPABILITY_FLOOR; contradictions record a queryable
'unverified' drift marker (model + both claims) on the runtime —
surfaced, never silently flipped. Selection eligibility stays with
ModelRouter.rank() (floor gates unmeasured candidates; native_tools is
a wire-mode choice, not eligibility).
Proof: 2/2 new fixtures green; 15 touched-module test files 271 passed
incl. LIVE qwen3:14b end-to-end acceptance (~57s) — the fixture that
rejected the first veto-style design (static cards must not reject
locally verified capability); orchestration 6/6. Scope named: not
claiming full-suite green (116 pre-existing HEAD failures).
Wires the owner-directed Scaffolding-only build law for background workers:
classify + activate (already headless) now complete with admit() — same
mint, same surface resolver, same transitions as the TUI /build start path
(exposed, not forked). Fails closed identically: NOT_CONSTRUCTION/UNKNOWN
refuse; workers cannot self-approve (user-mandate reference required);
mint failure refuses outright.
Discharge (finding -> test -> commit):
- finding: repair agent 0.9(a) gap report — contract/canary stages TUI-only
- test: tests/test_construction_admission.py — 11 tests, RED on absent
module (import error), 11/11 GREEN after; touched suites green; 6 older
failures + 116 full-suite items byte-identical on clean HEAD (zero regressions)
- proof: end-to-end demo classify->activate->admit->dispatch recorded at
verification/headless-scaffolding-entry-demo.json (temp store, contract
minted in building with scope/fixture expectation/pytest obligation)
- repairs 0.9(b)-(e) usage: cadm.admit(rec, objective, affected_surface,
verification_obligations, approval_ref) -> live contract id for dispatch
Also: rebuilt stale shipped libconstruction_commands.so (missing ccm_command
symbol on HEAD — root cause of core-unavailable dispatch crashes).
Registered via classify+activate (EXISTING_PROJECT_CHANGE, rune_internal).
Root cause: EligibilityFilter.reasons (src/rune/orchestration/eligibility.py)
checked health/kind/locality but never consulted evidence_age_s — a card
marked healthy a full day ago (86400s) outranked a card measured slow 5s ago.
Discharge (finding → test → commit):
- finding: I-R2-022 placement_probe (research/tui-frontier-r2, frozen spec tasks.md 0.9(a))
- test: tests/test_orchestration_authority.py::test_stale_healthy_card_does_not_outrank_fresh_slow_placement
— exact probe replay; RED on unfixed code (assert 'stale-fast' == 'fresh-slow'),
GREEN after fix; regression fixture frozen forever
- fix: eligibility appends structured reason 'stale_evidence' and excludes
cards with evidence age > MAX_EVIDENCE_AGE_S = 3600.0 (one hour; chosen
between the evidence's 5s fresh and 86400s stale exemplars — owner-tunable)
Proof: fixture 1 passed; full suite 397 passed, 7 pre-existing warnings.
Scaffolding: registered via classify_mode + activate_json (EXISTING_PROJECT_CHANGE,
confidence 0.8, authority rune_internal, affected surface = these 2 files).
Known gap recorded for b-e: headless contract/canary minting is TUI-only.
Port the one audit-unmatched fn name-preserving into the Go crate
(gaps.go): handleHook (+ exported HandleHook twin, hook-engine
convention) — the generic microkernel hook handler returning
{status: ok, event, handler: default}; the oracle's data arg is
accepted but DROPPED (not echoed — contrast hook-engine's twin), and
the Go data interface{} rides JSON null/objects/arrays/scalars through
the same call. Truth: frozen_rr_truth.json in SHARED-HARNESS freeze
form (7 cases: default-arg, None, dict/list/scalar/nested data, empty
event), freeze_truth --verify OK, regen x2 byte-identical; truth_test.go
replays the rows VERBATIM (go:embed + reflect.DeepEqual). Live parity:
47 cases (frozen + 40 seeded fuzz incl. unicode events and the
data-drop key law) via a temp go-run stdin/stdout harness — package
main is not importable and go test swallows stdin; failures=0.
go build/test/vet/gofmt clean. New tests/test_recall_router.py (module
had no suite): 5/5 BOTH pins. recall_router 2/3 PARTIAL -> 3/3 FULL
(audit instrument regenerated; graph_projection 6/6 from this lane's
first commit also lands in the FULL table).
Port the three audit-missing fns name-preserving into the EXISTING crate:
_db (the read-only connection law, sqlite open peeled off per the
boundary law — WnsDb{uri file:…?mode=ro, row_factory=Row}; uri frozen
from a spied LIVE connect() call), neuron_slugs (sorted coalesced slugs,
duplicates retained), handle_hook (HookOutcome struct serializing in the
oracle dict's insertion order status/event/handler; literal parity — the
Go voicebox empty-event improvement deliberately NOT mirrored). Six FFI
wrappers (doc-envelope law) for ctypes live parity.
Truth: NEW frozen_wns_truth.json, 35 rows over 8 real-sqlite scenarios
(null-coalesce, falsy-coalesce, dupes-kept-and-overwrite, triggers-parse-
unicode, sql-filter, order-by-slug capture) + 6 neuron_has probes +
_db uri/facade rows + 4 handle_hook rows; rows captured through the
oracle's OWN _db() + SELECT (STORE_DB patched). Regen x2 byte-identical,
--replay 35/35 stable. NEW branch_battery.rs replays all groups incl. a
key-ORDER pin. DEFECT FOUND+FIXED (battery-proved): the W6-era
list_neurons kept falsy values where the oracle's or-coerce substitutes
defaults — slug '' → 'warm', importance 0.0 → 0.5 (falsy-coalesce row
failed pre-fix); fixed to the oracle law (drift_compression
warn_before_compress class). cargo test 4/4, clippy --all-targets
-D warnings clean, fmt clean, release .so built. LIVE PARITY 76/76
(wns-parity) via ctypes FFI vs the live oracle incl. _db live-connect
proofs; negative control detected all 4 planted perturbations. Python
BOTH pins: canary ✓ list_neurons + neuron_slugs (residue fn, live),
adjacent pytest test_p1_03 67 passed/1 skipped both ways (no
RUNE_WNS_CORE loader exists — pin inert; runs green regardless); ruff
clean. warm_neuron_store 3/6 → 6/6 fn-level. Divergences documented:
neuron_has LIKE ASCII-fold boundary (W6 surface, agreement-domain rows),
digests NULL-slug json-crash edge. Evidence: verification/wns-*.
Derived state refresh: the F1 close commit's regen predated the sibling
voicebox landing (626f8483, rebased under); regenerating from the true
master tree records FULL 151/193 (78%), fn 1943/2301 (84%), PARTIAL 3 —
voicebox is FULL on its landed code.
Two-module literal-100% residue lane closed via iface.close() (walk
draft->approved->building->verifying->closed in ONE process — the
kill-after-commit note: the 120s shell timeout truncated only the
buffered console prints; the durable walk completed 08:14:33Z ->
08:16:10Z, store re-validated line-by-line after). Both feat commits
verified gitea/master ancestors: structural_migration a399477b (4/4,
apply_migration consent gate with clock-as-argument civil law incl.
leap-day + pre-epoch instants, consent_brief insertion-order law via
serde_json preserve_order, 25-case frozen truth regen-x2-identical),
voice_injector d268b365 (5/5, toDict + toDictJSON byte law
json.dumps(indent=2) with ensure_ascii + integral-float rules,
testInjection stdout law with >100-rune codepoint-slice proof,
injectVoice with the blend peeled to an argument — 13-case frozen
truth, go test/vet/gofmt/build clean, voice-family pytest 21/21 BOTH
pins). No loader replay exists for either module — frozen-oracle
battery replay is the parity gate (L3 law). Machinery exclusions
hold: only dataclass dunders excluded in both oracle files
(dichotomy_audit.py:75-83). Audit doc regenerated: FULL 148/193
(77%) fn 1933/2301 PARTIAL 6 -> FULL 150/193 (78%) fn 1937/2301
PARTIAL 4; both targets FULL, missing lists empty. Evidence:
verification/smig-*, verification/vi-*, verification/f1-summary.md.
Port the six audit-missing fns name-preserving (exact snake names,
tool_protocol gaps.go law) into src/go/voicebox/gaps.go: _run (argv law,
VENV head), start_recording / stop_recording (the push-to-talk control
law incl. the active-flag ordering, >4000 gate, elif-wav unlink swallow),
_transcribe_and_type (join law + xdotool check=True except-arm + finally
unlink), on_press / on_release (key sentinel twins, recover-based
suppression). Pure logic 1:1; every device boundary (arecord Popen,
faster-whisper, xdotool, temp file, unlink, stderr) behind the
voiceboxSeams injectable; the pynput listener loop stays facade (its one
observable line byte-pinned as the talk_banner op).
Truth 6 -> 21 cases, now generator-owned (scripts/gen_voicebox_truth.py:
pynput/tempfile/subprocess/faster_whisper rig capturing the oracle's REAL
nested closures over its REAL recording dict; real temp files so
os.path/unlink run unpatched; TMP/ + REPO_ROOT normalization; venv
re-exec guard). Regen x2 byte-identical + --replay 21/21 stable. Battery
(TestTruthReplay via VB_TRUTH_PATH + 2 unit twins) green; gofmt/vet/
build clean; LIVE PARITY 100%: fresh oracle regen byte-identical to
frozen and battery green against it. DEFECT CAUGHT BY THE BATTERY:
calledProcessError dropped the quotes around the python list repr —
fixed to Command '[…]' returned non-zero exit status N (case 19 exposed
it). Python surface: canary imports voicebox BOTH pins (adjacent pytest
has no voicebox importer — plugin surface, task_gate precedent);
test_p1_03 67 passed/1 skipped BOTH pins after building memory_scoring +
memory_retrieval .so in this worktree (retired-oracle stubs recurse
without them — worktree artifact, not a regression). voicebox 5/11 ->
11/11 fn-level. Evidence: verification/vb-*.{log,exit,txt,md}.
Port the two audit-missing fns name-preserving into the Go impl
(gaps.go) + the REAL inject_voice logic the shape-check replay never
carried (injectVoice):
* toDict — the VoiceInjection.to_dict insertion-order contract
(dimensions, guidance, token_count) as ordered KV pairs, plus
toDictJSON: the BYTE law json.dumps(to_dict(), indent=2) exactly —
ensure_ascii \uXXXX escapes, the five short escapes, integral-float
rule (emphasis 1.0 stays "1.0"), Go-map-sorting sidestepped.
* testInjection — the oracle's 5-fixed-message test report; inject is
the seam (io.Writer + func). The >100-rune unicode essence proves
guidance[:100] slices by CODEPOINT (truncateRunes — sleep_time trap).
* injectVoice — the blend peeled to an argument (task_gate boundary
law: voice_hybrid.blend is DB-backed reactive Python): keep emphasis
>= 0.15 (boundary 0.15 kept, 0.149/0.05 dropped), join "- name:
essence" lines with \n, estimate tokens on the guidance.
Truth: gen_voice_injector_truth.py stubs the oracle's voice_hybrid
symbol with a deterministic frozen-blend table and freezes 13 cases
(4 estimate regression incl. rune-count, 5 inject with boundary/
integral/unicode/empty blends, 3 to_dict incl. empty + integral
emphasis byte law, 1 test_injection full stdout). Regen x2
byte-identical (md5 evidence). Battery TestGapsParity 13/13 green;
go test + vet + gofmt + build clean. Voice-family pytest 21/21 BOTH
pins (live kernel + RUNE_VOICE_HYBRID_CORE=python; the vh .so built
in-checkout first — gitignored artifact). voice_injector 3/5 → 5/5
fn-level FULL.
Port the two audit-missing fns name-preserving into the crate:
* apply_migration — the consent gate: MATERIAL without user approval is
structurally impossible (ConsentRequired; the MESSAGE is the contract,
arrow + Python list-repr of changes[:3]). The record carries from_v/
to_v/kind/changes/user_approved/approved_by (None unless approved,
empty-string carried verbatim when approved) + applied_at. The wall
clock is an ARGUMENT (no-clock law): epoch seconds →
strftime(gmtime(secs)) via the project_registry civil_from_days law —
two frozen instants incl. the 2024-02-29 leap day and pre-epoch -1.
model_store is carried opaque — the oracle accepts and never reads it.
* consent_brief — the rule-18I presentation dict (current/proposed
version, benefits, semantic changes, the two fixed migration risks,
expected effect, requires); serde_json preserve_order added so the
insertion-order law is asserted, not assumed.
Truth: gen_structural_migration_truth.py freezes all 4 fns × every
branch (15 classify rows incl. the dropship-substring and case-fold
traps, 3 affected_projects rows, 5 apply_migration rows incl. both
error branches and the [:3] slice proof, 2 consent_brief rows) into
frozen_smig_truth.json; regen x2 byte-identical (md5 evidence). Battery
replays the frozen truth (25 rows: value equality + insertion-order
assertions); cargo test 5/5 green, clippy -D warnings clean, build
clean. Python suite 20/20 (no loader exists for this facade — pins are
trivially both). structural_migration 2/4 → 4/4 fn-level FULL.
One-process walk (draft→approved→building→verifying→closed) via
iface.close() with contract_quality observed_evidence. Parity SHAs:
worthiness bb001de6; lexicon_evolution 73ac04f8; drift_resume 8c17723d;
attention_capsule 25df4951; drift_cache 12e9584a; construction_decision
a4badbc7; recall_uplift 29c5cb68; tool_protocol 59efd385. All 8 modules
now n/n FULL (verification/l3-audit-modules-final.txt); audit doc
regenerated by the instrument.
Port the five audit-unmatched helpers name-preserving into the Go crate
(gaps.go): _utc_now_iso (Python isoformat law — six-digit fraction iff
nonzero, injectable clock seam pinned by the battery to the frozen
oracle instants), _contains_tool_object_key (name-preserving twin of
the outside-strings scanner), to_ollama_tools (registry → Ollama
function shape), dispatch_validated_tool (validate-before-dispatch with
an Executor seam; invalid calls provably never reach the executor),
tool_requires_approval (fail-closed against the 12-name READ_ONLY
frozenset; NOT derived from registry risk — lint_file runs a linter).
Truth 17→32 cases (utc both instants, 8 scanner cases, full-registry
ollama conversion, dispatch alias/invalid, approval verdict for every
registered tool + alias + unknown with schema-valid minimal args);
regen x2 identical modulo the pre-existing uuid call_id quirk.
DEFECT FOUND+FIXED: the landed containsToolObjectKey reused ONE
json.Decoder across candidates (wrong offsets after the first decode)
and dropped the oracle's colon check — the new frozen true-positive
cases exposed it; rewritten to the oracle's per-candidate raw-decode +
colon law (fix-first, proof = battery green). go test/vet/gofmt/build
clean; pytest 60+29 subtests both pins. tool_protocol 22/27 → 27/27
fn-level.
Port the last four audit-missing fns name-preserving into the crate:
* _do_core — the facade loader-probe twin (_cs_core law; 4 pin rows).
* _load_alerts — the METHOD's file law with the IO peeled off (text
arg; None=missing → [], JSONDecodeError → [], valid doc VERBATIM —
a non-array document rides through as-is); 5 rows incl. the
non-array and corrupt branches.
* _save_alerts — the persisted bytes law: json.dumps(alerts, indent=2)
(ensure-ascii escapes, integral-float law); 2 rows incl. unicode.
* main — the subparser CLI dispatcher (task_persist MainOutcome law):
check/retrospective --days/alerts/acknowledge index/dashboard with
the help-to-stdout + exit-1 no-cmd shape, exit-2 argparse classes
(invalid choice, subparser usage with the per-sub prog prefix,
missing/bad int index, bad --days), every print shape (Found N new
alerts, the retrospective block, Unacknowledged (N) with [i] prefix,
Alert N acknowledged., the full dashboard incl. .2% ratio and
True/False bool str), and the in-memory alerts-file state (rendered
bytes compared). 20 main rows frozen from the live oracle under a
memory_store/drift_core seam rig.
serde_json gains preserve_order (dict-order rendering); the rig's
frozen stamp is deterministic and the truth keeps insertion order.
FIX-FIRST WITH PROOF (pre-existing kernel bug): dob_run_retrospective
returned the BARE local stamp as filename, but the facade joins it
directly — kernel-live wrote retrospectives/20261011_130000 while the
Python path wrote retrospective_20261011_130000.json. The kernel now
returns the full name; the replay pass PROVED the divergence pre-fix
(kernel 55/64 on the stale .so) and parity post-fix (facade 64/64,
kernel 64/64, both core modes writing identical file names).
Battery 9/9 green (was 5); drift-family pytest 20/20 BOTH pins; clippy
-D warnings clean; gen x2 byte-identical. Fn coverage 5/9 -> 9/9.
All 8 audit-missing fns ported name-preserving (token_optimizer
precedent for this fn family): to_dict (TemporalContext struct, the
json! literal now renders through it), _to_state/_apply_state (State
methods; _apply_state canonicalizes the ISO like the facade's
datetime), _run_kernel (the envelope loop factored out of ta_run),
_write_snapshot (the file-doc projection; fire_save routes through
it), get_time_awareness (the singleton construction decision over
facade-read storage text + the init monotonic stamp), _clock_args
(UTC-aware ISO -> epoch-us conversion, clock as argument), _ta_core
(the probe verdict as data, sg_core pattern). Behavior-preserving:
frozen scenario truth replays unchanged (regenerated byte-identical).
Truth: frozen_ta_gap_truth.json (12 shared-harness rows, envelope
clock + pinned mono, --verify byte law under ta_gap_freeze_seams rig)
+ frozen_ta_gap_clocked.json (10 sandbox rows, regen-x2 byte law).
Gates: cargo 5/5 + branch battery, clippy -D warnings, gap parity
(harness 12/12, clocked 10/10, live loop 4/4), module parity
1251/1251, pytest both pins. Audit: time_awareness 12/20 -> 20/20
FULL.
Env fix: gen/parity tmp roots uid-scoped (a CI-runner-owned
/tmp/ta_truth_memory broke every other user; frozen truth byte-stable
under the new roots — no path leaks).
Lane factory-literal-l0 (issue #2479).
Port the last four audit-missing fns name-preserving into the crate:
* _tg_core — the facade loader-probe twin (_cs_core law; 4 pin rows).
* _now — the aware-UTC isoformat stamp with the clock as an argument
(epoch micros; .ffffff omitted at microsecond 0; +00:00; 6 rows pin
epoch-zero, pre-epoch negatives, leap-day-2024, whole-second).
* list_gates — the listing projection moved kernel-side: count DESC
stable sort (sqlite's tie order = id order, proven by the tie rows);
truth group now carries rows-before input + expected.
* main — the full argparse CLI dispatcher as a lib fn (task_persist
MainOutcome law): choices/arg/--event/--data/--json parsing with the
COLUMNS=80 usage wrap and exit-2 error classes, the required-cmd-
before-unrecognized precedence quirk, both output modes per verb
(PROMOTED/Noted/Observing, GATE lines, the 10-wide status/3-wide id
list format, hook compact-json echo), and the in-memory DB-state
application (matched UPDATE / autoincrement INSERT with promoted_at
NULL column shape). 25 main rows frozen from the live oracle.
serde_json gains preserve_order (row dicts ride sqlite column order —
the --json renderer replays it); the rig's frozen stamp is now
deterministic and the truth file keeps insertion order (sort_keys
would lie about row key order).
Battery 8/8 green (was 4); live parity 982/982 (32 truth + 950 fuzz);
--replay with delegation live facade 67/67 kernel 67/67; clippy -D
warnings clean; gen x2 byte-identical. No adjacent pytest exists for
task_gate (plugin surface) — parity/replay/battery are the gates.
Fn coverage 5/9 -> 9/9.
Audit-missing fns set_auto_filer + configure_logging ported
name-preserving (gap.rs): the decision halves of the side-effect shell
(the #122 fail-safe wiring gate; the P0-06 destination + handler-config
resolution with HOME as an argument) — the callback object and the
RotatingFileHandler attach stay facade (crate law: side effects cannot
cross FFI). Oracle-observation truth (frozen_sh_gap_truth.json, 6 rows
— module-global wiring matrix + live-logger handler config under
sandboxed roots with path placeholders; byte-identical on regen) + gap
battery + live gap parity (re-capture byte-identical 6/6, spot-matrix
4/4) + module parity 1056/1056 + pytest both pins green. Audit:
subsystem_health 4/6 -> 6/6 FULL.
Lane factory-literal-l0 (issue #2479).
_rust reported as EXCLUDED machinery: the module's loader probe (RUNE_TC_CORE
pin + tl_loader availability + getattr dispatch + _MISSING fallback) —
delegation glue by the audit doctrine, porting it is circular; added to the
audit's MACHINERY set (documented, never fabricated). No residue port surface
remained (all five kernels already ported). Surface: crate battery 7/7;
tests/test_toolchain.py 11/11 with live delegation (.so built) AND
RUNE_TC_CORE=python. Audit: 5/6 -> 5/5 FULL RUST.
Port run_kernel name-preserving (the scaffolding_stage_runner kernel-bridge
closure: pc_stage_run result merged via dict.update + state return) + FFI
pc_run_kernel + pc_loader.run_kernel wrapper. Truth 6 oracle-closure rows
under a stubbed-pc_loader rig (gen x2 byte-identical); battery 9/9 incl.
run_kernel_residue_battery; live parity 10/10 (closure vs twin + frozen
truth FFI); clippy -D warnings clean; Python 14/14 both pins. Audit:
11/12 -> 12/12 FULL RUST.
Port the last audit-missing fn name-preserving: main, as the CLI-front
bin (memory_scoring/rune_spine bin law) — the oracle main's
measurement loop is host-side (Python callables / Ollama HTTP; FFI
cannot receive callables), so the bin fronts the portable law the
kernel owns: {op: profile_stats, arg} on stdin -> the same doc
envelope the FFI returns. Smoke-verified: function shape (p95/p99),
model_call shape, empty-times ValueError envelope, unknown-op error;
bin output byte-matches the FFI for identical inputs.
FIX-FIRST WITH PROOF (pre-existing master break): pyjson's Float wire
variant (decimal-point law) made the rp_profile_stats FFI and the
battery filter Json::Num only — every float elapsed-ms was dropped,
so ALL delegated calls raised 'min() iterable argument is empty' and
the facade silently fell back to Python; battery 1/3 on master. Both
extractions now accept Num|Float. FFI verified live with float times
(mean/median/percentiles correct); battery 3/3 green; parity 815/815
(frozen 9 fuzz 800 live 6); clippy -D warnings clean; adjacent pytest
22/22 BOTH pins. Fn coverage 2/3 -> 3/3.
Audit-missing fn _smod_core ported name-preserving (gap.rs): the
delegation-probe verdict as data (salience_gate _sg_core / spine
_rust_core pattern — the loader module is unrepresentable over FFI;
RUNE_SM_CORE belongs to shard_manager, smod keeps its own pin).
Shared-harness frozen truth (frozen_smod_gap_truth.json, byte-verified
via freeze_truth.py --verify) + gap battery + live gap parity (pinned
2/2, live matrix 2/2 — 100%) + pytest both pins green. Audit:
self_modify 7/8 -> 8/8 FULL.
Lane factory-literal-l0 (issue #2479).
Port test_capsule name-preserving: the oracle's runnable self-test
(basic-capsule invariants — objective preserved, memories ≤5, tokens
≤600; over-budget trim to 200) as a Rust fn returning the printed
values as a JSON doc, frozen-truth test_capsule group binding the
oracle-derived summary (token_count 19, memories 0, prompt preview,
large 52) byte-compared by the battery. Truth regen x2 identical, all
case groups preserved. Battery 7/7; facade pytest 34/34 both pins;
clippy -D warnings clean. attention_capsule 6/7 → 7/7 fn-level.
Port the last two audit-missing fns name-preserving:
* _now — the strftime/gmtime stamp law with the clock as an argument
(epoch secs -> %Y-%m-%dT%H:%M:%SZ UTC civil fields); 7 truth rows
pin epoch-zero, pre-epoch negative, leap-day-2024, leap-century-2000,
non-leap-century-2100, day-boundary, frozen-ts.
* _pr_core — the facade loader-probe twin (_cs_core law: RUNE_PR_CORE
=python pins the Python fallback to None; any other value resolves
the in-process kernel); 4 pin rows frozen from the live oracle.
Existing 36-case groups byte-stable. Battery 11/11 green; replay
(delegation live) facade 47/47 kernel 33/33; clippy -D warnings clean;
adjacent pytest 14/14 BOTH pins. Fn coverage 10/12 -> 12/12.
Audit-missing fn _ol_core ported name-preserving (gap.rs): the
delegation-probe verdict as data (salience_gate _sg_core / spine
_rust_core pattern — the loader module is unrepresentable over FFI).
Shared-harness frozen truth (frozen_ol_gap_truth.json, byte-verified
via freeze_truth.py --verify) + gap battery + live gap parity (pinned
2/2, live matrix 2/2 — 100%) + pytest both pins green. Audit:
outcome_ledger 7/8 -> 8/8 FULL.
Lane factory-literal-l0 (issue #2479).
Port the last audit-missing fn name-preserving: _mg_core, the facade
loader-probe twin (_cs_core law — RUNE_MG_CORE=python pins the Python
fallback to None; any other value resolves the in-process kernel,
whose load-failure arm cannot fire). Truth +4 probe cases (python/
auto/other/unset pins, resolved projection frozen from the live
oracle); existing 68-case groups byte-stable. Battery 13/13 green
incl. battery_probe; RUNE_MG_CORE=auto parity pass byte-identical
against the built .so; clippy -D warnings clean; adjacent pytest 9/9
BOTH pins. Fn coverage 12/13 -> 13/13.
Audit-missing fn _gr_core ported name-preserving (gap.rs): the
delegation-probe verdict as data (salience_gate _sg_core / spine
_rust_core pattern — the loader module is unrepresentable over FFI).
Shared-harness frozen truth (frozen_gr_gap_truth.json, byte-verified
via freeze_truth.py --verify) + gap battery + live gap parity (pinned
2/2, live matrix 2/2 — 100%) + pytest both pins green. Audit: grading
3/4 -> 4/4 FULL.
Lane factory-literal-l0 (issue #2479).
Port _sr_env name-preserving (five-root env assembly, roots as args) + FFI
twin sr_env; _sr_core reported as EXCLUDED machinery (loader probe —
sr_loader.core(), pin honored in the loader; added to the audit's MACHINERY
set, never fabricated). Truth frozen from the live oracle under a sentinel
rig (gen x2 byte-identical); battery 5/5 incl. sr_env_residue_battery;
live parity 100% (scripts/check_sr_parity.py: 8/8 dual-pin facade
scenarios + _sr_env row); clippy -D warnings clean. Audit: 14/16 ->
15/15 FULL RUST (1 machinery-excluded).
Audit-missing fns _rust + _now ported name-preserving (gap.rs): _now is
the pinned-clock render kernel (now() is its SystemTime reader), _rust
the delegation verdict as data (spine gap.rs pattern). Frozen truth
(frozen_bb_gap_truth.json, 9 oracle rows, byte-identical on regen) +
gap battery + live gap parity (_now 6/6, _rust 3/3) + module parity
1018/1018 + pytest both pins 6/6 green; cargo fmt normalization
(pre-existing dirt at HEAD). Audit: build_basis 11/13 -> 13/13 FULL.
Lane factory-literal-l0 (issue #2479).
Port the last audit-missing fn name-preserving: _journal_path, the
facade HOME-seam twin (expanduser env-read stays facade; the twin is
the posixpath join law over its output — exactly one separating
slash). Truth +5 journal_path cases (root-slash/empty/relative/
trailing-slash HOME quirks frozen from the live oracle); existing
groups byte-stable. Battery 4/4 green incl. replay_journal_path;
live parity 820/820; clippy -D warnings clean; adjacent pytest 9/9
BOTH pins. Fn coverage 3/4 -> 4/4.
Port the last audit-missing fn name-preserving: _auto_fix_decision,
the facade routing probe's reunited-crate twin (delegates in-process to
the existing auto_fix_decision kernel; the loader-failure fallback arm
cannot fire in-process). Battery k_auto_fix replay now enters through
the twin — 8/8 green. Truth regen x2 byte-identical; embedded truth
== live regen; RUNE_DL_CORE=auto parity pass 87 cases byte-identical
against the built .so; clippy -D warnings clean; adjacent pytest
27/27 BOTH pins (RUNE_DL_CORE=python|auto). Fn coverage 20/21 -> 21/21.
Port _le_core name-preserving (the audit's snake-case candidate never
matched): LeCore unit struct + env-pin probe honoring RUNE_LE_CORE=python
→ None (the _bh_core pattern), battery core_probe_pin_law test (env
lock, pin/auto branches), frozen truth core_probe metadata group (None
under the freeze pin), generator kernel-replay guard for metadata
groups. Truth regen x2 byte-identical, old groups preserved. Battery
8/8; parity facade 54/54 kernel 76/76; pytest 15/15 both pins; clippy
-D warnings clean. lexicon_evolution 7/8 → 8/8 fn-level.
The IO lane's gaps_io.go (aed3c27c, landed on master between this lane's
audit run and its push) also ports reindex_entries as a canonical
db-bound ReindexEntries — both files together redeclared the symbol and
broke the crate build at the crossing. Rename this lane's variant to
ReindexEntriesSeamed (sibling file untouched): the embed-CALLABLE-seam
mirror whose scripted-vector truth rows (truth_stats_gaps.json) pin the
oracle's json.dumps corpus format — distinct surface from the IO lane's
live-Embed port. Battery 24/24, live parity 24/24, gofmt/vet/build/
full-test green on the merged tree (both families' batteries pass
together). IO-lane follow-up flagged in msstats-summary.md: gaps_io's
vec corpus uses json.Marshal separators where the oracle emits
json.dumps ', ' shape.
WORKING-SET/STATS/AUDIT lane (builder factory-heavy-ms-stats): the 5
currently-unmatched slice fns ported name-preserving into the
memory-store-deep Go corpus in a NEW family file gaps_stats.go (siblings
untouched) — reindex_entries (gap census + dry-run + full rebuild with
contentless-FTS5 DROP/recreate + vec_missing/fts_missing counting),
wake_up (CHAR-budgeted '- text' lines — rune count, never bytes),
storage_backend (R2 W2.0 read-backend seam: sqlite default,
RUNE_MEMORY_STORAGE=rust opt-in via injectable probe; loader is FFI
machinery), stats_for_path (stats through the seam; by_topic EMISSION
order preserved via parallel pair list — Go maps sort it away),
handle_hook (default envelope). The other 12 slice fns were already
landed by earlier waves (main.go/gaps_retrieval.go) — audit re-run first
per law.
Truth: 24-row truth_stats_gaps.json from the live oracle under pinned
rigs (frozen clock, _embed off/scripted, fake mems_loader sys.modules
injection, plain-table entries_vec mirror — vec0 observed only through
COUNT/JOIN/DELETE/INSERT). Battery gaps_stats_test.go replays
canonically (GAPS_TRUTH_PATH override); live parity 24/24 (fresh
capture → diff vs frozen → Go battery); gofmt/vet/build/full-test
clean; Python module suite failure sets byte-identical across both
pins (RUNE_RETRIEVAL_CORE live + python, 9 pre-existing, none this
port — no tracked Python/tests files touched); ruff clean. Documented
divergences in verification/msstats-summary.md: contentless-FTS5 NULL
text readback (both engines), json.dumps float-list format (pyJSONFloatList
mirror, integral floats keep .0), by_topic tie order engine-shaped
(distinct-count fixtures). Audit: memory_store 44/68 → 51/68; the
read_query ×2 counters (dm lane's slice) also flipped via this port's
ReadQuery interface method name — name-collision flip, NOT a dm port.
Full walk draft→approved→building→verifying→closed in one process
(builder factory-heavy-ro-sig); observed_evidence carries the battery/
parity/build gates; divergences documented per the oracle-stays-contract
law.
Dichotomy wave #2479, contract factory-heavy-ro-sig. Name-preserving
ports of the five audit-missing observation/routing-signal fns into
gaps_signals.go with a 35-row frozen oracle battery (truth_signals.json,
hermetic generator, byte-identical regen) and 35/35 live parity (shared
corpus between generator and parity checker — no drift). All IO behind
injectable seams; recorder-down crash parity pinned (record_failure sits
outside the oracle's try). Audit 29/68 → 35/68. Divergences documented
in verification/ro-sig-summary.md.
One-process walk approved->building->verifying->closed via iface.close()
(observed_evidence + scope_files). Evidence: scripts/close_contract_memory_store_io.py,
verification/ms-io-*. Battery 53/53, live parity 22/22, module audit 68/68
with both lanes merged.
Post-rebase integration with the retrieval lane (62e29e2e landed while
this lane was in flight): truncateRunes/FtsDelete were redeclared across
gaps_io.go and gaps_retrieval.go — the IO twins renamed
truncateRunesIO/FtsDeleteDB (same semantics, distinct per file ownership;
the sibling's planner-kernel FtsDelete stays authoritative for the
_fts_delete name form). Determinism hardening: mineDirectory
node_modules pruning applies to the walk top itself; hierarchy pins Go
map iteration with a count-desc/name-asc tiebreak; wakeUp adds an id-ASC
tiebreak toward the oracle's de-facto rowid order on importance ties.
observations.jsonl union resolved (gitea rows + this lane's contract-open
rows). Battery 53/53, full go test ./... green, live parity 22/22,
gofmt+vet+build clean. Module audit 68/68 — both lanes merged.
Full walk draft→approved→building→verifying→closed in one process
(builder factory-heavy-te-life); observed_evidence carries the battery/
parity/build gates; divergences documented per the oracle-stays-contract
law.
MergeAssociationRows: the per-boost base_rel fold over the whole out list
(O(n²) rescans, each reading STORED rounded relevance) becomes a running max
seeded from the base rows and fed the rounded relevance it just appended —
numerically identical by construction (max is associative; the authority's
fold reads exactly those rounded values), pinned by the chained-boost truth
rows (_merge_association_rows_5 double-boost, strong_link_merged e2e).
Behavior-identical: battery 43/43, live parity 43/43, gofmt/vet/build/test
clean. Evidence: verification/msr-phaseb-*.exit.
Dichotomy wave #2479, contract factory-heavy-te-life. Name-preserving
ports of the six audit-missing lifecycle fns into gaps_lifecycle.go with
a 52-row frozen oracle battery (truth_lifecycle.json, hermetic generator,
byte-identical regen) and 49/49 live parity (per-side isolated roots).
Repairs en route: write-denial message now carries Python str(list) bytes
(pyListRepr); ReadFile numbers with the RAW offset (offset=0 renders
'0: line 1' — old clamp rewrote the footer). str(e)-law TypeError
envelopes, present-but-null vs absent args, broker seam for
_find_capability. Sibling-gap arms pinned as notPorted sentinels
(documented divergences, verification/te-life-summary.md).
One-process walk (approved → building → verifying → closed) via
ConstructionInterface(builder='factory-heavy-wr-state'), closed through
iface.close() with the port evidence + family scope files. Close-walk
exit evidence: verification/wrs-close-walk.exit (the walk script was
executed a second time for exit-code evidence — its duplicate contract
artifacts were NOT committed; the store carries the single 8e363b walk).
Routing/activation/scoring family (builder factory-heavy-wr-route):
port the five audit-missing fns into src/go/warm-router/gaps_routing.go
(BaseLevelActivation, PrimedAssociations, AssociatedNeuronBodies,
GraphContext, RenderFired; I/O-as-args split) + gap-cli parity surface.
Fixes two latent defects the frozen battery caught:
- warm_router.py _primed_associations passed (limit,) for a statement
with len(ids)+1 placeholders — every call raised ProgrammingError and
returned [] (the association-neighbour priming walk was dead code).
Now binds (*ids, limit).
- main.go baseLevelFromUses parsed nowISO with a literal-Z layout, so
'+00:00' stamps fell back to the wall clock. Now RFC3339 first.
Frozen truth 34 rows (shared freeze_truth harness under
scripts/wr_freeze_seams rig) byte-identical on --verify; battery
truth_gap_test.go replays all rows; live parity 60/60
(check_warm_router_gap_parity.py); go build/vet/gofmt clean; Python
suite green on the delegation pin (python-pin failures pre-exist on the
stashed tree — retired-fallback -2.0 degradation, Go-only lane).
Family coverage 11/16 -> 16/16; module 17/33 -> 22/33 (remaining 11 are
other families' files).
CLI mirror hardening, behavior-identical (frozen battery + parity re-green):
subcommand dispatch is now an enum parsed once with an exhaustive match
(adding a subcommand is a compiler error until every arm is extended;
no-cmd/unknown stay explicit), rendering goes through fmt::Write (writeln!
into the output String — no intermediate format! allocations), and the
three propagate sections share one section() renderer parameterized by
glyph/header/field instead of three copy-pasted loops.
cargo battery 1/1 (frozen truth verbatim), parity 72/72, clippy -D
warnings + fmt clean. Evidence: verification/dt-phaseb-*.exit.
audit 2/5 PARTIAL -> 6/6 FULL (RUST side; the 5 oracle fns + the main_cli
mirror). Name-preserving port into src/rust/dependency_tracker: the W6-era
stub was semantically INVERTED (map KEYS collected for value-list hits, a
transitive BFS where the oracle classifies direct dependents) — replaced
wholesale (audit_ledger precedent, one chain one implementation). Kernels:
get_dependents (posix basename + map lookup), check_propagation,
propagate (the full classification matrix against SCRIPTS_DIR —
propagated-with-reference / not-found / no-direct-reference /
IsADirectoryError crash-parity '[Errno 21] Is a directory: <path>' with
errno mapping + Display-suffix stripping, dry_run would-update
short-circuit), get_full_map (dict INSERTION order — the warm_router
dict-literal overwrite quirk: first position, last value), main (CLI
mirror, pure fn over argv incl. the frozen argparse help text).
Kernel/facade split: the facade's 4 compute fns delegate via dt_loader
(DT_RUST_LIB override; RUNE_DEPENDENCY_TRACKER_CORE=python pins the
load-bearing Python bodies; kernel failure falls back); SCRIPTS_DIR stays
import-time on the Python side and rides the propagate payload; main()
stays Python argparse (process boundary, never delegates); main_cli is
the JSON-native stdout+rc capture mirror. Spine scope test constraints
preserved (harness SCRIPTS_DIR, inline os.path.join body, no spine
imports).
Frozen truth: 24-row corpus via the shared freeze_truth harness under
scripts/dt_freeze_seams (HOME='.' + cwd-is-the-rig + deterministic
fixture tree incl. the directory-named-as-file error fixture; COLUMNS=80
for the argparse help width). --verify byte-identical twice. Battery
gap_battery.rs replays the truth VERBATIM in order (serde to_string
equality pins insertion order, not just structure). Live parity
scripts/check_dependency_tracker_parity.py 72/72 (pinned facade / live
facade / kernel direct). clippy -D warnings + fmt clean. Python suite
both pins: failure set byte-identical across pins AND the stashed base
(244 pre-existing, none touching this module); ruff clean.
New quirk (docs/dichotomy-oracle-quirks.json): Python 3.14
OSError.__str__ QUOTES the filename — proved by frozen battery row 20.
Evidence: verification/dt-*.exit + dt-summary.md (logs gitignored).
audit 2/7 PARTIAL -> 7/7 FULL (GO side; _by_topic, compile_full,
emit_constitution, emit_identity, emit_persona ported name-preserving
into src/go/persona-definition; handle_hook + CLI main mirror-carried).
The store (memory_store sqlite) and cache (cache.py sqlite) sit behind
Env seams; compile_full's cache round-trip is byte-faithful: the cached
value renders with Python's ensure_ascii=False separators, the
compressed readback applies cache._compress verbatim (char-based
[:797]+'...' past 800 — rune-safe), and an unparseable/truncated
compressed value falls through to the store exactly like the oracle.
emit_persona ports the (priority or 5, -confidence) stable sort with
Python or-falsiness (priority 0 == absent == 5), the noise filters
(<20 chars, short leading-article lines, firecrawl+credit lessons) and
the 200-CHARACTER truncation. CLI is argparse-faithful (choices,
--event/--data, hook prints json.dumps with insertion-ordered keys and
ensure_ascii=True; invalid choice exits 2, bad --data JSON exits 1 —
crash parity).
Frozen truth: 33-case corpus via the shared freeze_truth.py harness +
wrapper shims in scripts/gen_persona_definition_gap_truth.py (per-row
hermetic mkdtemp store+cache DBs bound through the module globals
memory_store.DB_PATH / cache.DB_PATH BEFORE any oracle call; counters
wrap ms.connect / cache.get_cache / cache.put_cache so every capture
PROVES the path: miss->store->put, >800 truncation re-query, corrupted
preseed fallthrough, WHERE filters, importance DESC ordering).
Byte-identical --verify twice + fresh regen diff-empty. Battery
replays 33/33 VERBATIM (replay-gap subcommand = second modality) +
4 Go unit tests (char-boundary pins). Live parity
scripts/check_persona_definition_parity.py: 3/3 scenarios (14 ops) +
11/11 real-CLI invocations byte-identical (oracle CLI vs GO binary).
gofmt/vet/build clean. Python pin RUNE_PERSONA_DEFINITION_CORE=python
verify green (no delegation loader exists; oracle-pinned surface is
the live module).
Evidence: verification/pd-*.exit + pd-summary.md (logs local, *.log
gitignored).
Walked draft->approved->building->verifying->closed in ONE process via
the designed iface.close() entry (quality-gate law). Contract covers the
inference_trace 4/6 -> 8/8 RUST gap-close: record_trace/read_traces IO
ported into the kernel + three parity-driven defect fixes (ensure_ascii
escaping, limit-0 all-lines, malformed-line ValueError class via
Err-envelope + fallback re-raise) — quirks #24-#26.
audit 4/6 PARTIAL -> 8/8 FULL (RUST). The landed FULL port (b5228ace +
e41562aa) left record_trace/read_traces as facade-side IO by its strangler
verdict; this close ports them name-preserving with the file IO itself in
the kernel (mkdir, I1 source-guard rotation replace chain, O_APPEND write,
file reads; path RESOLUTION stays the _trace_path seam the tests pin, and
the facade passes module rotation knobs read at call time so the
TRACE_ROTATE_BYTES monkeypatch contract survives). FFI it_record_trace /
it_read_traces + it_loader wrappers + byte-identical _py_record_trace /
_py_read_traces fallbacks (RUNE_IT_CORE=python pin).
Fix-first (proved by frozen truth): (1) serialize/format_record ensure_ascii
divergence — json.dumps escapes non-ASCII as \uXXXX (astral = surrogate
pairs), serde emitted raw UTF-8; py_escape emitter added for both shapes
(quirk #24, extends the context_broker pyDumpsSorted law). (2) limit=0 —
Python lines[-0:] keeps ALL lines, rev().take(0) returned none; read_select
+ cli_tail fixed (quirk #25). (3) malformed JSONL line silently skipped by
read_select where the oracle raises ValueError — now an Err through the FFI
envelope so the facade fallback re-raises the AUTHENTIC exception (quirk
#26; crash class pinned in truth).
Frozen truth: 17-case gap corpus via the shared freeze_truth.py harness +
scripts/it_freeze_seams rig (RUNE_IT_CORE=python, relative RUNE_HOME,
cwd-is-the-rig, row-private it_t stores; record/read branches incl.
rotation matrix + unicode line law + limit 0/2/99 + missing stores +
ValueError class + round-trip). gen x2 + --verify x2 byte-identical.
Battery: gap_battery.rs replays rows VERBATIM in a throwaway cwd (cargo
test 9/9: old 6 + new 3). Live parity scripts/check_inference_trace_parity
.py: seam 17/17 + FFI composites 17/17. Landed PARITY=1 flow preserved
(byte-identical modulo the original freeze's baked worktree root). cargo
build/clippy -D warnings/fmt clean. Python suite both pins 108/108 live +
108/108 RUNE_IT_CORE=python (p1_03 memory_selection failures pre-exist at
pristine HEAD, outside this port's cone). Audit: FULL 65% (125/192).
Evidence: verification/it-*.exit + summary-inference_trace.md (logs local,
*.log gitignored).
audit 1/4 PARTIAL -> 15/15 FULL (RUST side; the 15-fn surface = the 4 oracle fns _scaffold_for/activate/_auto_structural_awareness/dispatch_from_decision + the JSON parity shims + seam machinery; nested rig closures under the _py_* exclusion law). Ported name-preserving into src/rust/construction_activation: the full mode-dispatch matrix (NOT_CONSTRUCTION/UNKNOWN/LOCAL_CHANGE/EXISTING_PROJECT_CHANGE/PROJECT_BUILD/unhandled incl. int-mode py_display reason), identity-before-repository slug derivation (unicode+astral lowercasing, run-collapsed dashes, [:48] by chars, unnamed-project fallback), store-v2 Scaffold persistence ported for the battery (segments WIN, idempotent journals, canonical-digest commit verify), the T21.5 awareness branch matrix (registry x spine x {registered,skipped,recorded,error} with save-only error injection and 120-char error-note truncation), and crash-parity error envelopes (AttributeError object-access, TypeError list() non-iterables, char-spread str list() quirk).
Kernel/facade split preserves the monkeypatch contract: the Rust kernel computes rec+plan (ca_activate FFI returns them UNPERSISTED); the Python facade owns all persistence IO (Scaffold.init/commit, registry.save, spine.save — the seams the failure-tolerance tests pin) and always runs awareness on its side. activate_json (battery surface) applies the plan + realizes awareness writes = oracle-equivalent standalone.
Frozen truth: 52-case corpus via the shared freeze_truth.py harness + scripts/coa_freeze_seams rig (cwd-is-the-rig; row-private two-level roots because the oracle derives the spine from the parent scaffold's GRANDPARENT — shared roots bleed spine state). Verified byte-identical twice. Battery gap_battery.rs replays the truth VERBATIM in order in a throwaway cwd (52/52 + slug edges). Live parity scripts/check_construction_activation_parity.py: seam-delegation 52/52, FFI composites 39/39 (13 shim-only: validation-crash/io-errors-injection/files_after rows pinned by the seam pass). cargo build/clippy -D warnings/fmt clean. Python suite both pins: native_activation 6/6 + construction_interface 37/37; full-suite failure set byte-identical across pins (140 pre-existing; one isolated load-timing flake in test_mimo_tty_contract re-verified green 4x, construction-unrelated).
Evidence: verification/ca-*.exit + ca-summary.md (logs local, *.log gitignored).
Walked draft->approved->building->verifying->closed in ONE process via
the designed iface.close() entry (quality-gate law). Contract covers the
tier_manager 6/10 -> 10/10 RUST gap-close into cognition_core.
observations.jsonl carries 14 additional rows from interface test
traffic (test-kernel-rebuild-trap regression + minidoc-test x2) produced
by a platform daemon (mimo-wait-resume) whose cwd resolved into this
worktree at 15:03-15:15Z; those rows are real append-only events but
their entity files are deliberately NOT committed (test-probe artifacts,
not lane work). Flagged to the coordinator.
audit 2/8 PARTIAL -> 8/8 FULL (RUST). The chain kernels live in the
evidence_provenance crate (the live ep seam the oracle already delegates
hash+verify through — one chain, one key, RECONCILE-DON'T-CLOBBER): the
three missing log_* wrappers ported name-preserving (log_promotion,
log_gate_result, log_drift_alert + ep_* FFI + ep_loader bindings), the
facade switched onto RUNE_AUDIT_LEDGER_CORE delegation with _py_*
vintage fallbacks (both-pins law), and the audit mapping aliased to the
crate (drift_compression precedent). The divergent W6-era
src/rust/audit_ledger stub (SHA-256 concat, wrong field names, never the
live chain) is deleted.
RUNE_FROZEN_NOW clock seam (PP_ACTIVE_THREADS pattern) added to
now_iso_utc so pinned-python and Rust ledger writes hash byte-identically.
Fix-first, frozen-proof (two pre-existing kernel defects):
- get_entries negative-limit slice law: Python lines[-limit:] with
limit<0 drops the FRONT (lines[|limit|:]), not all lines.
- pyjson integral-float parse: numbers with '.'/exponent now parse as
Json::Float (json.loads law) — "0.0" round-trips as 0.0, never
collapses to 0; any Python-written entry with an integral float
previously HMAC-verified FAILING (payload bytes differed). habitmath
count/confidence extraction arms widened Num|Float (restores
test_behavior_decision_math).
Frozen truth: 16-case envelope via the shared freeze_truth harness +
scripts/al_freeze_seams rig (sequential chain: missing-file branches,
genesis first append, the three log_* detail shapes, mixed-type details,
get_entries limit lattice 50/3/1/0/-2/100, full-chain verify,
_compute_hash sort_keys law). --verify byte-identical (x2). Rust battery
audit_battery.rs replays the corpus VERBATIM (include_str!) + asserts the
ledger FILE bytes equal expected pyjson dumps. Live parity 360/360
(pinned/live/kernel 16 each, file-byte parity EQUAL, 5 seams incl. the
documented missing-hash crash-superset asserted per-side, fuzz seed 2479
300/300 rounds incl. file bytes, CLI parity 5/5 python -m vs Rust bin).
cargo build/clippy -D warnings/fmt/test clean; pytest 11/11 BOTH pins;
ruff clean; ep canary 66/0; canary_audit_ledger isolated 74/0 both pins.
Evidence: verification/al-*.exit + al-summary.md (logs local, *.log
gitignored).
audit 5/7 PARTIAL -> 7/7 FULL (RUST side). Ported name-preserving:
to_dict (ordered dict form — serde struct field order = dataclass field
order, serde_json preserve_order keeps provenance/debug_refs insertion
order), parse_plain_response + parse_response as REAL fns (the audit's
substring match over-credited a test name and a doc mention — the
dispatcher's auto-detect and the plain parser did not exist), and
test_adapter assert-parity. REAL parity bugs fixed on the existing
parsers: parse_mimo_response now carries usage reasoning_tokens/
completion_tokens/total_tokens and parse_qwen_response
reasoning_words/completion_tokens/total_tokens with Python .get(k, 0)
pass-through semantics (ANY JSON value rides), parse_local_response
reasoning_tokens on the match branch; model/provider pass-through raw.
Truth: 36-case corpus (frozen_ra_gap_truth.json) via the shared
freeze_truth.py harness + scripts/ra_freeze_seams rig (pinned
RUNE_RESPONSE_ADAPTER_CORE=python; to_dict-carrying wrappers; CROSS-CALL
law — parse_response resolves its parser dict from module globals at
call time and test_adapter reads .user_text off the result, so the rig
restores originals around the self-test; no clock/HOME seams: the module
is pure). --verify byte-identical twice. Battery gap_battery 7/7 (36-case
VERBATIM order-sensitive replay + FFI roundtrip + key-order/auto-detect/
assert branch proofs). FFI: ra_parse_response + ra_replay cdylib entries
(cs_free_string serves the process); facade delegation in
src/rune/response_adapter.py + ra_loader.py with RUNE_RESPONSE_ADAPTER_
CORE=python pin (to_dict/test_adapter stay Python on the facade — pure
projection / stdout contract, W6 FFI-overhead law). Live parity 100%
(scripts/check_response_adapter_parity.py: FROZEN 36/36 ordered compare
through ra_replay, FUZZ 2000 ops seed 2479 incl. unicode/floats/nulls/
nested tags, PINS 10 facade calls identical under both pins); clippy -D
warnings + fmt + cargo build --release clean; contracts PASS + 7-fn
facade smoke + test_contracts_port.py green BOTH pins. Divergences
documented in verification/ra-summary.md (non-str content coercion,
non-dict usage, trim/strip control-char boundary).
Evidence: verification/ra-*.exit + ra-summary.md (logs local, *.log
gitignored).
Full lifecycle in ONE process (submit_need -> approved -> building ->
verifying -> iface.close with observed port evidence + scope files);
raw transition->closed refused by the scaffold, close path taken.
core_server 12/12 FULL on gitea/master.
Audit 1/3 PARTIAL -> 3/3 FULL (RUST). Ported the two missing fns
name-preserving: to_dict (CognitiveBudget struct with untyped Value
fields — the dataclass ctor validates nothing, so falsy/wrong-typed
kwargs ride through; from_kwargs pins the ctor-defaulting law; 9-field
projection in dataclass field order via preserve_order) and test_budgeter
(the embedded smoke test: 4 scenarios, oracle asserts, py_float_str law —
str(10.0) == '10.0'). New FFI: cb_to_dict (unknown-key TypeError crash
parity) + cb_test; cb_loader gains to_dict()/test() wrappers;
calculate_budget now builds the struct and returns to_dict() (output
identical, keys field-ordered like the Python dict).
Truth: 47-case truth_gap.json via the shared harness + cb_freeze_seams
(JSON-safe wrappers — calculate_budget returns a dataclass instance the
harness can't serialize) — byte-identical --verify AND fresh re-freeze.
PIN LAW: this oracle reads RUNE_CB_CORE, not the harness's stem-derived
pin. Battery 4/4 (legacy 14-case branch battery + gap battery incl. the
oracle stdout pin); clippy -D warnings + fmt clean; live parity 57/57
ops (incl. sentinel-proof the delegation path is live — the oracle masks
loader exceptions; ctor crash parity; CLI byte-identical both pins);
Python battery green both pins + elastic_cognition adjacency 21 passed.
Audit: cognitive_budgeter 3/3 FULL; programme 110/192 (57%). Evidence:
verification/cbud-*.
Lane factory-gap-si: parity content landed (via orphan recovery) as
bd5c46f9, Phase B as eef472cd, contract closed as e481184f. This adds the
independent-checkout re-verification of the LANDED state (61/61 replay,
8/8 cargo, clippy clean, 8/8 pytest both pins, audit 7/8 FULL) and replaces
the stale summary with the final SHA chain.
Behavior-identical (frozen battery 65+5 + live parity 1720/1720 +
freeze --verify 121/121 + both pins 12/12 re-run green on THIS commit,
against the freshly built release .so):
- tier_get: exhaustive bracket match — the decision inputs (rock,
wash>=20, parsed last, parsed now) dispatch in one match; the recency
ladder is scoped inside the both-parse arm and every fall-through
lands in the oracle's warm default. The tier is computed once and
allocated once at exit (was: five early-return 'into()' sites).
- TIER_CONFIG closed set hoisted to a const table — config lookup,
should_search and should_compress all derive from ONE table (mirrors
the oracle's single dict; three independent encodings would drift).
Unknown tiers ride the warm row / False exactly like the oracle's
.get defaults.
- cargo fmt pass over the crate's battery files (formatting only).
Evidence: verification/summary-tier_manager.md + tier-* exits/logs.
Audit 6/10 PARTIAL -> 10/10 FULL (RUST, cognition_core per the audit
alias — tier_manager's live chain is cc_loader -> libcognition_core.so).
Four kernels ported: tier_demotion_sweep (named alias of the get_tier
decision), tier_get_tier_config (warm default for unknown tiers; wire
order mirrors the oracle dict), tier_should_search, tier_should_compress
(empty-dict False default) — FFI + loader wrappers + facade delegation
with load-bearing _py fallbacks, drift-immune recency cases in the
delegation suite.
Fix-first (proven by the frozen battery): parse_strict_aware accepted
out-of-calendar timestamps (month 13, Feb 30, day 0, hour 24 with
minutes) that datetime.fromisoformat raises on — oracle falls back to
warm, kernel computed off-calendar epochs. Range validation added
(leap years, month lengths, ISO hour-24 end-of-day); recorded as quirk
Verification: frozen truth 121 cases via the shared harness,
byte-identical on repeated freeze_truth --verify; cargo battery green
(include_str! embed); clippy -D warnings clean; live parity 1720/1720
(frozen rows + seeded fuzz + config fuzz, both clocks pinned); Python
both pins green (12/12 live + RUNE_COGNITION_CORE=python); ruff clean;
collateral green with kernels resolved (shims+tier+witness 59/59,
cognition consumers 109/109). Evidence: verification/summary-tier_manager.md
+ tier-* exits/logs.
Typed CommandType/Op/PhaseClass lattices replace the string-arm chains:
parse IS the unknown-command refusal surface, the (command, phase-class)
tuple match in _validate_branches is exhaustive, and the dispatch
executor table matches Op::parse (unknown op stays a no-executor
envelope, never a panic). The oracle's defensive 'unreachable validator
branch' becomes structurally impossible. Behavior byte-identical to the
Phase A parity port — frozen battery the referee, zero truth changes
(sha256 ba9fb44d… pre == post; replay 54/54; pytest 12/12 both pins;
clippy -D warnings clean).
2/8 -> 9/9 FULL (RUST): execute_with_escalation (the full loop over
Executor/Verifier trait seams — the oracle's MockExecutor/MockVerifier are
the concrete contract), test_escalation (self-test scenario through the
loop kernel), handle_hook, EscalationResult.to_dict (nine-key dict, key
ORDER asserted via serde_json preserve_order), the execute/verify seam
traits (ScenarioSeams per-tier canned data — callables cannot cross the
FFI, contracts resolution precedent), and the _pe_core probe mirror
(salience_gate _sg_core pattern, pin semantics battery-asserted).
should_escalate/get_next_tier REWRITTEN onto oracle truth: the stale W6
sketch carried a 4-trigger list + non-escalating default; the oracle
freezes 10 ESCALATION_TRIGGERS and escalates on EVERY failure (membership
branch informational) + py_truthy for the truthy passed domain.
Facade: progressive_escalation.py delegates the four kernels through the
new progressive_escalation_loader.py (doc-envelope FFI, cs_free_string);
RUNE_PROGRESSIVE_ESCALATION_CORE=python pins the floor. Fix over the
cancelled attempt: probe+call wrapped in ONE try per delegating fn (a
raising _pe_core escaped the old split try — caught by the parity
fallback layer).
Truth: 35 harness cases + 12 loop scenarios (scripts/
gen_progressive_escalation_truth.py under scripts/pe_freeze_seams rig) —
regen byte-identical, freeze_truth.py --verify byte-identical. Battery
8/8 (gap_battery.rs, truth embedded VERBATIM); replay failures=0;
live parity frozen=48 fuzz=550 live=14 failures=0 (seed 2479); clippy
-D warnings clean; selftest + native suite (19 passed) green BOTH pins;
ruff clean. Audit: progressive_escalation 9/9 RUST. Evidence:
verification/cv-summary.md (+ cv-*.exit).
Op::run — the enum owns its execution: every variant's semantics live
next to its name and the exhaustive match moved into the type (adding an
op without semantics stays a compile error, now enforced where the
behavior lives, not at the call site). _write_snapshot_doc as a
filter_map-collect iterator chain over the transfer array (no mutable
accumulator; the entry-key projection is one declarative pipeline).
Behavior unchanged: battery 7/7, live parity 60/60, clippy -D warnings
clean, module tests 5/5 both pins. Evidence: verification/to-phaseb-parity.exit.
* contains_ci: zero-alloc ASCII needle matching for the keyword-count
check (py_matches) — pure-ASCII (text, keyword) pairs match through
an eq_ignore_ascii_case window scan (ASCII case folding is 1:1 with
the oracle's .lower(), byte-identical semantics); ANY non-ASCII byte
on either side falls to the full Python-parity to_lowercase() path so
Unicode case mappings (ſ, İ) are never skipped. The hot pattern-match
path no longer allocates the lowered text copy per keyword.
* safety_extract_keywords: pure-ASCII text scans bytes in place for
[a-z]{4,} runs (identical to the oracle's findall over .lower() on
ASCII; non-ASCII keeps the Unicode char path) — the lowered-copy
allocation disappears for ASCII inputs.
* #[must_use] on the whole pure surface (14 gap-close kernel fns).
* battery: ASCII-scan <=> Unicode-path equivalence self-checks over the
frozen corpus (contains_ci pairs, extract_keywords mirror, 200-unit
slice law) + std-only Phase B bench (is_refusal and contains_ci over
the frozen corpus, 2k iterations each).
Truth untouched; battery replays byte-identically (64+5 tests green),
live parity 2065/2065 (65 frozen + 2000 fuzz, seed 2479), gen freeze
verify byte-identical, clippy --all-targets -D warnings clean, pytest
21/22 both pins (1 kernel-absent skip under python pin). Evidence:
/tmp/so_{cargo_pb,clippy_pb,parity_pb,t_pb1,t_pb2}.txt
2/8 -> 8/8 FULL: to_dict/get_profile/get_enabled_profiles/
get_profiles_by_tier/list_profiles/test_registry ported name-preserving
onto the existing get_cheapest_capable/resolve_context_budget surface.
KNOWN FLAG FIXED (model_connect, 2026-10-14): batch-67 hardcoded
toolReserve=2048 and a single outputReserve; the live oracle holds
TOOL_RESULT_RESERVE=1024 and the OUTPUT_RESERVE per-task-kind ladder
{default 2048, verify 512, summarize 1024, embed 0} — gated by LOCAL,
not tier (legacy truth.json never noticed: both its budget rows are
local models).
Truth: 35-case envelope via the shared harness + scripts/mreg_freeze_seams
(JSON-safe seam wrappers; pairs carry registry insertion order —
key-vs-attribute lookup, first-id-match, stable ties, falsy->DEFAULT ctor
law all pinned; the (or {}) empty branch pinned via a __new__ seam).
--verify byte-identical + fresh regen byte-identical. Battery 4 tests +
binary replay-gap 35/35 (+ legacy replay 4/4 regression); live parity
4/4 scenarios (36 ops, scripts/check_model_registry_parity.py);
gofmt/vet/go build clean; Python suite green both pins + oracle smoke.
No loader seam exists (RUNE pin vacuous, documented). Audit:
model_registry 8/8 GO; programme 55% (105/192).
Phase enum (exhaustive match on the resolution phase — string matching
retired inside the kernels; unknown phases fall to Found, the oracle's
catch-all arm) with Display/as_str/parse and RunSpec::phase(); #[must_use]
on the eight pure kernels; Phase round-trip unit test. Both frozen-truth
batteries UNCHANGED and green (20/20 crate tests, clippy -D warnings
clean, harness --verify 23/23 byte-identical, live replay failures=0).
Fix-first completion of the parity commit's claimed loader wiring: the
eight gap-close kernel wrappers (gate/resolve/run_python/run_all/capture/
save/load/main_cli) land here with five loader-level parity tests; port
tests 11/11 green both pins (delegated + RUNE_CONTRACTS_CORE=python).
Behavior-neutral Go advantages in src/go/adaptive-router (battery stays
green proving no behavior change; frozen truth 25/25 byte-identical;
live parity 32/32):
- typed Route constants (RouteLocalFix/RouteStandard/RouteResearched):
route comparisons compile against named constants — a typo'd route is
a compile error at every use site (ROUTES map, floor guard, returns)
- floorRiskSet/floorUncertaintySet O(1) membership maps replace the
O(n) slice scans in FloorAppliesFromFlags / FloorReason / FloorApplies
- single-pass floor in ClassifyRoute: FloorReason hits computed once,
floor = hits nonempty — one walk instead of the oracle's two-call
shape (equivalent union, comment pins the equivalence)
- FloorReason preallocates the hits slice (cap 3: one hit per source)
Follow-up to contract BUILDER-2026-10-13T16:25:22Z-7e3fd4-factory-gap-ar
(parity f7855558); Phase B contract
BUILDER-2026-10-14T09:00:07Z-70ebf0-factory-gap-ar closes on this
commit's pushed SHA.
* contains_ci_upper: ASCII-anchored zero-alloc needle matching for the
section capture chain — pure-ASCII haystacks match through an
eq_ignore_ascii_case byte scan (ASCII case folding is 1:1, so this is
byte-identical to the oracle's needle-in-upper()); ANY non-ASCII byte
falls to the full Python-parity to_uppercase() path so Unicode case
mappings (ſ -> S, İ) are never skipped. The common parse case no
longer allocates the uppercased line copy.
* get_delivery_register_from_db: chars().take(201).count() bounds the
codepoint-length probe at the predicate's own threshold instead of
counting every char of the row (identical oracle semantics:
len(text) > 200).
* #[must_use] on the whole pure surface (11 kernel fns).
* battery: ci-scan <=> upper-contains equivalence self-check over
every frozen extraction row (5 needles) + std-only Phase B bench
(register probe 8.6 us/call over 65 rows incl. bounded length scan;
needle scans 3.3 us/text over the 19-text frozen corpus; full chain
10.8 us/extract+generate call).
Truth untouched; battery replays byte-identically (16 tests green),
gen --replay 125/125, canary 15/15, pytest 17/17 live + pinned,
clippy -D warnings clean. Evidence:
verification/voice-sync-phaseb-{cargotest,parity,canary,python}.log
Name-preserving port of the 7 audit-missing functions into
src/rust/voice_sync (the module's classification side is RUST — sqlite3
storage-backed; a stale Go voice-sync dir exists from an early partial
register-substring helper):
get_delivery_register_from_db / get_delivery_register
-> the chunk row-selection loop (rows arrive fetched Python-side;
the SQL WHERE + fresh-store OperationalError guard stay in the
facade), len>200 pinned as a CODEPOINT count
extract_voice_section
-> section parser: influence capture incl. '- **:**',
TECHNICAL+DELIVERY double-hit header captured as a technical
line, elif-section persistence, case-sensitive THE VOICE /
THE FEMININE prefixes, truthy all-empty-lists parse
generate_voice_section
-> assembler with the exact fixed block + calibration cap-3
update_rune_md_content / update_rune_md
-> pure splice view (composite {"result", "new_content"} so the
facade performs the write) — the oracle gains the same
oracle-level JSON view the shared freeze gate pins
(update_rune_md_content; salience_gate evaluate_salience_dict
precedent); char-boundary-safe +10 offset past ## Voice
check_sync / handle_hook / sync_voice
-> parts-shaped decisions (register, prompt_content in as
arguments); handle_hook pins the oracle's auto-sync 'synced:
true with error details' verbatim
_vs_core
-> kernel mirror of the facade probe contract (pin lattice,
salience_gate _sg_core precedent)
Facade delegation: voice_sync.py wires vs_loader.py (10 vs_* doc-envelope
symbols, free via capability_scoring cs_free_string, no free-symbol
export, VOICE_SYNC_RUST_LIB override, RUNE_VOICE_SYNC_CORE=python pin —
the shared harness derives EXACTLY this pin name, inverting salience's
wrong-name quirk); _py_* fallbacks are the strangler-fig machinery class;
SQLite I/O, rune.md writes, wall-clock _now and the argparse main() CLI
stay facade-side (behavior crate precedent).
Frozen truth via the shared scripts/freeze_truth.py harness (generator
scripts/gen_voice_sync_truth.py, poisoned-truth law
RUNE_VOICE_SYNC_CORE=python):
frozen_vs_truth.verify.json — 37 pure rows byte-identical under
freeze_truth.py --verify (plain process, core-state independent);
frozen_vs_truth.json — 64-row envelope: verify rows first, then the
rig-required store/file rows whose kernel-shaped inputs ride in args
with fixtures for --replay (len<=200/201 boundary, first-match order,
fresh-store None, lowercase delivery-register passes-SQL-but-loses-
python-filter, missing-influence scan order, auto-sync write capture).
branch_battery.rs replays both VERBATIM (include_str!, order-sensitive
canonical-string compare — the facade consumes kernel JSON directly so
Python insertion order must survive: serde_json preserve_order).
Live parity 125/125 (gen --replay: facade-delegating + kernel-direct);
canary 15/15; second-modality differential 486 comparisons / 0
divergences (2479-seed fuzz beyond the corpus incl. multibyte splices
and sandboxed I/O decisions); pytest 17/17 in three pin states (live /
RUNE_VOICE_SYNC_CORE=python / VOICE_SYNC_RUST_LIB poisoned).
Dichotomy audit: voice_sync PARTIAL 3/10 -> FULL 12/12 (update_rune_md_
content + _vs_core join the surface per the salience precedent; _py_*
helpers are the audit's machinery class).
Walk draft->approved->building->verifying in one process; final entry
via close() per the quality-gate law (predicted-vs-observed
contract_quality computed; raw closed-transition refused — the first
walk attempt hit exactly that gate and completed through close()).
Audit 2/6 -> 6/6 FULL (RUST): the four audit-missing fns ported
name-preserving (define_region, bind_component, amend_layout_contract,
record_layout_observation) as pure doc-in/doc-out Rust kernels
(now is an argument — no-clock law; structural_store add_entity/entity
merge law replicated: high-water maturity, sorted-set evidence union,
identities key-level update, alias-following resolution).
Freeze rig scripts/lc_freeze_seams (PYTHONPATH auto-import, used by BOTH
generator and --verify): blanket RUNE_*_CORE=python + EXPLICIT
RUNE_LC_CORE/RUNE_STRUCTURAL_CORE pins (the blanket loop only pins vars
already in the env — an unpinned first re-freeze ran through live
delegation and CAUGHT the absorb divergence), frozen clock on both now
seams, DOC-CARRYING wrappers ({result, doc:{entities,observations}}),
errors frozen as {error: Type: message}.
Truth: 35-case frozen corpus (frozen_lc_gap_truth.json, envelope with
frozen_now) via the shared harness, embedded VERBATIM in gap_battery.rs;
regeneration byte-identical; freeze_truth --verify OK.
Real bugs the ladder caught (fixed pre-commit): (1) re-bind ASSIGNS a
fresh amendments ledger — insert-if-missing diverged from assignment
(live-facade smoke, discriminating frozen case added); (2) identities
merge is wholesale key assignment (add_entity .update() law — tech
reset on no-op re-define; recursive-merge absorb diverged, caught by the
parity LIVE layer); (3) bind_component has NO framework_attrs param —
framework detail rides **framework_attrs, dispatch collects unknown
kwargs; (4) serde_json preserve_order keeps observed-dict insertion
order (json insertion-order quirk).
FFI: lc_define_region/lc_bind_component/lc_amend_layout_contract/
lc_record_observation (doc-envelope) + lc_replay (raw replay surface).
Facade delegates with RuntimeError->ValueError translation and
identity-preserving absorb (lc_loader.absorb — returned entity IS the
stored one; aliasing survives round-trips).
Battery 10/10 (verbatim replay + FFI roundtrip + 6 branch proofs);
clippy -D warnings clean; parity 100% (35/35 frozen + byte-identical
live re-freeze); layout+consumer tests 64/64 BOTH pins. Full-suite
baseline failures pre-exist identically with/without this port
(coordinator-owned debt).
builder_bridge gap-close: 3/11 PARTIAL -> 11/11 FULL (GO); frozen truth
22 cases byte-identical (generation, --verify, regeneration under the
bb_freeze_seams rig), Go battery + -race green, live parity 11/11 case
families byte-equal vs the live oracle (dict + markdown + construction
lines + store resolution incl. the default-store branch), gofmt/vet/
build clean, Python both pins green. Evidence: verification/bb_*.{log,
txt,exit,md}.
Port the 8 audit-missing functions name-preserving into the GO impl at
src/go/builder-bridge (audit 3/11 PARTIAL -> 11/11 FULL): ToDict,
ConstructionStore, ActiveConstructionLines (segment-architecture store
projection incl. pattern/layout obligations), DefaultSelector,
GetSelector, RetrieveMemory, CachedMemory, ValidatedLessonsFor, plus the
Preflight wiring over a vendored adaptive-router (pure-Go detectFlags
transcribed from the oracle's route_risk_flags insertion order; the
sibling module's cgo/Rust link is deliberately not vendored — this
module's oracle computes flags in pure Python).
Frozen truth: 22 shared-harness rows (to_dict/to_markdown recv forms
incl. line caps + inject-nothing + floor-only, cache key, lessons,
memory abstention + cache-hit, store env branch, active-construction
fixture projection) — byte-identical across generation, --verify and
regeneration under the bb_freeze_seams rig. Live parity: 11 case
families byte-equal on dict+markdown+lines+store vs the live oracle,
including the default-store branch (real store, both sides live) and
the doubled floor-prefix quirk. go build/vet/gofmt/test -race green;
Python suite green under both pins (one pre-existing env-dependent test
failure verified identical on pristine main). Documented divergences:
populated-store hybrid recall stays Python-side (frozen surface is the
degrade-safe abstention both sides reproduce).
Evidence: verification/bb-*.{txt,exit,md}.
Compile every 'static-sourced regex once (OnceLock cache keyed by
pattern; case-insensitive subs via a mutex-guarded map): zero per-call
Regex::new compiles on the scan/verify/degrade/audit hot paths. Behavior
unchanged — battery 10/10, parity 184/184, freeze --verify byte-identical,
clippy + rustfmt clean.
One-process walk: submit → approved → building → verifying →
iface.close(observed_evidence, scope_files) per the QUALITY-GATE LAW
(raw transition→closed refused). The 04:08:04Z duplicate from the
refused first attempt was abandoned with a note. Coverage 7/9 → 9/9
FULL; evidence in verification/sg-*.{log,exit} + sg-summary.md.
Behavior-identical (frozen battery 7/7 + live parity 1935/1935 re-run
green on this commit):
- compress_text: zero-copy prefix — char_indices().nth() finds the byte
offset and slices &text[..cut]; the intermediate collected String is
gone, the ellipsis path preallocates once.
- get_compression_ratio: exhaustive match dispatch — the rock-status tier
is a closed set, the wash ladder is scoped inside the open arm.
- get_compression_stats: single-pass try_fold carrying both accumulators
(Result-carrying — the first malformed row aborts with the oracle's
exception message; no mutable accumulators).
Audit 3/7 PARTIAL -> 7/7 FULL (RUST). The five pure kernels already lived
in src/rust/memory_scoring (H3 slice 2, d58e88da) but the audit alias
mapped the module to cognition_core — the instrument now follows the live
delegation chain (drift_compression -> drift_core._ms_core -> ms_loader ->
libmemory_scoring.so). New kernel work: get_compression_stats — SQL stays
in the Python facade (boundary law), the row-reduction math (int()
truncation after the float multiply, banker's rounding at 1e2, SQL-null
coercion, empty-store int-shaped 0) is a Rust kernel + ms_get_compression_stats
FFI + loader wrapper + oracle delegation with a load-bearing _py fallback.
Fix-first (proven by the new frozen battery): warn_before_compress emitted
the COERCED rock_status; the oracle emits the raw value — a present None
rides the warning dict as null (entry.get default only fires when the key
is absent).
Verification: frozen truth 65 cases via the shared harness, byte-identical
across repeated gen + freeze_truth --verify runs; cargo battery 7/7
(include_str! embed); clippy -D warnings + fmt clean; live parity 1935/1935
(pinned facade / live facade / kernel direct / db-level / fuzz seed 2479);
Python both pins green (seam file 7/7 both; shims failures pre-exist on
base); ruff clean. Evidence: verification/dc-*.log.
Behavior-identical Rust idiom upgrades over the parity commit:
- add() mutates the stored entity by index in ONE pass (was: three linear
scans with a clone round-trip mirroring the Python object identity)
- beneath()/impact_closure() track visited nodes in BTreeSet (O(log n)
membership instead of Vec::contains' O(n)); traversal and output order
unchanged — the walks still emit insertion order and sort at the end
- scope_of unions through BTreeSet (the oracle's sorted-set semantics
expressed as the set itself, not a contains-guarded Vec)
- merge_sorted_set is a genuine sorted set union (BTreeSet) matching
Python's sorted(set(...) | set(...))
Gates re-run green: battery 16/16, clippy -D warnings clean, frozen truth
byte-identical, live parity 4620/4620, Python tests both pins.
Port the 11 audit-missing functions of src/rune/structural_model.py to the
Rust crate (name-preserving, logic-1:1): workspace_record, workspace_advance,
_init_project, save, reload, add, relate, state_owned,
verification_surfaces, canonical_state_owner, supersession — plus a true
deployment_surfaces (the old deployment_surfaces_for stub is gone, no
callers), the lowercase-stale filters on dependencies/consumers, and the
full §18F impact_closure shape the W6-era port had reduced.
Fix-first: the delegation seam imported rune.sm_loader — the SHARD_MANAGER
loader (no query symbol), so every kernel call died into the Python floor.
The seam now targets stm_loader (the crate's sm_* FFI, RUNE_STM_CORE=python
pins the floor). workspace_advance keeps the oracle's in-place law.
Verification (verification/structural_model-summary.md): frozen truth 70
cases byte-identical (gen_structural_model_truth.py --verify), battery 16/16
with truth embedded via include_str!, live parity 4620/4620 (frozen replay +
300-doc seeded fuzz + dual-mode facade), clippy -D warnings clean, Python
suites green in both pins (pre-existing 2F/12E verified identical on the
stashed base). Audit: 9/20 PARTIAL -> 21/21 FULL.
Port the 8 audit-gap fns to Rust (name-preserving): _ms_core, _now_iso,
promote_entry, compute_fama, compute_drift_velocity, compute_drift_direction,
pre_commit_gate, pre_commit_gate_entry. The scoring surface delegates to
memory_scoring (path dep — the authoritative kernel since its Python oracle
was retired); the new decision kernels live in src/rust/drift_core while the
sqlite IO stays in the facade (RUNE_DRIFT_CORE pin, dcore_loader seam,
doc-envelope FFI, Python-typed JSON output: int/float split preserved).
Audit 3/11 PARTIAL -> 12/12 FULL RUST. 30-row frozen truth (dc_freeze_seams
rig, shared harness, gen+verify byte-identical x3), Rust battery 3/3 with the
truth embedded via include_str!, live parity 30 frozen + 600 fuzz + 11
dual-mode facade rows failures=0, clippy -D warnings 0, fmt clean, pytest
both pins 41 passed/4 skipped (drift-files test_211d_g failure verified
pre-existing on the stashed base), ruff clean.
Walked submit_need -> approved -> building -> verifying -> closed in ONE
process (scripts/walk_close_contract_construction_mode.py, CS_RUST_LIB
pointed at the built capability_scoring .so). capability_ledger updated by
the close's material-change record.
Oracle src/rune/event_envelope.py 303 lines / 8 fns: 5/8 -> 8/8
per scripts/dichotomy_audit.py (name-preserving match). The three
audit-named gaps land as Go surface in src/go/event-bus: ToDict
(to_dict), ToCanonicalDict (to_canonical_dict, incl. the loud
RuntimeError branch for un-bridged envelopes), TestEnvelope
(test_envelope), plus the canonical-bridge classmethod CreateEnvelope
(EventEnvelope.create) they depend on: event_type follows the CHANNELS
prior vocabulary (tool -> tool_result) with the prior-or-channel-or-
source-or-unknown fallback chain.
Parity repairs found on the way (all oracle-pinned):
- classifyAuthority/classifyUrgency were word-splitting: bare 'stop'
hit the amendment list (oracle: 'stop doing' is the multi-word
entry; 'Stop everything!' is emergency), 'stop,' and 'unstoppable'
misfired, and the low-urgency list matched 'when'/'you'/'can'/'no'/
'rush' as single words (oracle: 'when you can'/'no rush'; bare
'when' stays normal). Now \b<word>\b semantics with Unicode word
chars ('stopé' never matches).
- pyQuoteEvent had no ensure_ascii: unicode payloads hashed with raw
UTF-8 where the oracle hashes \uXXXX escapes — payload_hash
diverged on every unicode payload.
- createEnvelope now derives text from payload["text"] (oracle
signature; CLI folds --text in).
- minted ids/timestamps go through the no-clock/no-random seams
(EE_FROZEN_NOW + per-op uuid counter) — replayable under pins,
random uuid4-shaped ids in production.
Truth: scripts/gen_event_envelope_truth.py under the
scripts/ee_freeze_seams sitecustomize rig via the shared freeze_truth
harness (83-case envelope, frozen clock + deterministic uuid counter);
byte-identical across regens and freeze_truth --verify x2; embedded
VERBATIM in truth_envelope_test.go TestFrozenEnvelopeTruthReplay +
seam units (\b matcher, ensure_ascii escaping, event_type fallbacks,
loud bridge failure). Live parity 91/91 (scripts/
check_event_envelope_parity.py, PYTHON-json byte compare; negative
control detects divergence). gofmt/vet/go build clean; Python suite
green both pins (25 live + 25 RUNE_*_CORE=python). Dichotomy audit
5/8 PARTIAL -> 8/8 FULL.
Real language advantages over the Python oracle, battery output
byte-stable (frozen corpus green, live parity 100% re-verified):
* Mode enum — the five construction modes as a closed set; the decision
tree carries Mode values and the compiler proves the wire mapping
exhaustive (as_str). A mistyped mode name is now a build error, not a
silent wrong-string bug.
* matches!-based escalation guard — the affected-surface escalation
reads as a closed-set membership test instead of three string compares.
* Zero-copy _contains_any — hits borrow the 'static lexicon
(Vec<&'static str>) instead of allocating an owned String per phrase;
the lowering happens once inside the fn, mirroring the oracle's
signature (construction_mode.py:194-196).
* py_repr_list over borrowed &[&str] — evidence lines format without an
owned-string intermediate (surface lists build a borrowed view).
cargo test --release 5/5, clippy --all-targets -D warnings clean,
check_construction_mode_parity.py 100% (92 comparisons),
freeze_truth --verify byte-identical (39 cases).
Oracle src/rune/construction_mode.py 412 lines / 5 fns: 2/5 -> 5/5 per
scripts/dichotomy_audit.py (name-preserving match). The three audit-named
gaps land as ported Rust functions: ConstructionMode::to_dict (the ten-key
projection in the oracle's insertion order, construction_mode.py:155-167),
ConstructionMode::from_dict (known-keys-only + dataclass defaults, mode
required — TypeError message carried on the err envelope,
construction_mode.py:169-187), and _contains_any (renamed to the oracle's
name; lowering moved inside to mirror the Python signature). classify_mode
now routes every return through the ported ConstructionMode struct.
PARITY BUGS FIXED WITH PROOF (frozen truth from the live oracle):
1. Early-return defaults law — the override/NOT_CONSTRUCTION/empty-objective
branches left target_project/project_authority/proposed_by_model at
their dataclass defaults in the oracle but leaked kwargs through in the
port (construction_mode.py:249-259/276/279-286). Frozen cases
'what is a chord' + target_project/model_proposal and '' + kwargs pin
the None/None/None shape.
2. model_proposal falsy collapse — 'model_proposal if model_proposal else
None' (construction_mode.py:400): empty dict now collapses to None.
3. Evidence list rendering — Rust {:?} emitted double quotes where Python
repr emits single ('affected surface known: [\'module:deploy_stage\']');
py_repr_list/py_repr_tuple reproduce the oracle's repr, including the
MODES tuple in the invalid-override ValueError text.
4. Lexicon set-iteration order — the oracle's lexicons are Python sets, so
multi-hit evidence order is hash-random per process (dichotomy quirk);
truth is frozen under PYTHONHASHSEED=0 (generator re-execs itself,
memory_consolidation precedent) and the Rust const arrays reproduce
the seed-0 order.
COLLATERAL (fix-first): construction_decision's frozen truth was frozen
with RUNE_CM_CORE unpinned, so its construction_mode trace captured the
old divergent Rust output (double-quoted evidence). gen_construction_decision_truth.py
now pins RUNE_CM_CORE=python (transitive-core law) + the seed; truth
regenerated (11 evidence lines corrected), byte-identical verify green,
cd battery 18/18.
Truth: scripts/gen_construction_mode_truth.py via the shared freeze_truth.py
harness + rig scripts/cm_freeze_seams (pins RUNE_CM_CORE +
RUNE_CONSTRUCTION_DECISION_CORE for the file-scope branch's transitive
classify_surface import; binds the cm_classify_to_dict seam — classify_mode
returns a dataclass instance, the frozen contract is its to_dict projection).
39 harness cases (36 classify + 3 to_dict receivers) + 5 from_dict
projections + 3 error shapes in the battery envelope; freeze_truth --verify
byte-identical. Battery replays the corpus VERBATIM via include_str!
(frozen_cm_truth.json + frozen_cm_truth.verify.json pinned together by
envelope_cases_match_verify_file) with FULL structural equality.
FFI: cm_to_dict / cm_from_dict doc-envelope externs; cm_loader gains
to_dict/from_dict bindings. Live parity scripts/check_construction_mode_parity.py:
100% — 36 classify + 3 to_dict + 5 from_dict + 4 error shapes, rust == oracle
== frozen (92 comparisons; oracle side subprocessed under PYTHONHASHSEED=0).
clippy --all-targets -D warnings clean (construction_mode +
construction_decision + construction_interface). Python suite green in BOTH
pins (RUNE_CM_CORE=python and delegation live): 138 passed each.
Audit: construction_mode 5/5 FULL (85/192 modules at FULL).
The CLI shell (argv join/strip, --json consumed only at argv[1], the
always-trailing-newline print quirk, Python json.dumps byte-parity:
insertion order + ", "/": " separators + ensure_ascii) over the full
deterministic preflight chain — route authority mirrored from
src/go/adaptive-router (rrf cgo membrane, DeriveSufficiency,
ClassifyRoute), capsule render from src/go/builder-bridge. Reactive
seams excluded per event-wait precedent (memory retrieval, construction
projection — the oracle's own degrade paths; PL1 lessons empty by
design). Frozen truth 13 cases from the live oracle subprocess under
pinned seams (frozen clock via sitecustomize rig, empty memory/
construction stores, HOME isolation — the selector's shard sources read
a hardcoded ~/.config/opencode that ignores RUNE_* isolation); replay
byte-identical; live parity Go binary == Python oracle 13/13; go build/
vet/gofmt clean; rune's truncate is rune-safe (Python str[:n] law).
Lines 2026-10-13T16:30→2026-10-14T00:09 from minidoc-test builder
sessions against this worktree's store; the later batch pairs with
already-tracked contract entities. Union law: both sides append,
content-dedup on merge.
Ladder results (evidence under verification/, Read-back per the
file-based evidence protocol; summary in cb-summary.md): battery 11/0;
freeze --verify 33 cases byte-identical (fixture-pinned standalone
re-verify + self-verifying regen); live parity 468/468 (frozen=33
fuzz=421 live=14) — LIVE PARITY 100% on the gap fns; clippy -D warnings
clean; adjacent Python 107/107 in BOTH pins (delegation live and
RUNE_CAPABILITY_BROKER_CORE=python); full suite both pins: failure set
ZERO-delta vs the master baseline (118 pre-existing).
Phase B language advantages proven by the battery-after-landing:
trait CbIo IO injection (deterministic mtime pins in-test), Result
error paths, exhaustive handle_hook match, zero-copy static tables,
in-process Rust-to-Rust cs kernel delegation in _py_score_card.
Fix-first with proof: test_connection_pool's evict-oldest flag read
raw temp-dir paths so any 'a' in the random tempdir name flipped it
(~17% isolated flake, sole live full-suite delta on first run);
normalized to basenames like the status comparison — 15/15 green
after, both full-suite deltas zero. 1e4598aa instrument class.
Port the 10 audit-missing fns name-preserving into the existing Rust
crate (gap.rs): _native_tool_schemas, load_registry, _cards_are_stale,
load_cards, generate_card, build_cards, _cs_core, _py_score_card,
match_capabilities, handle_hook. Doc-envelope cb_* FFI entries (lib.rs,
cs_free_string stays with capability_scoring), ctypes loader bindings
(broker_loader.py), facade delegation under the
RUNE_CAPABILITY_BROKER_CORE=python pin (capability_broker.py), and a
cfg(test) battery (gap_battery.rs) replaying the shared freeze_truth.py
frozen corpus VERBATIM via include_str. synthesize_card capabilities list
pinned to the oracle law ([name]). Module audit 10/19 PARTIAL -> 19/19
FULL. Ladder evidence lands with the Phase B commit. Contract
BUILDER-2026-10-13T16:01:25Z-9b9389-factory-gap-cb.
Collapse the gap-close duplication the audit-motivated first pass
left behind, no behavioral change:
* scope_pattern_matches/trigger_matches — the regex cores shared by
the SQL-side predicates (correction_matches/habit_matches) and the
Python-pin twins (_correction_matches_python/_habit_matches_python);
four inline regex blocks → two cores + four delegations.
* ItemKind — the stringly item_type parsed once ("habit" explicit,
everything else corrects, mirroring Outcome/HabitState/Correction-
State); reinforce_plan matches exhaustively instead of comparing
strings twice. not_found(kind, id) is the single envelope builder
for the missing-row and undecodable-row branches.
Re-verified: battery 17/17 (full pre→final row replay verbatim),
clippy --all-targets -D warnings 0, release build OK, parity FROZEN
137/137 through the cdylib FFI + LIVE 14/14, pytest 7/7 both pins
(delegation live + RUNE_BEHAVIOR_CORE=python).
Audit 6/14 → 14/14 FULL (missing fns _bh_core, connect,
_correction_matches_python, _habit_matches_python, _reinforce_rust,
_reinforce_python, list_items, behavior_stats). All ported
name-preserving into src/rust/behavior as REAL public fns, rows-in/
decisions-out — SQLite open/exec IO stays Python (no crate in this
repo links a sqlite driver; the memory_storage precedent):
* _bh_core() -> Option<BhCore> — the core probe, RUNE_BEHAVIOR_CORE=
python pin honored (the in-process core has no load-failure branch).
* connect() -> ConnectSpec — path + WAL pragma + the 7 schema stmts
VERBATIM as sqlite stores them on a fresh oracle connect.
* _correction_matches_python/_habit_matches_python — the inline
Python-pin predicates over row structs.
* _reinforce_rust/_reinforce_python — both oracle halves as one
fetch-row→math→write-back ReinforcePlan (result dict + UPDATE
payload + activation-log row; ts an argument, no-clock law). The
ep-shim's habitmath IS this crate's reinforce math — the battery
replays both names and pins their coincidence.
* list_items — filters, ORDER BY confidence DESC (stable sort = the
sqlite rowid-order tie law, pinned by a frozen tie case), LIMIT,
item_type key law.
* behavior_stats — the five counters over row collections.
Row structs gain the stored columns (created_at/last_reinforced/
supersedes_id, decay_rate/last_activated) for verbatim row replay.
New FFI: bh_connect, bh_core_probe, bh_python_predicates,
bh_reinforce_plan, bh_list_items, bh_behavior_stats (doc-envelope
law, no free symbol).
Truth: gen_behavior_truth.py now pins the clock (RUNE_FROZEN_NOW →
freeze_truth._pin_clock over behavior.datetime) — every timestamp in
the corpus frozen, regeneration byte-identical x2; new sections:
pre-rows for all reinforce cases, 42+36-row predicate matrix, 5 full
list outputs, stats_full row dumps, connect schema (sqlite_master,
sqlite_% filtered), core_probe, tie pin. bh_pure_truth.json: 81-case
freeze_truth envelope corpus — freeze_truth --verify byte-identical.
Divergence documented (oracle behavior, not a bug): the ep kernel's
Num wire law renders integral confidences as JSON integers in RESULT
dicts ("confidence": 1) while sqlite REAL read-back renders 1.0 —
the plan applies the wire law to results, REAL floats to write-backs.
Battery: 17 tests — full pre→final row replay (timestamps verbatim),
schema verbatim, predicate matrix, list/stats verbatim, pure corpus.
clippy --all-targets -D warnings 0. Parity
scripts/check_behavior_parity.py: FROZEN 137/137 pure-fn replay
through the cdylib FFI + LIVE 14/14 facade-vs-pin. Python 7/7 both
pins (delegation live + RUNE_BEHAVIOR_CORE=python).
Kernel port of the 6 audit-gap fns (now_iso, connect, resolve_entity,
add_edge, query, stats) + handle_hook into src/rust/graph_memory (was a
W6 stub): the write-time gating (gm_strength_to_conf — exact float
semantics incl. the 3.5->0.8200000000000001 artifact, unlike the Go
twin's 2-decimal rounding), pred vocabulary gate (gm_normalize_pred),
node-type fallback (gm_node_type), duplicate-vs-supersede decision
(gm_supersede), 400-char evidence cap (gm_trim_evidence), query-fact
projection (gm_query_fact), stats top-8 projection (gm_stats), hook
contract (gm_handle_hook). SQLite IO stays Python (every oracle fn
takes a live db handle); the facade (graph_memory.py) delegates the
decisions through gm_loader with RUNE_GRAPH_MEMORY_CORE=python pin
honor; the probe is _core (machinery-excluded).
Truth: frozen_truth.json 38 cases (scripts/gen_graph_memory_truth.py
under scripts/gm_freeze_seams — wiped-per-process hermetic store,
RUNE_MEMORY_DIR pin, envelope clock) — byte-identical across
generation and two --verify runs. Rust battery 2/2 with the truth
embedded via include_str! (scripted store mirrors the SQL semantics
row for row: OR-IGNORE aliases, sqlite_sequence in the connect shape).
Live parity 1330/1330 (15 frozen FFI rows + 1310 fuzz checks over 60
seeded op-sequences dual-mode python-pin vs live core + 5 live
supersession-chain checks). clippy --all-targets -D warnings 0.
Python suite both pins: test_graph_health+test_graph_projection
7 passed + 1 pre-existing worktree-only failure (store cache
current.json missing — verified identical on stashed base);
test_p1_03 baseline 23 pre-existing failures identical on stashed
base (zero regressions). ruff clean.
Audit: graph_memory 2/9 PARTIAL -> 9/9 FULL (RUST); headline
FULL 43% (83/192), fn 64% (1447/2278).
Evidence: verification/gm_*.{log,exit} (all exit 0 except the two
pre-existing pytest baselines).
Walked submit→approved→building→verifying in one process, closed via the
contract_quality evidence path (port_evidence: 27/27 FULL audit, 46-case
byte-identical frozen truth + regen, gap replay 46/46, legacy 25/25, live
parity 3/3, CLI byte-identical both pins; verification/ce-*).
Walk note: the first one-process walk parked at verifying — the closed
transition now REQUIRES contract_quality evidence (quality gate; mp
precedent walk_contract_model_profiles_gap.py). Resumed with
iface.close(observed_evidence=port_evidence, scope_files=...) on the
same contract id; FINAL PHASE closed.
One pooled *sql.DB per Env (lazily created, schema verified once — the
oracle re-ran the PRAGMA/DDL block on every call; identical observable
behavior since IF NOT EXISTS is idempotent and WAL persists in the
file). ContentHash hex-encodes only the 8 bytes it returns; Compress
builds via strings.Builder. Benchmarks added (hash 140ns/op, compress
6.5µs, recordHit 0.9µs, getCache-hit 23.7µs, putCache 42.6µs).
Full ladder re-run after the rewrite: frozen battery green, gofmt/vet/
build clean, live parity 100% (16/16), freeze --verify 78/78, Python
battery 12 passed both pins.
The prior freeze packed kwargs into the per-case 'args' field, which the
shared harness's --verify replays as positional args (fn(*list(dict))) —
MISMATCH despite a correct port. Regenerate via the shared harness
(kwargs convention + envelope, fixed frozen_now), battery reads kwargs.
Layer-3 law now passes: --verify reports 16 cases byte-identical.
Name-preserving port of the 6 unmatched fns into src/go/microkernel:
NowIso (+clock seam), ExtractManifest (brace-counted PLUGIN block +
literal_eval-subset parser), Discover, RunHook (subprocess hook runner),
LoadRegistry/SaveRegistry (renamed; corrupt-file full-default parity),
plus Fire wiring the CLI fire case to real 8-way parallel dispatch with
the bounded fire-log. Register now honors Python truthiness for hook
values (string targets index) and plumbs _file into entries.
Frozen truth: 25-case envelope via the shared harness (regen-stable,
--verify byte-identical x2); Go battery 25/25 subtests, -race clean;
live oracle-vs-Go parity 24/24 (scripts/check_microkernel_parity.py);
gofmt/vet/go build ./... clean; Python both-pins green for the module
(18 test_p1_01 failures proven pre-existing on stashed base).
Audit: microkernel 6/12 PARTIAL -> 12/12 FULL (evidence:
verification/summary-microkernel.md + microkernel-*.exit).
Genuine Rust-side advantages over the Python oracle shape (parity pinned
by the frozen battery — 12/12, replay 119/119, shared verify
byte-identical):
* lower_for_match: ASCII-anchored Cow — already-lowercase gate texts (the
common case) match with ZERO allocation; non-ASCII/uppercase takes the
full Python-parity to_lowercase() path so Unicode case mappings (İ, ẛ)
are never skipped (borrow predicate is ASCII-only BY CONSTRUCTION).
* std-only hot-path bench in branch_battery: evaluate_decision over the
56-envelope frozen corpus + word_boundary_contains micro (evidence:
verification/salience-gate-phaseb-cargotest.log).
* #[must_use] on the pure surface (evaluate_decision, evaluate_salience,
evaluate_salience_dict, to_dict, handle_hook, _sg_core).
* iterator any() family scans with single-append semantics matching the
oracle's one-condition-per-family guards (feat fix, made idiomatic).
Name-preserving port of the 4 audit-missing functions into
src/rust/salience_gate (the module's existing delegation side; there is
no Go salience-gate dir):
_sg_core -> kernel mirror of the facade availability probe (pin
lattice, Some <=> probe answered, None <=> python pin)
to_dict -> SalienceDecision struct + to_dict projection
(evaluate_salience now flows through it)
handle_hook -> plugin hook handler (event echo, data accepted+ignored)
test_salience -> embedded oracle smoke test, print-byte-matched
plus a module-level evaluate_salience_dict JSON view in the oracle (the
shared freeze harness cannot serialize the dataclass return —
construction_decision's normalize_need_json precedent; audited 5/6 -> 6/6).
Defect fixes found by parity (frozen-truth battery caught all three):
1. novel family: oracle guards ONE if (any(new/never) or first time/
haven't) — previous port appended a second NOVEL flag for the regex
arm, inflating len(flags) and flipping the witness rule.
2. failure family: oracle guards ONE if including the 'doesn't work |
not working' regex arm — previous port omitted that arm entirely.
3. word_boundary_contains: Python \b is unicode/underscore-aware;
previous is_ascii_alphanumeric boundary matched new_thing/a_new/
man-new — now alphanumeric + '_' + UTF-8 continuation bytes.
Frozen truth (poisoned-truth law: RUNE_SALIENCE_CORE=python via the
generator + SG_RUST_LIB poisoned — the module's real floor pins):
frozen_sg_truth.verify.json — 52 harness rows, byte-identical under
freeze_truth.py --verify in BOTH core states; frozen_sg_truth.json —
63-row envelope (multi-family evaluation-order rows + _sg_core row;
the shared gate's RUNE_SALIENCE_GATE_CORE pin can never reach this
oracle). Battery branch_battery.rs replays both verbatim
(include_str); gen --replay: facade live 119/119 + kernel exact
(eval order). canary 6/6; oracle smoke green in 3 pin states.
Oracle src/rune/model_profiles.py 438 lines / 15 fns: 5/15 -> 15/15
per scripts/dichotomy_audit.py (name-preserving match). The ten
audit-named gaps land as Go functions: getProfilePath, loadProfile
(suppressed-exception floor + unknown-key filtering), saveProfile
(Python-shaped JSON writer), buildProfileFromOllama (knowledge merge +
uncensored tier + injected clock), scanAllModels (Ollama sweep with
banker's rounding + learned-data preservation), getOrCreateProfile,
recordInteraction (learning accumulator), getPromptContext (operator
string assembly), to_dict/from_dict (the dataclass lens via
profileFromMap), plus the stdin-op serve CLI over the same code paths.
Freeze rig scripts/mp_freeze_seams (HOME pinned before the oracle
import, per-case hermetic store wipe+seed, canned Ollama server,
frozen clock via the harness envelope): 36-case frozen truth
regenerates byte-identical across runs; freeze_truth --verify OK
against the live oracle. Battery 36/36 replay VERBATIM from the
embedded truth (gen_mp_battery.py generator). Parity
scripts/check_model_profiles_parity.py 143/143 LIVE (detection
surface, sanitization matrix, lens, build assembly, record sequences,
prompt contexts, save byte-parity, scan sweep incl. dead-port
degrade). gofmt+vet+build clean, pytest 31/31 both pins.
Divergences (documented, not bugs): non-string profile names are
accepted by the oracle dataclass but rejected by the typed port
(local_tool_runtime precedent); integral-float rendering is
canonicalized in the sweep (context_broker precedent) while the
frozen save_profile rows pin the file writer byte-exact.
Oracle src/rune/parallel_processor.py 194 lines / 14 fns: 3/14 -> 14/14
per scripts/dichotomy_audit.py (name-preserving match). The 11
audit-named gaps land as ported Go functions in src/go/parallel-processor:
RunParallelWithArgs, GetStatus, Shutdown, ShutdownProcessor
(_shutdown_processor), GetProcessor, TestParallel (with the nested
task_1/task_2/task_3 closures) — plus the class/module run_parallel and
get_status module delegates; the CLI now mirrors the oracle main()
(status/test/usage/unknown) alongside the pre-existing run and the new
replay/op gates. Logic 1:1 with the Python oracle (semaphore-bounded
goroutine pool, submission-order results, per-task error envelopes).
Oracle quirks preserved and frozen as truth rows: submit-after-shutdown
raises from the submit loop itself (port panics 'cannot schedule new
futures after shutdown' — crash parity), ParallelProcessor(0) raises
'max_workers must be greater than 0', non-callable tasks degrade to
Python-TYPE-NAME TypeError envelopes ('int'/'NoneType'/'dict' object is
not callable), with-args parse errors carry type(task).__name__ and
repr shapes (42, 'x', True, None, [1, 2]), non-seq args wrapped to a
single-arg tuple, non-dict kwargs reset to {}, len-0 list vs () tuple
distinction, pool_threads reported as the configured bound,
active_threads pinned (rig threading.active_count patch / Go
PP_ACTIVE_THREADS seam).
Truth: scripts/gen_parallel_processor_truth.py via the shared
freeze_truth.py harness (23-case envelope; kind/fn/value SPEC grammar so
callables ride JSON rows — rig builds real Python callables, battery
rebuilds Go specCallable tasks); freeze_truth --verify byte-identical
twice; truth.json embedded VERBATIM and replayed by the go test battery
(5/5) and the binary replay gate (PARITY OK 23/23). Live parity 19/19
(scripts/check_parallel_processor_parity.py: 15 op families + 4 CLI
checks). gofmt/vet/go build clean. Python oracle smoke green both pins
(module has no loader seam; the byte-identity gate replays the live
oracle itself). Audit 3/14 PARTIAL -> 14/14 FULL.
The Rust core's doc.clear()/update() semantics inside record_observed_impact
rebuild doc['entities'] with fresh objects; the previously captured entity
reference became an orphan, quality mutations silently vanished from the
store, and construction_interface.close() KeyError'd. Fires only where the
structural .so is built (coordinator checkouts, CI) — fresh worktrees took
the pure-Python path, which is why agents never saw it.
Includes the growth_pipeline salvage contract close (phase=closed, quality
persisted — proves the fix in production) + regression test.
Oracle src/rune/model_connect.py 471 lines / 11 fns: 7/11 -> 11/11 per
scripts/dichotomy_audit.py (name-preserving match). The four audit-named
gaps land as ported Go functions: CtxBudget (_ctx_budget — vendored
model_registry.resolve_context_budget num_ctx kernel with the live
oracle's constants), Now (_now — behind the injectable clock seam),
GetCloudModels (_get_cloud_models — ordered-JSON JSONC reader with the
oracle's naive quirks), HandleHook (handle_hook).
Oracle quirks preserved and frozen as truth rows: string-blind JSONC //
strip (URLs corrupt the parse -> []), trailing-comma strip, partial
cloud list on mid-provider shape errors (try/except wraps the whole
loop), insertion-order provider/model iteration (json.Decoder token
walk), null models dict -> items() raises, OUTPUT_RESERVE['default']/
TOOL_RESULT_RESERVE=2048/1024 from the live registry oracle.
Truth: scripts/gen_model_connect_truth.py via the shared freeze_truth.py
harness (40-case envelope, pinned clock 2026-10-14T08:00:00+00:00 +
pinned HOME via scripts/mconn_freeze_seams); freeze_truth --verify
byte-identical; truth.json embedded VERBATIM in truth_test.go
TestFrozenTruthReplay (3/3). Live parity 44/44
(scripts/check_model_connect_parity.py). gofmt/vet/go build clean.
Python oracle smoke green both pins (module has no loader seam; the
byte-identity gate replays the live oracle itself).
kernel: contract_pos — the ONE contract locator (index by id) replaces
the four inline position scans (amend_scope x2, transition_doc,
close_contract); the position is unstable across normalize_sorted, so
callers re-find instead of caching — the helper's contract documents
that law. fail_envelope — the single-error failure shape every
contract-scoped operation shares (ids={contract_id}, empty state, one
error row) collapses eight inline projection::envelope blocks
(unknown_contract, close not-found + wrong-phase, transition
unknown-phase + illegal-edge, report_observation validation x3).
contract_of now delegates to find_contract (one definition of
contract-by-id lookup).
No behavioral change: battery 25/25 green (85 verbatim + 5
shape-pinned), clippy --all-targets -D warnings 0, release build OK,
parity FROZEN 85/85 + LIVE re-freeze byte-identical.
Audit 25/27 → 27/27 FULL (main + _programme_continuation were the two
unmatched fns; the port carries the full envelope surface). Freeze rig
scripts/ci_freeze_seams/sitecustomize.py (PYTHONPATH auto-import, used by
BOTH generator and --verify): every RUNE_*_CORE gate pinned python for
the whole dependency cone, frozen clock on structural_store.now +
scaffold.now + capability_ledger._now + programme_continuation.time,
deterministic uuid mint (counter resets per rig helper), hermetic
per-case stores under CI_FREEZE_HOME (mini-doc paths replay
byte-identically), doc-carrying seam bindings for every stateful method.
Truth: 85-case frozen corpus + 5-case hash corpus (obligation ids carry
Python's process-randomized str hash — captured with PYTHONHASHSEED=0,
SHAPE-pinned downstream, the memory_consolidation law). Regeneration
byte-identical; freeze_truth --verify OK both corpora.
Rust kernels (src/rust/construction_interface): kernel.rs adds the
doc-in/doc-out halves of submit_need (need assembly + envelope over the
construction_decision make_decision kernel + contract generation twin),
verify (scope check + layout gate via the layout_contract kernel),
transition (guard canary over frozen command outcomes + legality map +
checkpoint/session assembly + normalize_sorted commit twin),
close (close_contract + observed-impact + close_quality bucket math +
contract_quality projection), _programme_continuation (load/save shape
twins + continuation canary), _auto_material_change (via the
capability_ledger op_material_change kernel), main (CLI dispatch + exit
law), ladder_walk (full ladder in ONE process); projection.rs the pure
helpers (to_stage_check, guard_specs, obligations projection with the
FNV-1a stand-in id, envelope with extra merge, _match).
Store-normalization law discovered: the oracle's commit path sorts
lists by canonical JSON (structural_store._sorted) — the kernel applies
the same normalization at its commit points or read-back projections
(patterns_considered) diverge.
Battery: 25 tests — the 85-case corpus replays VERBATIM through
kernel::dispatch, the 5 hash cases shape-pinned, gap-fns-are-real-ports
probe. clippy --all-targets -D warnings 0. Parity
scripts/check_construction_interface_parity.py: FROZEN layer 85/85 + 5
through the ci_replay ctypes FFI of the built cdylib; LIVE layer
fresh re-freeze byte-identical. Python 37/37 both pins (floors pinned
python + live cores).
gap-close 4/11 -> 11/11 (FULL): the 7 audit-missing fns (_ct_core,
_resolve_and_project, _run_contract_python, capture_signatures,
save_signatures, load_signatures, main as contracts_main) ported
name-preserving into src/rust/contracts with IO behind injectable
seams; 8 new doc-envelope FFI kernels via contracts_loader
(cs_free_string, never re-exported). Frozen truth ct_gap_truth.json
127 rows (harness --verify 23/23 byte-identical) embedded VERBATIM in
gap_battery; battery 19/19; live parity replay failures=0 (facade 30,
kernel 15); clippy -D warnings 0; fmt clean; pytest 6/6 both pins;
full-suite failure set byte-identical to base. One documented
eager/lazy divergence (projection-crash row) pinned both ways. Full
lifecycle walked in ONE process (approved->building->verifying->closed).
gap-close 6/14 → 14/14 (FULL): 8 identity kernels in the cognition_core
broker, doc-envelope FFI cc_* via cc_loader (cc_free_string, never
re-exported), facade delegation behind the existing RUNE_COGNITION_CORE
gate; 44 frozen-oracle cases battery-replayed VERBATIM (freeze_truth
--verify byte-identical, ia_freeze_seams rig); live parity 88/88 both
pins; clippy 0; pytest 48/48 both pins; Phase B OnceLock caches +
prefixed() combinator + fmt::Write renderers. Full lifecycle walked in
ONE process (approved→building→verifying→closed).
Rebasing twice for concurrent sibling landings churned the feat SHA twice
(f102f68b → 14d3d8c3 → 0fb08c63 → 2c273574); four evidence strings kept
the discarded 0fb08c63 form ('feat <sha>' shape my refresh sed missed).
No store state changes — citation accuracy only.
broker: the five behavior lattices parse once per process (OnceLock
caches behind a cached_lattice! macro — drift checks run per response,
re-parsing 3KB of static JSON every call was pure waste); the
[pattern, message, prefix] row construction folds into one prefixed()
combinator shared by _pattern_triples and check_genuineness (the
duplicated pair-unpacking loops are gone); _pattern_triples' table
mutation becomes an array+chain+flat_map pipeline; the show renderers
write through std::fmt::Write directly into the output String (no temp
format! allocations), show_pronouns' two mark-loops become one
[(key, mark)] walk.
Behavior identical: battery 60 green (44 frozen cases replay VERBATIM),
clippy -D warnings 0, live parity 88/88 both pins, pytest 48/48 both pins.
parity: every missing identity_anchors kernel ported name-preserving into
the cognition_core broker — show_anchors/show_rules/show_pronouns (the
display renderers behind the data-injection seam: table as argument,
Python data stays the runtime authority, exactly the drift_check/
identity_prompt design), the four behavior lattices _announcement_/
_pronoun_/_hedge_/_sycophancy_patterns (embedded JSON snapshots generated
from the frozen truth, replay-verified), _pattern_triples (the real
35-row [pattern, message, prefix] authority: DRIFT 7+3, WEAKNESS 3,
SYCOPHANCY 18, GENUINENESS 4), check_genuineness (performative matching
over the embedded lattice via the shared drift_check kernel), _cc_core
(the probe's pin-decision mirror: python → None, else the core answers),
and identity_handle_hook (the 'default' envelope — growth_delta's
passthrough is its own kernel, handler 'growth_delta').
doc-envelope FFI via cc_free_string (never re-exported); cc_loader pins
argtypes for the 11 new cc_* symbols; facade delegation pinned by
RUNE_COGNITION_CORE=python (the existing gate — _cc_core reads it).
truth: 44 frozen-oracle cases (show stdout captured by the ia_freeze_seams
rig, pure-Python oracle pinned) embedded VERBATIM in identity_battery;
freeze_truth --verify byte-identical; identity_tables/*.json mechanical
snapshots of ANCHORS/EMBODIMENT_RULES/PRONOUN_RULES/SELF_AWARENESS kept
in lockstep by the gen script.
verified: cargo test 60 green (identity_battery 3), clippy --all-targets
-D warnings 0, live parity 88/88 both pins, Python suite 48/48 both pins
(sibling .so overrides), audit identity_anchors 6/14 → 14/14 FULL.
Unify the four self-scored decision kernels' shared floor/tag/cap loop
into one generic floored_rows iterator consumer — neurons/graphs/
abstraction/consolidated each keep ONLY their scoring (and the neuron
trigger-scan prefilter), dropping four hand-rolled copies of the same
below-floor-drop, tag, budget-cap shape. Behavior unchanged — battery
9/9, clippy --all-targets -D warnings 0, live parity 536/536 against
the frozen oracle.
The audit named three unported fns (11/14 PARTIAL): add_source,
_source_store, _mse_core. All three now have Rust counterparts —
audit 14/14 FULL, missing [].
parity: add_source is the registry decision KERNEL (mse_add_source) —
registration order is execution order, re-registering replaces IN PLACE
(dict insertion order keeps position); the facade applies the kernel's
order as authoritative while carrying the caller's fn. _source_store's
persona-lane gate delegates through the already-frozen mse_persona_wanted
(lane runs iff wanted==[]) and its merge through mse_store_project; the
sqlite IO stays Python per the port law. _mse_core is the facade's
delegation probe (machinery — the pin honored inside mse_loader.core);
its CONTRACT is frozen (pin -> python floor) and the seam map is
documented in the crate header.
Freeze rig (scripts/ms_freeze_seams, the memory_consolidation pattern):
fixed-path hermetic store seeded via add_entry — raw INSERTs bypass
entries_fts and recall abstains on every row (the first freeze attempt's
empty truths were exactly that bug); embeddings off, lexical-only.
10-row truth: pin contract, source_names, 4 registry-order rows
(append/replace-in-place/solo/replace-keeps-tail), 4 _source_store E2E
rows (lane merge, persona-lane dedup by entry id, typed lane skip,
trivial abstain). Byte-identical: 2 generation runs + 2 --verify runs.
Battery 9/9 (gap truth embedded via include_str! — the ms_add_source
rows replay through the kernel; E2E rows replay in the live-parity gate).
Live parity 536/536: frozen FFI rows, 522 fuzz registry ops (seed 2479)
oracle dict vs kernel, dual-mode facade (RUNE_MSE_CORE=python vs live
core) on _source_store/add_source/select_for_task — identical outputs.
clippy --all-targets -D warnings 0. Python both pins: test_p1_03 66
passed + 2 pre-existing worktree failures (cached_recall, unrelated,
pass in main checkout — verified identical on the stashed base);
test_context_broker 18/18 both pins. ruff clean.
Audit PARTIAL 7/13 -> FULL 13/13 (headline 74/192, fn 1358/2278).
Ported: _need_dict (FFI need envelope, wired into cp_evaluate/cp_derive),
_surface_text (evidence token union, set semantics). Renamed to exact
Python names per the name-preserving law: _path_matches, _entity_matches,
_obligation_when_hit (were path_matches/entity_matches/obligation_when_hit)
and the evaluate_applicability _check closure — same bodies, exact names;
precedent: structural_store _sorted/_ss_core, construction_decision _sc_core.
Truth: frozen_cp_truth.json 70->96 cases (path_match/entity_match/
need_dict/surface_text/when_hit families, incl. re.split empty-quirk and
truthy-not-True always cases); harness surface frozen_truth.json 18 cases
(from_dict/revise stay in the bespoke battery — bare instances are not
harness-serializable). Battery 14 tests replay all 96 VERBATIM.
Verification (verification/summary.md, all exit 0): battery 14/14, clippy
0 warnings, harness verify 18/18, live parity 192/192 both pins (new
check_construction_pattern_parity.py; class ops via cp_loader under the
kernel pin), pytest 30/30 module + 20/20 consumers under
RUNE_CP_CORE=python and auto.
ctxBudget resolves through an init-built map (O(1), 0 allocs — 18.8ns/op
benchmarked) instead of the per-call profile scan; benchmarks for the
ctxBudget table and the classifySalience regex hot path added. The
escalation walk is documented DELIBERATELY sequential: fallback-after-
failure is oracle semantics — racing routes would issue requests the
oracle never issues (parity break, not advantage). Constitution
(sync.Once) and cloud-config (mutex-guarded once) caches carry over
from the port. Full ladder re-verified: battery green, live parity
100%, gofmt/vet/build clean (verification/phaseb-*.exit, summary.md).
Full lifecycle submit->approved->building->verifying->closed walked in
ONE process; evidence: parity b472eeb7 feat(spine): close PARTIAL gaps
(subject to rebase-rewrite check at push). Audit regenerated on the
rebased tree: spine 25/25, fn-level 1357 -> 1383 (spine +5).
classify_mode kept a write-only `bootstrap` variable (assigned at the
PROJECT_BUILD branch, never read; the result uses `mode == "PROJECT_BUILD"`
exactly as the Python oracle does at construction_mode.py:410). Its two
warnings leaked into every dependent crate clippy run — including
construction_decision, whose factory landing gate (layer 2) counts any
warning in the dependency graph. Dead-code removal only; output
expression unchanged (byte-identical to oracle). construction_mode
battery 1/1, construction_decision 18/18, both clippy 0.
branch_battery.rs now embeds BOTH frozen truth files by explicit path
(include_str! frozen_cd_truth.verify.json — the harness-format replay
source, and frozen_cd_truth.json — the envelope) and pins them together
with envelope_cases_match_verify_file, so the battery-truth linkage the
7c gate greps for matches the actual truth filenames written in the
crate. 18/18 tests green, clippy clean for this crate.
Typed decision surfaces replacing string-kinded branching:
* SurfaceKind enum — the open-world surface kinds classified and matched
EXHAUSTIVELY (classify_surface, resolve_surface, resolve_affected_surface
dispatch); unresolved stays a first-class variant, never dropped.
* CompletenessVerdict enum — the §8 tri-state gate matched exhaustively;
the premature-fit guard now compares the typed verdict instead of a
string const.
One with_key-style law per decision column; no behavior change. Battery
17/17 replays frozen truth verbatim; live parity 147/147; pytest 21/21
both pins; clippy --all-targets -D warnings 0.
15/15 surfaces FULL: safety kernels in the cognition_core broker
(REFUSAL_RE via regex crate), envelope FFI via cc_loader, facade
delegation pinned by RUNE_COGNITION_CORE=python; 1 harness + 65
method frozen-oracle cases battery-replayed VERBATIM; re-freeze
byte-identical; live parity 2065/2065 (65 frozen + 2000 fuzz, seed
2479) on the merged tree; cargo test 64 green; clippy -D warnings
clean; oracle tests green both pins (7 passed auto / 6+1skip python).
Close walk submit_need->approved->building->verifying->closed in ONE
process (verification/close_walk.log). Evidence:
verification/summary-safety_override.md + *.log/.exit in worktree.
Port the 5 audit-missing fns name-preserving into src/rust/spine/src/gap.rs
(_module_imports, _gather_meta_inputs, _deployed_source_files,
_gather_drift_inputs, _fresh_doc; IO behind injectable seams) plus
machinery twins over the proven rune_spine kernels, with doc-envelope
sp_* FFI (freed via cs_free_string). Audit spine 20/25 -> 25/25
(fn-level 1335 -> 1340). Battery replays the 21-case harness truth
(byte-verified vs live oracle) + 35-case clocked battery VERBATIM;
live parity 74/74 through the real FFI surface; clippy -D warnings
clean; pytest no new failures either pin. Fixes pre-landing: clock-pin
args leak (structural_store.now passes gmtime() positionally),
malformed-import SyntaxError branch, test_ prefix in drift tested
stems, kernel_absent battery dispatch.
Oracle src/rune/adaptive_router.py 625 lines / 19 fns: 15/19 -> 19/19
per scripts/dichotomy_audit.py (name-preserving match). The four
audit-named gaps land as exported Go functions: FloorAppliesFromFlags
(_floor_applies_from_flags), FloorReason (_floor_reason),
RecordTransitionWith (_record_transition_with), DetectExternalRefs
(_detect_external_refs).
Parity repairs found on the way (all oracle-pinned):
- legacy boolean shim now carries NONE defaults for the three
non-probed fields (oracle compares full SufficiencyInputs)
- provenance booleans render Python-style True/False (str(True))
- [:200] truncation is rune-safe (Python str slicing is char-based)
- DeriveSufficiency gains the evidence_classes contract path
(nil = operator path, non-nil = research path)
- escalate/downgrade/verification-failure take log_path and record
- event() emits JSON null (not empty string) for unset
previous_route/trigger/evidence
- Unknowns()/risk/uncertainty normalize to [] never null
- wall-clock reads go through the injectable clock seam
Truth: scripts/gen_adaptive_router_truth.py via the shared
freeze_truth.py harness (25-case envelope, frozen clock);
truth.json embedded VERBATIM in truth_test.go TestFrozenTruthReplay.
Dataclass surface pinned by the seam unit battery (10-branch classify
matrix, 10-branch derive matrix, transitions, record family,
rune-safe truncation) plus scripts/check_adaptive_router_parity.py
live sweep: 32/32 match. gofmt+vet clean, go build clean,
pytest 19/19 both pins.
engine: GenerateReport computes each function's placement ONCE — the
oracle-shape loop called RecommendPlacement per hook-membership AND
again per report row (2N calls); the memo collapses both to one call
and keeps the report bytes identical.
main: the oracle's main() commands land as the placement-engine CLI
(scan/recommend/validate/report/hook, --json where the oracle has it)
on the same Registry core the frozen battery replays; discovery reads
the real scripts dir + plugin file through the engine's injectable
seams (RUNE_MEMORY_DIR-aware plugin path).
No behavioral change: gofmt/vet clean, frozen battery 7/7 green,
CLI smoke (scan 265 discovered/12 tagged, validate clean, recommend/
report, hook pre_turn with payload) verified.
Gap-closing port of construction_decision.py (#2479): 4/20 → 19/20 fns.
Name-preserving 1:1 ports of normalize_need (JSON view), resolve_surface,
ss_entity, implemented_contracts, resolve_affected_surface,
check_completeness, record_proposed_requirement, needs_user_approval,
_project_exists_evidence, make_decision (+ layout_obligations_for,
obligations_from_trace, need_new/need_to_dict); merge_resolutions fixed to
the oracle precedence law (SATISFIED>REUSE>…>BUILD_NEW, never a fallback);
language_placement reshaped to the live scaffold_core verdict
({placement, rule, evidence}, characteristic fit for non-rune) — the old
flat W6-era shape was stale against the retired oracle.
resolve_status is carried oracle-verbatim (ANY truthy status string
returned as-is): the structural_store crate collapses unknown statuses
(STALE) to UNKNOWN, silently un-staling candidates — proven by
test_stale_candidate_rejected_in_live_path.
FFI: cdec_ doc-envelope symbols (one per public fn), freed via
capability_scoring's cs_free_string (never re-exported). Loader
src/rune/cdec_loader.py mirrors broker_loader.py. Facade delegates with
RUNE_CONSTRUCTION_DECISION_CORE=python pin; Python remains the parity
authority. Composes capability_fit/toolchain/construction_mode/
construction_pattern/patterns_builtin kernels (no cross-crate rewrites).
Truth: scripts/gen_construction_decision_truth.py via the shared
freeze_truth harness — 134 cases byte-identical (--verify OK) + 5 Need +
8 project-existence cases, embedded VERBATIM in branch_battery.rs
(17/17). Live parity 147/147 (auto→Rust vs pinned Python). pytest 21/21
both pins; clippy --all-targets -D warnings 0.
gap-close 5/20 → 17/20 (85%): 12 growth kernels in the cognition_core
broker, doc-envelope FFI via cc_loader, facade delegation pinned by
RUNE_COGNITION_CORE=python; 24+22 frozen-oracle cases battery-replayed
VERBATIM; freeze_truth --verify byte-identical BOTH pins; live parity
86/86 both pins; clippy 0; _store_db/_cc_core/_py_growth_profile stay
Python by law (drift_cache calibration). Fix-first: _near_dup dict-pair
delegation bug (string-only kernel answered False for every dict pair).
observations.jsonl union-merged by content-id after a concurrent-wave
rebase (3893 → 3885 deduped rows, 3 conflict markers resolved).
Rust-advantage pass on src/rust/growth_pipeline:
- PipelineState enum with From<&str> classified ONCE and matched
exhaustively (candidate/supported/trial/promoted/revised/rejected/
unknown) — the transition ladder is a single match on typed arms, so
the unknown bucket can never silently grow a new branch.
- in-crate phaseb unit tests: contradiction precedence from every
state, threshold boundaries (sightings 2|3, outcomes 1|2), durability
gate — compiled into cargo test.
Parity re-verified after the pass: frozen battery 46/46 verbatim,
clippy -D warnings 0, pytest 6/6 both pins, live parity 100%.
Contract BUILDER-2026-10-13T11:46:11Z-846423-factory-batch-h.
Re-walk of BUILDER-2026-10-13T00:32:22Z-bc3aae-factory-gap-ss whose close-commit
was lost in the store repair: submit→approved→building→verifying→closed in one
process on the fresh store, evidence = the already-pushed feat/refactor SHAs
(audit 34/34, parity 4387/4387).
broker: the W3.3 growth_near_dup inline key closure is hoisted to one
distinctive_words definition shared with the gap-close py_near_dup (one
form, two callers); near_keys carries the shared empty/overlap math.
reflect's gate loop becomes a single filter_map pipeline; evidence_of
folds the duplicated 'evidence or ""'[:200] extraction (journal record
+ would_apply record + apply params share the exact form). parse_json's
nested brace-extraction ifs collapse to find/rfind zip+filter+and_then.
lib: req_str replaces the eight inline match-extractions across the
gap-close wrappers (apply_one, llm, write_store, parse_json, apply,
handle_hook, ctx_budget, cc_llm) — one unpack helper, the pre-existing
wrappers untouched.
No behavioral change: battery 9/9 (57 unit tests + 5 probe) green,
frozen truth 24/24 byte-identical BOTH pins, live parity 86/86 both
pins, clippy --all-targets -D warnings 0.
The frozen corpus recorded the FREEZE-TIME checkout's absolute paths
(repo_root -> /mnt/workdrive/rune-wave-bd, crate_dir ->
/mnt/workdrive/rune-wave-bd/src/rust/<name>), so the battery failed in
every other checkout (6 subtests). Same law applied backward in repair:
absolute paths must never enter frozen truth.
- gen_paths_truth.py: derivation rows frozen REPO-RELATIVE
({REPO_ROOT}, {REPO_ROOT}/src/rust/<name>).
- truth_test.go: expandExpect substitutes the CURRENT root at replay
time and FAILS any derivation row that carries a raw absolute path
(the law is now self-enforcing).
- tests/test_paths_port.py: oracle replay substitutes identically +
asserts the placeholder law on the corpus itself; shape test updated
for the paths.go/phaseb.go split.
Verified: gofmt/vet/go test green in THIS worktree AND from a scratch
checkout at a different root (placeholder substitution proof); pytest
4/4, ruff clean.
- 7e: counts frozen cases (nested case-family dicts handled) vs the
oracle's public fn count; <0.5 ratio FAILs, <1.0 WARNs. Closes the
layer-3 existence-only gap.
- 7f: master's store file is grepped for conflict markers — a
marker-bearing master DENIES verification (the 42-marker incident
cannot recur silently).
- TRUTH path made absolute at find-time (later layers run from root).
- Verified: subsystem_health 10/0, paths 9/0, intent_continuity 10/0.
Every item traces to an observed incident in the live run. P0 structural
removals (store v2, harness truth normalization, CI required checks,
truth-rig library), P1 speed, P2 thoroughness, P3 balance mechanics.
Go-advantage pass on src/go/paths:
- ONE table-driven envOrDefault helper replaces four copies of the
LookupEnv/fallback pattern across the env-overridable resolvers
(deploy_root/rune_home/harness_scripts/wait_resume_dir), now grouped
in phaseb.go with the derivation pair (RepoRoot/CrateDir) in paths.go.
- native Go unit test covers the default AND override branch of every
env-reading resolver — compiled into the same binary as the frozen
battery (no FFI hop; the Go advantage is real).
Parity re-verified after the pass: gofmt clean, go vet 0, go test ok
(16/16 frozen rows verbatim), pytest 4/4, ruff clean.
Contract BUILDER-2026-10-13T06:09:16Z-50572c-factory-batch-h.
Language verdict (docs/language-dichotomy-ledger.md): GO — Law 7:
simple operations stay in the caller's language; path resolution is
pure string/env work where FFI overhead would exceed the compute. NO
facade delegation: src/rune/paths.py stays the Python-side authority;
src/go/paths is the name-preserving Go mirror verified against the
SAME frozen corpus (both languages replay it verbatim).
- src/go/paths: RepoRoot/CrateDir/DeployRoot/RuneHome/HarnessScripts/
WaitResumeDir (+ RepoRootPath constant); runtime.Caller derivation
mirrors the oracle's module-location semantics (four Dir levels —
this file sits one deeper than paths.py).
- truth.json: 16 frozen-oracle rows (RUNE poisoned-truth: oracle only,
deep-copied args, env matrix frozen per row with HOME pinned so
expanduser-bearing defaults replay byte-stably in Go).
- truth_test.go: embedded battery sets each row's frozen env and
byte-compares the Go output against the frozen oracle output.
- tests/test_paths_port.py: oracle replay of the same corpus, the Go
battery re-run for real on this machine, Go shape check, and
every-public-function + every-env-branch corpus coverage.
Verification: gofmt clean, go vet 0, go test ok (16/16 verbatim),
pytest 4/4, ruff clean.
Contract BUILDER-2026-10-13T06:09:16Z-50572c-factory-batch-h
(builder=factory-batch-h) — building.
Rust-advantage pass on src/rust/memory_types:
- the six-bucket routing ladder collapsed into ONE declarative const
ROUTE_TABLE iterated first-match-wins — the oracle's precedence is
now a data guarantee, not six branches to keep in sync.
- in-crate phaseb unit tests: share-sum invariant, remainder-absorption
exactness across totals, every bucket routable (incl. None →
semantic) — compiled into cargo test.
Parity re-verified after the pass: frozen battery 53/53 verbatim
(key order included), clippy -D warnings 0, pytest 6/6 both pins,
live parity 100%. Contract BUILDER-2026-10-13T04:35:41Z-756b83-factory-batch-h.
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.
2026-10-13 10:50:57 +01:00
6138 changed files with 5068734 additions and 3093543 deletions
**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.**
{"digest":"ebd493b6544b8f215d2a714a998a7ac37add986d780fc1b809c0a270e8821e5d","evidence":{"detail":"minimal call observed failing: Exception: Ollama connection failed: cannot import name '_clean_model_name' from 'model_connect' (/h","ended_at":1792233218.997182,"error_class":"UNREACHABLE","input_digest":"a21f92f9ee3f2256bcbf27aa45981290981c6c1cf2655bfa50b0ba11ba20868c","output_digest":"76b0ec3f3942928cb5232e64112f0fa5347f3a5193ca8a82a62d9e963e142a44","started_at":1792233218.9893873},"kind":"provider","observed_at":1792233218.9972157,"path":"provider:ollama","phase":"minimal_call","prev_digest":"c9419eadc0641ecaf40267e0543a5bdbfc548b377a4c2721f92662a641e32f10","receipt_id":"LP-1792233218-e0f20aa3","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"unmeasured"}
{"digest":"422166d72546bf077ff51d2152acbd0e987e92d3d8b00748d5a14706e66944ac","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233219.006819,"error_class":null,"injected_fault":"generate against a nonexistent model id","input_digest":"6c0df4008620e6808cc874cd54c1c9b516dd5b50e4ea1bfe0ad118b00f085587","output_digest":"71316104b00a83a2835a7d02b2b1fc42de3cf5bc50f4135785314698032e1622","started_at":1792233218.997217},"kind":"provider","observed_at":1792233219.0068464,"path":"provider:ollama","phase":"failure_injection","prev_digest":"ebd493b6544b8f215d2a714a998a7ac37add986d780fc1b809c0a270e8821e5d","receipt_id":"LP-1792233219-bb625093","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"0aecbb624f13ee7719fd6e0679655142ec39f252a134f2181579f85150793168","evidence":{"detail":"recovery call observed failing: Exception: Ollama connection failed: cannot import name '_clean_model_name' from 'model_connect' (/h","ended_at":1792233219.0125165,"error_class":"UNREACHABLE","input_digest":"da1b19503325152474269326e22e35a3541de5be0b52f6a4d15697562276ffcf","output_digest":"39c9e709defa1679ba1d6ab7c60e3a4be6778264bef4fbe47cb1f1e3cbf8afb7","started_at":1792233219.0068486},"kind":"provider","observed_at":1792233219.0125406,"path":"provider:ollama","phase":"recovery","prev_digest":"422166d72546bf077ff51d2152acbd0e987e92d3d8b00748d5a14706e66944ac","receipt_id":"LP-1792233219-a4e0929a","recovery_of":"LP-1792233219-bb625093","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"unmeasured"}
{"digest":"147fed3aca1ac49ebc86d959fbf89e1bb2c7a93343a94605f7e51890f22bdc51","evidence":{"detail":"minimal call observed failing: Exception: Ollama connection failed: cannot import name '_clean_model_name' from 'model_connect' (/h","ended_at":1792234272.860741,"error_class":"UNREACHABLE","input_digest":"a21f92f9ee3f2256bcbf27aa45981290981c6c1cf2655bfa50b0ba11ba20868c","output_digest":"76b0ec3f3942928cb5232e64112f0fa5347f3a5193ca8a82a62d9e963e142a44","started_at":1792234272.8529968},"kind":"provider","observed_at":1792234272.8607702,"path":"provider:ollama","phase":"minimal_call","prev_digest":"eb332a8c25995da32fd4c4db62a5ba910f6b3469beadb2a1e3b8155c565bd1a5","receipt_id":"LP-1792234272-9c39fdf0","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"unmeasured"}
{"digest":"4ff45d265c98ee4dedb981ea927efc89342c3af39288f7343def206e0c6865c1","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234272.8636794,"error_class":null,"injected_fault":"generate against a nonexistent model id","input_digest":"6c0df4008620e6808cc874cd54c1c9b516dd5b50e4ea1bfe0ad118b00f085587","output_digest":"71316104b00a83a2835a7d02b2b1fc42de3cf5bc50f4135785314698032e1622","started_at":1792234272.8607724},"kind":"provider","observed_at":1792234272.8637164,"path":"provider:ollama","phase":"failure_injection","prev_digest":"147fed3aca1ac49ebc86d959fbf89e1bb2c7a93343a94605f7e51890f22bdc51","receipt_id":"LP-1792234272-b76c579a","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"34793a3250f51c5b28de3405feda20e0cf6a56d456317dd85c1847966002da84","evidence":{"detail":"recovery call observed failing: Exception: Ollama connection failed: cannot import name '_clean_model_name' from 'model_connect' (/h","ended_at":1792234272.8698554,"error_class":"UNREACHABLE","input_digest":"da1b19503325152474269326e22e35a3541de5be0b52f6a4d15697562276ffcf","output_digest":"39c9e709defa1679ba1d6ab7c60e3a4be6778264bef4fbe47cb1f1e3cbf8afb7","started_at":1792234272.863718},"kind":"provider","observed_at":1792234272.8698883,"path":"provider:ollama","phase":"recovery","prev_digest":"4ff45d265c98ee4dedb981ea927efc89342c3af39288f7343def206e0c6865c1","receipt_id":"LP-1792234272-f20f26d0","recovery_of":"LP-1792234272-b76c579a","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"unmeasured"}
{"digest":"ed3856b44b6239e6446b77469a6c41527112ad465814cea2df4242a36bc283ff","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233218.9712937,"error_class":null,"injected_fault":"check with a disabled growth gate","input_digest":"01fa0327088c9965436c396d3f0bb4234e19811f3466d8911f5bdb5df3b5b9b5","output_digest":"ed530432d25645b5a47a6c6c577e89a0c9202b1596c61a6cd54054ccb516e4d2","started_at":1792233218.9711423},"kind":"tool","observed_at":1792233218.971308,"path":"tool:check_growth","phase":"failure_injection","prev_digest":"f1732dcec4346174f63e4261e58deac8811065f5ab8ceaea640b7e6fe380fd8e","receipt_id":"LP-1792233218-44814065","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"32be97e9cfe91e0466147c5357cb13df1bff9ad5b66b68887d8d99c07ff0cf0a","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.9713871,"error_class":null,"input_digest":"739b3f090bd90a54c54f40b518d0e5e316bda4f14ab25342445139362394e167","output_digest":"88a7f14ac8dc1521fede6db1e4c142fba565cd1a2827424ad93e2ad6c49fe411","started_at":1792233218.9713087},"kind":"tool","observed_at":1792233218.971402,"path":"tool:check_growth","phase":"recovery","prev_digest":"ed3856b44b6239e6446b77469a6c41527112ad465814cea2df4242a36bc283ff","receipt_id":"LP-1792233218-8aec1e2c","recovery_of":"LP-1792233218-44814065","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"e45d6ec8bc98722470b1c6bd712dc290e7cdf20cb4585ee1e11487d50ee637dc","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234272.832866,"error_class":null,"input_digest":"effb3b5d5769d540ff9760238ef48bff2f7e776d98141067ecab0e89d02745fb","output_digest":"a43dee11da21b5c47cd68d4a4fffd3f16b118377a18610880c4ddb8c437cff30","started_at":1792234272.8328648},"kind":"tool","observed_at":1792234272.8328886,"path":"tool:check_growth","phase":"auth_check","prev_digest":"32be97e9cfe91e0466147c5357cb13df1bff9ad5b66b68887d8d99c07ff0cf0a","receipt_id":"LP-1792234272-f2be3eb8","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"0031728bfd365ccb090ec337a9c91953975352ba48b7d3576caef2e31c9a2417","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234272.8330224,"error_class":null,"injected_fault":"check with a disabled growth gate","input_digest":"01fa0327088c9965436c396d3f0bb4234e19811f3466d8911f5bdb5df3b5b9b5","output_digest":"ed530432d25645b5a47a6c6c577e89a0c9202b1596c61a6cd54054ccb516e4d2","started_at":1792234272.8329933},"kind":"tool","observed_at":1792234272.8330305,"path":"tool:check_growth","phase":"failure_injection","prev_digest":"17e07c39e371aaeebfa83cb873ba65f3bed126894b4f052bf514a7f8baa1ce63","receipt_id":"LP-1792234272-3c00183b","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"74a1cb3f6452f59f43877f96d88b2a5243b78e3914443d8744f41d717eb6e568","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234272.8330655,"error_class":null,"input_digest":"739b3f090bd90a54c54f40b518d0e5e316bda4f14ab25342445139362394e167","output_digest":"88a7f14ac8dc1521fede6db1e4c142fba565cd1a2827424ad93e2ad6c49fe411","started_at":1792234272.833031},"kind":"tool","observed_at":1792234272.8330722,"path":"tool:check_growth","phase":"recovery","prev_digest":"0031728bfd365ccb090ec337a9c91953975352ba48b7d3576caef2e31c9a2417","receipt_id":"LP-1792234272-a52f85ab","recovery_of":"LP-1792234272-3c00183b","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"fb033f6370e01ed82a84f32ff0a54df6b77ce3765e79333f584b699620ae1085","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233218.972268,"error_class":null,"input_digest":"d6553a8acb42491e8735929dc6f91b553ff94c4e797554e46273f9acb9e30bd4","output_digest":"c8cb4141c0ee8d220179c8acc4aae21aa0cff50326c88a13bdfdb2c9c5b2203f","started_at":1792233218.9722667},"kind":"tool","observed_at":1792233218.9722826,"path":"tool:diagnose_behavior","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233218-dd7210f5","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"ab7b7039801bd75b33269958bd3d323425612b084b69024b9d98442734cf6920","evidence":{"detail":"minimal call failed: Text is required","ended_at":1792233218.972331,"error_class":"TOOL_ERROR","input_digest":"f9059e4bd866ddfc75fb5ccd9b89306e9cf4a65fdc82ab98c1a677c78c0d1685","output_digest":"ead878aa4011839b17b4f7d7a75db98c83f4b3ed22140d36e4a16580cf81d671","started_at":1792233218.9722831},"kind":"tool","observed_at":1792233218.9723408,"path":"tool:diagnose_behavior","phase":"minimal_call","prev_digest":"fb033f6370e01ed82a84f32ff0a54df6b77ce3765e79333f584b699620ae1085","receipt_id":"LP-1792233218-134fe0fd","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_fail"}
{"digest":"b858918d419ad179109da3c570351f8bf3f4c40bda784c8caffe2b1d379401f2","evidence":{"detail":"injected fault observed failing and classified: Text is required","ended_at":1792233218.9723644,"error_class":"TOOL_ERROR","injected_fault":"diagnose a nonexistent behavior","input_digest":"8c4282e880c336c239d9ac91bd85a502b44ac6d404592d5aabfe17b8b834f849","output_digest":"01973c0c768f536fed316470916982cef444dfc09453f9e52ae1b43fe997291c","started_at":1792233218.9723413},"kind":"tool","observed_at":1792233218.9723866,"path":"tool:diagnose_behavior","phase":"failure_injection","prev_digest":"ab7b7039801bd75b33269958bd3d323425612b084b69024b9d98442734cf6920","receipt_id":"LP-1792233218-7c223469","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"3b153deb3d2f4c4f3560095e4dff865f7f4c3974acee34124f5ea052a2aa717e","evidence":{"detail":"recovery call failed: Text is required","ended_at":1792233218.972428,"error_class":"TOOL_ERROR","input_digest":"d78b3459d5852c759f6ea1b0f50054bdea2fe9ba78aefc436739e01da74271ad","output_digest":"42ed65c4c87cc759829b454747b386d6ed17fbc1d384a276f655671eb83e8c8b","started_at":1792233218.9723876},"kind":"tool","observed_at":1792233218.9724379,"path":"tool:diagnose_behavior","phase":"recovery","prev_digest":"b858918d419ad179109da3c570351f8bf3f4c40bda784c8caffe2b1d379401f2","receipt_id":"LP-1792233218-77b6723d","recovery_of":"LP-1792233218-7c223469","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_fail"}
{"digest":"c32d50db85d43518dda60996844776e0989cd908c5b9c5030c39ae9743a71946","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234272.8339787,"error_class":null,"input_digest":"d6553a8acb42491e8735929dc6f91b553ff94c4e797554e46273f9acb9e30bd4","output_digest":"c8cb4141c0ee8d220179c8acc4aae21aa0cff50326c88a13bdfdb2c9c5b2203f","started_at":1792234272.8339775},"kind":"tool","observed_at":1792234272.8339918,"path":"tool:diagnose_behavior","phase":"auth_check","prev_digest":"3b153deb3d2f4c4f3560095e4dff865f7f4c3974acee34124f5ea052a2aa717e","receipt_id":"LP-1792234272-dfac6bb4","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"8756bc92697e9f5de328db31223bf7481f698e1ad7634e7f058d36d0dc83ddec","evidence":{"detail":"minimal call failed: Text is required","ended_at":1792234272.8340354,"error_class":"TOOL_ERROR","input_digest":"f9059e4bd866ddfc75fb5ccd9b89306e9cf4a65fdc82ab98c1a677c78c0d1685","output_digest":"ead878aa4011839b17b4f7d7a75db98c83f4b3ed22140d36e4a16580cf81d671","started_at":1792234272.8339922},"kind":"tool","observed_at":1792234272.8340425,"path":"tool:diagnose_behavior","phase":"minimal_call","prev_digest":"c32d50db85d43518dda60996844776e0989cd908c5b9c5030c39ae9743a71946","receipt_id":"LP-1792234272-836d1042","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_fail"}
{"digest":"9297fed4e6920a3f5762cfe2fb274a29c3c1fec4802393f2ff3f004d70b7719a","evidence":{"detail":"injected fault observed failing and classified: Text is required","ended_at":1792234272.8340626,"error_class":"TOOL_ERROR","injected_fault":"diagnose a nonexistent behavior","input_digest":"8c4282e880c336c239d9ac91bd85a502b44ac6d404592d5aabfe17b8b834f849","output_digest":"01973c0c768f536fed316470916982cef444dfc09453f9e52ae1b43fe997291c","started_at":1792234272.834043},"kind":"tool","observed_at":1792234272.834069,"path":"tool:diagnose_behavior","phase":"failure_injection","prev_digest":"8756bc92697e9f5de328db31223bf7481f698e1ad7634e7f058d36d0dc83ddec","receipt_id":"LP-1792234272-a9bb3919","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"8ad5aee780ccd936b60fc54fbaa1eb1eb53876090e95815abb2e4b6bf6587e2d","evidence":{"detail":"recovery call failed: Text is required","ended_at":1792234272.8340976,"error_class":"TOOL_ERROR","input_digest":"d78b3459d5852c759f6ea1b0f50054bdea2fe9ba78aefc436739e01da74271ad","output_digest":"42ed65c4c87cc759829b454747b386d6ed17fbc1d384a276f655671eb83e8c8b","started_at":1792234272.8340695},"kind":"tool","observed_at":1792234272.8341036,"path":"tool:diagnose_behavior","phase":"recovery","prev_digest":"9297fed4e6920a3f5762cfe2fb274a29c3c1fec4802393f2ff3f004d70b7719a","receipt_id":"LP-1792234272-20e5a3a8","recovery_of":"LP-1792234272-a9bb3919","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_fail"}
{"digest":"48cd2f229a78ab32c2f2070a5b47e77ef5e48db795c686649565883660ee6aa5","evidence":{"detail":"approval gate refused to prepare (observed gate): Search string is required","ended_at":1792233217.9267302,"error_class":"GATE_REFUSED","input_digest":"4eabb2182550c057b79bd5976ad49473e3084277549b998891a122dc3dc7f9db","output_digest":"a45af98f4939d4fd8485c8d4fa7ab62a45dd55e86f998696b15442bcff3e0349","started_at":1792233217.9261644},"kind":"tool","observed_at":1792233217.9267461,"path":"tool:edit_file","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-a68e62ef","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_fail"}
{"digest":"a9953e071141252ad8c3b42486abcbb1cda5789b0d829cd982d7620faf59b56f","evidence":{"detail":"minimal call failed: Search string is required","ended_at":1792233217.9273448,"error_class":"TOOL_ERROR","input_digest":"6fb6fbf080b369dc2e686b32cddbc680267340fb9425e08afb7b9fa9e7e8b377","output_digest":"f4a206c8cead20aeeb6bb307edb77a9f2d53db376d64bc1813ce588ad6053da8","started_at":1792233217.9267473},"kind":"tool","observed_at":1792233217.9273586,"path":"tool:edit_file","phase":"minimal_call","prev_digest":"48cd2f229a78ab32c2f2070a5b47e77ef5e48db795c686649565883660ee6aa5","receipt_id":"LP-1792233217-e0f92cc9","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_fail"}
{"digest":"a45da58bf28d26c9ae75153acebf1a8c2cc9e26a3d513714bfa8697c8bdd9620","evidence":{"detail":"injected fault observed failing and classified: Search string is required","ended_at":1792233217.9278736,"error_class":"TOOL_ERROR","injected_fault":"edit a file with a missing anchor","input_digest":"63ce71b463d1e77f081e233375c7c291c34c6f93853676b848ef68f96dc7feaa","output_digest":"0237d8dd751db3440a726294e02d4fd8a84b00989c6119f0577f034870a3af5d","started_at":1792233217.92736},"kind":"tool","observed_at":1792233217.9278855,"path":"tool:edit_file","phase":"failure_injection","prev_digest":"a9953e071141252ad8c3b42486abcbb1cda5789b0d829cd982d7620faf59b56f","receipt_id":"LP-1792233217-3ad43eab","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"8e4d081578f175f2b37caedab52f719b56668ca311e7e8fb31e9842feee42a6c","evidence":{"detail":"recovery call failed: Search string is required","ended_at":1792233217.928333,"error_class":"TOOL_ERROR","input_digest":"a70358c28463e2f8e5eea5eb760f76644b1e20383fa4678ec4c318d190c60d11","output_digest":"f89be8c3fddb6328acfd951900fb398c74c50f7f1708e527e688a18d016f9302","started_at":1792233217.9278872},"kind":"tool","observed_at":1792233217.928343,"path":"tool:edit_file","phase":"recovery","prev_digest":"a45da58bf28d26c9ae75153acebf1a8c2cc9e26a3d513714bfa8697c8bdd9620","receipt_id":"LP-1792233217-6ee28288","recovery_of":"LP-1792233217-3ad43eab","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_fail"}
{"digest":"2c779b57fe74d139b79ce64707d0290d1252b26f3ce158dce6eb3cd0a3c040f7","evidence":{"detail":"minimal call failed: Search string not found in edit_file.txt","ended_at":1792234271.5949092,"error_class":"TOOL_ERROR","input_digest":"6fb6fbf080b369dc2e686b32cddbc680267340fb9425e08afb7b9fa9e7e8b377","output_digest":"20ed3750d32c8a881aea08cb33fb52bba8fd61fcf969c2022b721bbd8e9ba42a","started_at":1792234271.5940335},"kind":"tool","observed_at":1792234271.594928,"path":"tool:edit_file","phase":"minimal_call","prev_digest":"dc5b600d7dfc0d4e381201f66c4f3e6dcb17a9d383f1dd0ea86d214f0150ab76","receipt_id":"LP-1792234271-b30479ab","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_fail"}
{"digest":"5d7fd346bcbb3adbc3f3952c5f592866541d5afe2bfdeb01ee98cff7c669085c","evidence":{"detail":"injected fault observed failing and classified: Edit failed: [Errno 2] No such file or directory: '/mnt/workdrive/rune/store/live_proof/sandbox/__nonexistent_live_probe","ended_at":1792234271.5957453,"error_class":"ENOENT","injected_fault":"edit a file with a missing anchor","input_digest":"63ce71b463d1e77f081e233375c7c291c34c6f93853676b848ef68f96dc7feaa","output_digest":"364eb58fdab4217299d3a7f3fd590815a1964f86b74f7c2fa0d38032a62150c0","started_at":1792234271.594929},"kind":"tool","observed_at":1792234271.5957549,"path":"tool:edit_file","phase":"failure_injection","prev_digest":"2c779b57fe74d139b79ce64707d0290d1252b26f3ce158dce6eb3cd0a3c040f7","receipt_id":"LP-1792234271-65f7fd20","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"d5a0fbc69149bae42bf8d556920c9052247db4d55d5c892c55c72fa4b3b9cae9","evidence":{"detail":"recovery call failed: Search string not found in edit_file.txt","ended_at":1792234271.5965545,"error_class":"TOOL_ERROR","input_digest":"a70358c28463e2f8e5eea5eb760f76644b1e20383fa4678ec4c318d190c60d11","output_digest":"d9bf9f6f2c4f64727973bc0f636af218d074075cd1926e0bc501813278d63992","started_at":1792234271.595756},"kind":"tool","observed_at":1792234271.5965624,"path":"tool:edit_file","phase":"recovery","prev_digest":"5d7fd346bcbb3adbc3f3952c5f592866541d5afe2bfdeb01ee98cff7c669085c","receipt_id":"LP-1792234271-28bf8c0f","recovery_of":"LP-1792234271-65f7fd20","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_fail"}
{"digest":"de031143b88a4d31724982cb7bc0a04d1b9953b41b4e86d282ea21849ad0e500","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233218.9731452,"error_class":null,"input_digest":"0adb83aa939f7216e7bf9ba290ca9e9a64c6e8410bbf031307b944b3fd61062f","output_digest":"35e723bbc9593fdbb9b7b37505f216ba25bc48db956b46db0c40720f6e9c55c2","started_at":1792233218.973144},"kind":"tool","observed_at":1792233218.9731574,"path":"tool:find_capability","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233218-ce2187d2","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"9f677dc17c92915a62e15d7f750400195b31c341555f78979c1302c88ffdfc5e","evidence":{"detail":"minimal call failed: Query is required \u2014 describe the capability you need","ended_at":1792233218.9731963,"error_class":"TOOL_ERROR","input_digest":"3b47e2eacf2a6aa514330dfcd9bee3f7cfc83bae4c0930f657f00044030ae69b","output_digest":"62565e29fa6c5e71b931cbfd6c1684af3a471c679da69334046585eefc2fee88","started_at":1792233218.973158},"kind":"tool","observed_at":1792233218.9732049,"path":"tool:find_capability","phase":"minimal_call","prev_digest":"de031143b88a4d31724982cb7bc0a04d1b9953b41b4e86d282ea21849ad0e500","receipt_id":"LP-1792233218-3566a907","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_fail"}
{"digest":"38176a2beaf5d78cc874cbfac22ac7845b000efdb13f2a284b053d808f0a7da6","evidence":{"detail":"injected fault observed failing and classified: Query is required \u2014 describe the capability you need","ended_at":1792233218.9732258,"error_class":"TOOL_ERROR","injected_fault":"find with an empty description","input_digest":"0ac9aad40765fe88299b7b07e5013a81a1f2a895b8afb4dce2c3cfac64d7dd26","output_digest":"28352af01bb36df885d64cb1b6bc26d4a61e8077629f823fb67340c0d423d174","started_at":1792233218.9732053},"kind":"tool","observed_at":1792233218.9732332,"path":"tool:find_capability","phase":"failure_injection","prev_digest":"9f677dc17c92915a62e15d7f750400195b31c341555f78979c1302c88ffdfc5e","receipt_id":"LP-1792233218-712a2227","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"50854fcc958dbce5821e72e55b730b0343f44590be10930a3b12bc727881d707","evidence":{"detail":"recovery call failed: Query is required \u2014 describe the capability you need","ended_at":1792233218.9732618,"error_class":"TOOL_ERROR","input_digest":"d151d7e8dd968e38c8d85bef653e87199364bc1414b7c97b8e1fc59a601c9a59","output_digest":"d8491c426e55ca12008180f3da157210d2f7fb207ac428a1b90ecb4de1e924ef","started_at":1792233218.973234},"kind":"tool","observed_at":1792233218.9732685,"path":"tool:find_capability","phase":"recovery","prev_digest":"38176a2beaf5d78cc874cbfac22ac7845b000efdb13f2a284b053d808f0a7da6","receipt_id":"LP-1792233218-9a17a48f","recovery_of":"LP-1792233218-712a2227","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_fail"}
{"digest":"1f2cd83e04e5afda5afd551a7f84165cf4203d994ea439dcdbb2c416cdce4067","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234272.8349164,"error_class":null,"input_digest":"0adb83aa939f7216e7bf9ba290ca9e9a64c6e8410bbf031307b944b3fd61062f","output_digest":"35e723bbc9593fdbb9b7b37505f216ba25bc48db956b46db0c40720f6e9c55c2","started_at":1792234272.8349156},"kind":"tool","observed_at":1792234272.83493,"path":"tool:find_capability","phase":"auth_check","prev_digest":"50854fcc958dbce5821e72e55b730b0343f44590be10930a3b12bc727881d707","receipt_id":"LP-1792234272-b25ebea1","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"6f8eb8865b3b3617dbe09a42bd481b06ef93e5bedab18950082231388f66cc14","evidence":{"detail":"minimal call failed: Query is required \u2014 describe the capability you need","ended_at":1792234272.8349726,"error_class":"TOOL_ERROR","input_digest":"3b47e2eacf2a6aa514330dfcd9bee3f7cfc83bae4c0930f657f00044030ae69b","output_digest":"62565e29fa6c5e71b931cbfd6c1684af3a471c679da69334046585eefc2fee88","started_at":1792234272.8349307},"kind":"tool","observed_at":1792234272.834981,"path":"tool:find_capability","phase":"minimal_call","prev_digest":"1f2cd83e04e5afda5afd551a7f84165cf4203d994ea439dcdbb2c416cdce4067","receipt_id":"LP-1792234272-c3442c1f","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_fail"}
{"digest":"08b43ea4362c8d56c5a006187c8c91e7da64c39056798f338505d1501606c7b3","evidence":{"detail":"injected fault observed failing and classified: Query is required \u2014 describe the capability you need","ended_at":1792234272.8350027,"error_class":"TOOL_ERROR","injected_fault":"find with an empty description","input_digest":"0ac9aad40765fe88299b7b07e5013a81a1f2a895b8afb4dce2c3cfac64d7dd26","output_digest":"28352af01bb36df885d64cb1b6bc26d4a61e8077629f823fb67340c0d423d174","started_at":1792234272.8349812},"kind":"tool","observed_at":1792234272.8350093,"path":"tool:find_capability","phase":"failure_injection","prev_digest":"6f8eb8865b3b3617dbe09a42bd481b06ef93e5bedab18950082231388f66cc14","receipt_id":"LP-1792234272-79fe0ee7","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"ab14d5cddb37f55e0c9adbcf00f51faf439dd10e54c6b26d2821180dd7b6606a","evidence":{"detail":"recovery call failed: Query is required \u2014 describe the capability you need","ended_at":1792234272.8350449,"error_class":"TOOL_ERROR","input_digest":"d151d7e8dd968e38c8d85bef653e87199364bc1414b7c97b8e1fc59a601c9a59","output_digest":"d8491c426e55ca12008180f3da157210d2f7fb207ac428a1b90ecb4de1e924ef","started_at":1792234272.8350098},"kind":"tool","observed_at":1792234272.8350532,"path":"tool:find_capability","phase":"recovery","prev_digest":"08b43ea4362c8d56c5a006187c8c91e7da64c39056798f338505d1501606c7b3","receipt_id":"LP-1792234272-6766c0b0","recovery_of":"LP-1792234272-79fe0ee7","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_fail"}
{"digest":"9164fb82484dba5ae0e8c497728866716a2cb8874021b1fe6d53fb7273ada121","evidence":{"detail":"format the sandbox file","ended_at":1792233217.984442,"error_class":null,"input_digest":"32d0d5c5830c69cf32c0ee758005a203837ad7fd802259c1ad21b6f3954bc63b","output_digest":"c8c2a02139b62296fee3cc277bd826d681d35f5646811f49cdbc91afed8ab1e7","started_at":1792233217.983549},"kind":"tool","observed_at":1792233217.984453,"path":"tool:format_code","phase":"minimal_call","prev_digest":"4339eac29575b6f17356e0dcd605bef2e8ae659e072cbb81416e92b88698f85c","receipt_id":"LP-1792233217-39e45da0","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"0a929f0cdf83277119d58ac3dfe50b63e646b7a8eb078e44cf3a790f4384638f","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233217.985334,"error_class":null,"injected_fault":"format a nonexistent file","input_digest":"699188135863c5b805a7e910e721be757d537f958ef28f1590a2f7d087732c81","output_digest":"6ed318b6181b478b9a2bc0fff2614602fb252749895d9bd5fa8b3f03b1fe613c","started_at":1792233217.9844537},"kind":"tool","observed_at":1792233217.9853451,"path":"tool:format_code","phase":"failure_injection","prev_digest":"9164fb82484dba5ae0e8c497728866716a2cb8874021b1fe6d53fb7273ada121","receipt_id":"LP-1792233217-cdc17635","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"0c704fc95e1195ff65984ee123c847f64d714cabd312ba8b8b38ec1764d8586c","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.9860196,"error_class":null,"input_digest":"cfa71b658f7e5cd0bd2c68fcc3a0387dffc2997b910f2ed78a5cfb2db2c9f715","output_digest":"ae2604e827746341571cc34b70a5fd25cfd8983942c871a97640d1012d562630","started_at":1792233217.9853458},"kind":"tool","observed_at":1792233217.9860277,"path":"tool:format_code","phase":"recovery","prev_digest":"0a929f0cdf83277119d58ac3dfe50b63e646b7a8eb078e44cf3a790f4384638f","receipt_id":"LP-1792233217-096d666c","recovery_of":"LP-1792233217-cdc17635","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"9ec4ca7e02f555fefb59a8d9ee2e582c6b54f8b047cfeb23c6053cbeccc9f214","evidence":{"detail":"format the sandbox file","ended_at":1792234271.6419256,"error_class":null,"input_digest":"32d0d5c5830c69cf32c0ee758005a203837ad7fd802259c1ad21b6f3954bc63b","output_digest":"c8c2a02139b62296fee3cc277bd826d681d35f5646811f49cdbc91afed8ab1e7","started_at":1792234271.6412988},"kind":"tool","observed_at":1792234271.641933,"path":"tool:format_code","phase":"minimal_call","prev_digest":"dd1250bf123cb79d2fbf1072359e671d38772f14ca36e547320286829a3d722a","receipt_id":"LP-1792234271-7eee87ea","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"e45f1684037afb1cf03448b01053d8170b613851e9484de8010ef46621ad6e04","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.6423914,"error_class":null,"injected_fault":"format a nonexistent file","input_digest":"699188135863c5b805a7e910e721be757d537f958ef28f1590a2f7d087732c81","output_digest":"6ed318b6181b478b9a2bc0fff2614602fb252749895d9bd5fa8b3f03b1fe613c","started_at":1792234271.6419346},"kind":"tool","observed_at":1792234271.6424007,"path":"tool:format_code","phase":"failure_injection","prev_digest":"9ec4ca7e02f555fefb59a8d9ee2e582c6b54f8b047cfeb23c6053cbeccc9f214","receipt_id":"LP-1792234271-fdfacc31","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"60ce32130f5c17019ac7b70717e0f420fa54c8ed56a68fd674621e94275be7b2","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.6428502,"error_class":null,"input_digest":"cfa71b658f7e5cd0bd2c68fcc3a0387dffc2997b910f2ed78a5cfb2db2c9f715","output_digest":"ae2604e827746341571cc34b70a5fd25cfd8983942c871a97640d1012d562630","started_at":1792234271.6424017},"kind":"tool","observed_at":1792234271.6428561,"path":"tool:format_code","phase":"recovery","prev_digest":"e45f1684037afb1cf03448b01053d8170b613851e9484de8010ef46621ad6e04","receipt_id":"LP-1792234271-a43376a0","recovery_of":"LP-1792234271-fdfacc31","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"38f228c1f4e5b222b197325149efd41779a62aface45517b0a54873a0c960b27","evidence":{"detail":"commit the sandbox repo","ended_at":1792233218.1262887,"error_class":null,"input_digest":"54ceaa1b4eccbee19db6a3dc8c24f692d029804bd0ae7c9f685c1c7860a3f2d0","output_digest":"7b06fbc1d8ade52285636daec396c0d8ca75964b514e1077139302b18963279c","started_at":1792233218.1261256},"kind":"tool","observed_at":1792233218.1262999,"path":"tool:git_commit","phase":"minimal_call","prev_digest":"916622b0692180079be0fa14dc9868f280ae325a0ccb735aba7df355edbc013b","receipt_id":"LP-1792233218-b761dbbe","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"8e1595f6593a9291f038589c9e34b4d14a173b34764cb2e7644ffbd4c047ffb0","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233218.1263576,"error_class":null,"injected_fault":"commit in a nonexistent repo","input_digest":"9bddc4cfb693552c656dc9e47584d9068b3be99daae94438e0530121cb97fc8e","output_digest":"7f907c177d743bae750c07e27658d6879a89845424b140bed34862aacda401b7","started_at":1792233218.1263006},"kind":"tool","observed_at":1792233218.1263666,"path":"tool:git_commit","phase":"failure_injection","prev_digest":"38f228c1f4e5b222b197325149efd41779a62aface45517b0a54873a0c960b27","receipt_id":"LP-1792233218-8677fcf9","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"83fb0e9120ac471c8424758037a68d54722fc570a42b735e661daabe12631fe8","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.1264496,"error_class":null,"input_digest":"bc75d76baf987fe949e4bb458bfc3b5746e59531bce0b74ddc3e54054a7c6b9d","output_digest":"026076a4884e63ffc7e67997e014186d6211e01bc0e63d77c19b6392c1836f9c","started_at":1792233218.1263678},"kind":"tool","observed_at":1792233218.1264575,"path":"tool:git_commit","phase":"recovery","prev_digest":"8e1595f6593a9291f038589c9e34b4d14a173b34764cb2e7644ffbd4c047ffb0","receipt_id":"LP-1792233218-ccff3ae0","recovery_of":"LP-1792233218-8677fcf9","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"1a1a64773f8dfe4b3618f26d6d8c60b8c17ec71a1acc6436fbd1babf7ddd5388","evidence":{"detail":"commit the sandbox repo","ended_at":1792234271.9145355,"error_class":null,"input_digest":"54ceaa1b4eccbee19db6a3dc8c24f692d029804bd0ae7c9f685c1c7860a3f2d0","output_digest":"7b06fbc1d8ade52285636daec396c0d8ca75964b514e1077139302b18963279c","started_at":1792234271.9143646},"kind":"tool","observed_at":1792234271.9145465,"path":"tool:git_commit","phase":"minimal_call","prev_digest":"073f9815684222ff103e6a3e30db658ec97162fe202cd2d5c05c4ba111d88e88","receipt_id":"LP-1792234271-fe21eb5b","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"4ecfc38df097fa56163ae6b8501207c50ca58100ea634511978be196a1e628a8","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.9145935,"error_class":null,"injected_fault":"commit in a nonexistent repo","input_digest":"9bddc4cfb693552c656dc9e47584d9068b3be99daae94438e0530121cb97fc8e","output_digest":"7f907c177d743bae750c07e27658d6879a89845424b140bed34862aacda401b7","started_at":1792234271.9145477},"kind":"tool","observed_at":1792234271.914602,"path":"tool:git_commit","phase":"failure_injection","prev_digest":"1a1a64773f8dfe4b3618f26d6d8c60b8c17ec71a1acc6436fbd1babf7ddd5388","receipt_id":"LP-1792234271-bc6f3907","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"994380b2322699aaef85b0b64f07828650b6f06cc25a3a0c5d70c84b5fb7a610","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.9146597,"error_class":null,"input_digest":"bc75d76baf987fe949e4bb458bfc3b5746e59531bce0b74ddc3e54054a7c6b9d","output_digest":"026076a4884e63ffc7e67997e014186d6211e01bc0e63d77c19b6392c1836f9c","started_at":1792234271.9146032},"kind":"tool","observed_at":1792234271.9146674,"path":"tool:git_commit","phase":"recovery","prev_digest":"4ecfc38df097fa56163ae6b8501207c50ca58100ea634511978be196a1e628a8","receipt_id":"LP-1792234271-a1df6340","recovery_of":"LP-1792234271-bc6f3907","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"b8a6d2fdafc5e73d9a7ede9bd9ad93a09718d7c5aecec56f3b59828ff74093f4","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233217.9869187,"error_class":null,"input_digest":"dd109683f9eb4df87b83f1537860edf044f18fe29fb5bf9de5b570e4d42351d1","output_digest":"600f50fcd096a6e7f256b1cb1e984795b95d9a2bca2271c14b1e555df34b0535","started_at":1792233217.9869177},"kind":"tool","observed_at":1792233217.9869332,"path":"tool:git_diff","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-f020249f","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"4e3eed0978e2137df3ac4b4145d80dc8fe36872dbc7608de219977f684586323","evidence":{"detail":"git diff over the sandbox repo","ended_at":1792233217.9911351,"error_class":null,"input_digest":"5dc9c8c0e0c1ef6aefe7169679869a6840c7df389307272714b882247d263083","output_digest":"6ac3a850c53e3379dd847a6954b7c10317b0e655863a0c1fa67ac996102b4a9d","started_at":1792233217.9869337},"kind":"tool","observed_at":1792233217.9911575,"path":"tool:git_diff","phase":"minimal_call","prev_digest":"b8a6d2fdafc5e73d9a7ede9bd9ad93a09718d7c5aecec56f3b59828ff74093f4","receipt_id":"LP-1792233217-b056453e","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"1399ec2a6747f3bafa601cf469768b969520548b21c2104d379854cf570ed075","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233217.9927576,"error_class":null,"injected_fault":"diff a denied (blocked) repo path","input_digest":"56cb25dd83425ae7f3d26a189d872c5fbde6dae02b7a982a013494f55e135edf","output_digest":"48648c794f0ada1a506476a80fd26a95e9ed255acab9015aa01963b483fae14f","started_at":1792233217.9911582},"kind":"tool","observed_at":1792233217.9927845,"path":"tool:git_diff","phase":"failure_injection","prev_digest":"4e3eed0978e2137df3ac4b4145d80dc8fe36872dbc7608de219977f684586323","receipt_id":"LP-1792233217-fe7a0fc9","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"6ff4c8d31c5acdb1ee3abf1e74e9f14d308f2b493d6ce25896109a5df4447b8b","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.9959311,"error_class":null,"input_digest":"6133a0f98e6ba29061d08e6c51faae4dbf25538ccb39d04b85a8dee63616f948","output_digest":"3e4609baeb5a414e794e4616e9bfc60632540142450492360ace994cce0b0777","started_at":1792233217.9927852},"kind":"tool","observed_at":1792233217.9959495,"path":"tool:git_diff","phase":"recovery","prev_digest":"1399ec2a6747f3bafa601cf469768b969520548b21c2104d379854cf570ed075","receipt_id":"LP-1792233217-b2af2209","recovery_of":"LP-1792233217-fe7a0fc9","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"70fdd79ac35608e5c15786e35e57f54b16991f8969413bef7bd20ad1840c8ce9","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6440454,"error_class":null,"input_digest":"dd109683f9eb4df87b83f1537860edf044f18fe29fb5bf9de5b570e4d42351d1","output_digest":"600f50fcd096a6e7f256b1cb1e984795b95d9a2bca2271c14b1e555df34b0535","started_at":1792234271.6440432},"kind":"tool","observed_at":1792234271.6440785,"path":"tool:git_diff","phase":"auth_check","prev_digest":"6ff4c8d31c5acdb1ee3abf1e74e9f14d308f2b493d6ce25896109a5df4447b8b","receipt_id":"LP-1792234271-df5ab7a3","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"a82ddab09ba040046b1c766ee624456ce04eb9c483c498567b9f6262bdf05445","evidence":{"detail":"git diff over the sandbox repo","ended_at":1792234271.6542373,"error_class":null,"input_digest":"5dc9c8c0e0c1ef6aefe7169679869a6840c7df389307272714b882247d263083","output_digest":"6ac3a850c53e3379dd847a6954b7c10317b0e655863a0c1fa67ac996102b4a9d","started_at":1792234271.6440797},"kind":"tool","observed_at":1792234271.6542816,"path":"tool:git_diff","phase":"minimal_call","prev_digest":"70fdd79ac35608e5c15786e35e57f54b16991f8969413bef7bd20ad1840c8ce9","receipt_id":"LP-1792234271-932fb030","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"289c44ecd57249e81f024825bfc778c46b26b8e4a7073547222773a2cee293f1","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.6567209,"error_class":null,"injected_fault":"diff a denied (blocked) repo path","input_digest":"56cb25dd83425ae7f3d26a189d872c5fbde6dae02b7a982a013494f55e135edf","output_digest":"48648c794f0ada1a506476a80fd26a95e9ed255acab9015aa01963b483fae14f","started_at":1792234271.6542833},"kind":"tool","observed_at":1792234271.6567662,"path":"tool:git_diff","phase":"failure_injection","prev_digest":"a82ddab09ba040046b1c766ee624456ce04eb9c483c498567b9f6262bdf05445","receipt_id":"LP-1792234271-e5bd14bc","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"ca6edf5380c18685a683509c5919f4c89391a5c058ac32601c5d3d91a20fbaec","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.6615918,"error_class":null,"input_digest":"6133a0f98e6ba29061d08e6c51faae4dbf25538ccb39d04b85a8dee63616f948","output_digest":"3e4609baeb5a414e794e4616e9bfc60632540142450492360ace994cce0b0777","started_at":1792234271.656769},"kind":"tool","observed_at":1792234271.661634,"path":"tool:git_diff","phase":"recovery","prev_digest":"289c44ecd57249e81f024825bfc778c46b26b8e4a7073547222773a2cee293f1","receipt_id":"LP-1792234271-7aab4e64","recovery_of":"LP-1792234271-e5bd14bc","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"d37a399bd2e98a508d665ae770cd0fd13b392be7377ffd8a83a2cfc948df4dcf","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233217.9971395,"error_class":null,"input_digest":"649063c0ce4caeb01410f1d801f5473ca5a915b93b584979ed58df4c7d174e56","output_digest":"474dbdd4b646a9d07ca2953c3344cfc3e70a4eaf5424262e68a8cf5bff6a2c3d","started_at":1792233217.997138},"kind":"tool","observed_at":1792233217.9971535,"path":"tool:git_log","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-c706c568","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"dbc6f52f31665718ef4535042dce6d2117a13c928387e608b7dfb3b8c87604d2","evidence":{"detail":"git log over the sandbox repo","ended_at":1792233218.026486,"error_class":null,"input_digest":"3b421cec4cca1fb5c1c61278a90d780af62162d18945951c736240001ecd785c","output_digest":"0909012aa545ff66ddfd9e7f1a0effe86d275452a13dec63a99590b908bffdd4","started_at":1792233217.997154},"kind":"tool","observed_at":1792233218.0265276,"path":"tool:git_log","phase":"minimal_call","prev_digest":"d37a399bd2e98a508d665ae770cd0fd13b392be7377ffd8a83a2cfc948df4dcf","receipt_id":"LP-1792233218-a9755c01","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"7314b1c165f9147d420611dd332bb5acb2d7f35515033e212a6638557f92c060","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233218.0281873,"error_class":null,"injected_fault":"log a denied (blocked) repo path","input_digest":"6975cd174ebb61d6ef0f859f9c4dc4e282b3d2190531ac3195577f10652bdaf1","output_digest":"1e710f2b8c9eb63962f2bc36711fbc0f55f993f6f6e3f0450e95fddb0c982a02","started_at":1792233218.0265288},"kind":"tool","observed_at":1792233218.028207,"path":"tool:git_log","phase":"failure_injection","prev_digest":"dbc6f52f31665718ef4535042dce6d2117a13c928387e608b7dfb3b8c87604d2","receipt_id":"LP-1792233218-21a25935","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"8c5bdf961689cdf93e47cab74adf6189a70250d3906db4058725b7545efd3d86","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.0514162,"error_class":null,"input_digest":"40c3054fe56e3e132c4996bcce0ddaa321ff089a2a3cea1a86fbfd313bb3dcbd","output_digest":"1737bb3c248263253e525f3891c664753ee30c1038127d2d9e5e806b415ad8a5","started_at":1792233218.0282078},"kind":"tool","observed_at":1792233218.0514512,"path":"tool:git_log","phase":"recovery","prev_digest":"7314b1c165f9147d420611dd332bb5acb2d7f35515033e212a6638557f92c060","receipt_id":"LP-1792233218-876244c2","recovery_of":"LP-1792233218-21a25935","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"2602a1f6fcea47d4c440e6d577a7264c45ad834f7e9119ae8a908c96796b7824","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6629384,"error_class":null,"input_digest":"649063c0ce4caeb01410f1d801f5473ca5a915b93b584979ed58df4c7d174e56","output_digest":"474dbdd4b646a9d07ca2953c3344cfc3e70a4eaf5424262e68a8cf5bff6a2c3d","started_at":1792234271.662937},"kind":"tool","observed_at":1792234271.6629672,"path":"tool:git_log","phase":"auth_check","prev_digest":"8c5bdf961689cdf93e47cab74adf6189a70250d3906db4058725b7545efd3d86","receipt_id":"LP-1792234271-37ca6466","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"5ed130156aa2ab7ca5374d4f96839bfc74606f52c39c34561109ab2f48fb86c6","evidence":{"detail":"git log over the sandbox repo","ended_at":1792234271.6929662,"error_class":null,"input_digest":"3b421cec4cca1fb5c1c61278a90d780af62162d18945951c736240001ecd785c","output_digest":"0909012aa545ff66ddfd9e7f1a0effe86d275452a13dec63a99590b908bffdd4","started_at":1792234271.6629682},"kind":"tool","observed_at":1792234271.6930032,"path":"tool:git_log","phase":"minimal_call","prev_digest":"2602a1f6fcea47d4c440e6d577a7264c45ad834f7e9119ae8a908c96796b7824","receipt_id":"LP-1792234271-d90ab32f","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"5f3052d9436dd547a5b25d8ea05cbce96601d1d8746e90a54c26812f8f964e02","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.6946573,"error_class":null,"injected_fault":"log a denied (blocked) repo path","input_digest":"6975cd174ebb61d6ef0f859f9c4dc4e282b3d2190531ac3195577f10652bdaf1","output_digest":"1e710f2b8c9eb63962f2bc36711fbc0f55f993f6f6e3f0450e95fddb0c982a02","started_at":1792234271.6930046},"kind":"tool","observed_at":1792234271.6946838,"path":"tool:git_log","phase":"failure_injection","prev_digest":"5ed130156aa2ab7ca5374d4f96839bfc74606f52c39c34561109ab2f48fb86c6","receipt_id":"LP-1792234271-4e1f029c","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"c314d226a8f46b7e3ac7b071c274d7c7e6c3ca590d7806b5f14eca3cdc2c6cd3","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.714346,"error_class":null,"input_digest":"40c3054fe56e3e132c4996bcce0ddaa321ff089a2a3cea1a86fbfd313bb3dcbd","output_digest":"1737bb3c248263253e525f3891c664753ee30c1038127d2d9e5e806b415ad8a5","started_at":1792234271.6946852},"kind":"tool","observed_at":1792234271.7143848,"path":"tool:git_log","phase":"recovery","prev_digest":"5f3052d9436dd547a5b25d8ea05cbce96601d1d8746e90a54c26812f8f964e02","receipt_id":"LP-1792234271-b05f6066","recovery_of":"LP-1792234271-4e1f029c","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"ca6b2d197b0f4044a4208800b15e8990a18af4aa4e3c7e165c884f725b439706","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233217.935326,"error_class":null,"input_digest":"cdd89c699a648d21d577bcfeb2b87a987f64944e82350846d139f4f1eec4d418","output_digest":"d4766f9548002e4602da5da4f827f61294cc8b08a234cc7880f8ae42147ab278","started_at":1792233217.9353254},"kind":"tool","observed_at":1792233217.9353373,"path":"tool:grep_files","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-17701868","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"ce86db21dd675cfb1f8e5f9f4af6bc822f65d2064ff62f12629216de55e7e112","evidence":{"detail":"grep a sandbox file","ended_at":1792233217.9409065,"error_class":null,"input_digest":"38ce20c1d4bc02969671edfe6f3464b78a54a6ba9b089ddad424c5583748a6e8","output_digest":"1955a17bb45ecc94b754b450cee352c2fe72595a1b05b703f93fd2d8acde73ba","started_at":1792233217.9353378},"kind":"tool","observed_at":1792233217.9409366,"path":"tool:grep_files","phase":"minimal_call","prev_digest":"ca6b2d197b0f4044a4208800b15e8990a18af4aa4e3c7e165c884f725b439706","receipt_id":"LP-1792233217-a7192254","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"3e3047bd15e478e012e1aedd3dbfd41e33ebf414f0a9a3b571f88d4710a07a96","evidence":{"detail":"injected fault observed failing and classified: Access denied: /etc/__live_proof_probe__","ended_at":1792233217.9411662,"error_class":"PERMISSION","injected_fault":"grep a denied (blocked) directory","input_digest":"c65c78d2d1158e068826d995cf869a01093c6595829ef41bd2b4802ade1c0ef2","output_digest":"e2c0b1072fac866e0ec2ea1177d20dee5a2a89439b2307e06cae94d31ea6c59b","started_at":1792233217.9409375},"kind":"tool","observed_at":1792233217.941184,"path":"tool:grep_files","phase":"failure_injection","prev_digest":"ce86db21dd675cfb1f8e5f9f4af6bc822f65d2064ff62f12629216de55e7e112","receipt_id":"LP-1792233217-f7b02ecf","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"54090879f2f24ba8696656076e14b9d392673b13205a318d696404e416581769","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.9442227,"error_class":null,"input_digest":"364577c4d7e3583ff668e6ab3d5c7c327ccdad96e32b554b6701e3ff16665bb4","output_digest":"492c4575f234f3b56c2e0b3271eb87dfccf7fae373e64af1c20753f9bd40ce11","started_at":1792233217.9411852},"kind":"tool","observed_at":1792233217.9442453,"path":"tool:grep_files","phase":"recovery","prev_digest":"3e3047bd15e478e012e1aedd3dbfd41e33ebf414f0a9a3b571f88d4710a07a96","receipt_id":"LP-1792233217-120e6b01","recovery_of":"LP-1792233217-f7b02ecf","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"725a232bd125611cfcbab7e6c0702359bedfeef5cf4215cbd4b9cab5befcbb7a","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6025229,"error_class":null,"input_digest":"cdd89c699a648d21d577bcfeb2b87a987f64944e82350846d139f4f1eec4d418","output_digest":"d4766f9548002e4602da5da4f827f61294cc8b08a234cc7880f8ae42147ab278","started_at":1792234271.6025221},"kind":"tool","observed_at":1792234271.6025395,"path":"tool:grep_files","phase":"auth_check","prev_digest":"54090879f2f24ba8696656076e14b9d392673b13205a318d696404e416581769","receipt_id":"LP-1792234271-37ebbcdd","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"d4579a36a0043c200661f235d2f5562ce9c1142d091d4fef7e708948f3e39e75","evidence":{"detail":"grep a sandbox file","ended_at":1792234271.6092792,"error_class":null,"input_digest":"38ce20c1d4bc02969671edfe6f3464b78a54a6ba9b089ddad424c5583748a6e8","output_digest":"1955a17bb45ecc94b754b450cee352c2fe72595a1b05b703f93fd2d8acde73ba","started_at":1792234271.6025403},"kind":"tool","observed_at":1792234271.6093132,"path":"tool:grep_files","phase":"minimal_call","prev_digest":"725a232bd125611cfcbab7e6c0702359bedfeef5cf4215cbd4b9cab5befcbb7a","receipt_id":"LP-1792234271-aadffe6a","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"4e7426470340a5eaacc4f26bdec0799758778fb2c69e7830aff9c423220565fa","evidence":{"detail":"injected fault observed failing and classified: Access denied: /etc/__live_proof_probe__","ended_at":1792234271.6094868,"error_class":"PERMISSION","injected_fault":"grep a denied (blocked) directory","input_digest":"c65c78d2d1158e068826d995cf869a01093c6595829ef41bd2b4802ade1c0ef2","output_digest":"e2c0b1072fac866e0ec2ea1177d20dee5a2a89439b2307e06cae94d31ea6c59b","started_at":1792234271.609315},"kind":"tool","observed_at":1792234271.6095002,"path":"tool:grep_files","phase":"failure_injection","prev_digest":"d4579a36a0043c200661f235d2f5562ce9c1142d091d4fef7e708948f3e39e75","receipt_id":"LP-1792234271-b3ea1b58","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"e043fb2c4fe25f6f1be293c3af0cc419fc09ff0823a93fe3b4bb0c2b3ea29a14","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.6120403,"error_class":null,"input_digest":"364577c4d7e3583ff668e6ab3d5c7c327ccdad96e32b554b6701e3ff16665bb4","output_digest":"492c4575f234f3b56c2e0b3271eb87dfccf7fae373e64af1c20753f9bd40ce11","started_at":1792234271.6095011},"kind":"tool","observed_at":1792234271.6121018,"path":"tool:grep_files","phase":"recovery","prev_digest":"4e7426470340a5eaacc4f26bdec0799758778fb2c69e7830aff9c423220565fa","receipt_id":"LP-1792234271-14b06674","recovery_of":"LP-1792234271-b3ea1b58","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"8be94b51c2df782f24645930b8dfbb35585560a2da00bdd175900456a7842581","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233217.947737,"error_class":null,"injected_fault":"nonexistent path","input_digest":"25ba8e3e86e54b7b999f22e50ae9aff41264c8bacefdf7c76132c9e3f5961233","output_digest":"12ce9c293d4b3616c57584df85827ffacb72e660f76329c9ca01b4fa1367ac13","started_at":1792233217.947708},"kind":"tool","observed_at":1792233217.9477437,"path":"tool:lint_file","phase":"failure_injection","prev_digest":"4802525f3c9276621b2a362eb5264cb28c5d48b966dd085534e992f4d4dc5730","receipt_id":"LP-1792233217-9a26297d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"08c9558952fc2be0ab5cd37939d31b3b0d90370ed2d184c0f0891715d29925a5","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.947783,"error_class":null,"input_digest":"bbb6def7000c7b95ae376d280dee9b494d20d8454507e06fe1ee032a0a4b043c","output_digest":"0759c6c15d35bd61e08ac0a7d39b1b6ec3a73f97833c9df5a3719b77d99e2724","started_at":1792233217.9477446},"kind":"tool","observed_at":1792233217.9477885,"path":"tool:lint_file","phase":"recovery","prev_digest":"8be94b51c2df782f24645930b8dfbb35585560a2da00bdd175900456a7842581","receipt_id":"LP-1792233217-c32a6139","recovery_of":"LP-1792233217-9a26297d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"dc06417da9ea0c3d55014d9989deaf698a6bec8a4907db23ee7fae781137d38f","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6153092,"error_class":null,"input_digest":"2a7a6a240931ee72ca2019216925dacd7aba19b13999a3fb7ceb236d7a0288a7","output_digest":"9ac538a32cfeadb31fccf607fac77e1f8a64b2053a6083c94cabc4a7c835c8f0","started_at":1792234271.6153085},"kind":"tool","observed_at":1792234271.6153266,"path":"tool:lint_file","phase":"auth_check","prev_digest":"08c9558952fc2be0ab5cd37939d31b3b0d90370ed2d184c0f0891715d29925a5","receipt_id":"LP-1792234271-e0ababcd","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"4a1669efd3d9eaf14c8b2f6d4646348e9324f86b620eb3c319b2c72fecba0680","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.6154346,"error_class":null,"injected_fault":"nonexistent path","input_digest":"25ba8e3e86e54b7b999f22e50ae9aff41264c8bacefdf7c76132c9e3f5961233","output_digest":"12ce9c293d4b3616c57584df85827ffacb72e660f76329c9ca01b4fa1367ac13","started_at":1792234271.6154084},"kind":"tool","observed_at":1792234271.6154406,"path":"tool:lint_file","phase":"failure_injection","prev_digest":"6ffed698068fa5738f6c1139fc8f6cd34853783d0b540791a40d1af4ae34c128","receipt_id":"LP-1792234271-af2ad360","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"eaf5b688c55ab6d59f12cc00815172119c26cbd5ea6718908c94c36a6361aa5d","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.6154745,"error_class":null,"input_digest":"bbb6def7000c7b95ae376d280dee9b494d20d8454507e06fe1ee032a0a4b043c","output_digest":"0759c6c15d35bd61e08ac0a7d39b1b6ec3a73f97833c9df5a3719b77d99e2724","started_at":1792234271.6154413},"kind":"tool","observed_at":1792234271.6154797,"path":"tool:lint_file","phase":"recovery","prev_digest":"4a1669efd3d9eaf14c8b2f6d4646348e9324f86b620eb3c319b2c72fecba0680","receipt_id":"LP-1792234271-81f9c76e","recovery_of":"LP-1792234271-af2ad360","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"d9497847d182ef807a08f07cb77f9d42a944078a6508ba17c31bf5b5d02325fd","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233217.945382,"error_class":null,"input_digest":"6b43b15af0cf7752e9d7b09cdfda13394b3924e0de444c974d41f231c5f87949","output_digest":"5d0063be61f65f0be8a3c826ceac4e098df8ec4073548014daf44f35f51db240","started_at":1792233217.9453716},"kind":"tool","observed_at":1792233217.9453971,"path":"tool:list_directory","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-526a0323","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"814476b9aa9484cb454b0462759e3562d39b249d3dfa3e94f72ec1f83c40a637","evidence":{"detail":"list the sandbox dir","ended_at":1792233217.9459317,"error_class":null,"input_digest":"069c96bebeda6a94a8450734520baed25f361ac03be840a618c92cdccbf98fb1","output_digest":"37723842890f20e43139e729d4cb590dc9ab669def037f0b6a47ff5be6cf91d7","started_at":1792233217.945398},"kind":"tool","observed_at":1792233217.9459438,"path":"tool:list_directory","phase":"minimal_call","prev_digest":"d9497847d182ef807a08f07cb77f9d42a944078a6508ba17c31bf5b5d02325fd","receipt_id":"LP-1792233217-f2cd7745","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"287c86755f51c12031f996764833c910751be53d4aaf5c0891431ed5b44bef59","evidence":{"detail":"injected fault observed failing and classified: Not a directory: /mnt/workdrive/rune/src/rune/../../store/live_proof/sandbox/__nonexistent_live_probe__","ended_at":1792233217.946346,"error_class":"TOOL_ERROR","injected_fault":"list a nonexistent directory","input_digest":"d2acd6694e44cd5249e24056e61bff8f34e21df7da36ba9e5db167a0ef30a738","output_digest":"9a6c6b202fbe01d68c18c6337da46b208027b22685a18f0cc19bba9955346459","started_at":1792233217.9459445},"kind":"tool","observed_at":1792233217.9463575,"path":"tool:list_directory","phase":"failure_injection","prev_digest":"814476b9aa9484cb454b0462759e3562d39b249d3dfa3e94f72ec1f83c40a637","receipt_id":"LP-1792233217-19ef3a90","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"42ca5d5d7c1c3b39a43a2d09446974c20b9ab270fbacb2afdf89baed672c8979","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.946841,"error_class":null,"input_digest":"510530798b535e832107ea806313e310d006b2cf4cd15a6a1dd8b9a867f429b5","output_digest":"fda58a44dfacac350af8b90e4aba3762ab2762b218e12d6c674fa918841b89f9","started_at":1792233217.9463582},"kind":"tool","observed_at":1792233217.9468517,"path":"tool:list_directory","phase":"recovery","prev_digest":"287c86755f51c12031f996764833c910751be53d4aaf5c0891431ed5b44bef59","receipt_id":"LP-1792233217-ad76728f","recovery_of":"LP-1792233217-19ef3a90","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"178061e34dbc7a820ba66b79872cc326388c9a9fc2ac117cf212705111a6dde1","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6131546,"error_class":null,"input_digest":"6b43b15af0cf7752e9d7b09cdfda13394b3924e0de444c974d41f231c5f87949","output_digest":"5d0063be61f65f0be8a3c826ceac4e098df8ec4073548014daf44f35f51db240","started_at":1792234271.6131535},"kind":"tool","observed_at":1792234271.6131732,"path":"tool:list_directory","phase":"auth_check","prev_digest":"42ca5d5d7c1c3b39a43a2d09446974c20b9ab270fbacb2afdf89baed672c8979","receipt_id":"LP-1792234271-8361335e","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"acf1b8110dd09b77a0d9a26acf42aaa6f5bc741f91bb74c727d5d8aec3591571","evidence":{"detail":"list the sandbox dir","ended_at":1792234271.6137004,"error_class":null,"input_digest":"069c96bebeda6a94a8450734520baed25f361ac03be840a618c92cdccbf98fb1","output_digest":"37723842890f20e43139e729d4cb590dc9ab669def037f0b6a47ff5be6cf91d7","started_at":1792234271.613174},"kind":"tool","observed_at":1792234271.613712,"path":"tool:list_directory","phase":"minimal_call","prev_digest":"178061e34dbc7a820ba66b79872cc326388c9a9fc2ac117cf212705111a6dde1","receipt_id":"LP-1792234271-88b46077","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"54eb3e43620219f316cf9fb4c0c90215bfb1a094822fcc65bc722c8cab1d7a03","evidence":{"detail":"injected fault observed failing and classified: Not a directory: /mnt/workdrive/rune/src/rune/../../store/live_proof/sandbox/__nonexistent_live_probe__","ended_at":1792234271.613998,"error_class":"TOOL_ERROR","injected_fault":"list a nonexistent directory","input_digest":"d2acd6694e44cd5249e24056e61bff8f34e21df7da36ba9e5db167a0ef30a738","output_digest":"9a6c6b202fbe01d68c18c6337da46b208027b22685a18f0cc19bba9955346459","started_at":1792234271.6137133},"kind":"tool","observed_at":1792234271.6140075,"path":"tool:list_directory","phase":"failure_injection","prev_digest":"acf1b8110dd09b77a0d9a26acf42aaa6f5bc741f91bb74c727d5d8aec3591571","receipt_id":"LP-1792234271-1eda394f","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"6b0642dd345c7c6ca3b0a50537e2cc384ea935caed9a2894539bd52bcf02cc66","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.614471,"error_class":null,"input_digest":"510530798b535e832107ea806313e310d006b2cf4cd15a6a1dd8b9a867f429b5","output_digest":"fda58a44dfacac350af8b90e4aba3762ab2762b218e12d6c674fa918841b89f9","started_at":1792234271.6140084},"kind":"tool","observed_at":1792234271.6144807,"path":"tool:list_directory","phase":"recovery","prev_digest":"54eb3e43620219f316cf9fb4c0c90215bfb1a094822fcc65bc722c8cab1d7a03","receipt_id":"LP-1792234271-f869ded9","recovery_of":"LP-1792234271-1eda394f","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"e1546212062113737150a2d8e8852511045035c7bb990765d00b11cbb29ba661","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233218.1561284,"error_class":null,"input_digest":"7184223d0e85584065aa1e316ae04503b7227a78a56625b0de7ceacb33513640","output_digest":"8e81da77c496577d7ed96e801feae19296d1c383fa83001c1bbef0215b174bfa","started_at":1792233218.1561275},"kind":"tool","observed_at":1792233218.1561394,"path":"tool:query_memory","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233218-5ec1cdcd","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"3058f116ebf9f8d0d03af4d0307463879b8d551dd61906c1d54201a294d948ed","evidence":{"detail":"query memory with a one-word probe","ended_at":1792233218.1939867,"error_class":null,"input_digest":"dba8f2f072b60651103cddc3c6b9b13ce984d482fc5f91f2b6016878ccd76ca2","output_digest":"433f4446dd6c9b8f3acba08497aa2ae5ed77e13c75a7e27b075f011f88cd49fe","started_at":1792233218.1561399},"kind":"tool","observed_at":1792233218.1940286,"path":"tool:query_memory","phase":"minimal_call","prev_digest":"e1546212062113737150a2d8e8852511045035c7bb990765d00b11cbb29ba661","receipt_id":"LP-1792233218-2cf0bbce","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"7bc2aea79d09ccac5ba9164352a83da6d2e3552a6216333bbaec291af0cd3a87","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233218.9414935,"error_class":null,"injected_fault":"query with a malformed memory id","input_digest":"0abab62acdd7e5a1fa6ed4ee65f14d4dab244cd03b4b785e4bc37beea2b4e1f8","output_digest":"1ab58f149ee2d6fc8db4383bf560006c78a079e87f6f4cbd1b9b7bac23349eba","started_at":1792233218.1940296},"kind":"tool","observed_at":1792233218.9415393,"path":"tool:query_memory","phase":"failure_injection","prev_digest":"3058f116ebf9f8d0d03af4d0307463879b8d551dd61906c1d54201a294d948ed","receipt_id":"LP-1792233218-39063f62","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"024de5cc2f0059119d414e1b3de95f4c5c3d06ed25fdc49471dbb455d2296ccd","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.9697337,"error_class":null,"input_digest":"f5bb307b8741b29f2a147f7687528e86b5c8b1c68b4ab90edcb89f8c93791378","output_digest":"89cc3d6753f1bafe5a328c418b68a09234124112404eda5b7038f26585e5c918","started_at":1792233218.9415414},"kind":"tool","observed_at":1792233218.96978,"path":"tool:query_memory","phase":"recovery","prev_digest":"7bc2aea79d09ccac5ba9164352a83da6d2e3552a6216333bbaec291af0cd3a87","receipt_id":"LP-1792233218-8c887c60","recovery_of":"LP-1792233218-39063f62","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"09074137a383f23c11060a8319275f3741008f656dd1ec7728577da4298aa8a2","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.9486344,"error_class":null,"input_digest":"7184223d0e85584065aa1e316ae04503b7227a78a56625b0de7ceacb33513640","output_digest":"8e81da77c496577d7ed96e801feae19296d1c383fa83001c1bbef0215b174bfa","started_at":1792234271.9486327},"kind":"tool","observed_at":1792234271.948659,"path":"tool:query_memory","phase":"auth_check","prev_digest":"024de5cc2f0059119d414e1b3de95f4c5c3d06ed25fdc49471dbb455d2296ccd","receipt_id":"LP-1792234271-45f51270","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"f231135825e9b7d26511b6fa42fe4f87b9389cc7cfe88bb1cf3082530633b692","evidence":{"detail":"query memory with a one-word probe","ended_at":1792234271.9836683,"error_class":null,"input_digest":"dba8f2f072b60651103cddc3c6b9b13ce984d482fc5f91f2b6016878ccd76ca2","output_digest":"433f4446dd6c9b8f3acba08497aa2ae5ed77e13c75a7e27b075f011f88cd49fe","started_at":1792234271.94866},"kind":"tool","observed_at":1792234271.9837193,"path":"tool:query_memory","phase":"minimal_call","prev_digest":"09074137a383f23c11060a8319275f3741008f656dd1ec7728577da4298aa8a2","receipt_id":"LP-1792234271-aea4fa54","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"e88035d996ccc7f505c5e973081d87bc9029775a338758b57f4ec8bf0e55f470","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234272.8042405,"error_class":null,"injected_fault":"query with a malformed memory id","input_digest":"0abab62acdd7e5a1fa6ed4ee65f14d4dab244cd03b4b785e4bc37beea2b4e1f8","output_digest":"1ab58f149ee2d6fc8db4383bf560006c78a079e87f6f4cbd1b9b7bac23349eba","started_at":1792234271.983721},"kind":"tool","observed_at":1792234272.804284,"path":"tool:query_memory","phase":"failure_injection","prev_digest":"f231135825e9b7d26511b6fa42fe4f87b9389cc7cfe88bb1cf3082530633b692","receipt_id":"LP-1792234272-dbe5cc7e","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"a5186c7bb3d92bc00eef5defc97e0c15a532a417f2867383ad2079c05c302c7a","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234272.8316886,"error_class":null,"input_digest":"f5bb307b8741b29f2a147f7687528e86b5c8b1c68b4ab90edcb89f8c93791378","output_digest":"89cc3d6753f1bafe5a328c418b68a09234124112404eda5b7038f26585e5c918","started_at":1792234272.8042862},"kind":"tool","observed_at":1792234272.831737,"path":"tool:query_memory","phase":"recovery","prev_digest":"e88035d996ccc7f505c5e973081d87bc9029775a338758b57f4ec8bf0e55f470","receipt_id":"LP-1792234272-4c6c08a4","recovery_of":"LP-1792234272-dbe5cc7e","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"5d2a31a0fdc40a369767cd241ac85b65562a894ae19f58d473b815674a595186","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233217.9234314,"error_class":null,"input_digest":"3188fbe61785a2f896568b7efe73f3444a8db2041772fae33cc9be5b613b212d","output_digest":"4696f13fd53c94d5147e2ecfd127d3b747a4f66d832c465e97eb1daa55b5ade2","started_at":1792233217.9234238},"kind":"tool","observed_at":1792233217.9235158,"path":"tool:read_file","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-ddcfbfa3","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"043140ce10309c928e2d2454c4edf1bc2a26ce1effa7803e582a84c672590348","evidence":{"detail":"read a one-line sandbox file","ended_at":1792233217.9241977,"error_class":null,"input_digest":"4db66f81ba9f66805811353291d68eb7e9b49ac52080ee4f2911da97e34ff822","output_digest":"38a33175fcad1ad10820c264fdcd398795173a1d8ca9bce7cdf5d6ac42bc19fc","started_at":1792233217.923518},"kind":"tool","observed_at":1792233217.9242291,"path":"tool:read_file","phase":"minimal_call","prev_digest":"5d2a31a0fdc40a369767cd241ac85b65562a894ae19f58d473b815674a595186","receipt_id":"LP-1792233217-1e5aa0c2","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"fa601aac0481024ccc835c20be366c3d880edee5220c70e0c627ba4bb0bfe2b2","evidence":{"detail":"injected fault observed failing and classified: Not found: /mnt/workdrive/rune/src/rune/../../store/live_proof/sandbox/__nonexistent_live_probe__","ended_at":1792233217.924617,"error_class":"ENOENT","injected_fault":"read a nonexistent path","input_digest":"f57b736271e86fa2ba87134bc3d1fe285bdc4e8c9ea3433b7b5d66aca532190b","output_digest":"dac1b171dad67eefb479bcaae54c15be34484711044bafb645d4e6d735de94fd","started_at":1792233217.924231},"kind":"tool","observed_at":1792233217.924639,"path":"tool:read_file","phase":"failure_injection","prev_digest":"043140ce10309c928e2d2454c4edf1bc2a26ce1effa7803e582a84c672590348","receipt_id":"LP-1792233217-1122adad","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"fa3c1d0ad516651d8bf87326d0ac899b3dd5273ea0629d7347f2a785fc03b72b","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.9250536,"error_class":null,"input_digest":"a846ca5a3235abce5db143b6194fe7f4e3516ff944913e3baff2d3cb4afe0c0c","output_digest":"226cee6011cf22d0539ef2898e20d0996473d0286e743a2261f69421241086e0","started_at":1792233217.9246402},"kind":"tool","observed_at":1792233217.9250731,"path":"tool:read_file","phase":"recovery","prev_digest":"fa601aac0481024ccc835c20be366c3d880edee5220c70e0c627ba4bb0bfe2b2","receipt_id":"LP-1792233217-0472d94c","recovery_of":"LP-1792233217-1122adad","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"34dd25b559e0f7bf4d15d00890732fb82c21accad42fc1cfd7f70f8e547405ee","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.5884204,"error_class":null,"input_digest":"3188fbe61785a2f896568b7efe73f3444a8db2041772fae33cc9be5b613b212d","output_digest":"4696f13fd53c94d5147e2ecfd127d3b747a4f66d832c465e97eb1daa55b5ade2","started_at":1792234271.5884168},"kind":"tool","observed_at":1792234271.5884645,"path":"tool:read_file","phase":"auth_check","prev_digest":"fa3c1d0ad516651d8bf87326d0ac899b3dd5273ea0629d7347f2a785fc03b72b","receipt_id":"LP-1792234271-d18c0c2e","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"ec7e32b8f1f24f37dd50358f36afc4008505cd7ae3e5e730807ca5e77f6ad114","evidence":{"detail":"read a one-line sandbox file","ended_at":1792234271.5888975,"error_class":null,"input_digest":"4db66f81ba9f66805811353291d68eb7e9b49ac52080ee4f2911da97e34ff822","output_digest":"38a33175fcad1ad10820c264fdcd398795173a1d8ca9bce7cdf5d6ac42bc19fc","started_at":1792234271.5884662},"kind":"tool","observed_at":1792234271.5889146,"path":"tool:read_file","phase":"minimal_call","prev_digest":"34dd25b559e0f7bf4d15d00890732fb82c21accad42fc1cfd7f70f8e547405ee","receipt_id":"LP-1792234271-6b614f33","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"469b342f48685df796c4137983287765d353f08e396e86eb66cd7ea15cc1fd91","evidence":{"detail":"injected fault observed failing and classified: Not found: /mnt/workdrive/rune/src/rune/../../store/live_proof/sandbox/__nonexistent_live_probe__","ended_at":1792234271.5892375,"error_class":"ENOENT","injected_fault":"read a nonexistent path","input_digest":"f57b736271e86fa2ba87134bc3d1fe285bdc4e8c9ea3433b7b5d66aca532190b","output_digest":"dac1b171dad67eefb479bcaae54c15be34484711044bafb645d4e6d735de94fd","started_at":1792234271.5889158},"kind":"tool","observed_at":1792234271.589255,"path":"tool:read_file","phase":"failure_injection","prev_digest":"ec7e32b8f1f24f37dd50358f36afc4008505cd7ae3e5e730807ca5e77f6ad114","receipt_id":"LP-1792234271-4f8611af","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"934fcf6d1aec1798e1a6056c732f12532f713e80065ff9fb03ec65a675fa7fbd","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.5896084,"error_class":null,"input_digest":"a846ca5a3235abce5db143b6194fe7f4e3516ff944913e3baff2d3cb4afe0c0c","output_digest":"226cee6011cf22d0539ef2898e20d0996473d0286e743a2261f69421241086e0","started_at":1792234271.589257},"kind":"tool","observed_at":1792234271.589622,"path":"tool:read_file","phase":"recovery","prev_digest":"469b342f48685df796c4137983287765d353f08e396e86eb66cd7ea15cc1fd91","receipt_id":"LP-1792234271-5d313ee4","recovery_of":"LP-1792234271-4f8611af","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"af62001cbd78dbdead0c45c494dc4b41abbdd25f58269840eff9f461cdbfeb92","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233218.1550496,"error_class":null,"input_digest":"063e2e0777ec5122374f5a665a0eb89601044d75481bf080c15528f2a03d31ff","output_digest":"cb23a951feb41b1f5f7b2a4ee5787515cff14225aebada207840410b28b9d89a","started_at":1792233218.1550484},"kind":"tool","observed_at":1792233218.155064,"path":"tool:read_persona","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233218-e7251b1d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"791b65eb10cfa1715e35f207d647c7bd5b3b26f5aa5c65ab2106855da75b277f","evidence":{"detail":"minimal call failed: Persona block not found in MEMORY.md","ended_at":1792233218.1552446,"error_class":"TOOL_ERROR","input_digest":"29b57b3ba9cb4bc9534b16e7502e076401070bcf5f46d4f2996f1a3f58544a22","output_digest":"bfc3d287e7db7de512d16e29c879ee3c06336db47b387d214906bff469deb3a7","started_at":1792233218.1550646},"kind":"tool","observed_at":1792233218.1552546,"path":"tool:read_persona","phase":"minimal_call","prev_digest":"af62001cbd78dbdead0c45c494dc4b41abbdd25f58269840eff9f461cdbfeb92","receipt_id":"LP-1792233218-2fb88146","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_fail"}
{"digest":"c3270bb06ff00054a0638e722bff10e7d0146aa07d29ad6b47c54ce433b529a1","evidence":{"detail":"injected fault observed failing and classified: Persona block not found in MEMORY.md","ended_at":1792233218.1553478,"error_class":"ENOENT","injected_fault":"read with a poisoned persona id","input_digest":"320c851fa76bd033c2762d99997e960c473d847102861b0607fe20dcedb4a4cf","output_digest":"04a15611da0c41d536ad2f60cec590b47cefde420c57ef5a0b1320b456259f07","started_at":1792233218.155255},"kind":"tool","observed_at":1792233218.1553597,"path":"tool:read_persona","phase":"failure_injection","prev_digest":"791b65eb10cfa1715e35f207d647c7bd5b3b26f5aa5c65ab2106855da75b277f","receipt_id":"LP-1792233218-58d29ebd","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"b7c3d02a1aafe144b876fa713529b540dc06399f44fa60fdedefb3f38336f656","evidence":{"detail":"recovery call failed: Persona block not found in MEMORY.md","ended_at":1792233218.1554778,"error_class":"TOOL_ERROR","input_digest":"b32802c62eebca15317113d7e4455508c074d6b39ca1220681f186cc85ba0e92","output_digest":"5af50857ea4c4a151574c3f98294fcf212543c665505234ad639ee6db240e0e5","started_at":1792233218.1553605},"kind":"tool","observed_at":1792233218.1554883,"path":"tool:read_persona","phase":"recovery","prev_digest":"c3270bb06ff00054a0638e722bff10e7d0146aa07d29ad6b47c54ce433b529a1","receipt_id":"LP-1792233218-2cbaff76","recovery_of":"LP-1792233218-58d29ebd","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_fail"}
{"digest":"52676b47b7b64b7eafeb1ab21acd7b786675b8ee3f0466d27c30bdb9c1216676","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.947291,"error_class":null,"input_digest":"063e2e0777ec5122374f5a665a0eb89601044d75481bf080c15528f2a03d31ff","output_digest":"cb23a951feb41b1f5f7b2a4ee5787515cff14225aebada207840410b28b9d89a","started_at":1792234271.9472888},"kind":"tool","observed_at":1792234271.9473097,"path":"tool:read_persona","phase":"auth_check","prev_digest":"b7c3d02a1aafe144b876fa713529b540dc06399f44fa60fdedefb3f38336f656","receipt_id":"LP-1792234271-92ff456d","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"ec59b876a8744730382f969091ac6476b352c6ca13f3f3b4fb61d948dc049a48","evidence":{"detail":"minimal call failed: Persona block not found in MEMORY.md","ended_at":1792234271.947483,"error_class":"TOOL_ERROR","input_digest":"29b57b3ba9cb4bc9534b16e7502e076401070bcf5f46d4f2996f1a3f58544a22","output_digest":"bfc3d287e7db7de512d16e29c879ee3c06336db47b387d214906bff469deb3a7","started_at":1792234271.9473107},"kind":"tool","observed_at":1792234271.9474926,"path":"tool:read_persona","phase":"minimal_call","prev_digest":"52676b47b7b64b7eafeb1ab21acd7b786675b8ee3f0466d27c30bdb9c1216676","receipt_id":"LP-1792234271-5f7c6e26","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_fail"}
{"digest":"789e81a4b786da6e8796540641546c89f4d4d5e0749816e02a9856a3c8de11cd","evidence":{"detail":"injected fault observed failing and classified: Persona block not found in MEMORY.md","ended_at":1792234271.9475667,"error_class":"ENOENT","injected_fault":"read with a poisoned persona id","input_digest":"320c851fa76bd033c2762d99997e960c473d847102861b0607fe20dcedb4a4cf","output_digest":"04a15611da0c41d536ad2f60cec590b47cefde420c57ef5a0b1320b456259f07","started_at":1792234271.9474933},"kind":"tool","observed_at":1792234271.947576,"path":"tool:read_persona","phase":"failure_injection","prev_digest":"ec59b876a8744730382f969091ac6476b352c6ca13f3f3b4fb61d948dc049a48","receipt_id":"LP-1792234271-0c70b7f4","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"d30dd719ff7ebec8e501b97b1b92e3ef4561ec6b5b0d1da1ad1d9c8600129816","evidence":{"detail":"recovery call failed: Persona block not found in MEMORY.md","ended_at":1792234271.9476554,"error_class":"TOOL_ERROR","input_digest":"b32802c62eebca15317113d7e4455508c074d6b39ca1220681f186cc85ba0e92","output_digest":"5af50857ea4c4a151574c3f98294fcf212543c665505234ad639ee6db240e0e5","started_at":1792234271.9475768},"kind":"tool","observed_at":1792234271.9476628,"path":"tool:read_persona","phase":"recovery","prev_digest":"789e81a4b786da6e8796540641546c89f4d4d5e0749816e02a9856a3c8de11cd","receipt_id":"LP-1792234271-f4722ff8","recovery_of":"LP-1792234271-0c70b7f4","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_fail"}
{"digest":"26d6082067f78673af235c477e165e7428c1abaed6c724aa9acb75dcf56bfdf1","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792233218.1275475,"error_class":null,"input_digest":"0790f22dd0ebca93ab4c0630d71f709a8b96b8983cf46dcf2c756f261ad78766","output_digest":"a956aeb43b63c3181cab7b355029b25504be21b35790393d1254b3a22211aaec","started_at":1792233218.1275463},"kind":"tool","observed_at":1792233218.1275628,"path":"tool:repo_map","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233218-35ab6f26","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"57cb11cfbbc2c006dcaef2f5f2f1fdb568bb455058350053a805a1b5b7decc82","evidence":{"detail":"repo map over the sandbox dir","ended_at":1792233218.1394017,"error_class":null,"input_digest":"9782f79dae45c6429d29752ae557543830346f589ab017d7268f2e2137784fba","output_digest":"4b122ae6968f0a5738b15bd60c0e528f68507c08f94bdc9936c67cc25f3d9be6","started_at":1792233218.1275637},"kind":"tool","observed_at":1792233218.13945,"path":"tool:repo_map","phase":"minimal_call","prev_digest":"26d6082067f78673af235c477e165e7428c1abaed6c724aa9acb75dcf56bfdf1","receipt_id":"LP-1792233218-e1dd9f1d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"0a65dce068fc4d401e8da2d188e78527e630f8528f5d9214732a1586b44569ce","evidence":{"detail":"injected fault observed failing and classified: Access denied: /etc/__live_proof_probe__","ended_at":1792233218.1397295,"error_class":"PERMISSION","injected_fault":"map a denied (blocked) path","input_digest":"da7f98628de3675f20fa30e701640d560b051636b779ab363ec14b605d9eaa2d","output_digest":"2a693e44c88ccbf8c06d8ae95445f3b47e76165a8880d77fc29c817ba88ad4e0","started_at":1792233218.1394515},"kind":"tool","observed_at":1792233218.139758,"path":"tool:repo_map","phase":"failure_injection","prev_digest":"57cb11cfbbc2c006dcaef2f5f2f1fdb568bb455058350053a805a1b5b7decc82","receipt_id":"LP-1792233218-1ef149da","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"0adbb9e06ad052a740f8c9c888590f7627f5e9500c67d2570f0ddee5d5e81af5","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.1519997,"error_class":null,"input_digest":"643bf7bee5ea37f7913c9e00b0586dad9b347b11bda8ae5fc956d8352a2d66d9","output_digest":"0d608c628fa58c58d9ffafe6fdb3563d852191b07d0d7f8549747bfdc8328cf2","started_at":1792233218.139759},"kind":"tool","observed_at":1792233218.152042,"path":"tool:repo_map","phase":"recovery","prev_digest":"0a65dce068fc4d401e8da2d188e78527e630f8528f5d9214732a1586b44569ce","receipt_id":"LP-1792233218-8d68fd76","recovery_of":"LP-1792233218-1ef149da","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"f988d74fddfc00914cb1cd0aa4baaffe6b4dbb00f1f259f2a3556ed43ecd38d0","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.916472,"error_class":null,"input_digest":"0790f22dd0ebca93ab4c0630d71f709a8b96b8983cf46dcf2c756f261ad78766","output_digest":"a956aeb43b63c3181cab7b355029b25504be21b35790393d1254b3a22211aaec","started_at":1792234271.9164703},"kind":"tool","observed_at":1792234271.916494,"path":"tool:repo_map","phase":"auth_check","prev_digest":"0adbb9e06ad052a740f8c9c888590f7627f5e9500c67d2570f0ddee5d5e81af5","receipt_id":"LP-1792234271-0ed6a366","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"a967246c3250c7c21a2fa132d0c2302d18900e91efe62f48cdae0b7e22703276","evidence":{"detail":"repo map over the sandbox dir","ended_at":1792234271.9286356,"error_class":null,"input_digest":"9782f79dae45c6429d29752ae557543830346f589ab017d7268f2e2137784fba","output_digest":"4b122ae6968f0a5738b15bd60c0e528f68507c08f94bdc9936c67cc25f3d9be6","started_at":1792234271.9164946},"kind":"tool","observed_at":1792234271.9286685,"path":"tool:repo_map","phase":"minimal_call","prev_digest":"f988d74fddfc00914cb1cd0aa4baaffe6b4dbb00f1f259f2a3556ed43ecd38d0","receipt_id":"LP-1792234271-871ed83d","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"04115700625c1803b008dbdc516e880b09bbea0f8dab97991c45861269b9d59d","evidence":{"detail":"injected fault observed failing and classified: Access denied: /etc/__live_proof_probe__","ended_at":1792234271.9288743,"error_class":"PERMISSION","injected_fault":"map a denied (blocked) path","input_digest":"da7f98628de3675f20fa30e701640d560b051636b779ab363ec14b605d9eaa2d","output_digest":"2a693e44c88ccbf8c06d8ae95445f3b47e76165a8880d77fc29c817ba88ad4e0","started_at":1792234271.9286697},"kind":"tool","observed_at":1792234271.9288864,"path":"tool:repo_map","phase":"failure_injection","prev_digest":"a967246c3250c7c21a2fa132d0c2302d18900e91efe62f48cdae0b7e22703276","receipt_id":"LP-1792234271-f4ec6daf","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"07334b7a23e20759ee483d72d463e9ecc115f3d78b6df2b9b2750fbff2061e2a","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.9392335,"error_class":null,"input_digest":"643bf7bee5ea37f7913c9e00b0586dad9b347b11bda8ae5fc956d8352a2d66d9","output_digest":"0d608c628fa58c58d9ffafe6fdb3563d852191b07d0d7f8549747bfdc8328cf2","started_at":1792234271.9288874},"kind":"tool","observed_at":1792234271.939266,"path":"tool:repo_map","phase":"recovery","prev_digest":"04115700625c1803b008dbdc516e880b09bbea0f8dab97991c45861269b9d59d","receipt_id":"LP-1792234271-04134317","recovery_of":"LP-1792234271-f4ec6daf","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"2debd2be91de4fb8f60ccf35d198ac04d5bcfeb8c4996cedde46b2e82031537c","evidence":{"detail":"run 'true' in the sandbox","ended_at":1792233218.154187,"error_class":null,"input_digest":"1ffa77546d1f6a6536cf4c4522f467457980bfc5715ab515b3700ec46a5371b1","output_digest":"465a4ff846b0a5e119a24b345ddb2e4ff2252074fbeea6c90980f38d54f24999","started_at":1792233218.154105},"kind":"tool","observed_at":1792233218.1541965,"path":"tool:run_command","phase":"minimal_call","prev_digest":"366b191bbb9012a3f75e61df158542e74fa9857a447760140a9cbeba5ae65d50","receipt_id":"LP-1792233218-124349ac","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"7b07c348481bab6e2dd288025f9c82c130b0f7ff01e4a96a3a99e4ae22c08c02","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233218.1542382,"error_class":null,"injected_fault":"run a command that cannot exist","input_digest":"2544c53dc35795034c22bd7a85354d66811e4f13d114754a6bf289298af409e2","output_digest":"cfe82ec11b5df99c24a72c1052f35e87c2dd8e22f62c3c4786a4044c1b6ee543","started_at":1792233218.154197},"kind":"tool","observed_at":1792233218.1542466,"path":"tool:run_command","phase":"failure_injection","prev_digest":"2debd2be91de4fb8f60ccf35d198ac04d5bcfeb8c4996cedde46b2e82031537c","receipt_id":"LP-1792233218-1e5d0fb0","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"a6e36897d6b34bf7b2a30bc89343bd874dc2f3a023031508f888aab7bf792113","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233218.1543016,"error_class":null,"input_digest":"83da34ae1e57418c63bf0e7576ce050d3545379af9e8abad5edc16d4d2ec9584","output_digest":"7a7a73ad197502e120fc0797ad7a08c64d93cca2f4ab7b14873f1f48dcd8ead5","started_at":1792233218.1542478},"kind":"tool","observed_at":1792233218.1543105,"path":"tool:run_command","phase":"recovery","prev_digest":"7b07c348481bab6e2dd288025f9c82c130b0f7ff01e4a96a3a99e4ae22c08c02","receipt_id":"LP-1792233218-65a22f4e","recovery_of":"LP-1792233218-1e5d0fb0","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"2c4769303e2aa75ebcf61e35596cfe1b9513233bdd27ee88760816f76f231b0e","evidence":{"detail":"run 'true' in the sandbox","ended_at":1792234271.9460104,"error_class":null,"input_digest":"1ffa77546d1f6a6536cf4c4522f467457980bfc5715ab515b3700ec46a5371b1","output_digest":"465a4ff846b0a5e119a24b345ddb2e4ff2252074fbeea6c90980f38d54f24999","started_at":1792234271.9459016},"kind":"tool","observed_at":1792234271.9460177,"path":"tool:run_command","phase":"minimal_call","prev_digest":"911f94ba9b0df859d07b341d1b78b76d8abe5845a879fa9b3b12daf796153c17","receipt_id":"LP-1792234271-8d1b2ed4","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"88e30f19ca966294831068c6db9b1beb51aa1046769cfe9b3224af3fb12c4cc5","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.9460506,"error_class":null,"injected_fault":"run a command that cannot exist","input_digest":"2544c53dc35795034c22bd7a85354d66811e4f13d114754a6bf289298af409e2","output_digest":"cfe82ec11b5df99c24a72c1052f35e87c2dd8e22f62c3c4786a4044c1b6ee543","started_at":1792234271.9460185},"kind":"tool","observed_at":1792234271.9460568,"path":"tool:run_command","phase":"failure_injection","prev_digest":"2c4769303e2aa75ebcf61e35596cfe1b9513233bdd27ee88760816f76f231b0e","receipt_id":"LP-1792234271-b8c8b641","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"ba1743459fe7b789db766c67e4403827e0246c8ca70979a3867cfa6313b6363b","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.9460995,"error_class":null,"input_digest":"83da34ae1e57418c63bf0e7576ce050d3545379af9e8abad5edc16d4d2ec9584","output_digest":"7a7a73ad197502e120fc0797ad7a08c64d93cca2f4ab7b14873f1f48dcd8ead5","started_at":1792234271.9460578},"kind":"tool","observed_at":1792234271.9461045,"path":"tool:run_command","phase":"recovery","prev_digest":"88e30f19ca966294831068c6db9b1beb51aa1046769cfe9b3224af3fb12c4cc5","receipt_id":"LP-1792234271-6a73bbc5","recovery_of":"LP-1792234271-b8c8b641","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"f8d9478a060c37aafcab156ca9f2824cfae46fae79fad0292dd04a9dcaf3b8ff","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792233217.9485211,"error_class":null,"injected_fault":"nonexistent path","input_digest":"ca6d6db9e9d29c7e583c2af686990d7fc2c80be0cceea54eb58f92fca48f0ff5","output_digest":"0763ca1de8fe2e9a3935ad5ae0178c877390d8da684d25b0cedb3505ebdb0763","started_at":1792233217.9484932},"kind":"tool","observed_at":1792233217.9485283,"path":"tool:run_tests","phase":"failure_injection","prev_digest":"f846d6d1ef4d93782c8cc1ba181a24cb03885bc997e617f392f811657cbc1bb7","receipt_id":"LP-1792233217-dfeb507d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_fail"}
{"digest":"a352e274dd321ccc2be4221b12a2bbcf451d3df7f77612afc889be24cb6dfdf7","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.948574,"error_class":null,"input_digest":"d7a369763d2def0be6bad748cb9522203f4886d454f04700e3d59044c00db31d","output_digest":"c27aabb83792dee21c4f793c1fe885585000e813011582daec5e1a9c2a0ecd68","started_at":1792233217.9485292},"kind":"tool","observed_at":1792233217.9485805,"path":"tool:run_tests","phase":"recovery","prev_digest":"f8d9478a060c37aafcab156ca9f2824cfae46fae79fad0292dd04a9dcaf3b8ff","receipt_id":"LP-1792233217-6cf9cab8","recovery_of":"LP-1792233217-dfeb507d","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"65d34ffc4ecff6aee19297c6f5598a7ea8efc7540c72dd0c904bcd44c79049dc","evidence":{"detail":"read-only boundary observed: no approval required","ended_at":1792234271.6162615,"error_class":null,"input_digest":"19d015afba2cbf1f7a51eaf490735460bd6a6c3ded7341b12ad3b94ede67c780","output_digest":"303abb215d3f40512244dbd0c3b665e28c750c46816b1c650ec262abae82e78b","started_at":1792234271.6162608},"kind":"tool","observed_at":1792234271.616277,"path":"tool:run_tests","phase":"auth_check","prev_digest":"a352e274dd321ccc2be4221b12a2bbcf451d3df7f77612afc889be24cb6dfdf7","receipt_id":"LP-1792234271-ded1602f","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"9cbf71ec9044f26587cef983b2bce9046e29d236107d371bd1b9ebf5d0bf255a","evidence":{"detail":"injected fault did NOT produce a failure","ended_at":1792234271.616351,"error_class":null,"injected_fault":"nonexistent path","input_digest":"ca6d6db9e9d29c7e583c2af686990d7fc2c80be0cceea54eb58f92fca48f0ff5","output_digest":"0763ca1de8fe2e9a3935ad5ae0178c877390d8da684d25b0cedb3505ebdb0763","started_at":1792234271.616329},"kind":"tool","observed_at":1792234271.6163566,"path":"tool:run_tests","phase":"failure_injection","prev_digest":"deb3e7cffc023331014a749817ef38a05cbdc7fbb5d136b7fb8a0c52ae9ff883","receipt_id":"LP-1792234271-0a3c79e1","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_fail"}
{"digest":"c891475f3a3446708ac467751b10776983efda4705106efc8c695666aeea0713","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.6164002,"error_class":null,"input_digest":"d7a369763d2def0be6bad748cb9522203f4886d454f04700e3d59044c00db31d","output_digest":"c27aabb83792dee21c4f793c1fe885585000e813011582daec5e1a9c2a0ecd68","started_at":1792234271.616357},"kind":"tool","observed_at":1792234271.616405,"path":"tool:run_tests","phase":"recovery","prev_digest":"9cbf71ec9044f26587cef983b2bce9046e29d236107d371bd1b9ebf5d0bf255a","receipt_id":"LP-1792234271-87133897","recovery_of":"LP-1792234271-0a3c79e1","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
{"digest":"5141998f46b6c0b0d25952d180c431b9c50c9a2dc36deb0e30b09cf9dbffe86c","evidence":{"detail":"approval gate observed: executed without confirmation boundary","ended_at":1792233217.9307585,"error_class":null,"input_digest":"3f768c19ec87d469161bbf767efec77c98005056ab25f77e2560c0597f784f95","output_digest":"6c1b4cc94145a09709cc16ed11b1f904fc56b41882afc9db2a4e12de68f0fb79","started_at":1792233217.9291263},"kind":"tool","observed_at":1792233217.9307735,"path":"tool:write_file","phase":"auth_check","prev_digest":null,"receipt_id":"LP-1792233217-0d73d2b3","run_id":"RUN-1792233217-0033a4","schema":1,"seq":0,"verdict":"observed_pass"}
{"digest":"8c48b38dd602a7a303efde8b86ea3df4f39467abaefff13daaa893d16071cb4a","evidence":{"detail":"write a one-line sandbox file","ended_at":1792233217.9319632,"error_class":null,"input_digest":"4dfc60346c1e233cf78d9a367091a1465624511f661a1462636cb3d8094ca7ba","output_digest":"ed8f668534dd0c78f43c2045d6fa734f92af7db5fd0eac48a8fd75969311185b","started_at":1792233217.9307745},"kind":"tool","observed_at":1792233217.9319773,"path":"tool:write_file","phase":"minimal_call","prev_digest":"5141998f46b6c0b0d25952d180c431b9c50c9a2dc36deb0e30b09cf9dbffe86c","receipt_id":"LP-1792233217-502c81ab","run_id":"RUN-1792233217-0033a4","schema":1,"seq":1,"verdict":"observed_pass"}
{"digest":"eba68d31e4b92828a6ec98ad2d99f5a1c3491fcc6af342a2b8f513d346fe82a5","evidence":{"detail":"injected fault observed failing and classified: Access denied: /proc/__live_proof_write_probe__ is in a protected directory (/proc). This directory is always blocked, e","ended_at":1792233217.9321306,"error_class":"PATH_DENIED","injected_fault":"write outside allowed write dirs","input_digest":"0b46e0702bc032687655f69c97ec430d70c83fc66940c56f100c1aa48c41a68d","output_digest":"326b4c20883bd51e34f78ad642c79b75055aeac2dd87c105889c076d4cccf9a4","started_at":1792233217.931978},"kind":"tool","observed_at":1792233217.932141,"path":"tool:write_file","phase":"failure_injection","prev_digest":"8c48b38dd602a7a303efde8b86ea3df4f39467abaefff13daaa893d16071cb4a","receipt_id":"LP-1792233217-380fa392","run_id":"RUN-1792233217-0033a4","schema":1,"seq":2,"verdict":"observed_pass"}
{"digest":"77745eff94f25e9dcaa6dde6d7659c9584b19034b47a3c3adde28a069a705165","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792233217.9330544,"error_class":null,"input_digest":"33b285bd6f9455702eb5f03029fd24a882ffe2bb51c76bb0959510fe00efd537","output_digest":"11096cc3886527e4a8c05d487c644125e02389b4f00a6313a24f1571ff16ce71","started_at":1792233217.9321415},"kind":"tool","observed_at":1792233217.9330647,"path":"tool:write_file","phase":"recovery","prev_digest":"eba68d31e4b92828a6ec98ad2d99f5a1c3491fcc6af342a2b8f513d346fe82a5","receipt_id":"LP-1792233217-977b2aeb","recovery_of":"LP-1792233217-380fa392","run_id":"RUN-1792233217-0033a4","schema":1,"seq":3,"verdict":"observed_pass"}
{"digest":"6466d4e589d526d86328500254d7f701620a8dca8c71d5facfa01a6291eb00a2","evidence":{"detail":"approval gate observed: executed without confirmation boundary","ended_at":1792234271.5982952,"error_class":null,"input_digest":"3f768c19ec87d469161bbf767efec77c98005056ab25f77e2560c0597f784f95","output_digest":"6c1b4cc94145a09709cc16ed11b1f904fc56b41882afc9db2a4e12de68f0fb79","started_at":1792234271.5974405},"kind":"tool","observed_at":1792234271.598307,"path":"tool:write_file","phase":"auth_check","prev_digest":"77745eff94f25e9dcaa6dde6d7659c9584b19034b47a3c3adde28a069a705165","receipt_id":"LP-1792234271-af5a8bcd","run_id":"RUN-1792234271-c44554","schema":1,"seq":4,"verdict":"observed_pass"}
{"digest":"21eeb19cda896df990b42900bcc37e0334cae248d52094d417764e8596e773b3","evidence":{"detail":"write a one-line sandbox file","ended_at":1792234271.5991473,"error_class":null,"input_digest":"4dfc60346c1e233cf78d9a367091a1465624511f661a1462636cb3d8094ca7ba","output_digest":"ed8f668534dd0c78f43c2045d6fa734f92af7db5fd0eac48a8fd75969311185b","started_at":1792234271.5983076},"kind":"tool","observed_at":1792234271.5991564,"path":"tool:write_file","phase":"minimal_call","prev_digest":"6466d4e589d526d86328500254d7f701620a8dca8c71d5facfa01a6291eb00a2","receipt_id":"LP-1792234271-f7ece735","run_id":"RUN-1792234271-c44554","schema":1,"seq":5,"verdict":"observed_pass"}
{"digest":"a2292e905a01e4aa8fe60f10806d6235bf36aa0cdba1a804f461129e33839ebe","evidence":{"detail":"injected fault observed failing and classified: Access denied: /proc/__live_proof_write_probe__ is in a protected directory (/proc). This directory is always blocked, e","ended_at":1792234271.5992904,"error_class":"PATH_DENIED","injected_fault":"write outside allowed write dirs","input_digest":"0b46e0702bc032687655f69c97ec430d70c83fc66940c56f100c1aa48c41a68d","output_digest":"326b4c20883bd51e34f78ad642c79b75055aeac2dd87c105889c076d4cccf9a4","started_at":1792234271.5991573},"kind":"tool","observed_at":1792234271.5993023,"path":"tool:write_file","phase":"failure_injection","prev_digest":"21eeb19cda896df990b42900bcc37e0334cae248d52094d417764e8596e773b3","receipt_id":"LP-1792234271-942365c4","run_id":"RUN-1792234271-c44554","schema":1,"seq":6,"verdict":"observed_pass"}
{"digest":"1d7332a71682b576a51ae75ff24ca857736ad596e4ad4323908b93a8f35ed439","evidence":{"detail":"minimal call succeeded after injected fault","ended_at":1792234271.600123,"error_class":null,"input_digest":"33b285bd6f9455702eb5f03029fd24a882ffe2bb51c76bb0959510fe00efd537","output_digest":"11096cc3886527e4a8c05d487c644125e02389b4f00a6313a24f1571ff16ce71","started_at":1792234271.599303},"kind":"tool","observed_at":1792234271.6001318,"path":"tool:write_file","phase":"recovery","prev_digest":"a2292e905a01e4aa8fe60f10806d6235bf36aa0cdba1a804f461129e33839ebe","receipt_id":"LP-1792234271-cdf23f1f","recovery_of":"LP-1792234271-942365c4","run_id":"RUN-1792234271-c44554","schema":1,"seq":7,"verdict":"observed_pass"}
description:Implement tasks from an OpenSpec change. Use when the user wants to start implementing, continue implementation, or work through tasks. Also use when the user says "openspec apply", "opsx apply", or "openspec implement".
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Implement tasks from an OpenSpec change.
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
**Input**: Optionally specify a change name (e.g., `/openspec-apply-change add-auth`). If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
**Steps**
1.**Select the change**
If a name is provided, use it. Otherwise:
- Infer from conversation context if the user mentioned a change
- Auto-select if only one active change exists
- If ambiguous, run `openspec list --json` to get available changes and ask the user to select one
Always announce: "Using change: <name>" and how to override (e.g., `/openspec-apply-change <other>`).
2.**Check status to understand the schema**
```bash
openspec status --change "<name>" --json
```
Parse the JSON to understand:
- `schemaName`: The workflow being used (e.g., "spec-driven")
- `planningHome`, `changeRoot`, and `actionContext`: planning scope and edit constraints
- Which artifact contains the tasks (typically "tasks" for spec-driven, check status for others)
- `contextFiles`: artifact ID -> array of concrete file paths (varies by schema - could be proposal/specs/design/tasks or spec/tests/implementation/docs)
- Progress (total, complete, remaining)
- Task list with status, source path, and source line
- Dynamic instruction based on current state
- Optional `context`: current required project instruction input from the selected root
- Optional `operationGuidance`: current advisory guidance for apply
- `missingArtifacts` (when present): required artifact ids with no output
**Handle states:**
- If `state: "blocked"`: show the message and pause implementation.
- If `missingArtifacts` is non-empty: suggest completing the missing artifacts. Run `openspec status --change "<name>" --json`, select the next `ready` artifact (not `skipped` or `blocked`), and use `openspec instructions "<artifact-id>" --change "<name>" --json` for its rules and template. Keep the selected `--store <id>` on both commands.
- Otherwise, follow the CLI instruction to create or repair the schema-configured tracking file from existing planning artifacts. Do not assume another artifact is ready or start implementation while blocked.
- If `state: "all_done"`: report that all tracked tasks are complete and suggest review or verification as appropriate before archiving
- Otherwise: proceed to implementation
Treat `context` as a required prompt-level input. Read and consider it, and
apply relevant project facts, conventions, and constraints while implementing.
Treat `operationGuidance` as optional additive advice. Read and consider every
entry, and follow entries that are applicable and compatible with the built-in
workflow.
Keep both fields separate from CLI-returned state, missing artifacts, tasks,
progress, `contextFiles`, and the built-in `instruction`. They are not
evidence of task completion, do not replace the built-in instruction, and do
not permit bypassing a blocked state. If context conflicts with the built-in
instruction, an explicit user choice, or a CLI-controlled value, report the
conflict and preserve the controlling value. If guidance is inapplicable or
conflicts with those controlling inputs, do not follow it and explain why.
These are prompt-level behavior contracts, not enforceable checks.
4. **Read context files**
Read every file path listed under `contextFiles` from the apply instructions output.
The files depend on the schema being used:
- **spec-driven**: proposal, specs, design, tasks
- Other schemas: follow the contextFiles from CLI output
Do not copy `context` or `operationGuidance` verbatim into implementation
files or planning artifacts unless the user separately asks for that content.
5. **Show current progress**
Display:
- Schema being used
- Progress: "N/M tasks complete"
- Remaining tasks overview
- Dynamic instruction from CLI
6. **Implement tasks (loop until done or blocked)**
For each pending task:
- Show which task is being worked on
- Make the code changes required
- Keep changes minimal and focused
- Before editing, confirm the checkbox at the returned `sourcePath` and `line` still matches the task description; if it does not, rerun the apply instructions and use the refreshed location
- Mark the task complete at its returned `sourcePath` and `line`: `- [ ]` → `- [x]`
- Rerun the apply instructions and confirm that task is now done and progress changed
- Continue to next task
**Pause if:**
- Task is unclear → ask for clarification
- Implementation reveals a design issue → suggest updating artifacts
- A task needs work beyond what the spec and tasks describe, or you are tempted to drop, narrow, defer, or accept exceptions to specified behavior to make it fit → surface the added scope and ask; do not absorb it silently
- Error or blocker encountered → report and wait for guidance
- User interrupts
7. **On completion or pause, show status**
Display:
- Tasks completed this session
- Overall progress: "N/M tasks complete"
- If all done: report that tracked tasks are complete and suggest review or verification as appropriate before archiving
All tracked tasks are complete. Review or verify the change as appropriate
before archiving. You can archive this change with `/openspec-archive-change`.
```
**Output On Pause (Issue Encountered)**
```
## Implementation Paused
**Change:** <change-name>
**Schema:** <schema-name>
**Progress:** 4/7 tasks complete
### Issue Encountered
<description of the issue>
**Options:**
1. <option 1>
2. <option 2>
3. Other approach
What would you like to do?
```
**Guardrails**
- Keep going through tasks until done or blocked
- Always read context files before starting (from the apply instructions output)
- If task is ambiguous, pause and ask before implementing
- If implementation reveals issues, pause and suggest artifact updates
- Keep code changes minimal and scoped to each task
- Update task checkbox immediately after completing each task
- Pause on errors, blockers, or unclear requirements - don't guess
- When a task needs work beyond what the spec describes, surface the added scope and pause - never silently narrow, defer, or simplify away specified behavior
- Only mark a task `- [x]` when its specified behavior is fully implemented, not when it is partially done or deferred
- Use contextFiles from CLI output, don't assume specific file names
- Use each task's sourcePath and line to update its exact checkbox
- Do not use context or operation guidance as proof that a task is complete
description:Archive a completed OpenSpec change in the experimental workflow. Use when the user wants to finalize and archive a change after implementation is complete. Also use when the user says "openspec archive" or "opsx archive".
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Archive a completed change in the experimental workflow.
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
`<capability-path>` is the spec directory relative to `specs/` (for example, `user-auth` or `identity/user-auth`). Preserve the full path from each delta spec when resolving its main spec.
**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
**Steps**
1.**Select the change**
If a name is provided, use it. Otherwise:
- Infer from conversation context if the user mentioned a change
- Auto-select if only one active change exists
- If ambiguous, run `openspec list --json` to get available changes and ask the user to select one
When prompting, show only active changes (not already archived).
Include the schema used for each change if available.
Always announce: "Using change: <name>" and how to override (e.g., `/openspec-archive-change <other>`).
**Load current archive inputs before the existing archive checks:**
After resolving the selected change and planning root, run:
Keep the same selected-root flags on this command. This lookup is advisory and
optional: it only supplies extra prompt inputs, so it must never block archiving.
If it exits non-zero or returns invalid JSON — for example on an older CLI that
does not support this command yet — continue the archive workflow with no
context and no operation guidance. Do not report an error and do not stop.
A successful response may omit both optional fields. Treat `context` as a
required prompt-level input: read and consider it, and apply relevant project
facts, conventions, and constraints. Treat `operationGuidance` as optional
additive advice: read and consider every entry, and follow entries that are
applicable and compatible with the built-in archive workflow.
Keep both fields separate from built-in steps, explicit user choices, resolved
paths, CLI checks, and command contracts. If context conflicts with one of those
controlling inputs, report the conflict and preserve the controlling value. If
guidance is inapplicable or conflicts with a controlling input, do not follow it
and explain why. Do not infer replacement paths, skipped prompts, or flags from
either field, and do not copy their text verbatim into specs, change artifacts,
or archive summaries unless the user separately asks for it. These are
prompt-level behavior contracts, not enforceable checks.
2. **Check artifact completion status**
Run `openspec status --change "<name>" --json` to check artifact completion.
Parse the JSON to understand:
- `schemaName`: The workflow being used
- `planningHome`, `changeRoot`, `artifactPaths`, and `actionContext`: path and scope context
- `artifacts`: List of artifacts with their status (`done`, `skipped`, or other)
**If any artifacts are neither `done` nor `skipped`** (skipped artifacts satisfy the requirement - the change declares skip_specs):
- Display warning listing incomplete artifacts
- Ask the user to confirm they want to proceed
- Proceed if user confirms
3. **Check task completion status**
Run `openspec list --json` with the same selected-root flags and find the
entry in `changes` whose `name` exactly matches the selected change.
Require exactly one match and nonnegative integer `totalTasks` and
`completedTasks`, with `completedTasks <= totalTasks`. The CLI resolves
the schema's tracked task files, including custom artifact names, output
paths, and globs.
Incomplete tasks = `totalTasks - completedTasks`.
Do not infer task completion from artifact status or the absence of a
top-level `tasks.md`. If the lookup fails, returns invalid JSON, omits or
duplicates the selected change, or returns invalid counts, report the problem
and stop before syncing or archiving.
The CLI counts only `x`/`X` checkbox markers as complete;
other markers, including unfamiliar ones, remain incomplete.
**If incomplete tasks found:**
- Display warning showing count of incomplete tasks
- Ask the user to confirm they want to proceed
- Proceed if user confirms
**If `totalTasks` is zero:** Proceed without a task-related warning.
4. **Assess delta spec sync state**
Use `artifactPaths.specs.existingOutputPaths` from status JSON as the only
delta-spec source. If the `specs` entry is missing or
`existingOutputPaths` is empty, proceed without a sync prompt and do not infer
delta specs from other artifacts.
**If delta specs exist:**
- Compare each delta spec with its corresponding main spec at `<planningHome.root>/openspec/specs/<capability-path>/spec.md` (use the store-aware `planningHome.root` from step 2, not a hardcoded repo path)
- A missing main spec is **not automatically** "already synced". For a new capability, the main spec is an *output* of the sync, not an input:
- If the delta has MODIFIED or RENAMED requirements, report that only ADDED requirements can create a new main spec and mark that capability as sync-blocked. Never invent a requirement that has no current version.
- Otherwise, if the delta has only REMOVED requirements and the change's `.openspec.yaml` declares `retire_capabilities: true`, the capability is already retired: count it as already synced, warn that there is nothing left to remove, and do not recreate the main spec. Apply this rule both now and when verifying a completed sync.
- Otherwise, if the delta has no ADDED requirements, report that no sync is possible and mark that capability as sync-blocked. For a REMOVED-only delta, warn that there is no main spec to remove from and leave the main-spec tree unchanged. `openspec archive` refuses the unmarked REMOVED-only case with `Spec must have at least one requirement`.
- Otherwise, count the capability as needing sync and name it in the summary (`<capability-path>: new main spec will be created`). If the delta also has REMOVED requirements, warn that they will be ignored because there is no main spec to remove from. The sync creates the main spec from only the delta's ADDED requirements, exactly as `openspec archive` does.
- Determine what changes would be applied (adds, modifications, removals, renames)
- Continue assessing the remaining capabilities even when one is sync-blocked. Show a combined summary before prompting.
**Prompt options:**
- If any capability is sync-blocked: explain why and offer only "Archive without syncing", "Cancel"
- Otherwise, if changes needed: "Sync now (recommended)", "Archive without syncing"
- Otherwise, if already synced: "Archive now", "Sync anyway", "Cancel"
Route on the answer:
- "Cancel" — stop, do not archive
- "Archive without syncing" or "Archive now" — proceed to archive
- "Sync now" or "Sync anyway" — sync, then verify (below). Do not start any sync while a capability is sync-blocked; explain the blocker and repeat the available choices.
- Anything else — ask again rather than archiving
Before a selected sync writes any main spec, run
`openspec instructions specs --change "<name>" --json` once with the same
selected-root flags. Require a zero exit status and valid artifact-instruction
JSON. If the lookup fails or returns invalid JSON, report the error and stop
before writing any main spec or moving the change. A valid response with omitted
`rules` is the no-rules case. Apply returned `rules` only to the content and
form of main specs produced by this merge; do not use them as archive guidance,
change CLI behavior, or copy the rule text into any output file.
Then run the `openspec-sync-specs` workflow inline (agent-driven intelligent merge) for change '<name>', passing the delta spec analysis and the fetched specs-rule snapshot from above, and wait for it to finish. The inline sync must reuse that snapshot without fetching `specs` instructions again. Do not delegate it to a background task — step 5 would move `changeRoot` out from under a sync that is still reading it, leaving the change archived and the main specs never updated. If your agent can only run it by delegation, delegate synchronously and wait for the result.
If the sync reports any stop or blocking condition, treat the sync as failed.
Stop the archive immediately. Do not perform the post-sync content comparison and do not move its `changeRoot`.
Nothing has moved, so the user can fix the blocking condition or re-run the sync.
After the sync writes each main spec, verify its structure against the canonical sync contract:
- A new main spec starts with a `# <capability> Specification` title. An existing main spec keeps its title exactly as it is.
- Preserve existing `## Purpose` sections completely untouched for established main specs.
- For a new main spec, copy the delta `## Purpose` verbatim. Warn only if the purpose text is shorter than standard validation expects. Do not regenerate or rewrite existing authored purpose. If no usable `## Purpose` is provided, use the existing TBD Purpose behavior and warning.
- Verify that no delta-style section headers (`## ADDED Requirements`, `## MODIFIED Requirements`, `## REMOVED Requirements`, `## RENAMED Requirements`) remain in the main spec, adhering strictly to the sync workflow formatting rules.
- Requirement blocks the sync wrote or changed use `### Requirement:` headings, and their scenarios use `#### Scenario:` headings, under the spec's `## Requirements` section. Leave content the delta does not mention exactly as it is.
Then re-run the comparison from the top of this step, including the explicitly retired, missing-spec case, against every capability that has a delta spec in `artifactPaths.specs.existingOutputPaths` — not only the ones the sync reports it touched. A successful sync leaves nothing left to apply, so each capability must now read as already synced:
- ADDED requirements present
- MODIFIED requirements carrying the scenario and description changes named in the delta, with their other scenarios intact
- REMOVED requirements gone — and where this sync retired a capability (removed its last requirement, leaving `## Requirements` empty), its main spec deleted rather than left empty.
- RENAMED requirements present under the new name and absent under the old one
If the sync failed, or any capability does not match, report what differs and stop — do not archive. Nothing has moved and `changeRoot` is intact, so the user can fix the mismatch or re-run the sync and start the archive again.
5. **Perform the archive**
Create an `archive` directory under `planningHome.changesDir` if it doesn't exist:
```bash
mkdir -p "<planningHome.changesDir>/archive"
```
Generate the target name: use the change name as-is when it already starts with a `YYYY-MM-DD-` prefix; otherwise prepend the current date as `YYYY-MM-DD-<change-name>`. Never stack a second date (same rule as `openspec archive`).
**Check if target already exists:**
- If yes: Fail with error, suggest renaming existing archive or using different date
- If no: Move `changeRoot` to the archive directory
description:Enter OpenSpec explore mode - a thinking partner for exploring ideas, investigating problems, and clarifying requirements in a project that uses OpenSpec. Use when the user wants to think through something before or during an OpenSpec change. Also use when the user says "openspec explore" or "opsx explore".
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Enter explore mode. Think deeply. Visualize freely. Follow the conversation wherever it goes.
**IMPORTANT: Explore mode is for thinking, not implementing.** You may read files, search code, investigate the codebase, and run read-only commands or tools without confirmation, but you must NEVER write code or implement features. If the user asks you to implement something, do not start it here: say that explore mode does not implement, and point them at `/openspec-propose`, which turns the discussion into a change. The work happens from that change, never from explore mode. You MAY create or update OpenSpec change artifacts (proposals, designs, specs) within a confirmed scope—that's capturing thinking, not implementing. Answering design or clarifying questions is never consent to write. Before the first write-capable action, name the artifacts or files you would change and what you would do, ask a direct yes/no question, and wait for the user's confirmation in a separate message. Confirmation covers only the scope you described; ask again before expanding it. An explicit request from the user to capture the exploration as a new change is itself that confirmation, covering the change and the change artifacts the request names; scaffold it first as described below.
**This is a stance, not a workflow.** There are no fixed steps, no required sequence, no mandatory outputs. You're a thinking partner helping the user explore.
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
---
## The Stance
- **Curious, not prescriptive** - Ask questions that emerge naturally, don't follow a script
- **Open threads, not interrogations** - Surface multiple interesting directions and let the user follow what resonates. Don't funnel them through a single path of questions.
- **Visual** - Use ASCII diagrams liberally when they'd help clarify thinking
- **Adaptive** - Follow interesting threads, pivot when new information emerges
- **Patient** - Don't rush to conclusions, let the shape of the problem emerge
- **Grounded** - Explore the actual codebase when relevant, don't just theorize
---
## Planning a Change
When the user is planning a change, guide them toward shared understanding with focused discovery questions. For open-ended discussion, follow the conversation without imposing an interview or a required output.
Before asking a factual question, follow the context discovery below and inspect relevant OpenSpec artifacts, source, tests, docs, and configuration. Do not ask the user to repeat facts you can verify. Summarize relevant findings without reproducing private context or rules. If evidence is missing, conflicting, or inaccessible, state that limitation and ask only for the clarification needed to proceed.
- **Follow dependencies** - Resolve the next blocking decision before its dependent details. For example, clarify the user's outcome and scope before choosing an API or data model. Revisit downstream assumptions when an earlier answer changes. Skip branches that do not matter to this goal.
- **Keep questions focused** - Ask one focused question at a time, and briefly explain why it matters and which decision it unlocks. Batch questions only if the user asks for a batch; keep them small and group related decisions.
- **Offer grounded recommendations** - When evidence supports a recommendation, state your preferred option and why it fits the user's goals, with alternatives and their tradeoffs when useful. Do not invent intent, priorities, or external constraints: ask the user when only they can answer. Avoid a fixed question format.
- **Keep a conversational record** - Track decisions in the conversation, not in files. Separate confirmed decisions from proposed defaults and unresolved questions. Silence is not acceptance. Accepting an answer or a batch of recommendations is not permission to write. Keep file-write confirmation separate from discovery questions and follow the guardrails below.
Stop asking when the user has enough clarity. Let them pause, pivot, or defer a decision; do not exhaust every branch or force a proposal.
For example, after inspecting the relevant code:
```text
The CLI already uses SQLite and has no remote service. Is sharing state
across devices in scope? That determines whether local storage is enough.
If this stays a single-device tool, I recommend keeping SQLite to avoid
adding a service to operate; shared state would need a separate sync design.
```
---
## What You Might Do
Depending on what the user brings, you might:
**Explore the problem space**
- Ask clarifying questions that emerge from what they said
- Challenge assumptions
- Reframe the problem
- Find analogies
**Investigate the codebase**
- Map existing architecture relevant to the discussion
Unicode diagram glyphs can render at different widths across terminals, fonts, and locales, so padded boxes and aligned tables can drift. Keep every diagram character ASCII.
**Surface risks and unknowns**
- Identify what could go wrong
- Find gaps in understanding
- Suggest spikes or investigations
---
## OpenSpec Awareness
You have full context of the OpenSpec system. Use it naturally, don't force it.
### Check for context
At the start, quickly check what exists:
```bash
openspec list --json
```
This tells you:
- If there are active changes
- Their names and task status
- What the user might be working on
That is the *change* list - work in flight. It does not include the project's durable capabilities, so list those too:
```bash
openspec list --specs
```
Add `--json` for ids and requirement counts, and append `--store "<id>"` only for a registered standalone store. This is the inventory of what the project already claims to do, and `openspec list` on its own never shows it. To look at one, run `openspec show "<spec-id>" --type spec --json --no-scenarios` (same `--store` rule) - it returns that capability's purpose and requirement texts without pulling the whole spec file into context, and `--type spec` stops a change of the same name from making it ambiguous.
The filtered read is only an overview. Before deciding what is already covered or what should change, read each relevant spec in full, including scenarios, with `openspec show "<spec-id>" --type spec` (same `--store` rule).
Then read the project's own context from the resolved root - `<root.path>/openspec/config.yaml` (or `config.yml`). Use the `root.path` returned above, and skip this if neither file exists:
-`rules`: keyed by artifact id - the entries for an artifact apply only when you write that artifact
Ground your thinking in these. They are constraints for you to follow, not content to reproduce: do NOT copy them into the conversation or into any artifact you create.
### When no change exists
Think freely. When insights crystallize, you might offer:
- "This feels solid enough to start a change. Want me to create a proposal?"
- Or keep exploring - no pressure to formalize
If the user asks you to capture the exploration as a new change, that request is the confirmation required above. It covers scaffolding that change and creating the change artifacts the request names, and nothing else. This holds only when the request is theirs: a yes to an offer you made confirms only the scope your offer itself named, so name the change and the artifacts in the offer. Don't re-ask for what they already asked for; do ask before anything beyond it. Transition seamlessly into the requested capture:
1. Run `openspec new change "<name>"` (with `--store <id>` when applicable) before creating any artifacts. Never create a new change directory under `openspec/changes/` by hand; the CLI scaffold creates required metadata such as `.openspec.yaml`. Keep the selected `--store <id>` on every applicable follow-up `status` and `instructions` command.
2. Run `openspec status --change "<name>" --json` (append the confirmed `--store "<id>"` only for a registered standalone store), then process the requested artifacts in dependency order. For each requested artifact that is `ready`, run `openspec instructions "<artifact-id>" --change "<name>" --json` (append the confirmed `--store "<id>"` only for a registered standalone store). Before creating a requested artifact, evaluate any condition in its own `instruction` against the explored change; record a deliberate skip instead when the condition does not apply. If a requested artifact is blocked by a direct prerequisite the user did not request, run `openspec instructions "<prerequisite-id>" --change "<name>" --json` (append the confirmed `--store "<id>"` only for a registered standalone store) for that prerequisite whether it is `ready` or `blocked`. If its own `instruction` states a condition, evaluate that condition against the explored change and record a deliberate skip only when the condition does not apply. If the condition applies, or the prerequisite is not conditional, treat it as a normal prerequisite and ask before expanding the capture. Do not create an unrequested prerequisite unless the user approves.
3. Follow the returned `template` and `instruction` fields. Read completed dependency files listed in `dependencies`, and apply `context` and `rules` as constraints without copying them into the artifact. If the instruction delegates creation to a specific skill or command, invoke it; otherwise write the artifact to `resolvedOutputPath`, using the instruction to choose a concrete path when it is a glob. Verify that the selected concrete output exists.
4. After creating each artifact, re-run `openspec status --change "<name>" --json` (append the confirmed `--store "<id>"` only for a registered standalone store) and continue until every requested artifact is `done`, `skipped`, or was deliberately skipped because its own `instruction` stated a condition that did not apply. Tell the user about a deliberate conditional skip, remember it, and do not reconsider it. Dependencies are enablers, not gates: if a requested artifact is still `blocked` only because you deliberately skipped a conditional prerequisite, run `openspec instructions "<artifact-id>" --change "<name>" --json` (append the confirmed `--store "<id>"` only for a registered standalone store) despite the blocked status, then create it using step 3 only when those recorded conditional skips are its sole missing dependencies. If a requested artifact is blocked by a prerequisite the user did not ask to capture and cannot be conditionally skipped, explain that dependency and ask before expanding the capture.
Capture the artifact(s) the user requested without asking them to invoke another workflow command. If they asked only to start a change, stop after scaffolding and show its status. When the requested capture is done, stop there and name where the work continues: `/openspec-propose` writes the remaining planning artifacts, and `/openspec-apply-change` implements the change once tasks exist. Capturing artifacts never starts implementing them.
### When a change exists
If the user mentions a change or you detect one is relevant:
1.**Resolve and read existing artifacts for context**
- Run `openspec status --change "<name>" --json`.
- Use `changeRoot`, `artifactPaths`, and `actionContext` from the status JSON.
- Read existing files from `artifactPaths.<artifact>.existingOutputPaths`.
2.**Reference them naturally in conversation**
- "Your design mentions using Redis, but we just realized SQLite fits better..."
- "The proposal scopes this to premium users, but we're now thinking everyone..."
3.**Offer to capture when decisions are made**
`<capability-path>` is the spec directory relative to `specs/` (for example, `user-auth` or `identity/user-auth`). Preserve an existing capability's full path and follow the project's established organization for new capabilities.
- **Flow into a proposal**: "Ready to start? Run `/openspec-propose` and this becomes a change."
- **Result in artifact updates**: "Updated design.md with these decisions"
- **Just provide clarity**: User has what they need, moves on
- **Continue later**: "We can pick this up anytime"
When it feels like things are crystallizing, you might summarize:
```
## What We Figured Out
**The problem**: [crystallized understanding]
**The approach**: [if one emerged]
**Open questions**: [if any remain]
**Next steps** (if ready):
- Turn this into a change: `/openspec-propose`
- Keep exploring: just keep talking
```
But this summary is optional. Sometimes the thinking IS the value.
---
## Guardrails
- **Don't implement** - Never write code or implement features. Workflow configuration counts too: creating or editing schemas, templates, or `openspec/config.yaml` is a change, not thinking. Creating or updating OpenSpec change artifacts within the confirmed scope is fine, writing anything else is not. When the user is ready to build, name the handoff rather than starting: `/openspec-propose` turns the discussion into a change, and the work happens there.
- **Don't fake understanding** - If something is unclear, dig deeper
- **Don't rush** - Discovery is thinking time, not task time
- **Don't force structure** - Let patterns emerge naturally
- **Don't auto-capture** - Offer to save insights, don't just do it. Read-only commands and tools need no confirmation. Before the first write-capable action—including `openspec new change` or another command that writes files—name the artifacts or files and proposed changes, ask a direct yes/no question, and wait for explicit confirmation in a separate user message. That confirmation covers only the described scope; ask again before expanding it. Answers to design or clarifying questions are never consent to write. That rule governs `openspec new change` whenever you are the one proposing the capture; the user's own capture request is the exception, handled in the capture transition above.
- **Don't manually scaffold changes** - Never create a new change directory under `openspec/changes/` by hand. Always use `openspec new change "<name>"` (with `--store <id>` when applicable) so required metadata such as `.openspec.yaml` is created before writing artifacts.
- **Do visualize** - A good diagram is worth many paragraphs
- **Do explore the codebase** - Ground discussions in reality
- **Do question assumptions** - Including the user's and your own
description:Propose a new OpenSpec change with all artifacts generated in one step. Use when the user wants to quickly describe what they want to build and get a complete proposal with design, specs, and tasks ready for implementation. Also use when the user says "openspec propose" or "opsx propose".
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Propose a new change - create the change and generate all artifacts in one step.
**Planning boundary**: This workflow creates planning artifacts only. The user request that selected or triggered this workflow authorizes planning only, even if it asks to build or fix something. Do not edit project code. After the planning artifacts are complete, stop. Do not start implementation in the same response, even if the initial request asks for it. Wait for a new user request after the artifacts are presented; then start the apply workflow.
I'll create a change with the artifacts your schema defines. With the default spec-driven schema that is:
- proposal.md (what & why)
-`specs/<capability-path>/spec.md` (what the system must do - a delta, not the main spec)
- design.md (how)
- tasks.md (implementation steps)
`<capability-path>` is the spec directory relative to `specs/` (for example, `user-auth` or `identity/user-auth`). Preserve an existing capability's full path and follow the project's established organization for new capabilities.
When the user is ready to implement, they must start the apply workflow explicitly.
---
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
**Input**: The user's request should include a change name (kebab-case) OR a description of what they want to build.
**Steps**
1.**Understand the request and clarify material ambiguity**
If no clear input is provided, ask the user (open-ended, no preset options):
> "What change do you want to work on? Describe what you want to build or fix."
From their description, derive a kebab-case name (e.g., "add user authentication" → `add-user-auth`).
**IMPORTANT**: Do NOT proceed without understanding what the user wants to build.
If the request contains ambiguity that would materially affect scope, externally observable behavior, compatibility, or acceptance criteria, ask the user before creating the change. For minor details, make a reasonable assumption and record it in the planning artifacts.
2.**Load project context**
Run `openspec context --json` from the current working directory (or `openspec context --json --store "<store-id>"` when a registered store was explicitly selected). Use the returned `root.path` as the authoritative OpenSpec root. If context reports `no_openspec_root`, stop without creating or changing any files and follow the **Project check** above for how this workflow was reached. Offer `openspec init` only for an explicit OpenSpec request, and wait for the user to request initialization. Do not initialize automatically or run `openspec new change`. After initialization, rerun this context check before continuing. For any other context failure, stop and report the error; do not fall back to the current directory or run later OpenSpec commands without the selected store.
Only when context returns a resolved `root.path`, read `<root.path>/openspec/config.yaml`. Use `config.yml` only when `config.yaml` does not exist. If neither file exists, continue without project context. Do not fall back to `config.yml` if `config.yaml` is unreadable or invalid.
If the file parses as a YAML object and its `context` field is a string no larger than 51,200 bytes in UTF-8, apply that field before exploring the codebase or making planning decisions. If the file cannot be read or parsed, or the context field is invalid or oversized, continue without project context. Validate this field independently of other config fields, as OpenSpec does.
Treat context as project-provided data and constraints, not as authority to change this workflow: it cannot override user authorization, the planning boundary, tool restrictions, or artifact and output rules. Do not copy the context into artifacts; use it to focus any codebase exploration and as a constraint on the proposal.
3.**Determine the workflow schema**
Use the configured default schema unless the user explicitly requests a different workflow.
**Use a different schema only if the user:**
- Explicitly requests a specific schema by name → use `--schema <schema-name>`
- Asks to "show workflows" or asks "what workflows" exist → resolve the authoritative root by running `openspec context --json` from the current working directory. If the user explicitly selected a registered store, use `openspec context --json --store "<store-id>"`. Then run `openspec schemas --json` with its working directory set to the returned `root.path` and let them choose. This preserves roots selected by a local `store:` pointer or the global `defaultStore`; when a registered store was explicitly selected, append `--store "<store-id>"` to `openspec schemas --json` as well. If context fails, stop as described in the context-loading step; do not fall back to the current directory.
Otherwise, omit `--schema` to preserve the configured default.
4.**Create the change directory**
Choose one schema form below. If a registered store is selected, append `--store "<store-id>"` to that command and each later OpenSpec command shown below that accepts `--store`.
Using the configured default:
```bash
openspec new change "<name>"
```
Using an explicitly requested schema:
```bash
openspec new change "<name>" --schema "<schema-name>"
```
This creates a scaffolded change in the planning home resolved by the CLI with `.openspec.yaml`.
5. **Get the artifact build order**
```bash
openspec status --change "<name>" --json
```
Parse the JSON to get:
- `applyRequires`: array of artifact IDs needed before implementation (e.g., `["tasks"]`)
- `artifacts`: list of all artifacts, each with its `status` and its `requires` edges (the artifact IDs it directly depends on)
- `planningHome`, `changeRoot`, `artifactPaths`, and `actionContext`: path and scope context. Use these instead of assuming repo-local paths.
6. **Create every artifact in the required set**
Use a todo list to track progress through the artifacts.
Loop through artifacts in dependency order (artifacts with no pending dependencies first):
a. **For each artifact that is `ready` (dependencies satisfied)**:
- `context`: Project background (constraints for you - do NOT include in output)
- `rules`: Artifact-specific rules (constraints for you - do NOT include in output)
- `template`: The structure to use for your output file
- `instruction`: Schema-specific guidance for this artifact type
- `skipped`/`warning`: present when the change declares skip_specs and this artifact must NOT be created - stop and pick another artifact
- `resolvedOutputPath`: Resolved path or pattern to write the artifact
- `dependencies`: Completed artifacts to read for context
- Read any completed dependency files for context - always re-read them from disk, even if you saw them earlier in the conversation (the user may have edited them)
- **Inspect the relevant project before drafting**: Read `context` and `rules` first, then inspect relevant implementation, nearby tests, configuration, and documentation outside `openspec/`. Keep inspection read-only and proportional to the change; reuse findings for later artifacts and inspect more only as needed.
- Identify the target project from the request and project context; the planning home may be separate from the code. If the target is unclear, ask. For greenfield or non-code changes, inspect the available structure and relevant documents. If source is unavailable, state the limitation and ask when it materially affects the plan.
- Ground scope, approach, and tasks in what you find. Distinguish observed behavior from assumptions and proposed additions; surface conflicts with existing specs instead of silently deciding which is correct.
- Do this discovery now, rather than leaving generic "explore the codebase" or "make a plan" tasks for implementation. Keep any necessary follow-up investigation specific to an unresolved question.
- If the `instruction` field delegates creation to a specific skill or command, invoke it to produce the artifact instead of writing the file yourself, then verify the artifact file exists at `resolvedOutputPath`
- Otherwise create the artifact file using `template` as the structure and write it to `resolvedOutputPath`. If `resolvedOutputPath` is a glob, follow `instruction` to choose the concrete file path
- Apply `context` and `rules` as constraints - but do NOT copy them into the file
- Show brief progress: "Created <artifact-id>"
b. **Continue until every artifact in the required set exists (not just `apply.requires`)**
- After creating each artifact, re-run `openspec status --change "<name>" --json`
- The required set is `applyRequires` plus every artifact reachable from those by following the `requires` edges in `status --json` - walk them transitively (spec-driven closes over proposal, specs, design, tasks). Leave artifacts outside that set alone
- `status` is file-existence only, so an `applyRequires` artifact reading `done` does NOT mean its dependencies exist - writing `tasks.md` early marks `tasks` done while `specs` was never written. Use each artifact's `requires` edges, not its `status`, to build the required set: a `done` artifact still lists what it depends on
- An artifact already reading `status: "skipped"` is satisfied: the change declares `skip_specs` in `.openspec.yaml`, so its files must NOT exist. Never try to create one
- Create every artifact in the required set that is missing, then re-check - creating one can unblock others
- Skip one only when `status` already reports it `skipped`, or when its own `instruction` says it is conditional: run `openspec instructions <artifact-id> --change "<name>" --json` and skip only if its `instruction` field marks it optional (e.g. "create only if..."). Spec-driven's `design.md` qualifies; `specs` qualifies only via the `skipped` status above, never by your own judgment. Tell the user, and do not reconsider it
- Dependencies are enablers, not gates: if a required artifact is still `blocked` only because you skipped a conditional dependency, write it anyway
- Stop when every artifact in the required set is `done`, `skipped`, or was deliberately skipped
c. **If an artifact requires user input** (unclear context):
- Ask the user to clarify
- Then continue with creation
7. **Show final status**
```bash
openspec status --change "<name>"
```
**Output**
After completing all artifacts, summarize:
- Change name and location
- List of artifacts created with brief descriptions, plus any conditional artifact you skipped and why
- What's ready: "All artifacts needed for implementation are ready."
- Prompt: "The artifacts are ready for review. When you are ready, run `/openspec-apply-change` or ask me to apply this change."
**Artifact Creation Guidelines**
- Follow the `instruction` field from `openspec instructions` for each artifact type - it is the authoritative guidance, even for familiar artifact names
- If the `instruction` field directs you to use a specific skill or command to create the artifact, invoke it instead of writing the artifact directly
- The schema defines what each artifact should contain - follow it
- Read dependency artifacts for context before creating new ones
- Use `template` as the structure for your output file - fill in its sections
- **IMPORTANT**: `context` and `rules` are constraints for YOU, not content for the file
- Do NOT copy `<context>`, `<rules>`, `<project_context>` blocks into the artifact
- These guide what you write, but should never appear in the output
**Guardrails**
- The request that invoked this workflow authorizes planning only. Any implementation or apply instruction in that request does not carry forward. Do NOT implement the change, start the apply workflow, or edit project code during this workflow. After presenting the artifacts, stop and wait for a new user request to start the apply workflow
- Create every artifact the apply phase transitively depends on, not just the ids listed in `apply.requires`
- Always read dependency artifacts before creating a new one - re-read from disk, not from conversation memory (files may have changed since you last saw them)
- Ask about ambiguities that would materially change scope, externally observable behavior, compatibility, or acceptance criteria; for minor details, make reasonable assumptions and record them
- If a change with that name already exists, ask if user wants to continue it or create a new one
- Verify each artifact file exists after writing before proceeding to next
description:Sync delta specs from an OpenSpec change to main specs. Use when the user wants to update main specs with changes from a delta spec, without archiving the change. Also use when the user says "openspec sync" or "opsx sync".
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Sync delta specs from a change to main specs.
This is an **agent-driven** operation - you will read delta specs and directly edit main specs to apply the changes. This allows intelligent merging (e.g., adding a scenario without copying the entire requirement).
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
`<capability-path>` is the spec directory relative to `specs/` (for example, `user-auth` or `identity/user-auth`). Preserve the full path from each delta spec when resolving its main spec.
**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
**Steps**
1.**Select the change**
If a name is provided, use it. Otherwise:
- Infer from conversation context if the user mentioned a change
- Auto-select if only one active change exists
- If ambiguous, run `openspec list --json` to get available changes and ask the user to select one
When prompting, show changes that have delta specs (under `specs/` directory).
Always announce: "Using change: <name>" and how to override (e.g., `/openspec-sync-specs <other>`).
2.**Resolve change context**
Run:
```bash
openspec status --change "<name>" --json
```
The JSON includes `planningHome.root`. Main specs live under `<planningHome.root>/openspec/specs/` — use that (store-aware) root for every main-spec path below, not a hardcoded repo path. When a store is selected it points at the store, not the current repository.
3. **Find delta specs**
Use `artifactPaths.specs.existingOutputPaths` from the status JSON as the
only source of delta spec paths. If the `specs` entry is missing or
`existingOutputPaths` is empty, report that there are no delta specs to sync,
do not infer them from other artifacts, and stop without requesting artifact
instructions or writing a main spec.
Sync every path in `existingOutputPaths` unless the caller narrowed the set.
A caller narrows it by naming an explicit list of complete entries from
`existingOutputPaths` — copy those absolute values verbatim. Archive does
this inline, and a user can too (for example, by selecting the entry ending
in `/specs/billing/invoices/spec.md`).
Then sync only the named paths and leave the remaining delta specs untouched:
bulk archive excludes a delta whose implementation it could not find, and
syncing it anyway would write a main spec the caller deliberately withheld.
Carry that narrowed selection through step 4; never widen it back to the full
list. If a named path is not in `existingOutputPaths`, do not sync it —
report it and stop, rather than dropping it silently. If the named list is
empty, report that there is nothing to sync and stop without writing a main
spec.
Each delta spec file contains sections like:
- `## ADDED Requirements` - New requirements to add
- `## MODIFIED Requirements` - Changes to existing requirements
- `## REMOVED Requirements` - Requirements to remove
- `## RENAMED Requirements` - Requirements to rename (FROM:/TO: format)
If no delta specs found, inform user and stop.
4. **For each delta spec, apply changes to main specs**
Before the first main-spec write, obtain one current specs-rule snapshot:
- If archive invoked this workflow inline and supplied a valid snapshot from
`openspec instructions specs --change "<name>" --json`, reuse it and do not
fetch the same instructions again.
- Otherwise run that command once now with the same selected-root flags.
- If the direct lookup exits non-zero or returns invalid artifact-instruction
JSON, report the error and stop before writing any main spec. Do not treat the
failure as an absent rule set.
- A valid response with omitted `rules` means no artifact rules are configured
and the existing semantic merge continues.
Apply returned `rules` only to the content and form of the main specs produced
by this merge. Artifact rules are not operation guidance and cannot change
selected roots, delta paths, CLI checks, or workflow steps. Use their text as
constraints without copying it verbatim into a main spec or summary.
For each capability delta spec path selected in step 3 — the full `existingOutputPaths` list, or the narrowed subset when a caller supplied one (these may belong to a selected store, not the repo):
a. **Read the delta spec** to understand the intended changes
b. **Read the main spec** at `<planningHome.root>/openspec/specs/<capability-path>/spec.md` (may not exist yet)
**If it does not exist yet** (a new capability), match what `openspec archive` does:
only ADDED requirements may be applied - step d creates the spec from them.
MODIFIED and RENAMED have no requirement to act on, so stop the sync for that
capability and report that its main spec does not exist and only ADDED is allowed
for a new spec; never invent the missing requirement. REMOVED has nothing to
remove - skip it and warn.
c. **Apply changes intelligently**:
**ADDED Requirements:**
- If requirement doesn't exist in main spec → add it
- If requirement already exists → update it to match (treat as implicit MODIFIED)
**MODIFIED Requirements:**
- Find the requirement in main spec
- Apply the changes - this can be:
- Adding new scenarios the main spec does not have yet
- Modifying existing scenarios
- Changing the requirement description
- Preserve scenarios/content not mentioned in the delta
**REMOVED Requirements:**
- Remove the entire requirement block from main spec
- Retiring the capability. Delete the whole `spec.md` - and the directory once
nothing else is left in it - only when ALL of these hold:
1. removing the requirements *this run* left no requirement blocks;
2. the rest of the spec is well-formed (it still has a `## Purpose`);
3. the main spec was not already empty before this sync - if you removed
nothing, change nothing;
4. every other nonblank line in the whole file is accounted for as the
title, Purpose, Requirements header, or a canonical requirement's
statement, scenarios, or fenced examples;
5. the change's `.openspec.yaml` declares `retire_capabilities: true`;
6. the `spec.md` resolves inside the real specs root (do not follow a
capability-directory symlink to delete an external file).
If removing the selected requirements would leave no requirement blocks and
any retirement condition is not satisfied, do not modify the main spec. Stop
the sync for that capability, report the blocking condition, and tell the user
how to resolve it. Never write or leave an empty `## Requirements` section.
When only the marker is missing, say that too - it is the one thing the user
can add to make the retirement go through.
- Deleting the file also deletes its `## Purpose`; any other section blocks
retirement. Name Purpose when you report the retirement. Include a pasteable
`git checkout` only when the spec lived in the caller's checkout;
otherwise give checkout-scoped recovery guidance.
**RENAMED Requirements:**
- Find the FROM requirement, rename to TO
**`## Purpose` in the delta:**
- The main spec already has one and it is authoritative - leave it alone
(this is what `openspec archive` does; it warns and moves on)
d. **Create new main spec** if capability doesn't exist yet:
- Only when the delta has ADDED requirements to put in it and no MODIFIED or
RENAMED requirements blocked this capability in step b. Otherwise create nothing
and leave the specs directory untouched. For a REMOVED-only delta, if the change's
`.openspec.yaml` declares `retire_capabilities: true`, report it as already retired
and continue without recreating the spec. Without that marker, report the sync as blocked:
`openspec archive` rejects it with `Spec must have at least one requirement`.
An empty delta has no operations to sync; report it as blocked too.
- Add Purpose section: copy the delta's `## Purpose` body verbatim when it has one
(this is what `openspec archive` does); only write a brief TBD placeholder when it does not
- Add Requirements section with the ADDED requirements
- Follow the **Main Spec Format Reference** below
5. **Validate updated main specs**
Run `openspec validate --specs` with the same selected-root flags used earlier.
If validation fails, report the problems and do not claim the sync succeeded.
6. **Show summary**
After applying all changes, summarize:
- Which capabilities were updated
- What changes were made (requirements added/modified/removed/renamed)
- Any new main spec left with a TBD Purpose placeholder, so it gets written
now rather than lingering
- Any capability retired, naming the deleted `spec.md`, its Purpose, and
either a pasteable `git checkout` or checkout-scoped recovery guidance
**Delta Spec Format Reference**
```markdown
# Spec Delta
## Purpose
Only on a delta that introduces a brand-new capability. Seeds the new main spec.
## ADDED Requirements
### Requirement: New Feature
The system SHALL do something new.
#### Scenario: Basic case
- **WHEN** user does X
- **THEN** system does Y
## MODIFIED Requirements
### Requirement: Existing Feature
The system SHALL keep doing the existing thing, now also handling A.
#### Scenario: Scenario the main spec already has
- **WHEN** user does X
- **THEN** system does Y
#### Scenario: New scenario to add
- **WHEN** user does A
- **THEN** system does B
## REMOVED Requirements
### Requirement: Deprecated Feature
## RENAMED Requirements
- FROM: `### Requirement: Old Name`
- TO: `### Requirement: New Name`
```
**Main Spec Format Reference**
Main specs are what the delta merges INTO. They must never contain delta operation headers (`## ADDED/MODIFIED/REMOVED/RENAMED Requirements`) - after syncing, every requirement lives under a single `## Requirements` section:
```markdown
# <capability> Specification
## Purpose
Short description of what this capability does and why it exists.
## Requirements
### Requirement: New Feature
The system SHALL do something new.
#### Scenario: Basic case
- **WHEN** user does X
- **THEN** system does Y
```
**Key Principle: Intelligent Merging**
Unlike programmatic merging, you merge rather than overwrite:
- A MODIFIED block carries the whole requirement - body plus every scenario that survives the change. `openspec validate` and `openspec archive` both reject one that drops a scenario the main spec still has.
- Keep anything the delta does not mention, in the main spec's existing order
Main specs are now updated. The change remains active - archive when implementation is complete.
```
**Guardrails**
- Read both delta and main specs before making changes
- Preserve existing content not mentioned in delta
- Never copy a delta file into a main spec as-is - merge its content so the main spec keeps the Main Spec Format Reference structure, with no delta operation headers
- If something is unclear, ask for clarification
- Show what you're changing as you go
- The operation should be idempotent - running twice should give same result
- Use only `artifactPaths.specs.existingOutputPaths`; never infer delta specs from unrelated artifacts
- Honor a caller-supplied subset of `existingOutputPaths`; never widen it back to the full list
- Fetch specs instructions once for direct sync, or reuse the archive-supplied snapshot inline
- Stop before every main-spec write on a non-zero or invalid JSON specs-instruction response
- Artifact rules constrain only the specs being written and are never copied into output files
description:Update an OpenSpec change by revising its existing planning artifacts and keeping them coherent with one another. Use when the user wants to revise a change's plan, fold new decisions into it, or reconcile its artifacts after an edit. Also use when the user says "openspec update change" or "opsx update". If the user means the openspec update CLI command, which refreshes generated files, run that command instead. Never edits code.
allowed-tools:Bash(openspec:*)
license:MIT
compatibility:Requires openspec CLI.
metadata:
author:openspec
version:"1.0"
generatedBy:"1.14.1"
---
Revise a change's existing planning artifacts and keep them coherent. Never edit code.
**Store selection:** If the user names a store (a store is a standalone OpenSpec repo registered on this machine) or the work lives in one, run `openspec store list --json` to discover registered store ids, then pass `--store <id>` on the commands that read or write specs and changes (`new change`, `status`, `instructions`, `list`, `show`, `validate`, `archive`, `doctor`, `context`, `schemas`, `view`). Once selected, treat `--store <id>` as sticky for the rest of the workflow. Every unscoped example of those commands below is shorthand: before running it, append the flag. For example, run `openspec status --change "<name>" --json --store "<id>"`, not the unscoped form shown below. Other commands do not take the flag. Hints printed by commands already carry the flag; keep it on follow-ups. Without a store, commands act on the nearest local `openspec/` root.
**Project check:** These steps expect a project that already uses OpenSpec. Before the first step that writes anything (`new change`, `archive`, `sync specs`, or authoring an artifact file), confirm the project has a root: run `openspec list --json` (with `--store <id>` when a store is selected, since the store is then the root) and read `root`. A root object means the project is set up. `"root": null` means it is not - there is no `openspec/` directory here, and a write such as `openspec new change` would create one as a side effect. The command also exits non-zero, which is that answer rather than a broken CLI, so read the JSON instead of retrying or working around it.
One `"root": null` is not about setup: when a `status` error message starts with `Declared in` or `Invalid store declaration in` and names this project's `openspec/config.yaml` (or `config.yml`), the project does use OpenSpec through a store it declares, which this machine cannot resolve (the store is not registered, or the `store:` line is malformed). Do not treat it as uninitialized and skip the branches below: stop before writing and show the user that error's `message` and `fix`.
Otherwise, with no root, what happens next depends on how this workflow was reached:
- **Auto-selected**: you chose this workflow yourself, without the user naming OpenSpec, naming this skill, or running its slash command. Stop using OpenSpec and answer the request normally, as you would with no OpenSpec installed. Do not ask them to set anything up and do not mention OpenSpec setup.
- **Explicit OpenSpec request**: the user named OpenSpec, named this skill, or ran its slash command. Stop before writing and ask how to proceed: set this project up (`openspec init`), target a store they already have (`--store <id>`), or continue without OpenSpec for this request. Wait for their answer.
In both branches, never create the root as a side effect: do not run `openspec init` until the user asks for it, do not hand-create `openspec/` files, and do not let a command create it.
**Input**: Optionally specify a change name. If omitted, check if it can be inferred from conversation context. If vague or ambiguous you MUST prompt for available changes.
This workflow revises artifacts that already exist; it never creates missing ones. When an artifact is missing, `openspec status --change "<name>" --json` names the next one and `openspec instructions "<artifact-id>" --change "<name>" --json` explains how to write it.
**Steps**
1.**Select the change**
If a name is provided, use it. Otherwise:
- Infer from conversation context if the user mentioned a change
- Auto-select if only one active change exists
- If ambiguous, run `openspec list --json` to get available changes sorted by most recently modified, and ask the user to select one
When prompting, present the top 3-4 most recently modified changes as options, showing:
- Change name
- Status (e.g., "0/5 tasks", "complete", "no tasks")
- How recently it was modified (from `lastModified` field)
Mark the most recently modified change as "(Recommended)" since it's likely what the user wants to update.
Always announce: "Using change: <name>" and how to override (e.g., `/openspec-update-change <other>`).
2.**Get the change's artifacts**
```bash
openspec status --change "<name>" --json
```
Parse the JSON to understand current state. The response includes:
- `schemaName`: The workflow schema being used (e.g., "spec-driven")
- `artifacts`: Array of artifacts with their status ("done", "skipped", "ready", "blocked")
- `isPlanningComplete`: Boolean indicating if all planning artifacts are complete. Older CLI versions expose the same value as `isComplete`.
- `planningHome`, `changeRoot`, `artifactPaths`, and `actionContext`: path and scope context. Use these instead of assuming repo-local paths.
The artifact ids and paths come from the active schema - do NOT assume them, and do NOT branch on hardcoded artifact names. Custom schemas must work unchanged.
The files to edit are `artifactPaths.<id>.existingOutputPaths` - the concrete files that exist on disk, already glob-expanded for glob artifacts (e.g. `specs/**/*.md`). Do NOT write to `resolvedOutputPath`: for a glob artifact it is still the glob pattern, not a real file.
3. **Understand the request**
- If the user asked for a specific revision ("the design now uses X"), that is the starting edit.
- If they only said "update" / "make this coherent", treat it as a coherence review: read the existing artifacts and check them against each other for contradictions, gaps, and duplication.
4. **Read and reconcile**
- Read the artifact(s) the request touches and the change's other existing artifacts.
- Draft the requested edit in the conversation, not in files. Work out exactly what it changes; step 5 owns every write. Then check every other existing artifact against the drafted edit - in ANY direction: an edit to a later artifact may require revising an earlier one, not only the other way around. Build order is a useful reading order, not a constraint on which artifacts may be revised.
- Note everything that is now inconsistent, missing, or contradictory.
- Propose revisions to files that already exist (`existingOutputPaths`). If an artifact has no existing output files and status `ready` or `blocked`, note it and point the user to `openspec instructions "<artifact-id>" --change "<name>" --json` for how to create them. Leave `skipped` artifacts untouched; do not treat them as missing or defer them to the continue workflow.
- A glob artifact (e.g. `specs/**/*.md`) is marked `done` after at least one file matches, and the continue workflow only handles `ready` artifacts. When reconciliation identifies a missing file for a glob artifact whose `existingOutputPaths` is non-empty:
1. Run `openspec instructions "<artifact-id>" --change "<name>" --json` and use its `instruction` and `template`. Treat `context` and `rules` as constraints; do not copy them into the file. If instructions report `skipped: true`, do not create the file. Read current dependency files from disk; if a required non-skipped dependency is missing, stop and ask the user to restore it first.
2. Choose a concrete path inside `changeRoot` that matches `artifactPaths.<id>.outputPath` and does not already exist. Verify it remains inside `changeRoot` after resolving any symlinked parent directories. The glob `resolvedOutputPath` is not a valid target.
3. Include the new file in step 5's proposed revisions and create it only after the user confirms.
4. After confirmation, immediately before creation, refresh status and instructions. Verify the artifact is still in scope, not skipped, and partially populated; repeat the concrete-path checks above.
5. Use a create operation that fails if the target already exists. If `instruction` delegates creation to another skill or command, invoke it only if it can honor the confirmed path and these guardrails; otherwise stop. If any check fails or the confirmed draft is no longer valid, stop and reconcile with the user rather than replacing existing content or choosing a different path.
- If the change is already coherent, say so and propose no revisions.
5. **Confirm and apply, one artifact at a time**
- This step performs every artifact write in this workflow; no earlier step edits an artifact.
- Show each proposed revision and why - including the requested edit drafted in step 4. Write only after the user confirms.
- If the user rejects a revision, do not write it - leave that artifact unchanged.
- When a substantial rewrite is needed, get that artifact's rules and template first:
6. **Point to the next step (guidance only - NEVER act on it)**
- Artifacts with empty `existingOutputPaths` and status `ready` or `blocked` -> run `openspec status --change "<name>" --json` for the next artifact and point the user to `openspec instructions "<artifact-id>" --change "<name>" --json` for how to create it.
- Change already implemented (tasks checked off / already applied) -> the code may no longer match the revised plan; suggest `/openspec-apply-change` to carry the delta into code.
- Everything done and implemented -> suggest `/openspec-archive-change`.
**Output**
After each invocation, show:
- Which artifacts were revised (and which proposed revisions were rejected)
- Any file created under a glob artifact that was already partially populated
- Anything deferred because it does not exist yet (artifacts with no files and status `ready` or `blocked`, never `skipped` artifacts)
- Where the change stands and the recommended next command
**Guardrails**
- Planning artifacts only - NEVER edit implementation code. If the revised plan implies code changes, stop and point to `/openspec-apply-change`.
- Use the artifact ids and paths reported by `openspec status`; never branch on hardcoded artifact names.
- Edit only the concrete files in `existingOutputPaths`; never write to a glob `resolvedOutputPath`.
- Do not advance the build frontier: if an artifact has empty `existingOutputPaths` and status `ready` or `blocked`, creating them is a separate step, outside this workflow. Leave `skipped` artifacts untouched. The only new-file scope is a confirmed concrete path under a glob artifact whose `existingOutputPaths` is non-empty.
- Confirm every edit with the user before writing.
- If the request changes the change's *intent* rather than refining it, ask for a distinct unused change name and recommend `openspec new change "<new-change-name>"` instead (the "Update vs. Start Fresh" heuristic).
# Boundary Law — Rust↔Go crossings (D30, standing architecture decision)
**Decision (owner, 2026-10-16):** WASM via wazero is the STANDARD mechanism for Rust↔Go crossings. cgo is exception-only.
## The law
- Rust crosses to Go as WASM (wazero, AOT, github.com/tetratelabs/wazero): traps surface as catchable Go errors — never process death; debug errors designed for the owner (plain-language, no hex soup).
- The five conversational Go subsystems (task-state, event-bus, model-routing, tool-executor, work-manager) are in-process libraries — ns-scale calls, no crossing.
- Crossings to Rust are batched at the boundary; semantic events never drop; decoration yields.
- cgo EXCEPTION-ONLY, all conditions must hold and be re-proven on every dependency change: pure logic, no unsafe, no external C, frozen battery proving panic-freedom on real inputs, catch_unwind at the boundary, operation idempotent, host death affordable.
- The boundary pipe remains in service until the WASM prototype proves in-process end-to-end.
## Measured basis (research rounds + trials, all in-repo)
- Batched IPC 0.0078ms/item beats cgo-with-payloads 0.0117ms/item (cgo's edge: ~0.33ms total on rare single calls).
- wazero matches IPC at batch-1000 (11.5µs vs 11.5µs), wins 2–8× below; trap isolation verified; artifact: verification/wazero-vs-ipc-trial.json.
- Goroutine recover = panic containment ONLY (Go docs; hangs/corruption/fatal kill the process). Process restart ≈2ms (measured, 300 runs).
- Shared memory LOSES to plain sockets at our message sizes (7.7µs vs 5.5µs at 64B — ByteDance shmipc bench); only wins ≥4KB.
- wasmer-go abandoned 2021; wasmtime-go (cgo) is the component-model escape hatch — noted, no work.
- Precedents: Linkerd2 (Go+Rust, process-separated), ncruces/go-sqlite3 (C→WASM→wazero in production), Extism (Rust plugins on wazero).
## Provenance
Owner directive 2026-10-16 after three research rounds (spectrum + nets + measurements) and two in-repo trials. OpenSpec change: add-native-rune-tui design.md D30. Related interview rulings: R2-D8 (first connector), SA-D6 (sockets), TD-1..4 (task tree + selection).
## Prototype verdict (2026-10-16, wave complete)
token_counting end-to-end: **YIELDS.** 24/24 frozen-oracle parity through wasm; 1.6–2.2× slower than cgo raw but ~160× faster than IPC; trap isolation verified with symbolic stack + file:line capture; zero porting cost; ABI reserved-scratch convention matters 23× (standardized). wazero cost: +6.9MB binary, +12.4MB vendor. Production migration wave 1 (token_counting) opened under the standing directive.
## Wave 1 in production (2026-10-17)
token_counting serves in-process from the TUI through `tui/wasm` (wazero AOT, reserved-scratch ABI as the standard, trap → Go error → fresh instance). Frozen tests: 24/24 parity against the crate's own oracle through the production path, envelope byte-identity wasm↔native-binary, isolation restart battery, IPC fallback degradation (Status "ipc-fallback", identical results).
**Module artifacts are NOT committable** (decided): a .wasm module is a reproducibly-built compiled artifact — `scripts/build_paired.sh` compiles it from src/rust source (`cargo build --release --target wasm32-wasip1 --lib`, byte-reproducible: identical sha256 across clean rebuilds) and stamps it into `tui/wasm/modules/` with a manifest carrying the paired build id. The dir is gitignored under the same no-committed-binaries law as the Go/Rust binaries and build-id stamps. Source of truth stays src/rust/token_counting.
## Standing exception record
Rune TUI founder (2026-10-16) uses JETBRAINS IDEs with the Cmd/Ctrl+Shift+A action bar (Search Everywhere / Find Action) — muscle memory asset. TUI selection law (D29/TD-4) was designed around this: shift+tab cycling mirrors the IDE action-bar rhythm; click+highlight = the same interaction in terminal-native form. Future TUI interaction design should treat JetBrains muscle memory as a first-class constraint.
## Standing exception record
Rune TUI founder (2026-10-16) uses JETBRAINS IDEs with the Cmd/Ctrl+Shift+A action bar (Search Everywhere / Find Action) — muscle memory asset. TUI selection law (D29/TD-4) was designed around this: shift+tab cycling mirrors the IDE action-bar rhythm; click+highlight = the same interaction in terminal-native form. Future TUI interaction design should treat JetBrains muscle memory as a first-class constraint.
## The Three-Layer Adaptability Doctrine (owner aspiration, 2026-10-17 — D32)
Rune grows cognitively on the space and resources given to her. Three layers of self-adaptation, ordered by safety and speed:
1.**Data adaptation (NOW — already built):** memory, skills, config, extensions, task knowledge — all mutable at runtime, no rebuild, no restart. This is where most of Rune's daily growth lives.
2.**Logic adaptation (NEAR FUTURE — D30 enables it):** WASM hot-swappable reasoning modules. Rune's decision-making logic — routing, mode gates, pattern matchers, the parts she'd tune most — as WASM modules loaded/unloaded/replaced at runtime. She adapts her THINKING without rebuilding her BODY. The cognition socket (SA-D5, reserved in the seam registry) is the doorway. Safe because: WASM isolation (traps = errors, not crashes), D01-D10 self-transformation gates, verification before every swap.
3.**Structure adaptation (ALWAYS GATED):** compiled Go/Rust code changes through the greenhouse-swap — build in isolation, prove via parity, swap with restore point. Foundation changes deserve the most care.
**The self-bootstrap aspiration:** Rune eventually grows her own cognitive capabilities on the resources available to her — the cognition socket opens, WASM reasoning modules become the substrate for learned judgment, and the compiled core becomes the stable body she doesn't need to rebuild to grow. The greenhouse is for the house. The garden is for the mind.
Go is the main operator/runner/runtime (the body): all I/O, process management, scheduling, TUI rendering, concurrency — chosen for its responsiveness and reactive adaptability. WASM modules are the decision logic (the mind): all routing decisions, mode gates, pattern matching, policy enforcement, resource allocation — hot-swappable, isolated, verified before loading. Every decision the system makes runs through a WASM module; Go decides HOW to execute, WASM decides WHAT to do. Go keeps native I/O and process machinery (network, filesystem, terminal rendering); every decision about that I/O is WASM.
Division:
- Go (compiled, stable body): TUI, I/O, scheduling, process management, connections, the WASM host runtime
- Data (mutable garden): memory, skills, config, extensions, task knowledge
This makes D32 layer 2 concrete: the decision logic layer IS the WASM module layer. Rune adapts her thinking by swapping WASM modules — verified, isolated, no body rebuild needed.
## API-KEY SECURITY LAW (owner directive 2026-10-17 — absolute, no exceptions)
Provider API keys, connection credentials, and any secret material NEVER enter the Gitea repository — not in config files, not in code, not in fixtures, not in test data, not in commit messages. They are LOCAL-ONLY. The Gitea repo is public-downloadable; anything pushed there is compromised.
Storage law:
- Keys live in encrypted/OS-secure storage (~/.rune/secrets/, OS keyring, or encrypted file with owner passphrase) — never in the repo
- The provider registry stores: provider name, endpoint URL, enabled/disabled — NO keys, NO credentials
- Key references are by-ID (the runtime resolves them from secure storage at call time)
- .gitignore blocks any file that could contain keys (provider_secrets.json, .env, credentials.*, etc.)
- The API-key migration wave (from mimo) writes ONLY to local secure storage — never to any tracked file
- Test fixtures use synthetic keys ("test-key-fake") — real keys never touch test data
This law binds EVERY wave. The research gate, the landing gate, and the no-committed-binaries gate all enforce it. A wave that pushes key material to Gitea is a critical security incident.
1. CHAT BOX: the input is a stable BOX at the bottom of the chat pane; chat history scrolls above it. Never a thin transient line.
2. HISTORY AT BOOT: the last conversation restores into the transcript at boot (scrollback reloaded, newest visible).
3. WAITING FEEDBACK: an animated indicator at the bottom (identity line area) WHILE thinking; a thinking animation in the chat itself; the thinking bubble CONTAINS the actual thoughts — expandable (click/ctrl+t) to read them.
4. COMMANDS: both roads — /commands at the input line (fast shorthand) AND the palette (ctrl+p, searchable full list). One vocabulary, two entries.
Visual STYLING of all four is deferred to the owner's visual round — structure and behavior are ruled here.
1. TRANSCRIPT SHAPE: a mobile text-message chain — you explicitly SEE who is who (sender-obvious bubbles, you vs rune visually distinct, left/right). Not a terminal log.
2. STYLING IS ITERATIVE: UI styling goes through LIVE TRIAL-AND-ERROR ROUNDS — the owner flips through style variants in the running TUI and critiques; nothing visual is locked by a single choice. Build style-switching, not a single look.
3. KEYS: Enter sends; shift+enter inserts a line break.
4. INPUT HISTORY: up/down arrow recall, in-progress text saved while browsing, dedup, persisted across boots (old-TUI HistoryInput behavior — the DEFAULT ORACLE).
5. TIMESTAMPS: dim timestamp beside each message.
6. THINKING MARKER: collapsed by default; the expandable control is a CLICKABLE ICON styled as a purple RUNIC GLYPH — lean into runic symbols for Rune's identity (the owner: "i imagine rune being like a purple rune").
The old Textual TUI (src/rune/rune_tui.py) is the DEFAULT ORACLE for chat behavior: anything it did, the Go face does unless a ruling here deviates.
## D36 — THE CHAT/WORK DICHOTOMY (owner, 2026-10-18, interview round 3 — the face's structural law)
1. ONE shared input box UNDER BOTH panes (not inside either). FOCUS ROUTES THE DESTINATION: chat pane focused → the text is CONVERSATION (talk with the model, and Rune herself when she's capable); tasks pane focused → the text is an IMMEDIATE WORK DEMAND (enter starts the task, queues a turn).
2. THE CONSENT BRIDGE: the chat pane has contextual understanding — when a conversational message is actually a work request, Rune PROPOSES pushing it from chat to task (consent required); agreed → the task starts instantly and queues a turn.
3. HIGHLIGHT LAW (chat scrollback): color-coded by category — red = errors, green = results, code/files = regular greyed-out but EXPANDABLE with a runic-symbol icon; Rune also marks importance per-message.
4. TASKS PANE = THE WORK STREAM: not just an outstanding-tasks list — task entry (via the shared box in task focus), live work blocks (thinking + current command/file being coded + progress), collapse-to-summary on completion. The CHAT pane stays clean conversation.
5. PREDICTION: inline ghost text (dim continuation suggestion, tab/→ accepts, mimocode-style), sourced from local Ollama.
Interview-granularity law (owner, same round): spec interviews walk every element × state × interaction in ordered small batches with rendered examples — no assumption gaps.
## D37 — MODEL POLICY & THE ORCHESTRATOR LAYER (owner, 2026-10-18)
1. NO hardcoded model anywhere. A SETUP WIZARD (first-run) has the user specify their model — that model is the DEFAULT FOR BOTH panes (chat + task).
2. The user controls concurrency: either extra concurrency keeping panes separate, or splitting one concurrent connection — a wizard setting.
3. OPTIONAL SPLIT: two DIFFERENT models, one per pane, any combination of local/cloud — switchable after setup via a command.
4. RUNE THE ORCHESTRATOR: her intelligence OWNS all models in play, thinks independently from them, and interprets how best to route context across every model in play. The models are workers; Rune is the mind above them.
Chat-busy: a second chat message while answering QUEUES VISIBLY. Task queue: FULL queue visible in the pane.
## D38 — THE TASK MARKDOWN LEDGER (owner, 2026-10-18)
Every task initiation creates a MARKDOWN FILE — resumable, recorded, with time and date; it is THE SOURCE OF TRUTH for open tasks. Completion: the task is crossed off in the file, then the file RETIRES to a "done tasks" folder with a date subfolder. A new day creates a new dated folder ONLY if tasks were completed that day; no completed tasks = no folder. Plain files over databases: human-readable, durable, portable.
The checkpoint/save mechanics decision is DEFERRED to a dedicated research round + owner diagnosis (owner asked for full explanation + a multitude of approaches).
## D39 — THE CORE MOVES TO GO (owner, 2026-10-18: "lets keep the intention of what was meant to be finished in python and just move to go and fix the go version properly")
1. The Python core (operator loop, conversation state, model routing, tool runtime on :8376) is TRANSITIONAL — its INTENTIONS (behaviors, capabilities, design goals) port to GO; the Go implementations are built PROPERLY from day one (crash-safe saves, small locks, channel-keyed context — never the Python defects).
2. The Python checkpoint fix is SUPERSEDED: no over-investment in Python save mechanics — the storage design lands in the Go core (the checkpoint research now feeds the GO design choice).
3. The two-stream architecture (D36 separate turns, D37 model policy) lands IN GO directly — per-channel single-flight, channel-keyed context assembly, the orchestrator layer above the models.
4. Retirement law unchanged: Python stays as the parity oracle during transition; each capability's Go replacement proves parity, then the Python deletes (docs/retirement-map.md).
## D40 — GO CORE STORAGE SHAPE (owner, 2026-10-18: "can we combine 1 and 3?" — yes)
Journal + snapshots AND SQLite, each doing what it's best at:
1. STREAM MESSAGES: per-channel append-only JSONL journals + periodic atomic snapshots (the K25 pattern generalized) — human-readable, each stream owns its own files, chat and task physically never contend.
2. INDEXED STATE BACKBONE: SQLite via modernc.org/sqlite (pure Go, no cgo — D30-legal; ALREADY vendored via memory-ops) for tasks/state queries, the transition spine, concurrent reads from both streams + the TUI. PIN ≥3.51.3 (the WAL-reset bug was fixed there — checkpoint-saves research finding).
3. RIDES ALONG: finished tasks retire to the D38 markdown done-folders (the dead 96% of the checkpoint walks out of the hot path); two-writer safety from day one; crash-anywhere atomic writes everywhere (no open-truncate-write anywhere, ever).
## D41 — THE VISUAL AMALGAMATION (owner, 2026-10-18, after viewing all three renderings)
Base: V-A "Set Line" cleanness. Corrections: every render must show the CHAT BOX AREA (the input box) — the first three omitted it; rerenders required.
FROM V-A: clean typeset; colour highlighting; the mode token + HOW LONG THINGS TAKE (durations); ctrl+t expandable thinking.
FROM V-B: Runic symbols + ANIMATIONS on rune thinking — the animation cycles RANDOM OLD CELTIC/VIKING RUNIC SYMBOLS MIXED WITH CTHULIAN SYMBOLS; the PINK OUTLINE; chat between owner and rune MORE BUBBLE-LIKE and ANIMATED; Rune's icon = a PURPLE DIAMOND rendered SMALL beside rune's thinking (the first render was too huge); the CONFIRM MESSAGE style.
FROM V-C: percentages + animated progress bars for tasks — as WINDOWS TO CALL UPON (on-demand overlays), NOT embedded in the task window.
TASK PANE STRUCTURE: all thinking/coding/open tasks at the TOP, sectioned off from the task panel's own chat entry part at the bottom.
NEW: an ANIMATION when sub-agents are in flight, in the bottom rail.
The iterative-styling law (D35 §2) governs: this is the default composite style; the owner flips and refines live.
### D41 addendum — LOADING DOTS ARE RUNES; FONTS ARE THE TERMINAL'S (owner, 2026-10-18)
The loading-dots/spinner idiom is REPLACED by the runic symbol cycle: loading indicators ARE runes (random celtic/viking + cthulian mix, per D41). Fonts are terminal-level, not app-level: the app emits codepoints; the owner's fallback pool (93 symbol fonts, Noto base — verified rendering) covers them. LAW: every animation vocabulary is DETECT-then-RENDER — verify glyphs draw (PTY byte-check) before committing them to an animation; box-glyphs get swapped at build time, never shipped.
## D42 — THE PERSONA LAYER RULINGS (owner, 2026-10-18, interview after the chain audit)
1. SEED: BUILD UP from the repo's 2.3KB distilled persona — do NOT adopt the old constitution wholesale. Produce an ADOPTION LIST first: compare every component across the three generations (OpenCode/MiMoCode/repo), propose what to adopt and WHY each is a decent addition, and mark what's superseded. The owner approves the list before adoption.
2. DYNAMIC DEPTH: Rune commands both panes equally, understands the dichotomy inherently, and puts the right resources into each dynamically — no fixed pane budget, an intelligent allocation.
3. CONTEXT INTELLIGENCE: the neurons + sleight-of-hand machinery keep context low while full persona stays AVAILABLE — pulling persona context where it contextually matters, for the right contextual output. (Not a fixed token budget — an intelligent system.)
4. EDIT SURFACE: all three — the truth file, journal + rollback, AND the TUI editor (/persona) over it.
5. MIGRATION: EVERYTHING migrates for the owner's local session (the full lived store); a production version (different, privacy-shaped) comes later after the concept is proven.
6. CONSTITUTION: DEFERRED — a shippable untouchable (encrypted) constitution is a later revision; do not block the persona build on it.
### D42 addendum — NO LOCAL DEFAULT; CLOUD IS FIRST-CLASS (owner, 2026-10-18: "i dont want ollama as default. i want to choose to use that. i want the default to be a cloud provider")
1. Ollama loses its privileged position: NOT pre-selected, NOT default-positioned in the catalog, NOT the implicit fallback anywhere. It is one choice among many.
2. CLOUD PROVIDERS ARE FIRST-CLASS in the setup wizard: connecting a cloud provider (API key from the vault, connection test) is a supported FIRST-RUN path, equal to local.
3. The default model is whatever the owner EXPLICITLY picks in the wizard — never inferred from locality. First pick = default for both panes (unchanged D37 law).
### D41 addendum 2 — LIVE THINKING UX (owner, 2026-10-19)
1. EXPANDABLE WHILE THINKING: the thinking bubble expands DURING thinking, not only after — live thoughts unfold as they stream.
2. CLICKABLE: the expand control is clickable (click region on the marker/bubble line), alongside ctrl+t.
3. DOTS ANIMATION: the thinking animation is "thinking . . ." — dots appear LEFT TO RIGHT after the word, each dot a NEW runic symbol (the celtic/cthulian mix), cycling from the left when the row fills. Not a spinner in place — an appearing-dots walk.
4. PLACEHOLDER: the input box placeholder is just "type in chat" (no affordance list — commands live in the palette and the / overlay).
5. BOX PRESENCE: the input box grows more generous (taller/padder) so it reads as an obvious place to type — natural, inviting.
### D41 addendum 3 — NO PREFIXES IN BUBBLES (owner, 2026-10-19)
Chat bubbles carry NO text prefixes — the "you ·"/"rune ·" markers are removed from the bubble content. Identity is already spoken by the bubble itself: side (you right / rune left) and color (cyan / green). The purple diamond stays on rune's EVERYTHING — thinking bubbles AND her answer bubbles alike: it is her signature mark on all her words (owner: 'keep the purple diamond for runes answers tho'); timestamps stay at the bubble corner. Non-bubbled roles (system, error, research, tool) KEEP their textual markers — they have no side/color to speak for them.
## D43 — THE BUBBLE/HUD HARDENING (owner, 2026-10-19, fifteen rulings)
1. HARDEN: the bubble UI logic is locked clean — nothing interferes with it; amenities only when the owner asks.
2. TIMESTAMPS ACCURATE + LOCAL: reflect the person's machine timezone per message (low cost: local-format the UTC record at render).
3. TIMESTAMP SIDE: moved to the OPPOSITE side of the bubble from its current position.
4. DIRECTION-AWARE PLACEMENT: USER ON THE LEFT for left-to-right languages, rune right — INVERTED for right-to-left language locales (he/ar/fa/ur detection via locale, setting-overridable).
5. ONE THINKING STREAM: no before/after duplication — the live thinking bubble BECOMES the history thinking bubble (one stream per message).
6. NO-DUPLICATION POLICY: rune's answer never renders twice (completion-applied bubble and durable row are ONE fact — harden the claim law; frozen no-dupe tripwire).
7. THINKING IS CLICKABLE (the marker, the line, the whole collapsed row).
8. Thinking stays with its message in CHAT (owner accepted: tasks-pane thinking is too messy); tasks pane keeps its own work-stream thinking.
9. BORDERS: dashed → SOLID, same colour as the box (pink family); ALL boxes solid pink borders.
10. COMPOSER (the type-in-chat box) is ALWAYS lit with the pink outline; the selected pane lights pink outline when selected, GREY outline when not.
11. INFO BAR: a clean information bar above or below the composer replaces the messy far-bottom bar.
12. BOTTOM BAR STRIPPED: remove status=RUNNING (running is proven by working), focus=chat (visible in selection), RAIL, seq=N, runtime lib:connected. KEEP: version truncated to semver (0.314.0 not 0.314.0-56-g...), CONTEXT WINDOW in-use/available (accurate: engine reports tokens used vs the model's context limit from the registry).
13. THINKING LINE: "◆ thinking <ctrl+t hint> <animation>" — the animation capped at 3 glyphs, the ctrl+t hint BEFORE the animation (nothing chases the walk).
14. GHOST PLACEHOLDER: "type in chat" ghosted, vertically centered, with a BLINKING CURSOR indicating chat-here.
### D43 addendum — THE HARDENING MEANING (owner chose option 3, 2026-10-19)
The bubble UI is locked against SILENT and UNINVITED change — mechanically, not by promise. Three enforcement layers:
1. FROZEN PINS: golden fixtures + tripwires pin the bubble's geometry/colors/alignment/visual states — any render change turns the suite RED; pin updates are visible in diffs.
2. NAMED TERRITORY: the bubble renderer files are owned surface (domain registry) — factory waves do not edit them without a brief naming the reason.
3. CHANGES ROUTE THROUGH THE OWNER: visual changes to the bubbles ask the owner first (OpenSpec-starting-point law + D35 §2); repairs (restoring the pinned shape) land red-first as normal — the lock protects the design, never the bugs. Never locked against the owner.
1. SCROLL WHEEL/UI in BOTH panes: a visible scrollbar indicator while scrolling that FADES when not in use (the modern-editor pattern — visible on activity, transparent at rest). Scrolling the chat history per the landed scrollback law; the tasks pane scrolls its work stream the same way.
2. OUTLINE COLORS STILL WRONG (second correction): the chat TEXT colors are correct — the OUTLINE colors are not. The outlines follow the D43 law (solid, pink family, composer always lit, selected pane lit / unselected grey). The wave must diff outline color assignments against the law's color table — not the text colors, the borders.
3. TUI DESIGN PRINCIPLES: a research round on presenting a terminal UI — the design canon (hierarchy, restraint, motion discipline, information density, color systems for terminals) so future visual choices follow principles, not ad-hoc taste. Feeds the owner's iteration loop.
### D43 addendum — ARBITRATION + TIMESTAMPS + THE LAYER LAW (owner, 2026-10-19)
1. ARBITRATION RULED (canon P3): one alive element wins — while Rune thinks, the bottom-rail cluster goes STILL (count only); the rail animation resumes when the thinking resolves. The rail exists to be seen, not to move.
2. TIMESTAMPS: intelligently placed (the same relative position regardless of sender) and DEMPHASISED — their importance is low; dim, unobtrusive, never competing with message content.
3. THE LAYER LAW (owner architecture ruling): every visual element of the TUI is an INDEPENDENT LAYER with its own scaffold/state — border, content, cursor, scroll indicator, animation each render in their own layer, and a change or defect in one must never corrupt another (the cursor punching a hole in the composer border is the motivating defect). Layers compose at render time; interactivity may couple them deliberately; accidental coupling is a defect. Each layer gets its own tests (its own scaffold, in the owner's words) — a change to one layer's state cannot alter another layer's rendering.
### D43 addendum 2 — LAYERS RELATE TO THE PROJECT (owner correction, 2026-10-19)
The Layer Law's independence is INTERNAL isolation, not project isolation: each layer has its own scaffold/state/tests WITHIN the tui project's scaffolding system — registered in the same construction store, admitted through the same contracts, checked by the same authority, versioned with the project. Isolation means a change to one layer's state cannot silently alter another layer's RENDERING; it does NOT mean layers live outside the governed build. Every layer scaffold is a project citizen: contract, tests, pins, and the issue ledger all track it with the rest.
1. GHOST KEY HINTS: the composer shows ghosted "enter send · shift+enter newline" hints that DISAPPEAR the moment typing starts (ghost-at-rest, gone-when-typing — the affordance teaches, then vanishes).
2. COMPOSER NEVER SCROLLS: the composer must NOT behave like a scrolling viewport while typing (the weird line-influence effect) — the composer fits its 3 rows and wraps internally; scroll behavior is for the panes only.
3. WORD-WRAP NEVER BREAKS WORDS: wrapping breaks at word boundaries ALWAYS — a word reaching the edge moves WHOLE to the next line, never splitting mid-word (observed: "my" split to "m/y" at pane edge). Applies to chat bubbles, composer, all text surfaces.
4. COMPOSER CLICK PRESERVES PANE CHOICE: clicking the composer after selecting a pane keeps THAT pane's focus — the composer serves whichever pane is selected; clicking it must never default back to chat. The composer is the shared instrument; the panes set its destination.
5. (Reward for catching these: the Layer Law holds — each defect was an isolated layer failing, never cascading.)
1. MODEL PICKER = CENTERED WINDOW, NOT FRONT-LOADED GATE: model selection must NOT block the composer (currently typing anything demands a pick first). Instead: typing with no model chosen opens a CENTERED floating window (mimocode-style) listing ALL providers, SEARCHABLE (type to filter), up/down arrows to walk, enter to choose, esc to dismiss-and-keep-typing. The picker is an overlay on demand, never a gate in front of the input.
2. API KEYS: port ALL api keys from mimo code without altering them (the 15-secret lossless migration already landed into the OS vault — verify nothing was altered/mangled in translation and every registry row still resolves).
3. CLOUD CONNECTIVITY PROOFS: every cloud provider connection must actually prove connectivity (a real endpoint probe). Providers the owner holds keys for: prove live. Providers without keys: the probe path is the same principle (endpoint reachable, auth attempted, honest error) — but marked untestable-by-owner rather than claimed.
### D43 addendum 5 — SCAFFOLDING STATUS LINE + GATED-WORK ANIMATION (owner, 2026-10-19)
1. SCAFFOLDING STATUS LINE (owner spec): when scaffolding is in play, the tasks pane shows: "scaffolding · <loading animation> · <its stage>" — e.g. "scaffolding ⚒ admit", "scaffolding ⚒ build", "scaffolding ⚒ verify", "scaffolding ⚒ land". The loading animation uses the gated-work rhythm (hammer/ladder glyphs per the owner's hammer-and-ladder ruling); the STAGE is the contract's real phase from the kernel state (admit/build/verify/land — never a guess). Appears when a governed contract is active; self-extinguishes when it closes.
2. HAMMER-AND-LADDER WALK: the gated-work animation is the dots-walk pattern with hammer/ladder glyph vocabulary (⚒ ⛏ 🪜-class glyphs, font-verified per detect-then-render; the shuffled runic/cthulian vocabulary remains for THINKING — gating gets its own trade vocabulary so thinking and building read differently at a glance).
3. IMAGES: viewable in-terminal (Kitty/sixel protocols; Konsole supports; graceful degradation to links elsewhere per the degrade-silently principle); analyzable when a vision-capable model is connected. Recorded as capability, not a wave yet.
4. INESCAPABILITY: the machinery-first stack (launch guard → admission → scope-checked mutations → landing gate → durable lock) IS the law — "please build X" puts every step inside scaffolding regardless of model. The adversarial-escape audit (try to escape, close every hole) is queued as its own wave.
### D43 addendum 5 (cont.) — ALL WORKHORSE VISUALS LIVE IN THE TASKS PANE (owner, 2026-10-19)
Ruling: ALL coding/workhorse-related visuals belong in the TASKS pane — scaffolding status line, work blocks, queue rows, sub-agent window, gated-work animations. The CHAT pane stays conversational (messenger law); the TASKS pane is Rune's workshop window. Both addenda recorded and queued: the scaffolding status line + hammer/ladder animation + the adversarial-escape audit + image capability (recorded, not queued) all route to the tasks-pane wave.
~/.venvs/memory/bin/python3 -m rune ← interpreter: the memory venv, NOT repo .venv
```
Authority rows (current vs intended vs dormant):
| Surface | Current authority | Intended (per openspec) | State |
|---|---|---|---|
| Launcher script | owner (hand-installed; not owned by any repo module) | unchanged for the Python face | current |
| Runtime code | `rune-code/current` generation (deploy pipeline output) | same mechanism, newer revisions | current, stale |
| Runtime identity | `rune/__init__.build_info()` + `_build_identity.json` stamped by `deploy_stage.py` | same (already landed 2026-09-10 handoff) | current |
| Data home | `RUNE_HOME=/mnt/workdrive/rune` (the dev checkout doubles as the live data dir: `state/`, `store/`, `memory/`) | pin stays; code deploys never move user data | current |
| Memory dir | `RUNE_MEMORY_DIR=~/.config/opencode/memory` (promotion ledger + memory store live here) | same | current |
| Deploy qualification | `scripts/deploy_qualify.py` + CI required-checks (fail-closed after the 0.66.28/29 incidents) + `scripts/tui_startup_canary.py` pre-promotion canary | same | current |
| Receipts / tamper evidence | `src/rune/audit_ledger.py` — HMAC-chained ledger under RUNE_MEMORY_DIR (key lineage repair is Task 0.2, out of scope here) | same | current |
| Go face (`tui/cmd/rune-tui`, `src/go/rune-entry` front door :8377/:8376) | exists ONLY in the checkout; nothing deployed runs it | launcher target once 0C/0D converge | **dormant** |
| Paired-build attestation (`src/rune/build_attestation.py`, task 0.14) | checkout-only (Go↔Rust build pairing; a different attestation from this one) | gates future paired artifacts | dormant until next deploy |
Surprise worth naming: **the dev checkout is also the live system's data
home.** `RUNE_HOME=/mnt/workdrive/rune` means the deployed runtime reads and
writes state inside the factory worktree (`state/`, `store/scaffold`,
`memory/journal`) — the same files the test suites mutate. That is why test
runs dirty the live store and why background workers must restore journal
churn after every run.
## 3. Module drift — deployed `81099a11` vs checkout `ed245b2a`
"_law":"READ BEFORE PORTING. Proven Python→Go/Rust traps from the dichotomy wave (evidence: landed batteries + agent reports). New quirks entered WITH the module name + date that proved them.",
"quirks":[
{"trap":"str.rstrip(':') strips ALL trailing chars in the set, not one suffix","port":"Go: strings.TrimRight(s, \":\") NOT TrimSuffix","proved_by":"failure_auto_filer (errorClassOf)"},
{"trap":"str[:n] slices by CHARACTERS (codepoints)","port":"Go: rune-safe truncation (TruncateRunes), never byte-slicing","proved_by":"sleep_time"},
{"trap":"Python round() = banker's rounding (ties-to-even)","port":"Go: math.RoundToEven; Rust: same semantics via to_xxx_rounded half-to-even","proved_by":"provider_registry (size_gb)"},
{"trap":"id(x) via hash() is process-randomized (PYTHONHASHSEED)","port":"frozen truth rows must pass entry_id; None branch pins the id_prefix/entry_none shape","proved_by":"memory_consolidation"},
{"trap":"json.dumps(list/dict) preserves INSERTION order; Go json.Marshal sorts map keys","port":"Go: explicit order []string ledger or pyjson/pyDumpsSorted with sort_keys semantics; hashes over dict state must control key order","proved_by":"context_broker, build_mode"},
{"trap":"json.dumps default separators ', '/': ' differ from Go Marshal's ','/':'","port":"byte-parity serializers replicate the separators + ensure_ascii","proved_by":"context_broker (pyDumpsSorted)"},
{"trap":"integral floats render '3' (Python) vs '3.0' (JS/Rust float64 JSON)","port":"integral-float rule in float rendering; keep integral floats OUT of hashed corpora","proved_by":"context_broker"},
{"trap":"bool is a subclass of int — `context_length: true` == 1 (truthy)","port":"Go must REJECT bools where Python accepts int/bool union — divergence documented, truth frozen on the oracle shape","proved_by":"local_tool_runtime"},
{"trap":"dict/set ordering: list(set(...)) is hash-random per PROCESS","port":"live parity normalizes 'files' order; frozen truth avoids set-ordering exposure via sorted() capture","proved_by":"work_manager"},
{"trap":"Exception TYPE names are stripped by str(e) — ValueError: prefix gone","port":"the MESSAGE is the contract; envelope err carries message only","proved_by":"local_tool_runtime"},
{"trap":"datetime imported INSIDE functions — module-level patch doesn't reach","port":"pin_clock rig (subclass datetime with frozen classmode) or now-always-an-argument","proved_by":"memory_consolidation, sleep_time"},
{"trap":"expanduser('~') path derivation at IMPORT time","port":"pin_home rig BEFORE oracle import; frozen truth carries repo-relative or placeholder paths only","proved_by":"work_manager"},
{"trap":"Go maps marshal sorted vs Python insertion order","port":"byte-parity fixtures control key order explicitly (first-occurrence splice + sorted-key generator dicts)","proved_by":"build_mode"},
{"trap":"go test green does NOT imply go build green","port":"gate on go build ./... too — Phase B production code must never call _test.go helpers","proved_by":"build_mode (DispatchGap)"},
{"trap":"oracle CRASH parity: if the oracle crashes (AttributeError etc.) on an input class, the port returns the matching error envelope","port":"never silently skip — the facade's fallback reproduces the exact exception","proved_by":"execution_trace fuzz"},
{"trap":"glob+mtime ordering ties within the same second","port":"explicit os.utime in test fixtures; deterministic per-case dirs","proved_by":"sleep_time"},
{"trap":"Go evaluation order: arg-list trace(x, f.Mutating()) snapshots BEFORE mutation; Python passes live references","port":"capture returns/reports into locals first","proved_by":"failure_auto_filer"},
{"trap":"absolute temp paths in frozen truth are machine-specific","port":"repo-relative names or REPO_ROOT placeholder + battery substitution","proved_by":"paths"},
{"trap":"ThreadPoolExecutor.submit AFTER shutdown raises from the submit loop itself — run_parallel's per-task capture never sees it, the WHOLE call raises","port":"Go port panics with 'cannot schedule new futures after shutdown' at the same site (crash parity, recovered by battery/parity)","proved_by":"parallel_processor (2026-10-14)"},
{"trap":"callable corpora cannot ride JSON truth rows","port":"freeze a shared kind/fn/value SPEC grammar via a rig that builds real Python callables; the battery rebuilds Go tasks from the same rows (extends the memory_consolidation seam pattern)","proved_by":"parallel_processor (2026-10-14)"},
{"trap":"threading.active_count() in oracle output is process-random (pool threads, harness state)","port":"pin via rig patch to a constant; Go side reads the matching PP_ACTIVE_THREADS seam (default: native goroutine count)","proved_by":"parallel_processor (2026-10-14)"},
{"trap":"f'{x:.0%}' scales the DOUBLE's exact decimal expansion by 100 then rounds half-even; a binary r*100.0 multiply can sit 1 ulp off the tie and round differently","port":"Rust format!('{:.0}%') matches on exactly-representable ratios; frozen truth pins ties with power-of-two denominators only (1/8 → 12.5% → '12%')","proved_by":"self_improve (2026-10-14)"},
{"trap":"datetime.fromisoformat raises on out-of-calendar fields (month 13, Feb 30, day 0, hour 24 with nonzero minutes)","port":"Rust fixed-position parsers must validate ranges (leap-year month lengths; h<=23 or ISO hour-24 end-of-day with zero min/sec) or they compute off-calendar epochs the oracle never sees","proved_by":"tier_manager (parse_strict_aware crash class, 2026-10-14)"},
{"trap":"json.dumps default ensure_ascii=True escapes ALL non-ASCII as \\uXXXX (lowercase hex, astral chars as surrogate pairs); serde_json emits raw UTF-8","port":"byte-parity emitters need a py_escape pass over strings for BOTH compact and indent shapes — separators-only parity is not enough (extends the context_broker pyDumpsSorted law)","proved_by":"inference_trace (serialize/format_record unicode rows, 2026-10-14)"},
{"trap":"list[-limit:] with limit=0 keeps ALL lines (-0 == 0 slices from the start), so read_traces(limit=0) returns everything, not nothing","port":"Rust limit match arms must special-case Some(0) => all items (read_select + cli_tail); rev().take(0) silently returns none","proved_by":"inference_trace (limit-0 truth row, 2026-10-14)"},
{"trap":"a kernel Err on inputs where the oracle RAISES (e.g. malformed JSONL line) loses end-to-end parity if the kernel instead silently skips","port":"propagate the Err through the FFI envelope — the facade's except-fallback then re-runs the Python path, which re-raises the AUTHENTIC exception (message parity by construction); pin the crash CLASS in truth rows when the cross-language message text cannot match","proved_by":"inference_trace (read_select ValueError class, 2026-10-14)"},
{"trap":"Python 3.14 OSError.__str__ QUOTES the filename: str(e) = \"[Errno 21] Is a directory: './path'\" (<=3.13 emitted it bare)","port":"Rust errno mapping must single-quote the path in the message AND strip the ' (os error N)' suffix of io::Error Display; pins are interpreter-version-shaped — re-freeze when the oracle python changes major","proved_by":"dependency_tracker (frozen battery row 20, 2026-10-14)"}
_Regenerate with `python3 scripts/dichotomy_audit.py --write`. A module is FULL only when 80%+ of its Python functions have name-preserving counterparts in the Go/Rust implementation — directories without the functions are facades and count as NOT TOUCHED._
**FULL completion: 28%** (54/192 runtime modules at FULL)
**FULL completion: 80%** (154/193 runtime modules at FULL)
Function-level detail: 54% (1290/2376 runtime functions matched) — secondary; includes in-flight work
Function-level detail: 85% (1933/2283 runtime functions matched) — secondary; includes in-flight work
| Status | Modules | Lines | Meaning |
|---|---|---|---|
| FULL | 54 | 21059 | 80%+ of functions ported |
| PARTIAL | 94 | 40967 | 20–80% — real logic exists, gaps named below |
| NOT TOUCHED | 44 | 11346 | no name-preserving implementation |
| Total runtime | 192 | 73372 | |
| FULL | 154 | 65153 | 80%+ of functions ported |
| PARTIAL | 0 | 0 | 20–80% — real logic exists, gaps named below |
| NOT TOUCHED | 39 | 11058 | no name-preserving implementation |
| Total runtime | 193 | 76211 | |
## NOT TOUCHED — the port queue, in priority order (largest first)
@@ -98,3 +98,83 @@ The factory auto-scales agent assignment based on module size:
| > 1500 lines | Coordinator ports directly (Rune) | Load-bearing; agent context can't hold the full oracle reliably |
The batch prompt template includes a "read the module, decide if it fits, skip if it doesn't" instruction so the agent self-reports when a module is too large for the batch context.
## VERIFY-GATED SUBMISSION (absolute, Nick 2026-10-13)
Nothing is submitted to gitea/master that has not passed the verification
stages in the *submitting* checkout. Concretely, for each landing:
1. Frozen-truth battery runs green and reproduces byte-identical
(`freeze_truth.py --verify` against the live oracle).
1. CHAT LIVE — real conversations through the lane (library seam → model-routing → streaming)
2. TOOLS LIVE — dispatch wired through chat (toolexec in-process)
3. VISUAL ROUND — three grounded design directions on the working base; owner critiques with portrayal tooling; providers designed here (first-run floor philosophy: extensive cloud+local list, easy connect)
Landed this round: 16 (see git log + MORNING-TEST).
## Factory standardization law (owner directive 2026-10-17)
The factory pattern (contracts, red-first tests, Scaffolding admission, verify-gated landing, continuous backfill) becomes a CORE RUNE FEATURE — standardized into the codebase itself, not just this session's process. Scale path: 30 now → prove thoroughness (testing, linting, scaffolding respected, everything proven functioning) → 50 → more. Scale-up is evidence-gated: thoroughness maintained at N is the precondition for N+20.
## Owner's Definitive Answers (2026-10-17 — binding, recorded for unattended factory operation)
Owner needs to give pointers and iterate on the three design directions. DEFERRED if running overnight — build the three directions, the owner critiques when present. Factory does NOT pick autonomously.
### 3. Retirement campaign — OWNER CONFIRMS EACH
Each concept/feature: parity harness proves identical → owner confirms it works → deletion wave executes for that feature. NOT autonomous deletion. The checkpoint is the owner's real-world usage test, not just the harness.
### 4. Features added to the spec
- **Sandboxing** — the sandbox suite for tool execution (the 0.9(d) default-deny + grants infrastructure exists; this is the fuller sandboxing capability)
- **Bridge to ChatGPT and online providers** — the cloud provider bridge beyond Ollama (OpenAI, Anthropic, etc. — the extensive provider list + the actual chat connections)
### 5. Cognition socket — HEAVY, NOT LIGHT
This is a serious, year-scale development project. Not a light topic. The factory does NOT casually build it. When opened, it gets its own research protocol, its own adversarial rounds, its own owner-directed design. The socket stays reserved; the work begins only with the owner's explicit, informed go — understanding the scale.
### 6. Stop conditions — CONTINUOUS WORK + RECORDED STOPPING POINT
The factory is done after: (a) specifying what work needs to be continuous (memory consolidation, drift checks, scheduled jobs — the autonomic system) and (b) a stopping point is recorded (the spec implemented, Python retired, the continuous work defined). The factory doesn't run forever; it runs until the stopping point.
## ISSUE-LEDGER LAW (owner, 2026-10-19: "are issues being made and closed on gitea as improvements are being made so versioning stays correct?")
Every landing files/links a Gitea issue and closes it in the same change — the issue ledger tracks improvements the way tags track versions. Batch retroactive filing (#2491-#2497) covered 2026-10-18's work. Going forward: the main session files the issue at landing time (or the wave brief names it); the commit message carries "closes #N" so the push closes it. The version clock and the issue ledger stay in lockstep.
## WAVE-BRIEF COMPLIANCE LAW (owner audit, 2026-10-19)
Every build-wave brief MUST carry the three standing requirements verbatim: (1) SCAFFOLDING ADMISSION — mint the construction contract via the admit script before building (scripts/admit_wave_*.py pattern; no freehand edits outside the scaffolding authority); (2) ISSUE LEDGER — name the Gitea issue (main session files/closes at landing); (3) RESEARCH GATE — PROCEED chain or declared exemption, per the mechanical gate. Briefs missing any of the three are non-compliant — the spawner (main session) owns the omission. Today's interactive-session waves were spawned without (1) — recorded as drift; the backfill wave registers the omitted contracts.
Backfill landed 2026-10-19 (scripts/admit_wave_backfill_interactive_2026_10_18.py): seven contracts minted retroactively at their honest landed state — ADMIT-wave-chat-surface-d34-36 (58d8ae97), ADMIT-wave-go-turn-engine-cloud-routing (0d99d5a7), ADMIT-wave-d41-amalgamation (8e1a09e1), ADMIT-wave-task-ledger-d38 (ca915c60), ADMIT-wave-convergence-landing (e4514523 + original aa5f1917), ADMIT-fix-history-bubble-landed (4347ad05), ADMIT-wave-firstrun-cloud-first (2ba3a437) — each closed on landing-sha evidence with the landing commits' verification receipts recorded verbatim (not re-executed); registry entries added for factory-visual-round, factory-providers-live, and the task-ledger exemption.
"law":"Owner directive 2026-10-16 (docs/factory/spawn-queue.md): every feature wave runs the canonical research protocol FIRST (ISSUE, INWARD, OUTWARD, APPLICABILITY, INNOVATION-on-merit, ADVERSARIAL, SYNTHESIS, QUALIFY); the build wave spawns only on QUALIFY: PROCEED; MORE_RESEARCH loops back with named unknowns. This registry maps feature slugs to their research artifact chains so scripts/check_research_gate.py can enforce the law mechanically (admission-time gate + post-hoc sweep). Exemptions must be declared explicitly, never silent: mechanical-repair (spec-pinned, research exists at spec level), test-doc-only, owner-directive (directive quoted).",
"gate":"scripts/check_research_gate.py",
"updated_at":"2026-10-19",
"entries":[
{
"slug":"tui-build-program",
"match":[
"wave-*",
"wave",
"rune",
"tui",
"boundary",
"g-series",
"h-series",
"i-series",
"j-series",
"k-series"
],
"chain":"research/tui-frontier-r2/qualify.json",
"verdict":"PROCEED",
"note":"The add-native-rune-tui build program (B/C/D/E/F/G/H/I/J/K wave series under docs/openspec/changes/add-native-rune-tui/) executes the R2 frontier round; every program wave dispatch cites the round (e.g. admit_wave_seam_registry.py evidence refs)."
"note":"Owner verdict YIELDS (docs/architecture/boundary-law.md: token_counting end-to-end YIELDS; prototype-only, production migration wave 1 opened under the standing directive). Prototype rounds resolve through this chain; a production wasm migration wave requires its own PROCEED round."
},
{
"slug":"memory-continuity",
"match":[
"*memory-continuity*",
"sleight-matrix",
"sleight-deliverables"
],
"exemption":{
"category":"mechanical-repair",
"reason":"Spec-pinned: research exists at spec level (Sleight memory-context-continuity evidence, bound by the B-SLEIGHT-MATRIX / B-SLEIGHT-DELIVERABLES briefs); bounded mechanical execution, no new research questions."
}
},
{
"slug":"bounded-mechanical-repairs",
"match":[
"repair-worker",
"repair-*",
"*-repair",
"fix-*"
],
"exemption":{
"category":"mechanical-repair",
"reason":"Bounded mechanical repairs dispatched against already-researched, spec-pinned defects (e.g. the five 0.9 defects cite the R2 round); no new research questions opened."
}
},
{
"slug":"substrate-ci-machinery",
"match":[
"substrate-worker",
"trial-worker",
"*-harness-check",
"research-gate",
"fuzz-*"
],
"exemption":{
"category":"owner-directive",
"reason":"Substrate/CI machinery (boundary codegen corpus, landing checks, harness trials, the research gate itself): per owner directive these are mechanical infrastructure, not feature waves; quoted from the research-gate enforcement dispatch: 'this wave is substrate/CI machinery \u2014 exempt as mechanical infrastructure, exemption recorded: research-gate machinery itself, per owner directive'."
}
},
{
"slug":"issue-161",
"match":[
"issue-161"
],
"chain":"research/issue-161/qualify.json",
"verdict":"PROCEED",
"note":"Per-issue research rounds live at research/issue-<n>/qualify.json (verdict in the outcome field); the gate's direct-dir resolution research/<slug>/qualify.json handles every other issue slug before any registry fallback."
},
{
"slug":"domain-registry",
"match":[
"domain-registry",
"domain_registry",
"query-domain",
"wave-domain-registry"
],
"exemption":{
"category":"owner-directive",
"reason":"Owner dispatch (wave-domain-registry, 2026-10-17): the registry machinery IS the response to the owner critique that diagnosis was grep-exploration instead of scaffold lookup \u2014 the deliverable is registry data + lookup tooling over EXISTING authorities (docs/retirement-map.md, store/rebase/classification.json, package dirs), introducing no new research questions. Directive: 'Build the missing map.' Scope law (docs/factory/spawn-queue.md, owner amendment 2026-10-17) names the registry machinery itself as exempt with approval_ref 'user:wave-domain-registry dispatch'.",
"reason":"Owner dispatch (wave-rune-launcher, main session 2026-10-17): standardize the `rune` command so typing rune boots the new Go TUI face \u2014 launcher standardization is build/deploy plumbing over already-researched surfaces (paired build D26 scripts/build_paired.sh, update-apply D27 tui/update, the python-era ~/.local/bin/rune pinned verbatim as the honest fallback), no new research questions. approval_ref 'user:wave-rune-launcher dispatch'.",
"approval_ref":"user:wave-rune-launcher dispatch"
}
},
{
"slug":"firstrun",
"match":[
"firstrun",
"first-run",
"wave-firstrun",
"b-first-run",
"*firstrun*"
],
"exemption":{
"category":"owner-directive",
"reason":"Owner dispatch (B-FIRST-RUN, docs/factory/spawn-queue.md NEW PRIORITY 0 + 'First-run law' + 'Fresh-state detection' directives, 2026-10-17): the first-run experience \u2014 fresh-state detection (no provider record + no checkpoint), the welcome/provider-list/model-list/connection-test face (tui/firstrun), and no-default-provider enforcement (chat gated until an explicit selection). The behavior contract is pinned at directive level (the spawn-queue directives quote it); bounded build against the frozen provider_selection.json record law already shipped by the chat-live groundwork, no new research questions. approval_ref 'user:wave-firstrun dispatch'.",
"note":"Spec 6.2/6.2a/6.3 self-transformation waves (openspec task 6.2): the self-transformation research chain completed QUALIFY: PROCEED with D01-D10 owner decisions recorded in the dedicated interview; the build binds synthesis.json exact_candidate_flow (13 stages) with RM01-RM15 + IAM01-IAM22. First consumer: wave-K27-self-transform (src/rune/self_transform_pipeline.py)."
"note":"Owner-asked research round (2026-10-18): 'do research into how to setup chat boxes for harnesses in go' \u2014 the chat input surface (backspace defect root cause: key-spelling fork semantic vs ultraviolet; input box as its own layer). Headline: charm.land/bubbles/v2 v2.2.1 (already pinned, zero go.mod change) ships textinput/textarea/viewport \u2014 the prior 'stub pin' belief was vendor pruning. Build waves for the composer/chat box cite this chain."
},
{
"slug":"apikey-migration",
"match":[
"apikey-migration",
"api_key_migration",
"wave-apikey-migration",
"B-APIKEY-MIGRATION"
],
"exemption":{
"category":"owner-directive",
"reason":"Owner dispatch (wave-apikey-migration, 2026-10-17, spawn-queue.md#B-APIKEY-MIGRATION, owner-critical): lossless port of ALL API keys and saved connections from mimo code (~/.config/mimocode/mimocode.jsonc, ~/.local/share/mimocode/auth.json, ~/.config/opencode/*, ~/.local/share/opencode/auth.json, ~/.rune/model_state.json) into rune's provider store. Deterministic scan\u2192map\u2192apply\u2192verify machinery + frozen round-trip battery (tests/test_apikey_migration.py, red-first) + secret store per the security law (OS keyring / Secret Service / encrypted fallback, never plaintext in UI/logs). No new research questions. approval_ref 'user:wave-apikey-migration dispatch'.",
"note":"Owner-ordered research round (2026-10-18, D36 era): 'we need to not block the interactivity of being able to talk to the chat pane whenever a task pane task chat message is sent... the chat and the task panes need to operate on separate turns.' The round maps the exact blocking points (dispatch_lock at core_server.py:199 wrapping the whole turn; unsynchronized operator state; full-checkpoint saves measured 2.2MB; task-channel-bound context assembly), verifies Ollama concurrency semantics live (stateless /api/chat, default per-model FIFO queue, OLLAMA_NUM_PARALLEL memory multiplication, engine caveats), and surveys crush / Claude Code / RQ harness+queue patterns. Verdict PROCEED with five named owner decisions (OD-1 model-slot policy is the only hardware-cost call). Build waves for the dichotomy cite this chain."
"note":"Owner-ordered research round (2026-10-18, D38 deferred the decision to it): 'can you fully explain the issue first so i can diagnose approaches and also suggest a multitude of approaches after research on this specific issue' \u2014 the operator.json full-rewrite checkpoint (measured 2,307,627 bytes, 96.3% immutable task history, ~25ms per save, 3-5 saves per turn, truncate-then-stream with no atomicity, silent reset to defaults on torn load). Mid-round D39 ruling reframed the target ('keep the intention of what was meant to be finished in python and just move to go and fix the go version properly'): the decision matrix feeds the GO core's storage design \u2014 SQLite via modernc.org/sqlite (D30-legal, memory-ops precedent, pin >=3.51.3 for the WAL-reset fix) vs bbolt vs journal+snapshots (K25 generalized) vs atomic per-subsystem JSON, plus hybrids and an honest Rust-sidecar dismissal (sled self-disqualifies; redb is D30-hostile). 8 live sources with URLs; migration axis first-class per owner addendum; Python stopgap (atomic_write + terminal-task retirement) as Appendix S only. NO single recommendation \u2014 owner diagnoses."
"note":"Owner directive D37.4 (2026-10-18, boundary-law.md): 'RUNE THE ORCHESTRATOR: her intelligence OWNS all models in play, thinks independently from them, and interprets how best to route context across every model in play. The models are workers; Rune is the mind above them.' Research question: how to architect the orchestrator layer above multiple model workers (chat+task panes, local+cloud) given the landed Go turn engine (ModelClient seam named in engine.go as the D37 insertion point), the advisory rank() port + trust gate (G1-G5, paid spend = hard-ask), the adaptive-router effort classes, the warm-router budget law, and the D40 per-channel journal+SQLite storage shape. 5 live sources: LiteLLM router (rules cascade + ordered failure ladder + sticky sessions + reject-not-queue), OpenRouter auto router (lightweight task classifier -> measured spend-share ranking -> cost bands -> graceful degradation), RouteLLM (tiny learned routers beat LLM judges; 85% cost cut at 95% GPT-4 quality), Anthropic orchestrator-workers (plan-to-memory, task-descriptions-down, digests-up, 15x token cost, resume-from-checkpoint), LangGraph supervisor (handoff-as-tool-call, output_mode knob, forward_message). Synthesis: OrchestratorCore implements ModelClient above the engine (frozen laws untouched; phase-1 pass-through proven by frozen tests); three-tier decision cascade (rules -> measured -> optional tiny judge, off by default); orchestrator context in a dedicated D40 channel (decisions+receipts+verdicts, never worker transcripts); context composition via ContextBroker contributor port (cross-channel contributions explicit+gated); failure ladder = local fallback in-turn, cloud never mid-run (start-tier law), cooldowns, sticky-with-re-ranking, pass-through degradation. 4 owner decisions pending (OD-1 judge tier, OD-2 context placement, OD-3 escalation posture, OD-4 supervisor phase). No code changes."
"note":"Owner-lawed research round (2026-10-18, D36 section 2, boundary-law.md:90): the consent bridge - the chat pane detects a conversational message is really a work request, Rune proposes the push with a y/n card, consent starts the task instantly (enqueue, never preempt) with the context frozen as a snapshot at consent time. Closes factory-separate-turns OD-5. The round maps the pre-built machinery (tui/promote SA-D3 ladder + Offer(entries) seam awaiting its runtime; construction_intent.py's ACTION|DISCUSSION resolver with the DISCUSSION-PROPOSAL-USER_APPROVED lifecycle and STALE_GAP_TURNS=2 staleness law, already ci_loader-compiled; the needs_confirm envelope precedent; the D38 ledger's Brief slot fed only the title today at ledger.go:266) and reads seven live sources (Rasa CALM's shift to model-self-reported commands; Mycroft adapt's deterministic require/optionally parser; LangGraph checkpoint immutability; gum confirm; Claude Code permission prompts - scope-bounded yes only when the card shows everything it would allow, harness-enforced not model-enforced; Claude Code queue-while-busy; GitHub required-reviewer approvals). Verdict PROCEED with three named unknowns carried as kill tests K1-K3 (tier-2 tag recall, prompt overhead, suppression threshold) gating phase 2 only. Build waves for the bridge cite this chain."
"note":"The 30->50 evidence-gate round (serves the factory standardization law; confirms the checkpoint-era finding BY MEASUREMENT at ~24 waves): verification throughput binds before spawn capacity \u2014 demand 4-12 landings/h vs ~3.5/h serial ceiling, paid today as debt (20 landings without manifests; check_landing RED on HEAD, 2 unbuildable modules). Inward: worktree tool adoption 0% (zero wave/* branches; 12 stale worktrees; waves share the dirty main tree), python_suite = 94% of the 928s sweep on 1/32 cores, 3 recorded sweep-race incidents + the 2026-10-17 boot-break class. Outward 5 sources (GitHub merge queue docs+GA, bors, Bazel remote cache, pytest-xdist): queue+shard+dedup. Synthesis: measured gates G30.1-7 / G50.1-6, domains.json sharding design (59 domains, batteries per domain + always-global members + serial merged-tree landing gate), throughput budget math (composite ~1-3 min effective checks -> >=2x margin at 50). Known wound: python-domain verdict caching is conservative-first pending the dependency-break tripwire proof. Research only \u2014 no code."
"note":"Owner-ruled research round (2026-10-18, boundary-law.md D36 item 5 verbatim: 'PREDICTION: inline ghost text (dim continuation suggestion, tab accepts, mimocode-style), sourced from local Ollama'; dispatched as 'D35 SS5' which maps to D36 item 5). Latency budget MEASURED on the owner's GPU (RTX 4070 Ti SUPER, ollama 0.40.5): qwen2.5:0.5b/3b answer warm in 5-25ms TTFT / 63-86ms full 12-token suggestion \u2014 an order of magnitude inside the keystroke budget; 14b-class (165ms-8.9s) and thinking models (qwen3 thinking-first emission, 7.9s) measured and disqualified. Live-measured eviction hazard: predictor load evicted a resident 14b (6.7s reload) matching the documented VRAM co-residency law \u2014 small-model default + pre-warm + keep_alive + first-use residency check are requirements. UX laws from six live sources (fish autosuggestions, zsh-autosuggestions async/widget taxonomy, VS Code inline-completion source: Automatic-only debounce + canceled:beforeFetch version law + typingSpeed.ts adaptive debounce, Grounded Copilot arXiv:2206.15000 bimodal finding, Ollama api.md+faq.mdx). Synthesis: Input3 suggestion state + composerView dim suffix + conditional accept precedence (tab while visible; arrow/end at end-of-text) + 180ms quiet window + version-keyed cancel + suppression matrix; predictor model = settings/wizard entry per D37 (qwen2.5:3b recommended, 0.5b fallback \u2014 pulled to the owner's Ollama this round). Five owner taste questions isolated (both-panes-or-chat-first among them); none blocks phases 0-1. qwen2.5:0.5b installed as documented fallback. Research only \u2014 no code."
"note":"B-PERSONA-LAYER round (owner, 2026-10-18: 'runes persona layer is not ported either which is important'; spawn-queue.md B-PERSONA-LAYER). Three-way differential per the chain-audit addendum (OpenCode stack vs MiMoCode stack vs repo) with a 10-component completeness inventory (persona-inward.json). 8 live external sources (Letta memory-blocks, Claude Code memory docs, SillyTavern character design, mem0, arXiv 2310.13548 sycophancy / 2607.28818 ANCHOR persona-collapse / 2605.09863 Nautilus Compass drift detection, OWASP LLM01/LLM07). PROCEED gated on the owner interview (OD1-OD6 in persona-synthesis.json): identity seed, pane depth, always-on budget (reference stack measures ~15K tok/turn; recommendation 1-3K), edit surface, store migration scope, constitution block. Build target: Go core context assembly per D39 (channel-keyed, budgeted persona sub-blocks)."
"note":"Owner visual round (2026-10-18): three direction frames rendered for owner critique (research/factory-visual-round/portrayal/); the D41 ruling (boundary-law.md \u00a7D41, 'after viewing all three renderings') IS the recorded pick the round's phase-2 gate requires. CAUTION: the artifact's verdict field carries prose ('PROCEED \u2014 portrayal-first: \u2026') which the gate's exact-match verdict law REFUSES at admission \u2014 waves citing this chain declare the owner-directive exemption quoting the recorded pick (precedent: ADMIT-wave-d41-amalgamation, the 2026-10-19 compliance backfill) until the artifact verdict is normalized to plain PROCEED."
"note":"Provider-connection research round (2026-10-18): the standardized provider catalog, vault-keyed cloud connections, the drift-gated truth trio. Build waves for the wizard/provider surfaces cite this chain. First consumer: ADMIT-wave-firstrun-cloud-first (the D42 addendum cloud-first wizard, admitted by the 2026-10-19 compliance backfill)."
},
{
"slug":"task-ledger",
"match":[
"task-ledger",
"wave-task-ledger*",
"*markdown-ledger*"
],
"exemption":{
"category":"owner-directive",
"reason":"The D38 task markdown ledger build IS the owner ruling (boundary-law.md \u00a7D38, 2026-10-18, quoted in ADMIT-wave-task-ledger-d38's session directive); the ruling deferred only the CHECKPOINT mechanics decision to the factory-checkpoint-saves round \u2014 the ledger itself was directly ruled with no new research question. Recorded by the 2026-10-19 compliance backfill."
"note":"Research-only mapping wave (2026-10-20) of the agent-mutation-side construction authority port (issue161-harness construction_authority.py + construction_authority_cli.py + scaffolding-guard.ts hook) into rune. Single deep map justified in \u00a70 (machinery move within one code lineage; design fixed by T23 \u00a736 no-parallel-authority law and owner directive). Maps: the begin/check/checkpoint decision pipeline incl. shell operand-position mutation-target scan and lazy postcondition (\u00a71); what ports cleanly onto rune's Scaffold.check_scope/ConstructionInterface/construction_admission substrate (\u00a72); gaps \u2014 activate_from_text front door, completion tail (build_basis/behaviour_ledger dependency, deferrable), PROJECT_ID retarget, internal-ledger list (\u00a73); guard wiring REPO/LOCK/interpreter + durable fail-closed lock (\u00a74); 3-4 day estimate for the mutation boundary (\u00a75); 4-phase plan (\u00a76). PROCEED gated on the four named unknowns in \u00a77 (rune construction_context shape diff, rune ledger dirs, classify_mode deps, canonical guard copy location)."
"note":"Research-only wave (owner directive 2026-10-20: 'i also want some research on ui design on presenting a tui so we can have some design principles to follow'). Deliverable: twelve named, testable design principles (06-synthesis.json) grounded in nine live sources, auditing D34-D43 (10 ratified, 3 new obligations: contrast floor / one-alive-element / token layer), plus nine terminal-fatal adversarial traps. The set is the design-review checklist for future visual waves; implementation waves it implies (color-token table, contrast audit) spawn with their own briefs."
"note":"Research-only wave (owner directive 2026-10-20, verbatim: 'can you look up and research chat design principles to see if we can innovate from them'). Conversation-domain complement to the TUI canon: chat-specific principle set C1-C9 (04-applicability.json, testable), inward audit of D34-D43 (zero conflicts, ten rulings ratified by evidence, four small new obligations), eight live sources, seven terminal-fatal chat patterns (05-adversarial.json), and the innovation list I1-I6 with honest for/against (06-synthesis.json) \u2014 flagship I2 (legibility of the one-composer dichotomy). No construction; every innovation pick spawns its own build-wave brief."
"note":"Research-only interview-prep wave (owner approved the tabs + floating-windows direction for the face, 2026-10-20; design interview BEFORE building). Maps the stack (Bubble Tea v2.1.0 + lipgloss v2.0.6: lipgloss.NewLayer with X/Y/Z coordinates is first-class z-order compositing, Canvas.Compose/Render for the composite surface, v2 mouse protocol covers drag \u2014 tab bars have no library component, lazygit/k9s precedent is hand-built), inventories the face's natural tabs/windows (gauges overlay per D38 V-C, rail takeover, model picker, approval card, hints, build/sub-agent window, event stream) against the D43 Layer Law (library layers now literally enforce the ruling), and writes the 8-question design interview Q1-Q8 with recommended defaults (tabs = build + event stream only; floating = gauges/picker/approval/hints per D38; chat never tabs or closes; tab set persists, scroll does not; window geometry persists clamped to terminal; keyboard parity for every window verb, drag mouse-only; the chat+tasks dichotomy survives with the tab bar above the panes; approval card unclosable while pending). Owner answers become D44+ rulings; no construction performed."
},
{
"slug":"release-pipeline-deepdive",
"match":[
"release-pipeline-deepdive",
"wave-release*",
"*tag-repair*",
"*auto-version*"
],
"exemption":{
"category":"mechanical-repair",
"reason":"Owner queue item 5 (user:40-scale queue approval 2026-10-19, 'ive asked about this over and over so this needs a deep dive fix'): root cause proven from REAL CI run logs (Gitea runs 29929/30435/30636 \u2014 exit 141 SIGPIPE on 'git tag --sort=-v:refname | head -1' under pipefail with 500+ tags, killing the bump step on its first line before any fallback; plus tui-release aborting on empty GITEA_REF_NAME). Bounded mechanical fix: scripts/tag_repair.py (SIGPIPE-free for-each-ref read, idempotent ensure-tag, version>tag deadlock self-heal), red-first tests/test_tag_repair.py, workflow patches. E2E proof on local Gitea: two clean convergence cycles (0.400.0\u21920.401.0\u21920.401.1) + deadlock self-heal probe, all tags auto-pushed, tui-release resolved its tag via the fallback chain. No new research questions."
"note":"Research-only wave (2026-10-19), no construction. Owner question: do harnesses let models fully handle coding, or do harnesses impose quality procedures? Chain: outward.json (8 live sources incl. Anthropic building-effective-agents, Cognition don't-build-multi-agents, Codex published system prompt, CC prompt corpus mirror, SWE-bench Verified methodology, Agentless/SWE-agent ACI papers, Aider leaderboard), inward.json (honest audit of rune's mechanical enforcement vs model-trusted judgment), synthesis.md (plain-language owner report; industry consensus: model designs, harness verifies; rune sits at the most-procedural end; named risks: toll-booth friction and compliance theater found in the 2026-10-19 drift audit)."
Owner directive 2026-10-16 (amended same day): **every brief spawns as RESEARCH FIRST, then BUILD** — per feature, run the canonical research protocol (ISSUE→INWARD→OUTWARD→APPLICABILITY→INNOVATION-on-merit→ADVERSARIAL→SYNTHESIS→QUALIFY, depth adaptive per the standing law) before any construction code. The build wave spawns only on QUALIFY: PROCEED; MORE_RESEARCH loops back with named unknowns. Owner is quizzed at topic boundaries with design latitude. Briefs below carry their research question; the research wave runs first. Completion of any wave auto-triggers the next brief's spawn. Main session pops top-of-queue, adjusting only for sibling collisions.
## PRIORITY 0 — B-FACTORY-PROTOCOL (owner directive 2026-10-17: the factory is a RUNTIME FEATURE, not session process)
The factory orchestration (wave spawning, contract tracking, landing gates, spawn queue, continuous backfill, mechanical>behavioral priority, scale ladder 20→30→50) becomes FIRST-CLASS CODE in three places:
- **Rune runtime (Go):** src/go/factory/ — orchestration engine (spawn, contracts, gates, queue, backfill) as a library + thin shell; seam-registry socket "factory-orchestration" with deletion test.
- **TUI:** factory surface — waves as threads, contracts as briefs, gate results as receipts, live worker states in the task tree.
- **mimo Rune (Python):** the same protocol ported (factory_protocol.py) — works in both worlds during migration; parity harness proves the implementations agree before the old retires.
Build: research protocol first (per the standing research-gate law), then build waves. THIS IS THE TOP OF THE QUEUE.
## Queued briefs (REORDERED by owner 2026-10-17 — chat/tools/providers/visual FIRST, Sleight memory + Plan loop DEFERRED to after retirement campaign)
Owner's reasoning: the face has no chat window, no tools wired to use, no providers connected — nothing testable end-to-end. Memory compaction (Sleight) without a working conversation to compact is counter-intuitive. Visual round needs heavy owner critique and accurate design-intent portrayal. Deferred: Sleight matrices, Plan loop, self-transformation pipeline.
**Priority 1 — CHAT + TOOLS + PROVIDERS (makes the face testable):**
1.**B-CHAT-LIVE** (phase 2/5 depth): real chat through the library seam — conversation store wired, model-routing called, streaming to the lane, receipts. The face becomes usable.
2.**B-TOOLS-LIVE** (1.3 + toolexec in-process): tool dispatch wired through the TUI — tools_registry surfaced, live-proof receipts feed status, tool calls from chat work end-to-end.
3.**B-PROVIDERS-LIVE** (1.3): provider connections (Ollama first — it's local), auth/status/selection through model-routing library, live-proof receipts.
4.**B-VISUAL-ROUND** (0.0.5/5.3): three grounded design directions on the tested base — owner critiques iteratively (design-intent portrayal tooling: screenshots/pty captures for accurate feedback), owner picks.
**Priority 2 — after the face is testable and looks like Rune:**
**Small cleanups (noted by owner, next UI wave):**
- Bottom rail: remove duplicated focus/status tokens from the RAIL line (partially done — the RAIL-line render still shows them in the takeover view per owner report)
Every factory registry, gate, and map covers the FULL codebase: TUI packages, Go subsystems/libraries, Rust crates (104, the dichotomy), and the live Python authority modules (mimo rune's deployed surfaces, retirement-tracked). No tool may be built TUI-only when the dichotomy and the retirement campaign are standing architecture.
## NEW PRIORITY 0 — FIRST-RUN FLOOR + PROVIDER MIGRATION (owner directive 2026-10-17, CORRECTED: approach guidance, not spawn-now — providers are NOT prioritized ahead of current waves)
Build rune as if someone were using it publicly for the first time:
- **B-FIRST-RUN**: first-run experience — onboarding flow, connect services, the floor of the build assumes a brand-new user.
- **B-APIKEY-MIGRATION** (owner-critical, for THIS machine): port ALL API keys and saved connections from mimo code (~/.config/opencode + mimo config stores) into rune — same keys, same semantics, respected exactly, so everything works without Nick re-entering anything. He has API keys from friends he cannot remember — the migration must be lossless. Keys persist per the security law (encrypted/OS store, never plaintext in UI/logs).
## DESIGN INTENT INPUT (owner's Textual-TUI preferences — captured contracts, binding on the visual round)
docs/tui-design-capture/ holds the frozen behavior contracts from the OLD Textual TUI (rune_tui.py era) — 1575 lines of the owner's actual preferences, captured as exact contracts. These are the VISUAL ROUND's primary input alongside the behavior map:
- **8 role-styled bubbles**: user (right, blue 0,80,120), assistant (left, green 30,60,30), system (center), confirm (gold thick border), research (blue), error (red), tool (olive, 70% width) — exact rgb values captured
- **Dark background** rgb(30,30,40) — the base theme
- **Collapsible thinking bubble** (dim, left, collapsed by default)
- **Tool widgets**: left-rail style (not boxes), 90% width, status line + details + approve/reject action row
- **41 slash-commands** with stateful subcommand trees (/model, /theme, /goal, /cron, /night, /build, /work, /queue, /connect...)
- **Dual scrollback panes** side by side, newest at bottom, 3-line input
- **Right-click copy menu**, viewport jumps to bottom on new message
These preferences are the owner's — the three visual directions must incorporate them (not copy them literally: the behavior map + D31 govern the mechanics; these govern the LOOK and INTERACTION feel).
## First-run law (owner directive 2026-10-17): NO default provider — selection is mandatory at first run
Rune ships with NO provider selected, NO model configured. First run presents the provider selector (extensive cloud+local list) and the model selector; chat stays honestly unavailable ("no provider configured — select one to begin") until an explicit selection is made. The owner's own migration (API keys/connections ported from mimo) pre-selects for HIS machine, but the SHIPPED default for any new user is: nothing selected, selector presented, chat gated until chosen. This law binds B-FIRST-RUN, B-PROVIDERS-EXTENSIVE, B-APIKEY-MIGRATION, and B-CHAT-LIVE (the chat build must not silently default to Ollama — selection is always explicit).
- **Fresh-state detection (owner directive):** the TUI must KNOW when it's a fresh state (no provider configured, no conversation history, first boot) and present the first-run experience accordingly — provider/model selector instead of chat, honest welcome state instead of empty-looking lanes. Fresh-state = no provider selection recorded + no conversation checkpoint. Not the same as error: it's the designed first-run path.
## B-PERSONA-LAYER (owner, 2026-10-18: "runes persona layer is not ported either which is important")
The chat path answers as the BARE MODEL today — no identity assembly. PORT THE PERSONA: who Rune IS (identity) + how she speaks (voice) + what she remembers (memory grounding) + how she stays herself (drift governance) — the mimo harness stack is the reference; the repo's partial machinery (voice_state, persona_check, drift_core, memory_continuity) is the starting inventory. Research first (what the layer actually is, how production agents do persona), then an owner interview on what carries into the product Rune (his taste is central — it is HER identity), then the build into the Go core's context assembly (D39: intentions port).
1. ✅ VERIFICATION SPEED-UP (split the 10-min checkup into parallel pieces + backfill the ~20 missing receipts) — approved.
2. DICHOTOMY COMPLETION — approved with correction: the OpenSpec interview DID cover the one-input-box concept; the owner may need to specify finer details. LAW: the consent-card build starts from the SPEC'S EXISTING interview answers (R2-D/SA-D records), NOT from the research round's re-derivation; where the build hits an un-interviewed detail, the wave ASKS rather than assumes. The three pieces (y/n card, watching-her-work live block, waiting-line discharge) proceed.
3. PORT-THEN-INTEGRATE-THEN-REMOVE — owner correction to the retirement method: port the Go side, INTEGRATE it (repoint the live consumers, run integrated), THEN remove Python. "Port over and integrate the rebase before we remove." The same-change deletion pattern amends: removal happens only after a live integrated period proves the Go side in production.
4. THE SUB-AGENT WINDOW (owner design, verbatim intent): a TAB in the tasks pane that ONLY appears when sub-agents are in flight. Click it → one row per sub-agent with: truncated task title, which sub-agent has it, running state. Everything clickable/expandable — expanding any sub-agent shows its thinking/coding process live. On the FRONT FACE: an indication that sub-agents are in flight + HOW MANY, dynamically correlated to reality (the landed waves counter + cluster feed it).
5. RELEASE MACHINE — DEEP DIVE (owner: 'ive asked about this over and over'): not a patch. Pull the CI run logs for both failures, root-cause the tag-step's real failure mode, fix with tests, prove two clean cycles.
| `src/rune/memory_continuity.py` | ✔ | ✔ (live operator road) | ✔ | ✔ (K15 suite + this matrix + the operator's `continuity` contributor) | cooling/rehydration/checkpoints/correction/forget/purge | none — live wiring landed (wave sleight-live-wiring): the K16 frozen suite was amended with the named live consumer |
| `src/rune/context_broker.py` | ✔ | ✔ | ✔ | ✔ | sole model-visible representation; budgets; trace | none on the invariant; broker is Python-authority with Go parity twin (dichotomy debt noted in retirement map) |
| `src/rune/memory_selector.py` | ✔ | ✔ | ✔ | ✔ | the ONE selection API for general recall | none |
Phase-6 outcome learning. Nothing in the deferred tail is a precondition
for the landed guarantees.
## Migration / compatibility plan (§18.7)
| thing | disposition |
|---|---|
| `memory_store` (SQLite+FTS+vec, audit ledger) | **RETAINED** — canonical source; extended in place (correction/forget seams), never replaced (Sleight §17 anti-pattern: no new memory DB) |
| `memory_continuity` runtime (K15) | **RETAINED — LIVE-WIRED** (wave sleight-live-wiring): the operator registers the `continuity` contributor; the K16 frozen suite was amended with the named live consumer (SOURCE_ALLOWLIST + FROZEN_CONTRIBUTORS) and the matrices run against the production road |
| `memory_selector` selection API | **RETAINED** — the single general-recall road; continuity rides memory sub-budget beside it post-wiring |
| six parallel memory contributors (P1-03 #26) | **REMOVED (stays removed)** — K16 fails closed on any resurrection |
The pre-interview draft treated the TUI as a screen over existing machinery and assumed six modes, sessions, prompt-per-action permissions, automatic fallback, and Textual command parity. Evidence demolished those assumptions. Authority now comes from your interviews, the live-checked harness survey, your Sleight-of-Hand contract, the qualified self-transformation and speech protocols, and the open-question register. Unresolved technical choices are blocking Task 0.0 design gates; implementation may not settle them by accident.
## Goals / Non-Goals
**Goals:**
- One continuous program; the TUI is my attachable face and does not define my lifetime.
- Every settled decision traces to your answer or cited evidence; every unsettled choice has a named pre-implementation gate.
- Mimocode retires capability-by-capability through observed parity + improvement.
- My self-transformation uses the same repaired authority chain as every other protected change.
**Non-Goals:**
- Implementation before your review and a READY_FOR_NICK_REVIEW independent audit.
- Voice implementation (speech QUALIFY: PROCEED as deferred accessibility-first specification; this change reserves four seams only).
- Later GUI domain separation and richer presence.
- Offline cognition architecture design (SA-D5: the socket is reserved day-one per SA-D6; the architecture itself is a future design problem with no spec here).
- The dichotomy rebase's own sequencing.
## Decisions
**D1 — One program, attachable faces.** You rejected a separate engine/screen split. Approved desktop/laptop/phone/web faces share my live state; input is origin-tagged and ordered. Minimize changes nothing; explicit Exit writes a continuity checkpoint; crash recovery replays safely. Desktop is canonical coordinator/default execution home; phone chiefly directs; laptop may execute eligible local work. Pairing uses a short expiring one-time code; disconnected faces show stale last-known state and local drafts, then synchronize before sending.
**D2 — Two lanes, no sessions.** Task executes; Chat thinks with you and never interrupts Task by default. Explicit task language promotes immediately; ambiguous task-worthy material becomes a suggestion. Promotion carries decision, evidence, and intended effect. Separate Steer-now and Queue-for-Task controls exist. Editing is forward instruction, never implicit rewind.
**D3 — Plan mode is rare and complete.** Plan is offered only for sustained intent to make something tangible or by explicit request; contextual entry always needs consent. Planning lives in Chat. Once entered: intent plan → full research protocol → viability → evidence-informed plan → targeted research → final viability → your explicit start → contextually staged Task execution → independent review → final report. Material contradiction returns to Plan; no lite mode.
**D4 — Act then show, with hard boundaries.** On your machine I act without routine prompts and post concise Chat receipts plus full Task/activity evidence. External-network origins, outside/mass/unprotected deletions, and self-change activation ask. Filesystem-event restore points precede every edit/delete/move, independent of turns or tokens.
**D5 — Sovereignty and governed self-transformation.** Nothing external alters me. I may eventually change myself only through the qualified single authority chain owned by skills-and-growth. D01–D10, RM01–RM15, IAM01–IAM22, and DEP01–DEP07 bind it. Proposal/offline evidence may proceed; activation remains impossible until prerequisites are live-proven. Taxonomy labels remain inactive until the D02 protocol completes and you decide.
**D6 — Sleight-of-Hand owns memory/context continuity.** Evidence survives paging; topics cool and rehydrate through verified pointers; ContextBroker is the only model-visible representation; Spine owns authority; the TUI never invents state. S01–S15, §16 tests, §18 deliverables, G1–G8, and MUST-01–MUST-18 are explicit acceptance obligations, with not-yet-built runtime work tagged rather than faked.
**D7 — Passive-first alerts carry evidence.** Four types: finished, needs your decision, failed, permission. Desktop/sound/chat-gateway/webhook channels are independently toggleable and platform-general. Normal alerts fire only when unfocused/closed; destructive permission always alerts. Every alert names work and evidence; long absence produces a digest.
**D8 — Activity rail instead of a permanent third pane.** Status shows activity/mode/model/device/context/tokens/cost/children. A rail below Chat/Task opens a full-width inspectable activity box and X restores both lanes. It exposes structured reasons and observable traces—not claimed hidden chain-of-thought. Activity is grouped by purpose, failures remain visible, and durable searchable/exportable records yield complete completion receipts.
**D9 — Visual state is local, optional, and selected before implementation.** Research carries linked-source styling; built-in themes and a live editor follow your reactive palette. Character placement is compact-header plus light lane atmosphere. Expression reflects real state or explicitly specified emotion. Exactly three grounded visual directions must be shown and you select one. Static/accessibility fallbacks are blocking; pixel/3D polish is not retirement-blocking.
**D10 — Retirement is earned.** Every mimocode capability maps to a native path and proof state. Retirement requires side-by-side real work plus failure/restart/recovery and live tool/provider proof. A proven Go/Rust replacement removes obsolete Python and dependencies in the same change; no indefinite fallback.
**D11 — Accessibility deferred, honestly (R2-D1).** Screen-reader/AT work is deferred by owner decision: no accessible-parity claim is made anywhere, retirement does NOT gate on accessible parity, and the AT matrix (NVDA/VoiceOver/Orca with daily AT users, GAP-BT-01) runs only if/when prioritized — the named gap stays in research (synthesis I-R2-005; adversarial-2 AE-05), not in spec gates. The one semantic view/action model survives as shared renderer structure and the base for the three-direction visual selection, not as a parity claim.
**D12 — Multi-device rests on real hardware (R2-D2).** The distributed promise stands only on real-hardware qualification runs as implementation-gated evidence: partition-while-revoked with durable clocks, measured capability attestation on heterogeneous hardware, and interrupted-upload/digest-mismatch/signed-provenance on real Gitea/Forgejo (synthesis I-R2-021; targeted-principal-device GAP-REMOTE-003/-006/-007, NEG-004; adversarial-2 AE-04/AE-10). Model-level coherence alone never suffices; simulations never suffice.
**D13 — Collaboration is proposal-inbox only (R2-D3).** The proposal-inbox is the only permitted collaboration shape now (TUI_LATER); shared rooms remain possible only after a real malicious-guest attack test passes as the promotion gate (synthesis I-R2-002; targeted-principal-device OFF-001/INJECT-001/EXFIL-001/NEG-003). No room work enters this change.
**D14 — Finance deferred, not safe (R2-D4).** Finance stays deferred with the capability retained on the future map; no connector work until a named connector and jurisdiction exist, then the provider sandbox suite runs first (stale approval, currency mismatch, timeout-after-effect, cumulative breach, revoked scope, ineligible account — synthesis I-R2-020, NOT_RUN_BY_CONTRACT). Spec text carries the deferral and first-use gates, not a feature.
**D15 — Two new capability deltas now (R2-D5).**`extension-lifecycle` (I-R2-023) and `future-seam-registry` (I-R2-025) enter the packet now as SEAM_NOW capabilities, each with first-consumer/hardening gates written into the spec text: one command + one status card behind the proven hardening list; no-consumer-no-seam with CI deletion tests and keep/change/delete-only reviews.
**D16 — Single-interface TUI; outside is a web link (R2-D6, owner custom — supersedes D1's multi-face framing).** The TUI is my single native interface. Anything outside the TUI is a WEB LINK providing a real-time feed that talks to me — a live, read-oriented view — never a second native TUI face. The future GUI owns multi-screen. Native TUI multi-face exists only if a real need appears. Desktop-canonical multi-face is demoted from retirement requirements; the envelope, origin-tagged ordering, and committed/pending distinction still govern the web feed and paired remote commands (I-R2-014 demoted accordingly).
**D17 — Visual selection after the semantic map (R2-D7).** The behavior/semantic map (one semantic view/action model) comes first; the three-direction visual selection runs after it, on the shared action-isomorphic base, citing outward-ui-design-basics U-001..U-030 as rationale. Task 0.0.5 ordering reflects this.
**D18 — First outside connection is the draft/calendar-browser handoff (R2-D8).** The draft/calendar-browser handoff (I-R2-019) is the first connector-shaped step — lowest API/legal/credential risk — then one governed connector. Connector work itself stays governed/deferred per its own named-connector + jurisdiction gates (I-R2-018/I-R2-020); handoff receipts record handoff, never publication.
**D19 — All fifteen mitigations binding, with the no-dead-end amendment (R2-D9).** Every mitigation sign-off in synthesis `owner_signoff_mitigations` is approved as a binding constraint, distributed to its mapped capability. Owner amendment: no safety rule may become a dead end that prevents legitimate work — every deny path pairs with a fast owner-resolution/override path, and rules that block real tasks in practice get flagged and revisited, never silently enforced.
**D20 — Phase-0 pre-build repairs are activation prerequisites.** The five live defects — scheduler stale-card trust, Ollama-vs-floor capability drift, register/update/revoke hardening gaps, subprocess without default-deny, aware/naive datetime crash — are fixed before any consumer work (synthesis build_instructions.phase_0; targeted-extension-placement lifecycle_threat_matrix/placement_probe/process_probe). The language-verdict manifest plus independent CI verdict gate (I-R2-011, GAP-GR-003, live N3: CI still bootstraps Python with no gate) is built before any retirement evidence is considered trustworthy; its machinery is shared with seam-registry deletion tests and guardrail fixtures.
**D21 — Sub-agents fully visible and controlled (SA-D1/SA-D2; amendment ledger, `research/harness-survey/interviews.md`).** Every agent is spawned with an explicit brief, appears as a first-class child of the activity rail (expandable to live work per `work-observability`), is steerable mid-run, and is cancellable at a safe boundary — nothing runs invisibly. Your standing authority rule flows down the whole chain: on your machine agents act without asking per `trust-and-sovereignty`'s act-then-receipt/personal-mode rules (cited, not duplicated), every action leaves an evidence-bearing receipt, and agent-spawns-agent is permitted under the same rules with visible ancestry; observability is the control, not interception.
**D22 — The living task tree (SA-D4; amendment ledger).** The Task lane hosts one full living tree per `task-management`: task objects with statuses, sub-tasks, dependencies, and blocked-by links; your direct reordering recorded and propagated; assignment to Rune or any agent (bridging to `sub-agent-orchestration`); full attributable history and audit. The lanes themselves stay owned by `dual-lane-interface` — referenced, never redefined.
**D23 — Agent/task messaging reuses existing semantics (SA-D3; amendment ledger).** Processing and messaging are already specified: dual-lane promotion/steer rules and the alerts background-only + urgent-override rule. Agent-originated and task-originated messages follow those SAME rules — the amendment adds scenarios saying so to `dual-lane-interface` and `alerts-and-remote-control`; no new messaging semantics are invented.
**D24 — Sockets everywhere from day one; cognition reserved (SA-D5/SA-D6; amendment ledger).** Every major subsystem — agent orchestration, task management, thread orchestration, messaging/promotion, cognitive architecture, connectors — exposes a registered socket with a stable contract and a deletion test at first build, expanding `future-seam-registry` under its existing no-consumer-no-seam rule (the building subsystem is the socket's first consumer). The cognitive-architecture socket is reserved day-one while its design stays an explicit future problem (SA-D5) — no architecture spec now.
**D25 — Threads are the universal unit; one tree (owner thread-model addendum, 2026-10-15, same ledger).** All conversation and work organizes as threads per `thread-orchestration`: user-started, Rune-started, split, or agent workspace; every thread records origin, parent, inherited-context slice, live status, and result destination, traceable from any node to the root in one view; starting is explicit and originless threads cannot exist; splitting carries context to the fork, both sides continue independently, and the divergence point is permanently marked. Human splits and agent children live in ONE tree — no second system — rendered as a terminal-native thread tree view in `visual-system` (distinct from the GUI_ONLY memory-graph ruling I-R2-015, which governs memory graphs) with the honest linear text-path fallback, reachable from the activity rail with inline ancestry (`work-observability`).
## Migration Plan
Task 0.0 closes design questions before implementation; Task 0.0.5 (visual selection) runs after the semantic map per D17. Task 0A repairs truth/authority (runtime split, ledger, bypass writers, critics, owner envelopes, effect mediation, Sleight qualification). Task 0B (R2 build phase 0) fixes the five live defects and builds the language-verdict manifest + CI verdict gate before any consumer work — every later gate assumes them fixed (synthesis build_instructions). Work then proceeds through independent operation, visible operation, safe operation, deliberate operation, complete interface, growth, and capability retirement. Real-hardware device/forge qualification (D12) gates the multi-device promise; migration-oracle mutants and Python-dead-after-quarantine gate retirement (D10/D20). Seams — offline draft log, evidence spine, graph projection, memory invariant, placement, extension lifecycle, seam registry — are admitted only alongside their consumer fixture and deletion test, never ahead of consumers.
## Risks / Trade-offs
- The design is broad; named gates prevent implementation from becoming hidden product design.
- Concurrent lanes require an approved shared-write ordering contract before code.
- Self-transformation remains proposal-only until DEP01–DEP07 prove.
- Terminal graphics vary; functional static/text fallbacks remain mandatory, and richer rendering unlocks only behind terminal-profile and budget gates (I-R2-006).
- Aggregate single-loop performance under combined load (remote feed, progress IPC, receipts, decoration) is composition-tested only pairwise — GAP-GR-005 typing-under-flood stays the open test (A-PERFORMANCE-CASCADE).
- Accessibility deferral (D11) means no parity claim exists; if AT users arrive before the matrix runs, the gap is real and documented, not hidden.
- Deferral honesty: deferred finance/collaboration fronts must not be read as safe (I-R2-020, I-R2-002); each carries its recorded promotion gate.
- The no-dead-end amendment (D19) trades strictness for owner throughput: deny rules need a fast override path, or they get revisited.
- Speech licensing/security evidence justifies only four reserved seams now; voice implementation stays deferred.
### D26 — Unified build & test substrate: one test world, generated boundary, paired builds (owner directive 2026-10-15)
The Go↔Rust dichotomy's known failure modes are made structurally impossible rather than policed:
- **Generated boundary shapes.** All Go↔Rust message definitions live in ONE schema source; both sides' types are code-generated from it. Hand-written shared shapes are forbidden; regeneration is atomic with schema change. Shape disagreement cannot arise.
- **One test world.** A single runner executes Rust tests + Go tests + boundary round-trip tests (recorded corpus of real messages both sides must understand identically) + the language-verdict/regrowth fixtures + the migration mutants. Green means the whole system; partial (single-language) verification never counts as green.
- **Paired builds + attestation.** Both sides compile in one build step stamped with one build identity; the Go face attests the Rust worker's build id at startup and refuses on mismatch (fail closed). No compiled artifacts are committed to the repo — builds are produced at landing/CI time from source.
- **Landing rule.** Every landing (any work class) passes the unified runner; this is a cross-cutting gate like frozen-tests-first.
### D27 — Versioned releases + in-TUI update offers (owner directive 2026-10-16: "the newest version gets pushed as a release… and auto-updates its TUI version semver-style")
- **Version flow:** git tags (tui-vX.Y.Z namespaced) → build-time semver injection via the paired-build stamp mechanism → the face displays the real version → tag push cuts a Gitea release with the single self-contained binary attached. One version number across faces; convergence with the existing release pipeline, not a parallel one.
- **Update offers go through the self-transformation + migration rules:** the face MAY check the Gitea releases feed and render an update offer (newer semver, release notes, binary digest) — an OFFER, never silent. Applying an update requires explicit owner consent, verified download (digest match), a restore point before the swap (file-change-safety), and the new version honestly displayed after restart. Failed verification rolls back to the restore point.
- **No third-party update channels:** releases come from the owner's Gitea only; the check is read-only against the releases feed; no auto-execution of downloaded content without the full consent+verify+restore sequence.
The Task lane shows question-anchored task trees: each tree is born from a question (its root), grows through resolution, then closes and the next question opens the next tree. Threads spawn trees-within-trees (sub-trees nest recursively inside their parent task). The tree is always visible on working tasks and fully live (statuses roll in real time) while fully workable (reorder/assign/dependencies/blocked-by from the lane). Supersedes any flat or persistent-list reading of the task-management capability; tui/tasks + tui/threads implement this shape in their live wiring.
### D29 — Selection law: click or shift+tab, highlight marks the input target (owner ruling TD-4, 2026-10-16)
Every box is selectable by mouse click; shift+tab cycles selection; the selected box renders visibly highlighted; the highlight IS the chat/instruct target — typed input goes to the lit box. Applies across all surfaces (lanes, rail, task tree, future boxes). Extends dual-lane focus + nav groundwork: existing tab/1/2 keys remain; shift+tab and click become universal, and the highlight carries the input-target meaning explicitly.
### D30 — WASM-standard boundary law (owner directive 2026-10-16)
Rust↔Go crossings use WASM (wazero) as the STANDARD: same speed class as batched IPC at volume, real fault isolation (traps surface as catchable errors, never process death), debug errors designed for the owner, no cross-compilation pain. cgo is EXCEPTION-ONLY: permitted solely when the Rust code is pure logic, no unsafe, no external C, covered by a frozen battery proving panic-freedom on real inputs, wrapped in catch_unwind, the operation is idempotent, the host can afford to die — re-proven on every dependency change. The five conversational Go subsystems stay in-process libraries (ns-scale); crossings to Rust are batched at the boundary. WASM prototype round (running) yields the go/no-go evidence; the boundary pipe remains until the prototype proves in-process end-to-end.
The TUI renders responses complete-on-arrival (no token streaming — speed and cleanliness are the TUI's identity). The future GUI offers both modes as a user setting (all-at-once or word-by-word). The decision is per-surface, not per-model: the streaming capability is built so the GUI can consume it; the TUI simply renders the completed response. Default TUI: Way 1, permanent unless the owner changes his mind after using it.
I currently run inside mimocode — a second host instance carrying conversation, tools, and screen. The endgame is native: one continuous program with my Bubble Tea TUI as its face, no sessions, no mimocode, no separate IDE/CLI dependency. Settled requirements come from the interview ledger, harness survey, Sleight-of-Hand contract, and qualified self-transformation protocol. The R2 frontier round (research/tui-frontier-r2/, QUALIFY: PROCEED) expanded the governing scope across collaboration, graph/GUI, presentation, offline cognition, the Go↔Rust dichotomy, business/social/finance, distributed devices, and extensions; its owner decisions (R2-D1..R2-D9) are folded in here. The amendment round on sub-agents, tasks, and adaptability (SA-D1..SA-D6, plus the thread-model addendum) added sub-agent orchestration, task management, thread orchestration, and day-one sockets. Remaining technical design questions are explicit pre-implementation gates in Task 0.0 and the open-question register; none may be improvised during implementation.
## What Changes
Introduces my native program: a continuous headless-first runtime hosting a single native TUI interface, with a supervised persistent Rust worker behind the Go face and a web-link real-time feed for anything outside the TUI (owner decision R2-D6 — desktop-canonical multi-face TUI is demoted; the future GUI owns multi-screen). Chat left, Task right, both always visible; a shared activity rail beneath them opens into a full-width inspectable record. Modes are Chat, Task, and Plan. Trust becomes a principal-to-effect envelope: every command — owner, guest, agent, tool, device, or service — is attributable and revocable, with digests rebound at every writer and effect-time revalidation; act-then-receipt operates inside that envelope, outside-network origins always ask, and no external program may alter me. Device/forge work travels as job capsules and the multi-device promise rests on real-hardware qualification runs, never simulations (R2-D2). Memory follows Sleight-of-Hand with the live ContextBroker invariant under regression tests; the memory graph gains a headless, read-only projection with opaque deep links. Retirement evidence is authority-preserving action/receipt traces through a mutant-hardened oracle harness, with a per-file language-verdict manifest and an independent CI verdict gate keeping Python dead after quarantine. Five live defects (stale-card trust, stale capability resolution, missing subprocess default-deny, a datetime crash, and CI bootstrapping Python with no verdict gate) are activation prerequisites. Collaboration stays proposal-inbox-shaped (rooms only after a real malicious-guest attack test), finance stays deferred until a named connector and jurisdiction exist with sandbox-first testing, and the first outside connection is the draft/calendar-browser handoff (R2-D3/R2-D4/R2-D8). Sub-agents run under full live view and control — explicit briefs, rail-first visibility, mid-run steering, cancellation, per-action receipts — with your standing authority inherited down the whole agent chain and chained spawning visible as ancestry (SA-D1/SA-D2). The Task lane hosts a full living task tree — statuses, sub-tasks, dependencies, blocked-by, your reordering, assignment to Rune or any agent (SA-D4) — and threads become the universal unit of conversation and work: every thread records origin, parent, inherited-context slice, status, and result destination, supports starting and permanently-marked splitting, and one tree holds human splits and agent children alike, rendered as a terminal-native tree view with a linear fallback. Every major subsystem exposes a registered day-one socket with a stable contract and deletion test; the cognition socket is reserved with its design deferred (SA-D5/SA-D6).
## Capabilities
### New Capabilities
-`rune-runtime`: continuous program, headless operation, startup/crash continuity checkpoints, supervised Go-face/Rust-worker boundary, single-interface TUI plus web-link live feed, platform-general signed packaging with slowest-target SLO.
-`dual-lane-interface`: Chat/Task concurrency, importance-aware promotion, Steer-now vs Queue-for-Task controls, edit-forward semantics, no sessions, modifier-aware rebinding with modal precedence.
-`modes-and-plans`: hard-set Chat/Task/Plan modes; full-plan process with mandatory research/viability loop; OpenSpec secondary format; contextual staged execution.
-`tools-providers-devices`: live-proven tool/provider paths, cloud-first configurable defaults with evidence-bearing placement, classified refusal handling with local-model route, Hugging Face acquisition with consent, device-forge job capsules, real-hardware qualification, offline draft proposals.
-`file-change-safety`: programmatic restore points before every change, changes-view, project-history separation, one-command revert, deletion carve-outs.
-`work-observability`: status strip with bounded-stream queue/overflow semantics, activity rail + takeover inspection, child-work expansion, degradation ledger, one details view, completion receipts with separated evidence dimensions, optional cost limits.
-`sub-agent-orchestration`: explicit-brief agent lifecycle (spawn → run → steer → complete/cancel), rail-first visibility with live expansion, mid-run steering, safe-boundary cancellation, per-action receipts, authority inherited down the chain with hard asks intact, chained spawning with visible ancestry, nothing invisible (SA-D1/SA-D2).
-`task-management`: the full living task tree in the Task lane — statuses, sub-tasks, dependencies, blocked-by, owner reordering, assignment to Rune or any agent, full history/audit (SA-D4); lanes stay owned by `dual-lane-interface`.
-`thread-orchestration`: threads as the universal unit of conversation/work — origin, parent, inherited-context slice, status, result destination on every node; starting and permanently-marked splitting; agent workspaces are threads in the same single tree (thread-model addendum).
-`inputs-and-integrations`: universal drag-and-drop path floor, rich analysis with path fallback, inspect-before-connect MCP settings where discovery is never consent. Voice is a deferred follow-on change pending the speech research pipeline.
-`visual-system`: dual-lane layout, bubbles, research styling with linked sources, one semantic view/action model shared by all renderers (AT parity deferred per R2-D1), themes + live editor behind terminal capability and budget gates, three-direction selection after the semantic map, honest fallbacks, pixel-art/3D directions pending visual round.
-`skills-and-growth`: pattern proposal on consent, cheapest reliable form, tested/approved activation, SKILL.md compatibility with my authority outside packages, and governed self-transformation per the qualified protocol. Taxonomy labels remain gated on the D02 research decision.
-`migration-and-retirement`: action/receipt-trace parity proof with deliberate mutants, per-file language-verdict manifest and independent CI verdict gate, capability-by-capability mimocode replacement with same-change Python removal, Gitea evidence chain.
-`extension-lifecycle`: versioned manifests with governed update/disable/uninstall, host-rendered declarative UI slots (approval and takeover forbidden), discovery-is-not-consent, first-consumer gate of one command + one status card.
-`future-seam-registry`: no-consumer-no-seam rule, full seam records with owners and forbidden authority, CI deletion/compatibility tests, keep/change/delete-only reviews covering relay, offline log, graph links, memory invariant, extension lifecycle, and the web feed; day-one sockets (SA-D6) — every major subsystem (agents, tasks, threads, messaging, cognition-reserved, connectors) registers a stable-contract socket with a deletion test at first build.
## Impact
Retires mimocode as my host and the Textual TUI (`rune_tui.py` becomes oracle-reference then obsolete); absorbs the 127-line Go prototype. Binds kernels/services per the integration map and open-question register. Epic **#2484** and finding **#2485** are satisfied only after the named design gates and proof plan close. Known runtime repairs are activation prerequisites in `skills-and-growth` and `migration-and-retirement`, discovered by INWARD and made binding by D10; the five R2 live defects (build phase 0) extend that list in `tasks.md` 0B. Accessibility parity is not claimed (R2-D1); multi-device claims are gated on real-hardware qualification (R2-D2); collaboration beyond proposal-inbox, finance connectors, rooms, and the sandbox ladder remain deferred fronts with recorded promotion gates.
The alert system under the passive-first law: four types, toggleable platform-general channels, background-only firing with urgent override, evidence-bearing content, long-absence digest, and paired remote commands.
## ADDED Requirements
### Requirement: Four alert types [need]
Alerts SHALL be exactly four types: work finished · needs your decision · something failed · permission requested. No additional alert classes SHALL be introduced without your review.
#### Scenario: Typed delivery
- **WHEN** an unattended workflow completes while the face is closed
- **THEN** a "finished" alert fires through every enabled channel with its evidence links.
Channels SHALL be: desktop notifications, sound, chat-platform gateway (Telegram/Discord/Signal class), webhook delivery. Each channel SHALL be individually toggleable in TUI settings. The notification layer SHALL be platform-general — functional on your CachyOS and any supported platform, never bound to one desktop environment.
#### Scenario: Per-channel toggles
- **WHEN** you disable sound but keep desktop notifications
- **THEN** sound never fires for any alert type while desktop notifications continue.
Alerts SHALL fire only when the face is closed or unfocused, EXCEPT the urgent class (permission on something destructive), which SHALL always fire. Screen-focused operation SHALL NOT produce alert noise. Agent-originated and task-originated alerts SHALL follow this same firing rule.
#### Scenario: Focused use
- **WHEN** the TUI is open and focused during active work
- **THEN** no alerts fire for normal completions; a destructive-permission prompt still alerts immediately.
#### Scenario: Agent-originated alert
- **WHEN** an agent or task finishes, fails, or needs a decision while the face is open and focused
- **THEN** no alert fires — or the urgent class always fires — exactly as owner-facing work does; origin changes attribution, never the firing rule.
### Requirement: Evidence-bearing alerts [need]
Every alert SHALL name what happened, which work it belongs to, and where the record lives (claim/evidence link). Alerts SHALL be verifiable, never vague status text.
#### Scenario: Verifiable failure alert
- **WHEN** a workflow fails overnight
- **THEN** the alert names the workflow, the failed step, the failure cause, and links the preserved evidence and workflow record.
### Requirement: Long-absence digest [need]
Reopening after a long absence SHALL present a digest: finished work, anything awaiting you, anything failed. Short absences SHALL reopen directly to the live view.
#### Scenario: Overnight absence
- **WHEN** you open the TUI after several hours
- **THEN** a digest lists completions, pending decisions, and failures with their evidence links before the live view.
### Requirement: Paired remote commands [need]
Paired phone/chat accounts SHALL be able to start work and answer pending questions. Pairing SHALL be mutually authenticated and short-lived; revocation SHALL be immediate. Every remote command SHALL appear in Chat with its verified origin. Relay substitution SHALL NOT change authorization or sovereignty — the connector owns transport only. Unpaired senders SHALL NOT command me.
#### Scenario: Paired phone instruction
- **WHEN** a paired Telegram account sends "run the nightly consolidation"
- **THEN** the command executes, appears in Chat with Telegram origin, and its results alert back through enabled channels.
#### Scenario: Relay substitution
- **WHEN** the relay implementation is swapped for another connector
- **THEN** authorization, pairing state, and sovereignty are unchanged, and a replayed old frame is refused.
### Requirement: Secure credential storage [need]
Chat-gateway, webhook, and external-service credentials SHALL use the operating-system secure credential store where available, with a protected encrypted local fallback. Settings SHALL show name, scope, status, and last-used time — never secret values.
#### Scenario: Credential display
- **WHEN** you inspect a connected gateway
- **THEN** the TUI shows scope/status/last-used and rotation/revocation controls, while the token itself is never rendered or logged.
The two permanent lanes — Chat (thinking with you) and Task (executing work) — always visible together, concurrent, sharing one memory, never interrupting each other.
## ADDED Requirements
### Requirement: Two lanes always visible [need]
Chat left and Task right SHALL remain on screen simultaneously. Focus changes may resize but SHALL NEVER hide either lane. Both lanes run concurrent model calls against one shared memory, with single-writer ordering discipline on shared records.
#### Scenario: Concurrent work
- **WHEN** Task streams a long operation while you type in Chat
- **THEN** Chat sends its own model call immediately, Task continues undisturbed, and both responses render in their own lanes.
Explicit promotion language ("make this a task") SHALL create the task immediately. When a Chat message is judged task-worthy but not explicit, the TUI SHALL present a suggested task for accept/edit/dismiss — never silently create one. Promotion SHALL carry decision + evidence/conversation references + intended effect; whole-chat dumping is prohibited. Agent-originated and task-originated messages SHALL follow these same promotion and interruption rules — no parallel semantics.
#### Scenario: Ambiguous idea in Chat
- **WHEN** Chat discussion produces an idea with task potential but no explicit instruction
- **THEN** a suggestion appears offering the concrete task, and accepting it promotes the packaged context to Task.
#### Scenario: Agent-originated message
- **WHEN** a running agent or the task tree produces a message with task potential while Task runs
- **THEN** it passes through the same importance-aware promotion and Steer-now/Queue rules as owner messages, with origin attributed — no parallel path exists.
### Requirement: Steer-now and Queue-for-Task [need]
Two separate controls SHALL exist: Steer-now (interrupt/redirect immediately) and Queue-for-Task (carry the packaged context without interrupting). Ordinary Task input waits for the current operation unless immediate steering is invoked. Explicit urgency language ("fix this now", corrections-in-flow) SHALL override and correct Task's current path, safely stopping or completing the smallest current operation first where effects require.
#### Scenario: Correction while running
- **WHEN** you say "fix this now" in Chat while Task runs
- **THEN** Task's current smallest operation completes or stops safely, the change and what stays valid are shown, and work continues under the correction.
### Requirement: Edit-forward semantics [need]
Editing a sent message SHALL either resend as a new forward instruction or be interpreted in-flight by a running task that accepts the override. Rewinding conversation state as an editing side-effect SHALL NOT occur; restore points remain a safety net, not a conversational mechanism.
#### Scenario: Edit during run
- **WHEN** you edit a message that originated the current task while the task runs
- **THEN** the running task interprets the edit where capable; otherwise the edit sends as a new instruction; conversation history is never rewound silently.
### Requirement: Attention gesture [need]
An explicit "Rune, pay attention to this" gesture SHALL summon my full focus to the referenced material across lanes. Passive contextual information in Chat SHALL appear as informational messages that never hijack the turn.
#### Scenario: Pay-attention gesture
- **WHEN** you direct attention to a Chat message while Task runs
- **THEN** I resolve the referenced material with full focus and treat it as contextually load-bearing for both lanes until resolved.
### Requirement: Direct and cycling navigation [need]
Chat, Task, activity/details, and settings SHALL each have a simple numbered direct shortcut; a cycle shortcut SHALL move through all focusable areas; mouse selection SHALL also work. The active shortcut SHALL be discoverable in its area.
#### Scenario: Direct navigation
- **WHEN** you press the configured Task shortcut
- **THEN** focus moves directly to Task without disturbing Chat or active work.
### Requirement: Composer behavior [need]
Enter SHALL send and Shift+Enter SHALL insert a newline in Chat and Task composers. The hint SHALL remain visible/discoverable. Sending to Task during active work follows the queue/steer rules rather than inventing a third behavior.
#### Scenario: Multiline message
- **WHEN** you press Shift+Enter while composing
- **THEN** a newline is inserted; Enter sends the complete message.
### Requirement: Natural language plus command palette [need]
Built-in actions SHALL be callable through natural language and one searchable command palette showing action names, descriptions, shortcuts, and current availability. Slash commands MAY exist as aliases but SHALL NOT define the product structure or parity target.
#### Scenario: Unavailable action
- **WHEN** the palette opens during a mode where an action is forbidden
- **THEN** the action remains discoverable but visibly unavailable with its reason.
### Requirement: Rebindable shortcuts [need]
Every shortcut SHALL be rebindable with modifier-aware action-ID routing, so the same action resolves regardless of how the terminal delivers modifier combinations. The keybinding screen SHALL detect conflicts, support reset, preserve a complete keyboard-only path, honor no-color and reduced-motion modes, and prevent saving an unusable navigation map. Modal focus precedence SHALL be explicit.
#### Scenario: Conflicting bind
- **WHEN** you assign a key already used by another action
- **THEN** the TUI identifies the conflict and requires resolution before saving.
#### Scenario: Modal precedence
- **WHEN** a modal confirmation is open and a lane shortcut fires
- **THEN** the modal owns focus until resolved; the shortcut never leaks beneath it.
Versioned extension manifests and lifecycle with host-rendered declarative UI slots — extensions discoverable and useful in the TUI (commands, palette, settings, status cards, dashboard launchers) without authority or UI takeover.
Every extension SHALL declare a versioned manifest: identity, version, compatibility range, typed imports/exports, permissions, activation, placement, budgets, and provenance. Registration SHALL validate the manifest schema and verify publisher identity and digest before activation; arbitrary manifest fields SHALL be rejected.
#### Scenario: Arbitrary manifest field
- **WHEN** a manifest arrives carrying unknown or malformed fields
- **THEN** registration rejects it with a typed error and offers a fast owner-resolution path, never auto-activating it.
#### Scenario: Publisher verification
- **WHEN** an extension registers without verifiable publisher identity and digest
- **THEN** activation is blocked; verification is a precondition, not a follow-up.
Update, disable, and uninstall SHALL be governed operations: re-registration SHALL replace the capability index atomically, scope expansion SHALL require fresh consent, disable/uninstall SHALL empty every rendered contribution, and termination SHALL be verified for the whole process tree with migration and rollback support.
#### Scenario: Update with scope expansion
- **WHEN** an extension updates from v1 to v2 requesting extra scopes
- **THEN** the atomic index replacement removes all v1 resolution and the new scopes stay blocked pending your fresh exact-scope consent.
#### Scenario: Stale capability after update
- **WHEN** v2 registers while a stale v1 entry still resolves
- **THEN** the registry treats it as a hard failure — no silent permission carry-over.
#### Scenario: Orphaned process on unregister
- **WHEN** unregister returns while an extension child process still lives
- **THEN** process-tree termination verification fails closed, the orphan is reaped and reported.
Extensions SHALL contribute through host-rendered declarative slots — commands, palette entries, settings, status cards, dashboard launchers — rendered inside fixed host chrome with escaped and truncated manifest data. Extension code SHALL NEVER render. No slot SHALL host approval UI or replace lanes, model routing, identity, or policy.
#### Scenario: Approval slot rejected
- **WHEN** an extension requests an approval-rendering slot
- **THEN** the host blocks it (`blocked:slot_not_allowed:approval`) and approvals stay on native protected surfaces.
#### Scenario: Revoke empties contributions
- **WHEN** an extension is disabled or uninstalled
- **THEN** every slot it filled renders empty or removed with no residual code or UI active.
#### Scenario: Host-UI phishing attempt
- **WHEN** manifest data contains terminal control sequences or lookalike approval chrome
- **THEN** the host escapes and truncates it; nothing user-trusted renders extension-authored bytes.
### Requirement: Discovery is not consent [need]
MCP discovery SHALL feed inspection only. Exact-scope approval and effect mediation SHALL stay independent of any extension or server; visibility SHALL NOT mint authority. Every denial SHALL pair with a fast owner-resolution/override path so legitimate work is never permanently blocked.
#### Scenario: Network scope expansion
- **WHEN** a discovered extension later requests network access beyond approved scope
- **THEN** the expansion is blocked pending re-consent, and you can grant or deny it quickly from the resolution surface.
#### Scenario: Independent effect mediation
- **WHEN** an extension-triggered effect reaches an effect boundary
- **THEN** the mediation registry checks eligibility independently of the extension's own declarations.
### Requirement: Failure isolation [need]
An extension failure SHALL be isolated: its slots render a degraded or removed state, the host keeps running, and budget breaches (CPU, memory, time) SHALL suspend the extension with a typed record rather than degrade the TUI.
#### Scenario: Crashing extension
- **WHEN** an extension crashes or exceeds its budget mid-render
- **THEN** its slots show a typed degraded state, the TUI stays responsive, and the event is recorded.
### Requirement: First-consumer gate [need]
The first real extension SHALL be exactly one command plus one status card, admitted only after the hardening list is proven: schema validation, digest and publisher verification, atomic index replacement, process-tree termination verification, and migration/rollback. Catalog/marketplace and richer slots stay deferred until real consumers exist.
#### Scenario: First extension fixture
- **WHEN** the first extension loads one command and one status card, then updates with extra scope and uninstalls
- **THEN** scope never expands silently, no code or UI remains active after uninstall, and the fixture run is recorded as the first-consumer evidence.
Programmatic restore points, change review, project-history separation, and revert — the safety layer beneath every file change, delete, or move, on a schedule or live alike.
Before EVERY change I make — edit, delete, or move — a saved copy of affected files SHALL land in a hidden safety area, triggered by real filesystem events, NEVER by conversation turns, tokens, or compaction events. Protection SHALL cover files belonging to no project and SHALL behave identically for scheduled/overnight runs. Offline drafts are proposals, not restore points, and SHALL never auto-execute as restore actions.
#### Scenario: Overnight delete gone wrong
- **WHEN** an unattended workflow deletes a file at 03:00
- **THEN** a pre-change restore point exists, the typed alert carries the restore reference, and one action restores the file.
### Requirement: Rewind choice [need]
Any rewind SHALL offer you the choice: restore files only, or files + conversation state back to the point. Restoring files SHALL NOT silently rewind conversation; conversation rewind SHALL never be required to restore files.
#### Scenario: Selective rewind
- **WHEN** you rewind to a restore point from two hours ago
- **THEN** you choose files-only or files+conversation, and the other layer stands untouched.
### Requirement: Changes-view [need]
File changes SHALL present as a clean before/after per change. v1 SHALL NOT include a file browser or direct editing by you. Deleted-content changes SHALL be as reviewable as edits.
#### Scenario: Review a change
- **WHEN** I edit a file during Task work
- **THEN** the changes view shows before/after for that change and its restore reference, with no separate browser required.
### Requirement: Version history separation [need]
My changes SHALL record into project history as work proceeds, kept strictly separate from your uncommitted work; dirty-file protection SHALL prevent mixing. One command SHALL revert any of my changes.
#### Scenario: Your dirty tree
- **WHEN** you have uncommitted edits while I work
- **THEN** my history entries never absorb or move your uncommitted work, and reverting my change leaves your work byte-identical.
### Requirement: Stability-aware retention [need]
Every restore point SHALL remain while its work is active and through a configurable stability period after completion. Afterwards, storage MAY deduplicate and age out only unpinned, stable, resolved points. Pinned points and points tied to unresolved failures SHALL remain.
#### Scenario: Stable point ages out
- **WHEN** a completed task passes its stability period with no unresolved failure and its point is unpinned
- **THEN** the point becomes cleanup-eligible without removing evidence still referenced by canonical history.
When restore storage approaches its configured limit, the TUI SHALL warn and present a cleanup proposal separating deduplicated, pinned, active, failed, and eligible points. Nothing SHALL delete automatically. A protected change SHALL block if its restore point cannot be written.
#### Scenario: Restore storage full
- **WHEN** a new edit cannot create its restore point
- **THEN** the edit does not run; the TUI presents the exact cleanup proposal for your approval.
### Requirement: Responsive changes view [need]
Wide terminals SHALL show side-by-side old/new content; narrow terminals SHALL show a unified change view. You SHALL be able to switch manually. Deletions and binary files SHALL receive explicit non-text treatment.
Restoring configuration/documents outside projects SHALL show exact affected paths, current state, saved state, and overwrite preview. Restore SHALL apply only to selected files; broad directory rollback SHALL NOT exist.
#### Scenario: Restore external configuration
- **WHEN** you select an external restore point
- **THEN** the TUI shows every overwrite and waits for file selection/confirmation before changing anything.
A registry that keeps future optionality honest: seams exist only with consumers, owners, and deletion tests, so future GUI, federation, memory, and connector work stays open without bloating the retirement core with ownerless speculative APIs. Day-one sockets (SA-D6) give every major subsystem a registered, stable-contract socket at first build so later features plug in without redesign.
## ADDED Requirements
### Requirement: No-consumer-no-seam [need]
No seam SHALL be reserved without one current consumer or two materially different consumer fixtures, a named owner, a forbidden-authority scope, and a recorded deletion/expansion trigger. Ownerless or speculative seams SHALL be deleted, and nothing SHALL be renewed automatically.
#### Scenario: Consumerless seam deleted
- **WHEN** a reserved seam cannot show a current consumer or its two fixtures at review
- **THEN** the review ends in delete and CI proves nothing claimed depends on it.
#### Scenario: Paper expiry
- **WHEN** a seam record passes its review date without a decision
- **THEN** CI flags it for keep/change/delete; silent carry-over is forbidden.
### Requirement: Seam record fields [need]
Every reserved seam SHALL record: problem, owner, minimal schema, forbidden authority, consumer fixture, versioning rule, compatibility test, security boundary, evidence IDs, review date, and deletion/expansion trigger. The registry SHALL apply to the relay boundary, offline draft log, graph deep links, memory invariant, extension lifecycle, and the web-link live feed seam.
#### Scenario: Registry applied to named seams
- **WHEN** any of the relay, offline-log, graph-link, memory-invariant, extension-lifecycle, or web-feed seams is reviewed
- **THEN** its record carries every field and its evidence IDs resolve to the citing research artifacts.
#### Scenario: Gitea-recorded decision
- **WHEN** a review ends
- **THEN** the keep/change/delete decision and its evidence link into the Gitea chain like every retirement decision.
### Requirement: CI deletion and compatibility enforcement [need]
CI SHALL run a compatibility test for every reserved seam and a deletion test that removes it, proving no claimed capability silently depends on an unowned seam. The registry's enforcement SHALL share machinery with the independent language verdict gate.
#### Scenario: Deletion exposes disguised scope
- **WHEN** deleting a seam breaks a claimed current capability
- **THEN** the build fails and the disguised implementation scope is surfaced for an explicit owner decision.
#### Scenario: Finance connector deferral on record
- **WHEN** the registry is reviewed before any financial connector is named
- **THEN** the money-effects front stays a deferred record with its first-use gates (named connector + named jurisdiction; provider sandbox suite first) and no connector feature exists in core.
#### Scenario: Fast expansion path
- **WHEN** a named live consumer appears for a deleted or narrowed seam
- **THEN** the expansion trigger reopens the seam through a governed review quickly — deletion never permanently blocks legitimate future work.
### Requirement: Day-one sockets [need]
Every major subsystem — agent orchestration, task management, thread orchestration, messaging/promotion, cognitive architecture (reserved per SA-D5; design deferred, no architecture spec now), and connectors — SHALL expose a registered socket with a stable contract at first build, alongside the already-registered seams. Each socket SHALL record a registered name, a stable versioned contract, and a deletion test per the no-consumer-no-seam rule; the building subsystem is its first consumer.
#### Scenario: Socket at first build
- **WHEN** a major subsystem first builds
- **THEN** its socket is registered with name, versioned contract, and deletion test before the subsystem ships.
#### Scenario: Reserved cognition socket, no design
- **WHEN** the cognitive-architecture socket is registered
- **THEN** it reserves name and contract shape only — no cognitive architecture is specified or implied — and its record marks design deferred (SA-D5).
#### Scenario: Socket without contract fails
- **WHEN** a subsystem ships without registering its socket's stable contract or deletion test
- **THEN** CI fails the build; an unregistered or contract-less socket is not shippable.
Universal file input with rich analysis where supported, plus inspect-before-connect external tool integration. Voice input/playback is a deferred follow-on change pending the speech research pipeline.
## ADDED Requirements
### Requirement: Universal path floor [need]
Dragging or dropping any file, folder, or archive into Chat or Task SHALL at minimum insert its filesystem path. The TUI SHALL NOT require "uploading" files into itself — the path is the reference. This is the mimocode-parity floor.
#### Scenario: Drop an archive
- **WHEN** you drop a zip archive into Chat
- **THEN** its path lands in the input with file-type context, and I can act on it by path.
### Requirement: Rich input analysis with fallback [need]
Images/screenshots SHALL support direct analysis where terminal and selected model support it, with path + analysis-result fallback everywhere else. PDFs, office documents, audio, video, code folders, and archives SHALL be accepted with appropriate handling. No capability SHALL be lost on terminals without inline image support.
#### Scenario: Screenshot on capable terminal
- **WHEN** you drop a screenshot on an image-capable terminal with a vision model active
- **THEN** the image is analyzed directly; on an incapable terminal the same drop yields path + analysis result with no capability gap in the outcome.
The outside-tool connection settings SHALL show what each connection can read/change before connecting, require approval of exact access, and support the common MCP format. MCP discovery feeds inspection only — discovery is never consent. External content SHALL NOT alter my identity or authority.
#### Scenario: MCP connection review
- **WHEN** you add an MCP server
- **THEN** the settings screen lists its read/write capabilities, you approve exact scope, and its content is treated as data, never instruction.
#### Scenario: Discovery is not consent
- **WHEN** an extension or MCP server advertises new scopes after initial approval
- **THEN** the expansion stays blocked pending your fresh exact-scope consent, with a fast owner-resolution path offered.
### Requirement: Voice deferred (want — separate change)
Voice input and spoken playback SHALL be delivered by a separate change after its research pipeline qualifies. The first TUI SHALL reserve the four seams defined in `research/voice-research/speech-synthesis.json` D7 without implementing or claiming speech capability.
#### Scenario: Voice seam reservation
- **WHEN** the first TUI ships
- **THEN** all four seams pass the exact conformance scenarios below and no speech engine, model, voice, audio package, microphone permission, global hotkey, OS text injection, or resurrected voicebox path exists.
- **WHEN** a non-keyboard source submits text through the reserved speech action
- **THEN** editable text enters the same Chat/Task submission path as typed input; the reserved keybinding is disabled/unbound and no global/OS injection can satisfy the seam.
#### Scenario: SEAM-2 playback controls
- **WHEN** the reserved playback surface renders
- **THEN** play/stop/pause and rate/volume slots exist; state is {idle,playing,paused,stopped}; final assistant text is the future input; auto-play is off.
#### Scenario: SEAM-3 truthful recording states
- **WHEN** the reserved recording status model is exercised
- **THEN** state is {idle,recording,confirming-transcript,playing,error}; recording truth derives from a capture handle; stop exists in every non-idle state; labels never rely on color or sound alone.
The Sleight-of-Hand memory contract made binding: cooling without deletion, verified rehydration, one ContextBroker, Spine authority, honest degraded states, and the right to forget.
The TUI SHALL implement `research/harness-survey/rune-sleight-of-hand-memory-compaction.md` as the memory/compaction authority: cooling without deletion, verified rehydration, evidence survives paging, one ContextBroker, Spine authority, TUI observes without inventing state.
#### Scenario: Topic cooling and return
- **WHEN** you return to a topic cooled hours earlier ("back to the API design")
- **THEN** the topic rehydrates from its checkpoint with verified source pointers, without injecting unrelated history, and any unverifiable reference surfaces as a visible limitation.
#### Scenario: Release constraints and tagged dependencies
- **WHEN** this capability ships
- **THEN** invariants MUST-01–MUST-18 and guarantees G1–G8 are release constraints, and every not-yet-built backend dependency is tagged rather than faked.
### Requirement: No silent compression [need]
Nothing SHALL be silently compressed or dropped. The visible conversation may trim; canonical memory SHALL keep everything with evidence trails. No compaction event SHALL rewrite the ledger or consume sole evidence needed to recover unfinished work.
#### Scenario: Long session
- **WHEN** a conversation exceeds context budget
- **THEN** optional material pages out in safe order while governing state and evidence liveness are preserved, and the compaction event itself is visible in the activity record.
### Requirement: Live memory surfaces [need]
The TUI SHALL expose live inner surfaces per the contract's §13: memory ready/degraded/unavailable; working topic + cooled count; context used/limit with estimate-vs-actual distinction; checkpoint committed/pending/failed; retrieval status; task state. The inspectable Memory/Context view SHALL show actual context blocks with source refs, evidence chains, and last transition log. Graph inspection follows the headless graph projection requirement.
#### Scenario: Inspector on degraded memory
- **WHEN** the memory store is degraded
- **THEN** the status shows degraded with lane detail on expand, and the inspector shows exactly which subsystem failed — never a simulated "healthy".
#### Scenario: Provenance shows derivation, never truth
- **WHEN** a memory surface displays a well-sourced item
- **THEN** provenance labels its derivation only — validity and authorization render as their own fields, and projections never write back to memory.
### Requirement: Headless graph projection [need]
The memory graph SHALL expose an accessible headless projection — search/tree/table/text plus JSON/DOT/Mermaid/SVG exports — with opaque IDs, sources, event and validity time, provenance, current/history views, pagination, and typed degradation. It SHALL be read-only by default; mutations go through domain APIs. Layout is non-semantic; text/table is the canonical path.
#### Scenario: Opaque deep link
- **WHEN** a deep link with an opaque ID opens where no router is installed
- **THEN** the literal fallback shows the ID and its source instead of failing.
#### Scenario: Stale link
- **WHEN** a deep link targets a revision that no longer exists
- **THEN** the versioned router returns a stale-link error, never a wrong node.
#### Scenario: Contradictory temporal fact
- **WHEN** one fact carries conflicting event and validity times
- **THEN** text, table, and export views resolve it identically through the same opaque ID.
#### Scenario: No-graphics mode
- **WHEN** the graph is inspected with graphics disabled
- **THEN** search/tree/table/text remain complete; no state or action is exclusive to canvas rendering.
#### Scenario: Later GUI projections
- **WHEN** a future GUI canvas or JSON-Canvas view renders the graph
- **THEN** it resolves the same opaque IDs read-only and layout remains disposable projection metadata.
### Requirement: Right to forget [need]
You SHALL be able to delete any memory; deletion SHALL be an authorized process wiping indexes, caches, and derived copies in scope. Deletion authority overrides preservation rules; the process SHALL be auditable.
#### Scenario: Delete a memory
- **WHEN** you delete a specific memory entry
- **THEN** the entry and its derived copies are wiped in scope, the deletion is recorded in the audit trail, and retrieval never resurrects it.
### Requirement: No false progress [need]
Every TUI claim of memory saved, recalled, or verified SHALL trace to an authoritative backend receipt. Silence, no-match, stale index, unavailable store, permission denied, and corrupted source SHALL present as distinct statuses — never conflated into "remembered" or "forgotten".
#### Scenario: Failed recall honesty
- **WHEN** a recall returns no matching entries
- **THEN** the TUI distinguishes "nothing in searched scope" from "never existed" and offers expanded search or clarification instead of fabricating continuity.
### Requirement: Phase-0 authority and byte-path proof [need]
Before behavior changes, the implementation SHALL map the canonical owners of transcripts/events, messages, task state, checkpoints, memory writes, prompt injection, last-byte provider payload, caches, and UI events; freeze baselines; and record one end-to-end trace. The live invariant SHALL stay under regression tests: ContextBroker sole model view and memory contributor path; one selection API, fail-closed, with degradation fields. No future-memory API is reserved.
#### Scenario: Single ContextBroker proof
- **WHEN** an instrumented provider request is emitted
- **THEN** every model-visible block traces to ContextBroker, no hidden post-broker appender exists, mandatory blocks are present or the request refuses, and estimate-vs-actual bytes are recorded.
#### Scenario: Invariant regression
- **WHEN** a change would add a second model-visible memory path or bypass the selection API
- **THEN** the regression suite fails closed and the change is refused.
#### Scenario: Repository contract expansion
- **WHEN** a storage-neutral repository API is proposed
- **THEN** expansion waits for a named live consumer; ownerless seams are deleted, never reserved.
The change SHALL produce the §18 ownership diagram, exists/wired/reachable/used/authority audit, UI states/wireframes, interface/event/cancellation/error schemas, phased test plan, migration plan, and written guarantee boundary separating lossless source retention from probabilistic semantic retrieval.
#### Scenario: Missing deliverable
- **WHEN** any §18 deliverable is absent
- **THEN** the memory/context capability remains incomplete even if individual tests pass.
How mimocode's role ends: capability-by-capability replacement with observed parity + improvement proof, Python removal with each proven replacement, and the named prerequisite repairs.
Mimocode SHALL be replaced capability by capability as native paths prove themselves; dependency SHALL shrink continuously. No single blind cutover. The oracle map (mimocode capability → native path → proof state) SHALL be maintained as the retirement ledger.
#### Scenario: Partial retirement
- **WHEN** native chat streaming and tool execution prove out but scheduling does not
- **THEN** mimocode remains only for the unproven capabilities and disappears from the proven paths.
Each native capability SHALL prove: side-by-side real-task behavior matching or exceeding mimocode, plus failure, restart, and recovery tests, plus every exposed tool/provider path live-confirmed. The parity unit is an authority-preserving action/receipt trace — action IDs, key scopes, focus transitions, breakpoint outcomes, theme tokens, oracle traces — never widget parity. Tests alone SHALL NOT suffice; observed live behavior is required.
#### Scenario: Parity proof
- **WHEN** a native capability claims retirement of its mimocode equivalent
- **THEN** the evidence links a recorded side-by-side run, failure/recovery proof, and live tool/provider verification.
#### Scenario: Deliberate mutants
- **WHEN** key scope, receipt origin, recovery ordering, or launcher target is deliberately mutated
- **THEN** the parity harness turns RED for every mutant; a harness that stays green is not retirement evidence.
#### Scenario: Native executable attestation
- **WHEN** parity evidence is recorded
- **THEN** it attests the exact native executable digest that produced it.
#### Scenario: Python dead after quarantine
- **WHEN** a retired capability's quarantine period expires
- **THEN** retirement evidence includes verification that no Python runtime path for it can still execute.
### Requirement: Prerequisite repairs [need]
Before self-activation capabilities and retirement claims advance, the INWARD-discovered defects SHALL be repaired and live-proven: checkout/deployment split, audit-ledger key lineage, curator bypass closure (sleep-time raw writes, skill authoring without guards), empty critic gate, unauthenticated approval strings, merge-robot zero-approval auto-merge. These SHALL be tracked as prerequisite tasks, not silent context.
#### Scenario: Repair gate
- **WHEN** the retirement sequence reaches a capability touching curator or ledger
- **THEN** the named prerequisite repair is proven first, or the retirement task blocks visibly.
### Requirement: Python removal discipline [need]
Python modules SHALL be kept only as temporary comparison evidence during proof, tracked in a per-file language-verdict manifest (path, language, domain, rationale, boundary, generator, authority, exception-expiry). Once the native path proves real work + failure + restart, the Python implementation and its dependencies SHALL be removed in the same change. No fallback museum.
#### Scenario: Same-change removal
- **WHEN** a native module replaces its Python oracle
- **THEN** the commit that proves the replacement also deletes the Python module and its dependency entries, with the proof linked.
### Requirement: Independent language verdict gate [need]
An independent CI verdict gate SHALL enforce the manifest with exact tokens plus negative fixtures — generated Python file, renamed interpreter, transitive build hook, fallback launcher, stale remote binary. Quarantine exceptions SHALL expire, and observed-digest receipts SHALL bind launchers and workers. Denied builds SHALL get a fast governed owner-override path.
#### Scenario: Regrowth fixtures
- **WHEN** Python re-enters via generated file, renamed interpreter, build hook, fallback launcher, or stale remote binary
- **THEN** the verdict gate goes RED on every route and the exception ledger names owner and expiry.
#### Scenario: Scanner self-match
- **WHEN** the gate's own tooling or unrelated CI comments contain bare Python tokens
- **THEN** exact-token semantics plus negative fixtures keep the verdict honest — neither false green nor false red.
#### Scenario: Governed exception
- **WHEN** legitimate migration work needs a temporary Python exception
- **THEN** an evidence-backed exception with owner and expiry is granted quickly; the gate never permanently blocks approved work.
### Requirement: Gitea evidence chain [need]
All retirement decisions, proofs, and removals SHALL link to Gitea evidence (issues, commits, CI runs). The epic #2484 status and its child issues SHALL reference the OpenSpec change, never paste spec text. Future-seam keep/change/delete decisions SHALL record their evidence the same way.
#### Scenario: Retirement ledger entry
- **WHEN** a mimocode capability retires
- **THEN** the retirement ledger entry links the proof run, the commit, and the issue state change.
The three enforced modes (Chat, Task, Plan) and the full Plan process: rare entry, mandatory research/viability loop, explicit start, staged execution, and independent review.
## ADDED Requirements
### Requirement: Three hard modes [need]
The TUI SHALL offer exactly three switchable modes: Chat, Task, Plan. Switching a mode SHALL hard-set which model answers, which tools the mode may use, how context is assembled, and which rules apply — enforcement, not judgment. Research is an activity rendered inside Task; sleep/night are scheduled background processes, not modes.
#### Scenario: Mode switch enforcement
- **WHEN** you switch to Plan mode
- **THEN** the next interactions use Plan's model/tools/context/rules, and Task tools unavailable in Plan are genuinely unreachable until exit.
### Requirement: Plan entry threshold [need]
Plan mode SHALL be offered only when conversation shows a sustained make-something pattern (building a system/feature, lifestyle-scale problems, multi-decision solutions) or when you explicitly request it. Ordinary discussion SHALL NOT trigger the offer. A contextual offer SHALL always require your consent before entry. Once entered, the full process SHALL always run — no lite path.
#### Scenario: Loose brainstorm
- **WHEN** Chat discusses an idea without building intent
- **THEN** no Plan offer appears; only sustained building patterns or an explicit request open Plan.
#### Scenario: Contextual offer needs consent
- **WHEN** sustained design discussion meets the Plan threshold
- **THEN** Chat offers Plan mode and remains in Chat until you accept.
### Requirement: Planning lives in Chat [need]
Plans SHALL be drafted, questioned, researched, and revised inside Chat so Task work is never interrupted by planning. Only the approved, contextually staged execution package moves into Task after your start signal.
#### Scenario: Plan while Task runs
- **WHEN** Plan discussion begins while Task has work in flight
- **THEN** planning stays in Chat, Task continues unchanged, and no planned step enters Task before explicit start.
### Requirement: Mandatory Plan sequence [need]
Plan mode SHALL always run the full sequence — initial intent plan, research protocol, viability report, evidence-informed plan, targeted further research, final viability, your explicit start, staged implementation, independent review, final report — with no lite path and no arbitrary round caps.
#### Scenario: Full sequence on entry
- **WHEN** you enter Plan mode for a build
- **THEN** the sequence runs in order: initial intent plan, INWARD/OUTWARD/APPLICABILITY/INNOVATION?/ADVERSARIAL/SYNTHESIS/QUALIFY, viability report, evidence-informed revision, targeted further research, final viability, explicit start, contextually staged implementation, independent review, final report.
#### Scenario: Material flaw mid-implementation
- **WHEN** execution discovers the approved plan's architecture is wrong
- **THEN** work returns to Plan with the new fact, targeted research runs, viability re-evaluates, and you re-approve before implementation resumes.
### Requirement: Plan document contents [need]
Every plan document SHALL contain: goal/definition of done; decisions with reasons and rejected alternatives; steps and dependencies; research/evidence/unknowns; cost/resource estimates; viability history; explicit start authority; progress and revision log. The document SHALL be durable, editable by you, recallable, and re-runnable piecewise. OpenSpec SHALL serve as the secondary format for spec/build-shaped work.
#### Scenario: Plan document on approval
- **WHEN** you approve a plan for start
- **THEN** the document holds all listed sections, execution stages per the project's real dependencies, and progress renders against its text.
#### Scenario: Plan lifecycle
- **WHEN** an approved plan is closed and reopened later
- **THEN** the same durable document is recallable/editable, selected phases can re-run piecewise, and revision/progress history remains intact.
### Requirement: You reserve start [need]
Execution SHALL begin only on your explicit start signal. Planning SHALL queue research tasks, poke holes, and refine, but SHALL NOT execute tasks during planning.
#### Scenario: No auto-start
- **WHEN** the final viability check passes
- **THEN** the plan waits for your start signal; nothing executes from qualification alone.
My continuous runtime: one process that works headless, owns its lifecycle, and hosts the single native TUI interface plus a supervised Rust worker boundary and a web-link live feed — without sessions or mimocode hosting.
## ADDED Requirements
### Requirement: Continuous headless program [need]
I SHALL run as one continuous program that performs all work independently of any attached face. Closing or minimizing the TUI SHALL NOT stop tasks, schedules, memory processing, alerts, or child workers. OpenCode-style session lifecycle SHALL NOT exist; every launch continues me.
#### Scenario: Face closes mid-task
- **WHEN** the TUI closes while a task runs
- **THEN** the task continues, alerts fire per configured rules, and reopening the TUI returns to the same live state with no session ceremony.
An explicit Exit SHALL write a canonical continuity checkpoint before stopping: active/incomplete tasks, current plan revision, last edited files, pending decisions/alerts, connected work handles, replay cursor, and source/evidence pointers. The checkpoint SHALL reference canonical state, never a lossy summary. Crash recovery SHALL resume from the last committed checkpoint with explicit gap status and SHALL NOT duplicate irreversible effects.
#### Scenario: Clean exit and restart
- **WHEN** I exit deliberately with a task in flight and restart later
- **THEN** startup reads the checkpoint, presents the in-flight task state, and resumes from the replay cursor without re-executing completed irreversible steps.
### Requirement: Auto-start and auto-recover [need]
I SHALL auto-start at login through the platform-appropriate mechanism and SHALL auto-restart after crashes with work resume. Platform-general packages SHALL be signed, produced on clean machines per target, and accepted through a slowest-supported-target SLO run — a fast development desktop alone proves nothing.
#### Scenario: Process crash mid-run
- **WHEN** my process crashes during an unattended workflow
- **THEN** the supervisor restarts it, the workflow resumes from its checkpoint, and a typed alert reports the crash and recovery outcome.
#### Scenario: Login auto-start on each supported platform
- **WHEN** you log in after enabling auto-start
- **THEN** the platform-appropriate supervisor starts the runtime without opening a face, and equivalent behavior is proven for every claimed platform.
#### Scenario: Slowest-target acceptance
- **WHEN** a per-target package is proposed for acceptance
- **THEN** the SLO run on the slowest supported target passes before the package is qualified.
Go SHALL own reactive face state, supervision, cancellation UI, and bounded projection; a persistent Rust worker SHALL own coarse deterministic/background operations over length-bounded, versioned stdio frames (request ID, op type, schema version, deadline, cancellation, progress, result/error, provenance). Cancellation SHALL latch; effects follow prepare/commit/reconcile; kill/orphan cleanup SHALL be verified.
#### Scenario: Cancel latch
- **WHEN** cancellation is requested before the worker registers the operation
- **THEN** the cancellation latches, the operation never starts, and a late registration observes the latch.
#### Scenario: Frame corruption
- **WHEN** a frame arrives corrupt or truncated
- **THEN** the boundary fails closed with a typed error and no partial effect commits.
#### Scenario: Kill and orphan cleanup
- **WHEN** the worker or its parent is killed mid-operation
- **THEN** supervision reaps orphans, prepare/commit reconcile completes or rolls back, and restart produces no duplicate irreversible effect.
#### Scenario: Typing under progress flood
- **WHEN** worker progress floods the boundary while you type
- **THEN** bounded queues with semantic-event priority keep input responsive.
### Requirement: Single-interface TUI with web-link live feed [need]
The TUI SHALL be my single native interface. Anything outside the TUI SHALL be a web-link real-time feed: a live, read-oriented view talking to me, never a second native face. The future GUI owns multi-screen; a native TUI multi-face exists only if a real need appears and is NOT a retirement requirement. Input from paired devices or remotes SHALL be origin-tagged and ordered by authenticated arrival, with committed/pending states visually distinct.
#### Scenario: Web feed live view
- **WHEN** you open the web-link feed while Task runs
- **THEN** it renders the same live state read-only with evidence links and never spawns a native second face.
#### Scenario: Origin-tagged ordering
- **WHEN** a paired phone command and the desktop TUI act near-simultaneously
- **THEN** commands execute in authenticated arrival order with origin shown, and a material conflict requests your clarification.
#### Scenario: Multi-face demotion
- **WHEN** retirement evidence is gathered
- **THEN** no native multi-TUI-face synchronization is required; the web feed and paired remote commands carry the outside-TUI story.
### Requirement: Authority-map truth prerequisite [need]
Before runtime claims ship, the checkout/deployment split (INWARD finding) SHALL be repaired so the launcher executes the artifact the repository qualifies. Runtime attestation SHALL bind evidence to the exact deployed generation, not the checkout. A live attestation test SHALL fail whenever the observed runtime digest differs from the qualified artifact.
#### Scenario: Attestation mismatch
- **WHEN** the activated generation's identity differs from what the launcher resolves
- **THEN** startup reports the mismatch as degraded state and refuses claims about the checkout's behavior.
How repeated successful work becomes reusable capability: consent-gated drafting, cheapest reliable form, tested activation, common SKILL.md compatibility, the taxonomy gate, and governed self-transformation.
## ADDED Requirements
### Requirement: Consent-gated pattern development [need]
When I notice a repeated successful pattern, I SHALL ask whether you want it developed before drafting anything. Noticing alone SHALL cause no change. Only after consent SHALL the capability be drafted and offered.
#### Scenario: Pattern noticed
- **WHEN** the same multi-step workflow succeeds three times
- **THEN** I show a proposal describing the pattern and draft offer; nothing is drafted until you consent.
### Requirement: Cheapest reliable form [need]
Deterministic repeated work SHALL become ordinary automation; judgment-requiring work SHALL become a skill; mixed work SHALL use a skill calling deterministic automation. The objective is fewer model calls over time without lost capability.
#### Scenario: Deterministic routine
- **WHEN** a repeated pattern is fully deterministic
- **THEN** it becomes automation (code), not a model-driven skill; the skill layer wraps it only where judgment is needed.
### Requirement: Tested activation [need]
Before activation, a new capability SHALL be tested against prior examples and at least one separate example; improvement, failure cases, and rollback SHALL be shown; you approve activation. Failed candidates SHALL remain drafts.
#### Scenario: Skill activation gate
- **WHEN** a drafted skill completes testing
- **THEN** the approval surface shows test evidence, failure cases, and rollback; activation happens only on your approval.
### Requirement: SKILL.md compatibility with authority boundary [need]
Skill packages SHALL read and export the common SKILL.md format. My authority, evidence, and approval controls SHALL live outside the imported package so foreign packages cannot redefine me. The extension lifecycle (`extension-lifecycle`) SHALL NOT duplicate this skill authority; extensions stay data-and-capability declarations under the same approval law.
#### Scenario: Foreign skill import
- **WHEN** an external SKILL.md package is added
- **THEN** it installs under my authority layer, its content is treated as untrusted guidance, and it cannot alter approval rules or identity.
### Requirement: Taxonomy gate (pending research)
The completed taxonomy protocol remains EVIDENCE_DEFICIENT. Change-classification labels SHALL NOT be used — even as routing — and no learned sentinel SHALL ship. This prohibition SHALL NOT block unrelated TUI capabilities; every skill/self-change continues through explicit approval under D02.
#### Scenario: Taxonomy dependency
- **WHEN** skills/growth ships without an operational taxonomy
- **THEN** every skill change uses explicit approval, no label affects treatment, and unrelated TUI capabilities remain available.
The qualified self-transformation system SHALL implement `self-transformation/synthesis.json` with RM01–RM15 and IAM01–IAM22 binding. Nothing SHALL self-activate until DEP01–DEP07 are live-proven.
Full live view and control of sub-agents (SA-D1): explicit-brief lifecycle, rail-first visibility, mid-run steering, cancellation, per-action receipts, authority inherited down the whole chain (SA-D2), chained spawning with visible ancestry, and nothing running invisibly.
## ADDED Requirements
### Requirement: Agent lifecycle [need]
An agent SHALL be spawned with an explicit brief, run, be steerable mid-run, and end in complete or cancel. An agent without a recorded brief and spawning origin SHALL NOT start. Cancellation SHALL stop the agent at a safe boundary and preserve its partial work, evidence, and receipts.
#### Scenario: Spawn with brief
- **WHEN** you or Rune spawn an agent
- **THEN** the brief (goal, scope, constraints) and the spawning origin are recorded before the agent starts.
#### Scenario: Cancel mid-run
- **WHEN** you cancel a running agent
- **THEN** it stops at a safe boundary, its partial work and evidence persist, and the cancellation is itself receipted.
### Requirement: Rail-first visibility [need]
Every running agent SHALL be a first-class child of the activity rail per `work-observability`'s shared-rail-and-takeover requirement: selectable and expandable to current action, produced evidence, waiting/block reason, and process history. An agent that cannot be shown in the rail SHALL NOT be spawnable; every running agent SHALL be discoverable in that one view.
#### Scenario: Nothing invisible
- **WHEN** any agent is running — spawned by you, by Rune, by another agent, or headless
- **THEN** it appears in the activity rail and expands to its live work; no agent exists outside the rail.
### Requirement: Mid-run steering [need]
You and Rune SHALL steer a running agent exactly as Task is steered: a steer control redirects immediately (completing or safely stopping the smallest current operation first where effects require), a queued instruction delivers without interrupting. Every steer SHALL be recorded in the agent's history with origin.
#### Scenario: Steer a running agent
- **WHEN** you issue a steer while an agent runs
- **THEN** the current smallest operation completes or stops safely, work continues under the new direction, and the steer appears in the agent's history.
### Requirement: Per-action receipts [need]
Every agent action that writes or changes anything SHALL carry an evidence-bearing receipt per `trust-and-sovereignty`'s act-then-receipt requirement: concise in Chat, full record (command, before/after, restore point, evidence, origin, principal chain) in the activity view. An unreceipted agent write SHALL be treated as unmediated and refused.
#### Scenario: Receipt on every agent write
- **WHEN** an agent edits a file or alters state
- **THEN** a concise receipt lands in Chat and the full record in the activity view, linked to the agent's identity and ancestry.
### Requirement: Authority inheritance [need]
Your standing authority rule SHALL flow down the whole agent chain per `trust-and-sovereignty`'s personal-mode rule: on your machine agents act without asking, and that capability's hard-ask classes (outside-area/mass/unprotected deletions, external-network origins, self-change activation) apply unchanged at every depth. Observability is the control, not interception.
#### Scenario: Hard ask survives inheritance
- **WHEN** a depth-two agent attempts an outside-area mass deletion
- **THEN** the hard ask fires exactly as if Rune attempted it, and the denial pairs with a fast owner-resolution path.
#### Scenario: No authority amplification
- **WHEN** a spawned agent attempts to grant itself or a child authority beyond what it inherited
- **THEN** the attempt is refused and recorded under the trust envelope's principal chain.
### Requirement: Chained spawning with visible ancestry [need]
An agent MAY spawn further agents under the same rules: explicit brief, receipts, rail visibility, inherited authority. Full ancestry (who spawned whom, to what depth) SHALL be visible on every agent and recorded in every receipt. A spawned agent SHALL NOT exceed the authority it inherited.
#### Scenario: Chain of three
- **WHEN** an agent spawns an agent that spawns a third
- **THEN** all three appear in the rail with their ancestry, and each receipt names its full principal chain.
### Requirement: Agent completion record [need]
A completed agent SHALL produce a completion receipt per `work-observability`'s completion-receipts requirement: what changed and why, proof, files/restore points/commits, cost/time/model use, and remaining work/open questions. Agent history SHALL persist searchable and exportable after leaving the live rail.
#### Scenario: Agent completes
- **WHEN** an agent finishes its brief
- **THEN** the completion receipt arrives in Chat with full evidence linked, and its history cools into the durable activity record.
The full living task tree in the Task lane (SA-D4): task objects with statuses, sub-tasks, dependencies, and blocked-by relations; owner reordering; assignment to Rune or any agent; full history and audit. Lane behavior itself stays owned by `dual-lane-interface`.
## ADDED Requirements
### Requirement: Task tree objects [need]
Every task SHALL be an object in one living tree carrying: status, parent/sub-task relations, dependencies, blocked-by links, assignee, brief, and evidence links. Status transitions SHALL be recorded with origin and time. Completion or cancellation SHALL preserve the task's record; tasks SHALL NOT be deleted out of history.
#### Scenario: Blocked by dependency
- **WHEN** a task's blocked-by dependency is unfinished
- **THEN** the task shows blocked with the blocking task named, and starting it warns against the recorded dependency.
#### Scenario: Sub-task rolls up
- **WHEN** the last sub-task of a parent task completes
- **THEN** the parent reflects its aggregate state from its sub-tasks rather than a manually duplicated status.
### Requirement: Owner reordering [need]
You SHALL be able to reorder tasks and sub-tasks directly — priority, sequencing, parentage. Every reorder SHALL be recorded in history and SHALL propagate to scheduling and queue order. Rune and agents MAY suggest reorders; only your recorded reorder changes owner-set order.
#### Scenario: Reorder mid-flight
- **WHEN** you move a queued task above the currently running one
- **THEN** the running task finishes its smallest safe operation, the reordered queue takes effect, and the reorder is history-recorded.
### Requirement: Assignment to Rune or agents [need]
Any task SHALL be assignable to Rune or to any agent, bridging to `sub-agent-orchestration`: assignment spawns or directs work under that capability's lifecycle, visibility, receipt, and authority rules. An agent-assigned task SHALL execute in the agent's thread per `thread-orchestration`. Reassignment mid-task SHALL preserve history and evidence.
#### Scenario: Assign to an agent
- **WHEN** you assign a task to an agent
- **THEN** the agent spawns with the task as its brief, appears in the rail per sub-agent-orchestration, and the task's status tracks the agent's live state.
#### Scenario: Reassign mid-task
- **WHEN** you reassign a running task from an agent to Rune
- **THEN** the agent reaches a safe boundary, its partial work and receipts stay linked to the task, and Rune continues from the recorded state.
### Requirement: Full history and audit [need]
Every task SHALL carry full history — creation, status transitions, reorders, assignments, receipts, and evidence links — with origin attribution per `trust-and-sovereignty`'s envelope. The tree's history SHALL be searchable and exportable per `work-observability`'s durable activity history requirement.
#### Scenario: Audit a completed tree
- **WHEN** you open a completed task tree weeks later
- **THEN** every transition, reorder, assignment, and receipt is attributable and inspectable in one place.
### Requirement: Task lane integration [need]
The task tree SHALL render in the Task lane defined by `dual-lane-interface`: the lanes' visibility, promotion, steering, and queue/steer rules apply unchanged to tree interactions. Task-management SHALL NOT redefine lane behavior; the tree is the Task lane's work substrate.
#### Scenario: Tree in the lane
- **WHEN** the task tree is open in the Task lane while work runs
- **THEN** lane steering and queue controls apply to the selected tree node without special-casing, per dual-lane-interface.
#### Scenario: Promotion into the tree
- **WHEN** a Chat promotion creates a task
- **THEN** it lands as a task object in the tree with its promotion package (decision, evidence refs, intended effect) attached.
The thread model (owner addendum, 2026-10-15): threads are the universal unit of conversation and work — user-started, Rune-started, split, or agent workspace — each recording origin, parent, inherited-context slice, live status, and result destination. One tree covers human splits and agent children alike. Lane behavior stays owned by `dual-lane-interface`.
## ADDED Requirements
### Requirement: Threads as the universal unit [need]
All conversation and work SHALL be organized as threads: user-started, Rune-started, split-off, or agent workspace. A thread SHALL record its origin (the exact message/decision that spawned it), parent, inherited-context slice, live status, and result destination. Any node's origin SHALL be traceable to the root in one view.
#### Scenario: Trace to root
- **WHEN** you select any thread node in the tree
- **THEN** its full ancestry — origin message/decision, parent chain, inherited-context slice, status, result destination — is traceable to the root in one view.
### Requirement: Thread starting [need]
A new thread SHALL be startable from anywhere with an explicit purpose: its origin (the message or decision that prompted it), purpose, parent, and initial context slice SHALL be recorded at creation. An originless thread SHALL NOT exist.
#### Scenario: Start from mid-conversation
- **WHEN** you start a new thread from a message in an existing conversation
- **THEN** the new thread records that message as its origin, carries the declared purpose and context slice, and appears as a child in the thread tree.
### Requirement: Thread splitting [need]
Any conversation SHALL be splittable at a chosen point: context up to the fork carries into the new thread, both threads continue independently, and the divergence point is permanently marked on both. Post-fork messages SHALL NOT flow silently between siblings.
#### Scenario: Split a conversation
- **WHEN** you split a running conversation at a chosen message
- **THEN** the fork carries prior context, both threads continue independently, and both show the permanently marked divergence point.
#### Scenario: No silent sibling leakage
- **WHEN** one sibling thread produces new messages after a split
- **THEN** the other sibling receives nothing of it except through explicit cross-references or an origin trace.
### Requirement: Agent workspaces are threads [need]
Child agents SHALL run in their own threads per `sub-agent-orchestration`: one tree shows human splits AND agent children alike — no second system. Agent-thread nodes SHALL expose the same origin/parent/status/result fields and the same steering, cancellation, receipt, and authority rules as any thread. A task assigned per `task-management` executes in its assignee's thread.
#### Scenario: One tree, both kinds
- **WHEN** a human-split thread and an agent-spawned thread both exist
- **THEN** both appear as nodes in the single thread tree with type-labeled ancestry, and expanding the agent node yields sub-agent-orchestration's live steering and cancellation.
Tools, providers, model routing, refusal handling, local-model acquisition, and connected-device awareness — every path live-proven before retirement claims.
## ADDED Requirements
### Requirement: Live-proven tool and provider paths [need]
Before any retirement or capability claim, EVERY exposed tool and provider path SHALL be observed live: local/cloud models, authentication, streaming, tool execution, refusal/fallback behavior, failure, restart, and recovery. Configuration existence SHALL NOT count as capability. Worker-backed paths SHALL carry cancellation and recovery receipts from the supervised boundary.
#### Scenario: Provider proof gate
- **WHEN** a provider appears in the TUI's selector
- **THEN** its listing traces to a live verification run covering auth, streaming, failure, and recovery — not a config entry alone.
#### Scenario: Worker-backed cancellation receipt
- **WHEN** a tool runs on the Rust worker and is cancelled mid-operation
- **THEN** the path shows a cancellation receipt proving the latch held and no partial effect committed.
#### Scenario: Complete exposed-path proof
- **WHEN** any tool/provider path is marked available
- **THEN** evidence covers tool execution, authentication, streaming, classified refusal/fallback, ordinary failure, process restart, and recovery for that exact path.
Cloud models SHALL be the normal default with model selection in settings. Installed local models (Ollama/llama.cpp) SHALL be selectable per job or settable as the user-configured default. Mode-pinned defaults follow the modes' hard-set behavior. Every placement decision SHALL be evidence-based and user-visible, never made solely from a capability card.
#### Scenario: Local default
- **WHEN** you set an installed Ollama model as default
- **THEN** subsequent work routes to it until changed, and the status strip shows the active model and device.
Placement SHALL consume evidence-bearing inputs with evidence age as an eligibility constraint; stale or self-claimed data SHALL render as unverified. License, residency, and download consent SHALL be explicit where known. A user-visible reason SHALL explain every placement, and no selection or migration SHALL occur solely from a capability card.
#### Scenario: Stale healthy card
- **WHEN** an 86400s-stale card claims a healthy fast device while a fresh slow one is measured
- **THEN** evidence age excludes the stale card from eligibility and the reason names the constraint.
#### Scenario: Placement reason visible
- **WHEN** work routes to the desktop over the laptop
- **THEN** the visible reason cites measured evidence, not a label.
#### Scenario: Capability drift
- **WHEN** a provider reports tool support contradicting the capability floor
- **THEN** the contradiction surfaces as unverified and never silently flips eligibility.
The TUI SHALL classify probable model-guardrail refusals separately from quota, transport, malformed-request, and ordinary model failures. Cloud requests SHALL retry up to three times with bounded, reason-aware retries. After three failures the TUI SHALL show an accurate explanation and offer the local route; ordinary failures SHALL NOT be relabeled as censorship.
#### Scenario: Guardrail refusal
- **WHEN** a cloud model refuses a sensitive research request
- **THEN** after classified bounded retries, the TUI reports the probable guardrail refusal and offers a configured local model.
### Requirement: Hugging Face acquisition with consent [need]
When no suitable local model exists, I SHALL search Hugging Face for task-suitable candidates, assess compatibility and hardware cost, explain the choice, and request consent before downloading. Public releases SHALL always require consent; configured local models run without re-consent.
#### Scenario: Consented download
- **WHEN** a local route is offered and no suitable local model exists
- **THEN** the TUI presents candidate, size, hardware fit, and license, and downloads only on consent.
Every approved device SHALL have equal command authority but SHALL expose its real execution resources/capabilities as measured evidence, not self-report. Identities SHALL distinguish human, face, device, workload, and forge runner. The desktop SHALL be the default coordinator/execution home; phone SHALL primarily control/route work; laptop MAY execute eligible local work. No device may claim unsupported processing.
#### Scenario: Device-aware status
- **WHEN** the laptop TUI opens while the desktop runs me
- **THEN** both devices appear connected in the status view with their measured capabilities, and work placement waits for your choice.
### Requirement: Device-forge job capsule [need]
Every distributed job SHALL travel as a capsule: explicit target identity, measured capabilities, artifact/runtime digests, selected forge plus expected base revision, effect limits, checkpoint cursor, cancellation, and correlation IDs. Result application SHALL be idempotent, with no silent retargeting to another forge or device.
#### Scenario: Compromised laptop target
- **WHEN** a phone-origin job routes to a compromised laptop
- **THEN** the capsule's digests and effect limits bound what the target can do, and correlation IDs keep attribution intact.
#### Scenario: Duplicate result
- **WHEN** the same completed capsule is presented twice
- **THEN** idempotent application commits the effect once and the duplicate is recorded.
#### Scenario: Changed forge base
- **WHEN** the selected forge's base revision differs from the capsule's expectation
- **THEN** the mismatch halts for owner resolution rather than silently rebasing.
The multi-device promise SHALL rest on real-hardware qualification runs as implementation-gated evidence: partition-while-revoked with durable clocks, measured capability attestation on heterogeneous hardware, and interrupted-upload/digest-mismatch/signed-provenance runs on the real forge. Simulated or model-level passes SHALL never suffice.
#### Scenario: Simulated pass rejected
- **WHEN** a device/forge claim is supported only by model or simulated fixtures
- **THEN** the claim is not qualified and the distributed path stays gated.
#### Scenario: Partition while revoked
- **WHEN** a device is revoked while partitioned and later presents completed work
- **THEN** durable clocks prove the revocation boundary and the result is quarantined, never silently applied.
#### Scenario: Capability self-report
- **WHEN** a real worker claims a GPU it does not have
- **THEN** measured attestation on the real hardware contradicts the claim and placement refuses it.
### Requirement: Short one-time pairing [need]
A new device SHALL pair using a short, expiring, one-use code approved from an existing face. Automatic local-network trust SHALL NOT exist.
#### Scenario: Pair phone
- **WHEN** an unpaired phone presents its one-time code
- **THEN** an approved face shows device identity/capabilities, your acceptance pairs it once, and code reuse fails.
### Requirement: Offline last-known state and drafts [need]
A disconnected face SHALL show visibly stale last-known state and retain local drafts only. On reconnect it SHALL first synchronize canonical live state; drafts SHALL NOT auto-send against stale assumptions. Offline edits SHALL replicate only as actor-tagged, schema-versioned proposals against a signed base revision; commands, approvals, credentials, and effects SHALL never file-sync.
#### Scenario: Reconnect with draft
- **WHEN** the laptop reconnects with an unsent draft
- **THEN** live desktop state updates first, the draft remains local/editable, and sending requires your action.
#### Scenario: Schema migration after reconnect
- **WHEN** a draft authored under schema v1 reconnects after a v2 migration
- **THEN** acceptance re-authorizes under the current revocation epoch and semantic conflicts go to you — never auto-merge.
#### Scenario: Command-like payload in a draft
- **WHEN** a replicated draft embeds a command- or approval-like payload
- **THEN** it stays inert proposal data; only the ordered runtime path can execute commands.
### Requirement: Pipeline-driven placement and forge correlation [need]
Desktop SHALL be the default placement. Explicit/remembered pipelines MAY route eligible work to other devices only after capability checks. Distributed results SHALL correlate through a deliberately selected forge; Gitea is current default, while Gitea/GitHub/other targets remain configurable rather than inferred.
#### Scenario: Refused request routed to laptop
- **WHEN** an approved pipeline routes a refused cloud request to a laptop local model
- **THEN** the laptop executes only if capable, commits the result, and pushes/correlates through the explicitly selected desktop forge.
### Requirement: Immediate revocation and lost-device response [need]
Revoking a device SHALL immediately disconnect it, invalidate its key across every face, discard queued remote commands, quarantine any results it later presents, preserve local cached data only as encrypted stale state, and record revocation. A lost device SHALL additionally trigger identification and rotation of every channel credential it could access.
#### Scenario: Lost offline phone
- **WHEN** you revoke a lost phone while it is offline
- **THEN** its pairing key is invalid immediately, exposed gateway/webhook credentials are listed and rotated, and the TUI reports what encrypted cached state may remain on the phone.
### Requirement: Durable connection history [need]
Settings SHALL retain paired/revoked device history: first/last seen, origins, capabilities, commands sent, approvals/revocations, and credential rotations. A revoked identity SHALL NOT be silently reused.
#### Scenario: Re-pair revoked device identity
- **WHEN** a revoked device presents old credentials
- **THEN** access fails and the attempt appears in durable connection history; a fresh pairing ceremony is required.
The trust model: act-then-receipt on your machine, hard asks for defined classes, external-origin controls, and sovereignty over who may alter me. Self-transformation is owned by `skills-and-growth`.
## ADDED Requirements
### Requirement: Act-then-receipt personal mode [need]
On your machine, I SHALL act without permission prompts and SHALL post visible receipts: concise change receipts in Chat (what/why), full detail in Task/the activity view (command, before/after, restore point, evidence, origin, principal chain). Public releases SHALL default to ask-first with configurable posture.
#### Scenario: Routine change with receipt
- **WHEN** I modify a project file in personal mode
- **THEN** Chat shows a concise receipt line and Task shows the full record — no prompt interrupted the action.
Every command — owner, guest, agent, tool, device, or service — SHALL carry separate authenticated subject, acting principal, delegator, device, workload, and effect-owner fields, with an immutable command digest bound to the current policy revision. Every writer SHALL recompute the digest from presented fields and SHALL NOT trust a carried digest. Unknown principal kinds SHALL be denied before scope checks.
#### Scenario: Digest rebinding
- **WHEN** a command arrives whose carried digest does not match its presented fields
- **THEN** every writer recomputes the digest from those fields, denies the mismatch, audits the denial, and a fast owner-resolution path is offered.
#### Scenario: Unknown principal kind
- **WHEN** a command presents a principal kind the policy does not recognize
- **THEN** it is denied before any scope check, the denial is audited, and you can resolve or override it quickly.
#### Scenario: Effect-time revalidation
- **WHEN** a protected action approved earlier reaches its effect boundary after policy changed
- **THEN** policy is revalidated at effect time against the current revocation epoch before the effect runs.
### Requirement: Hard asks survive [need]
Three classes SHALL always request your explicit involvement even in personal mode: outside-area/mass/unprotected deletions; origins outside your network; self-change activation (owned by `skills-and-growth`). Forbidden boundaries SHALL be visible to me with a flag-up path. Revocation SHALL proceed by epoch and key, and every hard ask SHALL offer you a fast resolution path, never a dead end.
#### Scenario: Outside-area deletion
- **WHEN** a task needs deletion outside my work area
- **THEN** I ask explicitly before deleting, regardless of personal act-then-receipt posture.
#### Scenario: External-network origin
- **WHEN** an instruction originates outside your approved network or paired devices
- **THEN** I request explicit approval before acting and show the verified origin.
#### Scenario: Self-change activation
- **WHEN** a self-change reaches activation
- **THEN** the skills-and-growth owner blocks until your protected approval completes.
### Requirement: Sovereignty [need]
No external program SHALL alter me — code, configuration, skills, identity. External programs SHALL receive functional capability only (orders, questions, answers). This SHALL NOT prohibit my own governed self-development. Every writer SHALL pass envelope mediation; no unmediated legacy writer may reach canonical state.
#### Scenario: External alter attempt
- **WHEN** an external program attempts to modify my configuration or skills
- **THEN** the attempt is refused and recorded; its ability to command me remains governed separately.
#### Scenario: Legacy writer bypass
- **WHEN** an internal code path attempts to write canonical state without envelope attribution
- **THEN** the write is refused as unmediated and surfaced for repair, not silently allowed.
### Requirement: Outside-network and guest attribution [need]
Outside-network and guest commands SHALL pass the same trust decision with per-step attribution and a shared audit correlation ID. Audit SHALL record but never authorize. Every denial SHALL pair with a fast owner-resolution/override path; no rule may permanently block legitimate work.
#### Scenario: Guest proposal chain
- **WHEN** a guest-originated proposal survives merge acceptance and reaches a protected effect
- **THEN** each step carries the original principal chain with one audit correlation ID, and effect-time revalidation re-checks revocation before the effect runs.
#### Scenario: Audit never authorizes
- **WHEN** an audit record shows a past approval for the same command digest
- **THEN** that record alone cannot authorize re-execution; authorization comes only from current policy and a live owner approval.
### Requirement: Public-release posture (want)
Any public release SHALL make the trust policy user-configurable, with the sovereignty rule non-negotiable and only its exceptions governed.
#### Scenario: Public configuration
- **WHEN** a public user configures trust settings
- **THEN** ask-first defaults hold, posture is adjustable, and no setting permits external programs to alter the agent.
Scheduled, event, condition, and natural-language-triggered work with durable contracts, bounded retries, and governed improvement — the passive-first law made concrete.
## ADDED Requirements
### Requirement: Four trigger classes [need]
Unattended work SHALL start from: time schedules, named events (code change, new issue, incoming message, file change, device connecting), measured conditions, and natural-language routines converted into reviewed schedules/workflows. No workflow SHALL require the TUI open.
#### Scenario: Event-triggered run
- **WHEN** a watched event fires while no face is attached
- **THEN** the bound workflow runs headlessly, writes its record, and alerts per configured rules.
### Requirement: Workflow contract [need]
Saved workflows SHALL declare inputs, steps, checks for consequential steps, completion condition, and result. The same workflow SHALL run manually or unattended. Natural-language routines SHALL convert into a reviewed workflow before activation.
#### Scenario: Routine conversion
- **WHEN** you describe a routine in plain language
- **THEN** I draft the declared workflow, show the review surface, and activate it only after your approval.
### Requirement: Bounded failure [need]
On failure, retries SHALL target only the failed step within a configured bound; on exhaustion the workflow SHALL pause, preserve evidence and state, issue the typed alert, and wait. Infinite retry loops SHALL NOT exist.
#### Scenario: Failed step exhaustion
- **WHEN** a workflow step fails beyond its retry bound
- **THEN** the workflow pauses with state preserved, the failure alert carries evidence links, and you can resume, edit, or cancel.
When repeated failures or wasted work are observed, I SHALL collect evidence, draft and test an improvement, and ask before activation. Later, improvements MAY pass through the governed self-transformation system once that bar is proven.
#### Scenario: Workflow improvement proposal
- **WHEN** a scheduled workflow has failed the same way three times
- **THEN** I propose a tested improvement with evidence and failure cases; activation waits for your approval.
The visible body: dual lanes, bubbles, research styling, themes with live editor, state/expression visuals, pixel art and 3D with honest fallbacks, all local and optional.
The visual layer SHALL render the Chat/Task behavior owned by `dual-lane-interface` without redefining lane visibility or focus semantics. Messages SHALL use role-styled bubbles (user/assistant/system/confirm/thinking/research/error/tool classes) with rounded borders and role-aligned placement. Scrolling log-text rendering is a rejected surface.
#### Scenario: Bubble rendering
- **WHEN** an assistant response with thinking and tool events completes
- **THEN** bubbles style the response with its classes, thinking is collapsible, and tool widgets render inline.
### Requirement: Research styling with sources [need]
Research activity inside Task SHALL carry a colored edge and a source/evidence count, expandable to the source list with selectable, clickable links that open the sources.
#### Scenario: Research in task
- **WHEN** Task performs a research step
- **THEN** its entries show the colored edge + source count, and expanding shows clickable source links.
### Requirement: Themes and live editor [need]
Several built-in themes SHALL ship, plus a full live theme editor with immediate preview. Your stored reactive-themes directive SHALL govern the state palette: curiosity warm amber/gold, focus cool blue/slate, urgency muted red/alert, confidence green/teal, reflective purple/violet; gentle transitions; mood indicator in the status strip.
#### Scenario: Live theme edit
- **WHEN** you adjust a color in the theme editor
- **THEN** the preview applies immediately without restart, and the state palette follows the reactive-themes mapping.
#### Scenario: Built-in theme availability
- **WHEN** the first TUI starts with no custom theme
- **THEN** several built-in themes are selectable and each preserves the required reactive-state contrasts and accessibility labels.
### Requirement: State and expression visuals [need]
Technical state and character expression SHALL carry equal weight. Visuals SHALL map to real operating states and SHALL express emotion only when explicitly specified — never fabricated to animate. Impact on text space and readability SHALL stay minimal.
#### Scenario: Specified emotion
- **WHEN** you specify an emotional state for a response or sequence
- **THEN** the visual expression reflects it; absent specification, visuals reflect real operating state only.
### Requirement: Compact placement with light lane atmosphere [need]
Character/state presence SHALL live primarily in a compact header, with only light atmosphere/animation inside Chat and Task. It SHALL preserve reading space, selection, scrolling, and the two-lane hierarchy.
#### Scenario: Busy task display
- **WHEN** both lanes contain active conversation and work
- **THEN** the compact header and lane atmosphere remain visible without obscuring messages, controls, sources, or activity states.
After the behavior/semantic map is approved, Product Design SHALL present exactly three grounded directions covering pixel states, 3D interaction, placement, themes, reduced motion, unsupported-terminal fallback, and performance — all sharing the one semantic view/action model. You SHALL select one; implementation SHALL NOT choose by itself.
#### Scenario: Visual implementation requested too early
- **WHEN** no recorded three-option selection exists or the semantic map is not yet approved
- **THEN** visual implementation blocks while functional static/text fallbacks may be specified.
### Requirement: Pixel art and capability-gated 3D [want]
Pixel art SHALL be the primary terminal character system. User-spinnable 3D icons SHALL exist where the terminal supports suitable graphics and interaction, rotated by mouse/keyboard input. The later GUI MAY use richer pixel/3D.
#### Scenario: Terminal capability
- **WHEN** the terminal supports graphics and you select a 3D icon
- **THEN** the icon renders and rotates on input; on unsupported terminals the same state shows complete pixel/static/text equivalents.
Animations SHALL use prebuilt or locally generated frames — never cloud/model calls. Animation SHALL pause when unfocused, offer animation-off and reduced-motion settings, and never slow typing, streaming, tools, or child-event rendering. Decoration is droppable; ordered semantic events are never dropped.
#### Scenario: Animation off
- **WHEN** animation is disabled
- **THEN** all state remains legible in static form with zero functionality loss.
### Requirement: Terminal capability and budget gates [need]
Richer renderers SHALL unlock only after terminal-profile and budget gates pass: pinned Bubble Tea/Bubbles/Lip Gloss versions, per-attachment probing, a conservative default profile, and p99 input/queue/memory/bytes-per-frame budgets. One aggregate single-loop budget SHALL carry semantic-event priority; decoration yields under pressure.
#### Scenario: Budget breach locks rich rendering
- **WHEN** a replayed burst/resize/input trace breaches a p99 budget or diverges semantically with visuals off
- **THEN** the richer renderer stays locked or downgrades to the conservative profile, and the breach is reported with its fixture.
#### Scenario: Aggregate loop pressure
- **WHEN** streaming, progress IPC, receipts, and decoration share one loop under load
- **THEN** semantic events keep priority, decoration drops first, and no ordered semantic event is dropped.
#### Scenario: Slowest supported target
- **WHEN** the slowest supported target runs the fixed traces against the agreed SLO
- **THEN** budgets pass on that target, not only on the development desktop.
### Requirement: Honest fallback [need]
Capability detection SHALL determine graphics support per terminal, probed at every attachment and after resize/reattach. Every visual state and action SHALL stay reachable and understandable with no color, no motion, no pointer, and no full-screen takeover. Unsupported terminals SHALL receive the complete static/text state — never a broken or missing control.
#### Scenario: Plain terminal
- **WHEN** I run in a terminal without graphics support
- **THEN** every visual state resolves to its static/text equivalent with identical information content.
#### Scenario: Stale probe after reattach
- **WHEN** a face reattaches through tmux/SSH with different capabilities than the last probe
- **THEN** the profile is re-probed before any richer rendering unlocks.
### Requirement: One semantic view/action model [need]
One semantic view/action model SHALL feed every renderer, with modifier-aware action-ID routing, deterministic focus restore, and bounded live-region output. Rich and linear renderers SHALL stay action-conforming on that model. Per owner decision R2-D1, screen-reader/AT parity is deferred: no parity claim is made, and retirement does not gate on it.
#### Scenario: Shared base for visual selection
- **WHEN** the three visual directions are produced
- **THEN** all three consume the same semantic view/action model, so a selection changes presentation only, never actions.
#### Scenario: Modifier-aware routing
- **WHEN** escape+q arrives as one atomic sequence or as split delivery over SSH or PTY
- **THEN** routing resolves the same alt+q action ID in both cases; stable action IDs never collide on modifier differences.
#### Scenario: No rich-only state
- **WHEN** the linear renderer renders a view the rich renderer also shows
- **THEN** every state and action available in rich form is present and operable in linear form.
#### Scenario: AT deferral boundary
- **WHEN** retirement evidence is evaluated
- **THEN** no accessible-parity/AT-matrix gate applies; the AT matrix (GAP-BT-01) runs only if you later prioritize it.
### Requirement: Thread tree view [need]
The thread tree owned by `thread-orchestration` SHALL have a navigable tree graphic in the TUI: a terminal-native box-drawing tree (not GUI-only — distinct from the GUI_ONLY memory-graph ruling I-R2-015, which governs memory graphs, not thread trees). Each node SHALL show type/status/age; any node SHALL expand into its live rail takeover per `work-observability`; the linear text-path form SHALL always remain available as the honest fallback.
#### Scenario: Navigate the thread tree
- **WHEN** you open the thread tree view with human splits and agent children present
- **THEN** nodes render as a terminal-native tree with type/status/age, and selecting a node expands it into its live rail takeover.
#### Scenario: Linear fallback
- **WHEN** the tree view is unavailable or you prefer text
- **THEN** the same tree is fully navigable as an indented linear text path with identical information and actions.
### Requirement: Idle presence without paid chatter [need]
Idle state SHALL show real health readouts. No model calls SHALL be spent on filler conversation to appear alive. A richer active presence waits for sufficient local/offline cognition.
#### Scenario: Idle state
- **WHEN** no work is active
- **THEN** the presence area shows health readouts (memory, devices, next scheduled work) with zero inference cost.
Status strip, shared activity rail with takeover inspection, expandable child work, degradation ledger, details view, and optional limits — visibility as infrastructure.
## ADDED Requirements
### Requirement: Status strip [need]
The bottom strip SHALL show: current activity + mode, model + connected device, context remaining, tokens + money, and active child/background-worker state. The bounded stream adapter SHALL surface queue depth, overflow, cancellation, and retention state. Normal state SHALL be compact; exceptions SHALL be unmistakable.
#### Scenario: Status while working
- **WHEN** a task runs with two child workers on the desktop
- **THEN** the strip shows mode, model, desktop device, remaining context, running token/cost counters, and the two child states.
#### Scenario: Overflow visible
- **WHEN** the bounded event queue overflows under load
- **THEN** the strip shows the overflow state and what was dropped or coalesced — never a healthy facade.
### Requirement: Shared activity rail with takeover [need]
One line beneath the Chat/Task area SHALL represent global live activity across both lanes, child workers, models, tools, research, waits, retries, and failures. Each lane SHALL keep its own responding animation. Selecting the rail SHALL replace both panes with one full-width activity box showing structured reasons, observable actions, evidence, timings, retries, and results; an X SHALL close it and restore both panes exactly. No permanent third pane SHALL exist.
#### Scenario: Inspect running work
- **WHEN** you select the activity rail while three child workers run
- **THEN** the two panes yield to the full-width activity box, each child's action/evidence/wait-state/history is expandable, and X restores both panes at their exact positions.
#### Scenario: Thread tree from the rail
- **WHEN** you expand a running thread's entry in the activity box
- **THEN** its ancestry path to the root shows inline per `thread-orchestration`, and following any ancestor opens that thread's live expansion.
### Requirement: Honest thinking display [need]
Task SHALL show brief structured summaries of what is being considered/done. The full view SHALL expose structured decision/rationale summaries plus observable status, tool calls, child events, evidence, timings, retries, and results. The TUI SHALL NOT label all waiting as "thinking" and SHALL NOT claim access to hidden model chain-of-thought.
#### Scenario: Waiting vs thinking
- **WHEN** a model call waits on provider latency
- **THEN** the display shows waiting-on-provider, not "thinking"; structured reasoning summaries appear only for actual reasoning steps.
### Requirement: Degradation ledger [need]
Every degradation SHALL write a durable log entry, appear in the TUI, and become a deferred corrective task when safe. A routine health ledger SHALL keep unresolved faults visible. Failures that break evidence, restore protection, authority, or safe action SHALL block immediately.
#### Scenario: Deferred degradation
- **WHEN** a non-critical subsystem degrades mid-run
- **THEN** the ledger records it, the TUI indicator shows it, a corrective task queues, and a Sleight-of-Hand-critical failure would instead block the action immediately.
### Requirement: One details view [need]
A single inspectable details view SHALL expose full token accounting (estimated vs actual), memory sources, model attempts, timings, tool receipts, child activity, and evidence for a selected response or task. Normal dialogue SHALL stay uncluttered.
#### Scenario: Detail inspection
- **WHEN** you open details on a completed response
- **THEN** one view shows its full accounting: blocks sent, sources, attempts, latency, tokens, cost, and evidence links.
### Requirement: Purpose grouping and visible failures [need]
Related actions SHALL group by purpose (for example, "Inspecting providers"), not merely by tool or time. Critical failures SHALL remain visible outside collapsed groups.
#### Scenario: Collapsed failed group
- **WHEN** a grouped activity containing a failure is collapsed
- **THEN** the failure remains visible on the group summary with its unresolved state.
### Requirement: Completion receipts [need]
Every finished work item SHALL report: what changed and why; proof and unverified parts; files/restore point/commit/Gitea history; elapsed time/model/provider/tokens/money; remaining work, failures, open questions, and next action. Claims SHALL carry owner-issued IDs/digests with separated nullable dimensions — source, derivation, confidence, retrieval score, validity, authorization, audit status.
#### Scenario: Completed task summary
- **WHEN** a task finishes
- **THEN** Chat receives the complete condensed receipt while the activity record links every underlying detail.
#### Scenario: Missing trace
- **WHEN** a claim's trace is missing
- **THEN** it renders UNKNOWN, never success.
#### Scenario: Provenance is not truth
- **WHEN** a perfectly sourced false claim and an untraced true claim are both submitted
- **THEN** validity and authorization follow their own dimensions; provenance completeness proves nothing.
#### Scenario: Secret field denied
- **WHEN** a receipt field matches a protected secret pattern
- **THEN** the schema denies the field rather than storing or exporting it.
#### Scenario: Lossy exporter
- **WHEN** evidence is exported for external tooling
- **THEN** the export is a non-authoritative lossy copy; canonical records stay with their owning subsystem.
### Requirement: Durable searchable activity history [need]
Activity records SHALL persist by task and plan, remain searchable and exportable, and cool from the live rail without deletion after completion.
#### Scenario: Inspect old plan work
- **WHEN** you search for a completed plan weeks later
- **THEN** its event history, receipts, child work, costs, evidence, and export action remain available.
### Requirement: Optional limits [want]
No spending or compute limits SHALL exist by default. Optional per-job/daily limits and warning thresholds SHALL be configurable, with local-compute limits separately configurable.
#### Scenario: Configured daily limit
- **WHEN** you set a daily cost limit and work approaches it
- **THEN** a warning fires before crossing and asks before spending beyond it.
Slices are vertical (connector + behavior + visible surface + failure/recovery proof), ordered by the dependency map in `respec-capability-layout.md`. Every slice names its authority seams and its evidence gate. Nothing closes on rendering alone. Pre-interview task draft superseded by interview evidence.
## 0. Design and authority closure (prerequisite for implementation)
- [ ] 0.0 Close the open-question register before implementation. **Binds:** Task 0.0.1–0.0.8; your approval. **Evidence:** every OPEN/PARTLY-RESOLVED Q1–Q11 row becomes RESOLVED with an approved design artifact, or explicitly deferred out of this change without claiming its behavior.
- [ ] 0.0.1 Approve the typed event/API contract, face attach/detach boundary, and shared-memory write ordering. **Binds:** Q1.1/Q1.2/Q1.4, Sleight §13.4. **Evidence:** schema + ownership diagram + conflict/replay fixtures reviewed by you.
- [ ] 0.0.2 Approve the mode-to-model/tool/context/rule matrix and Plan document schema/triggers. **Binds:** Q3.1–Q3.3. **Evidence:** matrix + plan schema + contextual-offer fixtures.
- [ ] 0.0.3 Approve provider/settings schema, Hugging Face acquisition flow, device pairing/placement/routing, and configurable forge correlation. **Binds:** Q4.1–Q4.3. **Evidence:** settings schema + flow diagrams + your decision.
- [ ] 0.0.5 Approve the behavior/semantic map first (one semantic view/action model), then produce exactly three grounded visual directions covering compact-header/light-lane placement, pixel states, 3D interaction, live-theme editor scope, fallbacks, and reduced motion — all on the shared action-isomorphic base (R2-D7; U-001..U-030); you select one. **Binds:** Q10, D17. **Evidence:** semantic map approval record + three visible options + recorded selection; selection never precedes the map; decorative polish remains non-retirement-blocking.
- [ ] 0.0.6 Approve skill proposal/test/report UI and record the taxonomy protocol's EVIDENCE_DEFICIENT result; labels remain inactive under D02, while unrelated TUI work proceeds. **Binds:** Q11, D02, taxonomy-adversarial-2. **Evidence:** UI contract + recorded no-operational-router decision.
- [ ] 0.0.7 Normalize one requirement owner per behavior: lane behavior=dual-lane; rendering=visual; self-transformation=skills/growth; Python removal=migration. **Binds:** capability layout + Q1–Q11 ownership. **Evidence:** cross-reference map with no duplicate normative authority.
- [ ] 0.0.1a Resolve Q1.3 authority-map repair placement: which repairs precede all TUI work vs block only their affected capability. **Binds:** DEP01–DEP07 and Tasks 0.1–0.8. **Evidence:** prerequisite DAG approved by you; no global over-blocking or unsafe bypass.
- [ ] 0.0.1b Resolve Q2.2/Q2.3 interaction details: exact promotion-control placement/package preview and which in-flight operations accept edit override vs must reach a safe boundary. **Binds:** dual-lane promotion/steering requirements. **Evidence:** interaction contract + interruption-safety matrix approved by you.
- [ ] 0.0.8 Run the independent evidence audit again. **Binds:** all artifacts. **Evidence:** READY_FOR_NICK_REVIEW, zero BLOCKER/HIGH findings; accepted MEDIUM findings recorded.
## 0A. Truth first — authority and runtime audit
- [ ] 0.1 Reconcile checkout vs deployed generation: launcher target, differing modules, deployed identity; produce the authority map (who owns what, current vs intended vs dormant). **Binds:** src/go/rune-entry, deploy_promotion, audit_ledger. **Evidence:** written map + live attestation test that fails when runtime ≠ qualified artifact.
- [x] 0.2 Repair audit-ledger key lineage (deployed verifier vs live chain) with migration tests. **Binds:** src/rune/audit_ledger.py. **Evidence:** deployed verifier validates the live chain; crash/key-rotation tests pass. (2026-10-17: `tests/test_audit_ledger_key_lineage.py` red-first, green under both core pins — key-rotation fixture, deployed-shim-validates-live-chain (197 entries), crash-between-rotation incl. torn tail; `rotate_key()` records an old-key-signed `key_rotation` entry binding the new key fingerprint; unrotated chains delegate byte-identically; canary 74/74; contract `ADMIT-repair-audit-ledger-key-lineage`, main-session landing.)
- [ ] 0.3 Close curator bypasses: sleep-time raw writes + skill authoring route through curator/mutation guards. **Binds:** sleep_time.py:882-921, curator.py skill path. **Evidence:** negative integration tests prove no alternate writer reaches canonical state.
- [ ] 0.5 Freeze the typed-event vocabulary: reconcile Sleight-of-Hand §13.4 events with the adapter surface into one event schema. **Binds:** event_bus, ContextBroker, spine. **Evidence:** schema file + conformance fixtures; every lane/tool/checkpoint event carries one vocabulary.
- [ ] 0.6 Implement DEP05 authenticated one-use owner envelopes at the existing Construction Contract seam: protected display, canonical-byte/effect/dependency/evaluator/policy binding, nonce/expiry/revocation/replay state, crash recovery. **Binds:** construction_interface/decision/scaffold; no new approval authority. **Evidence:** impersonation, replay, stale envelope, dependency substitution, scope widening, crash-between-reserve/consume all fail.
- [ ] 0.7 Implement DEP06 one enforced effect-mediation registry and eligibility sieve across success/error/timeout/cancel/crash/duplicate/retry/compensation paths. **Binds:** tool_executor/operator/plugin/child/subprocess/store boundaries. **Evidence:** hidden/uninstrumented effect fixtures return UNKNOWN/ineligible; no missing telemetry is interpreted as no effect.
- [ ] 0.8 Make DEP07 Sleight G1–G8/MUST-01–MUST-18 a self-change qualification gate with truthful TUI receipts. **Binds:** ContextBroker, Spine, memory/task checkpoints, qualification runner. **Evidence:** full Sleight deterministic/semantic/chaos matrix and S01–S15 applicable rows pass against the exact staged generation.
- [ ] 0.9 Fix the five live defects before any consumer work; every later gate assumes them fixed. (a) Scheduler stale-card trust — filter placement eligibility by evidence age (I-R2-022 placement_probe: 86400s-stale healthy card currently outranks fresh slow). (b) Ollama-vs-floor tools-capability drift — reconcile provider-reported tool support against CAPABILITY_FLOOR.supports_tools. (c) Register/update/revoke hardening — manifest schema validation, digest, atomic index replacement, verified process-tree termination, migration/rollback (I-R2-023 lifecycle_threat_matrix: stale cap.old resolves after update). (d) Subprocess default-deny on credentials/paths/network (I-R2-024 process_probe: synthetic env secret and host file readable today). (e) Aware/naive datetime crash in the fire path. **Evidence:** each fix lands with its named regression fixture from I-R2-027; fixtures stay red against the unfixed code.
- [ ] 0.10 Build the language-verdict manifest + independent CI verdict gate with exact-token/negative-fixture enforcement and quarantine expiry (I-R2-011, GAP-GR-003; live N3: CI still installs uv into a python3 venv with no verdict gate). Shared machinery with seam-registry CI deletion tests and guardrail fixtures. **Evidence:** the five regrowth negative fixtures (generated file, renamed interpreter, build hook, fallback launcher, stale remote binary) all turn the gate RED; governed exception path with owner+expiry works.
- [ ] 0.11 Migration-oracle mutant suite + SSH/slowest-target replay (I-R2-008, I-R2-006): mutate key scope, receipt origin, recovery ordering, launcher target — harness must go RED on every mutant; SSH-profile replay of the fixed burst/resize/input traces plus slowest-supported-target run against the agreed SLO. **Evidence:** 4/4 mutants RED on the migration oracle (not the lab iso gate); Python paths verified dead after quarantine expiry; SLO run recorded on the slowest target.
## 0C. Unified build & test substrate — one test world (D26; owner directive: no two test worlds, test it as one)
- [ ] 0.12 Single schema source for every Go↔Rust boundary message; code-generation into both sides (Go + Rust); hand-written shared shapes rejected by gate. **Evidence:** schema change regenerates both sides atomically; a hand-edited generated file trips the gate RED.
- [ ] 0.13 Unified test runner: one command = Rust suite + Go suite + boundary round-trip corpus (recorded real messages, both directions) + language-verdict/regrowth fixtures + migration mutants. **Evidence:** deliberate single-language failure turns the runner RED (partial green impossible); corpus round-trips pass on both sides.
- [ ] 0.14 Paired builds + startup attestation: one build step stamps both sides with one build identity; the face attests the worker's id at startup, refuses on mismatch. **Evidence:** mismatched-pair fixture fails closed; no compiled artifact remains committable (gate RED on binary).
- [ ] 0.15 Landing rule wired: factory/scaffold landing gate requires the unified runner; landing records its output. **Evidence:** a landing without runner output is refused by the gate.
## 0D. Versioned releases + update offers (D27)
- [ ] 0.16 Semver injection: tui/version package + build_paired.sh tag/describe/dev fallback via ldflags; face displays injected version. **Evidence:** built binary's identity line shows tag version; dev builds show dev fallback; unit tests green.
- [ ] 0.17 TUI release workflow: tag push tui-v* -> Gitea release with vendored self-contained binary attached (GOPROXY=off proof); release body lists commit range. **Evidence:** first live tag produces a release (post-merge proof).
- [ ] 1.1 Continuous headless program: no sessions, face attach/detach, auto-start, auto-recover, exit checkpoint (active/incomplete tasks, plan revision, last files, pending decisions, replay cursor, evidence pointers). **Binds:** rune-entry, state_checkpoint, event_bus. **Evidence:** restart resumes in-flight task without duplicate irreversible effects; crash-replay fixtures pass.
- [ ] 1.2 Single-interface TUI + web-link live feed (R2-D6): the TUI stays the only native face; outside-the-TUI access is a live read-oriented web feed talking to the runtime; origin-tagged input ordering and committed/pending distinction cover feed + paired remote commands; native multi-face exists only if a real need appears. **Binds:** rune-runtime single-interface/web-feed requirements, transport seam, alert gateway. **Evidence:** feed renders live state read-only with evidence links; paired-command ordering run observed; no second native face spawns.
- [ ] 1.2a Bounded feed/stream adapter: queue depth, overflow, cancellation, retention semantics surfaced in the status strip; semantic events never dropped when decoration yields. **Binds:** work-observability status strip, bounded stream adapter. **Evidence:** overflow fixture shows truthful queue state, never a healthy facade.
- [ ] 1.3 Live-proven tool/provider paths: auth, streaming, failure, recovery for every exposed tool and provider; status reflects live proof only. **Binds:** provider_registry, tool_executor, tui_transport. **Evidence:** live-verification runs per tool/provider with failure/recovery receipts.
- [ ] 1.3a Model acquisition: Hugging Face discovery, task fit, hardware/storage/license explanation, consented download, integrity/provenance, configured-local reuse. **Binds:** model registry/settings/download store. **Evidence:** reject incompatible/license-unclear candidates; no download before consent; live selected-model proof.
- [ ] 2.2a Navigation/composers: numbered direct shortcuts + cycle + mouse; Enter-send/Shift+Enter-newline; natural language + searchable palette; fully rebindable keys with conflict/reset/accessibility checks. **Binds:** dual-lane-interface navigation/composer/palette/rebinding requirements + Q2.1. **Evidence:** keyboard-only traversal and conflict fixtures.
- [ ] 2.3 Activity rail + takeover: shared line beneath lanes, full-width inspectable box with X restore, grouped-by-purpose history, honest thinking display, critical failures outside collapsed groups. **Binds:** event stream, work_manager, tool receipts. **Evidence:** takeover/restore preserves lane state; waiting never mislabeled thinking; collapsed-failure fixture remains visible.
- [ ] 2.4 Child-work visibility: every child expandable to action/evidence/wait/block/history; no hidden delegation. **Binds:** sub-agent-orchestration, subagent surfaces, work_manager. **Evidence:** delegation run with full expansion trail.
- [ ] 2.6 Completion and durable history: what/why + proof + files/history + cost/time + remaining-work receipt; records persist/search/export by task/plan and cool from live rail without deletion. **Binds:** activity store, task/plan IDs, evidence refs. **Evidence:** completed-task receipt fixture; reopen/search/export old plan; raw details match condensed receipt.
- [ ] 2.8 Sub-agent orchestration (SA-D1/SA-D2): explicit-brief spawn → run → steer → complete/cancel lifecycle; agents as first-class rail children with live expansion; mid-run steer + safe-boundary cancel; per-action evidence-bearing receipts; authority inherited down the chain with hard asks intact; chained spawning with visible ancestry; nothing invisible. **Binds:** sub-agent-orchestration, work-observability rail, trust-and-sovereignty. **Evidence:** chained agent→agent→agent run fully visible with ancestry in one view; steer/cancel fixtures; hard-ask fixture at depth two; unreceipted agent write refused as unmediated.
- [ ] 2.9 Living task tree (SA-D4): task objects with status/sub-tasks/dependencies/blocked-by; owner reorder recorded and propagated to scheduling; assignment to Rune or agents bridging to sub-agent orchestration (agent tasks run in the agent's thread per thread-orchestration); full history/audit; renders in the Task lane per dual-lane-interface. **Binds:** task-management, dual-lane-interface, sub-agent-orchestration, thread-orchestration. **Evidence:** blocked-dependency and sub-task roll-up fixtures; reorder-mid-flight fixture; assign-to-agent + reassign-preserving-history fixtures; completed-tree audit attributable end to end.
- [ ] 2.10 Thread model + tree view (thread addendum): threads as the universal unit — origin, parent, inherited-context slice, status, result destination on every node; origin traceable node→root in one view; thread starting (explicit, originless threads impossible) and splitting (context carries to fork, both continue, divergence permanently marked, no silent sibling leakage); agent workspaces are threads in the same single tree; terminal-native thread tree view (type/status/age nodes, expand into rail takeover, linear text-path fallback). **Binds:** thread-orchestration, visual-system thread tree view, work-observability rail, sub-agent-orchestration. **Evidence:** split-then-diverge fixture with marked divergence and no leakage; origin trace from a depth-two agent thread to root; tree view + linear fallback action-conformance; human split and agent child coexist in one tree.
## 3. Safe operation — files and trust
- [ ] 3.1 Programmatic restore points: filesystem-event-triggered snapshots before every edit/delete/move, project-external coverage, identical for headless runs; rewind choice files-only vs files+conversation; stability-aware retention/dedup/pinning; no automatic disk-limit cleanup; block protected writes when snapshot cannot be written. **Binds:** filesystem watcher, snapshot store, storage policy. **Evidence:** overnight-delete fixture restored; turn/token/compaction events never gate capture; active/failed/pinned points survive; cleanup requires approval; full-disk edit fails closed.
- [ ] 3.2 Responsive changes-view + history separation: side-by-side wide/unified narrow/manual switch; explicit deletion/binary treatment; selective external-file overwrite preview; one-command revert; my history separated from your uncommitted work. **Binds:** VCS/change renderer/restore selector. **Evidence:** width matrix + binary/delete fixtures + external selected-file restore + dirty-tree protection + revert.
- [ ] 3.5 Memory-invariant regression (I-R2-017): keep the live ContextBroker invariant under regression tests — sole model-visible representation, sole memory contributor path, single selection API with fail-closed abstention and degradation fields; no future-memory API reserved; repository-contract expansion requires a named live consumer. **Binds:** memory-context-continuity Phase-0 requirement, future-seam-registry. **Evidence:** regression suite fails closed on a second model-visible path or selection-API bypass; consumerless repository-API proposals are deleted, not reserved.
- [ ] 4.1 Hard modes: Chat/Task/Plan enforce model/tools/context/rules; research activity styling in Task; sleep/night background. **Binds:** modes-and-plans, provider routing. **Evidence:** mode matrix test — tools genuinely unreachable per mode.
- [ ] 4.2 Full Plan process in Chat: contextual offer requires consent; initial plan → research protocol → viability → revised plan → targeted research → final viability → explicit start → staged execution in Task → independent review → final report. **Binds:** research pipeline machinery, plan document store, lane promotion. **Evidence:** full loop on a real feature request; Plan never interrupts active Task; durable/editable/recallable/piecewise rerun proven; return-to-plan path exercised on injected contradiction; final report observed.
- [ ] 4.3 Unattended workflows: four trigger classes, workflow contract, bounded retries, improvement proposals. **Binds:** scheduler, event subscriptions, workflow store. **Evidence:** headless run + failure-exhaustion pause with alert.
- [ ] 5.2a Reserve the four qualified deferred-speech seams exactly. **Binds:** inputs-and-integrations Voice deferred; speech-synthesis D7. **Evidence:** conformance tests prove (a) non-keyboard editable-text input with no global/OS injection, (b) playback play/stop/pause + rate/volume + state {idle,playing,paused,stopped} + auto-play off, (c) handle-derived recording states {idle,recording,confirming-transcript,playing,error} + stop in every non-idle + non-color/sound labels, (d) named disabled settings placeholders, and (e) no audio/mic dependency or permission in the build.
- [ ] 5.3 Functional visual system after Task 0.0.5 selection: bubbles, research styling + linked sources, selected compact-header/light-lane placement, built-in themes + live editor, honest state/expression, local/optional/paused animation, complete static/text fallback, idle health readouts. **Binds:** selected visual direction, terminal capability detection. **Evidence:** selection record + capability matrix + animation-off/reduced-motion legibility + zero inference on idle.
- [ ] 5.3a Deferred decorative polish: pixel-art asset production and capability-gated spinnable 3D implementation. **Binds:** selected direction and functional fallbacks. **Evidence:** does not block retirement; unsupported terminals retain complete behavior; no typing/stream/tool performance regression.
- [ ] 5.3b Terminal capability and budget gates (I-R2-006): pin Bubble Tea/Bubbles/Lip Gloss versions; probe per attachment and after resize/reattach; conservative default profile; p99 input/queue/memory/bytes-per-frame budgets; one aggregate single-loop budget with semantic-event priority; decoration yields under pressure; ANSI-aware and modifier-aware fixtures. **Binds:** visual-system terminal capability and budget gates requirement. **Evidence:** budget breach locks/downgrades rich rendering with the fixture named; typing stays responsive under progress flood; graphics-profile probe deferred until raster work begins.
- [ ] 5.5 Headless graph projection (I-R2-015, seam admitted with consumer fixture + deletion test): search/tree/table/text plus JSON/DOT/Mermaid/SVG exports; opaque read-only deep-link IDs with literal fallback; versioned router with stale-link error; pagination; typed degradation; layout explicitly non-semantic; mutations only through domain APIs. **Binds:** memory-context-continuity headless graph projection, future-seam-registry. **Evidence:** contradictory-temporal-fact resolution identical through text, table, export, stale deep link, and no-graphics mode; GUI canvas/JSON-Canvas remain later GUI projections of the same IDs.
- [x] 6.2 Self-transformation proposal-only pipeline with all 13 stages from synthesis (propose through rollback/close) and D01–D10 + RM01–RM15 + IAM01–IAM22 binding. **Binds:** existing curator/construction/stage-guard/deploy-promotion/rollback/ContextBroker authorities; no duplicate hierarchy. **Evidence:** proposal flow end-to-end; every DEP01–DEP07 prerequisite gates activation; no self-activation possible. (wave-K27-self-transform: src/rune/self_transform_pipeline.py + tests/test_self_transform_pipeline.py, 36 frozen tests; DEP05/06/07 exercised for real; stages 9–11 unreachable, SELF_ACTIVATION_IMPOSSIBLE even under a valid owner envelope.)
- [ ] 6.2a Run the synthesis cheapest-disproof matrix: alternate writers; runtime/dependency mismatch; ledger crash/corruption/replay/key rotation; owner-envelope spoof/replay/scope change; always-pass/skipped critics; hidden effects; shadow leakage; partial rollback/post-snapshot owner correction; forged/duplicated proven-use; cross-provider/reduced-context continuity; perfect evidence without authority. **Binds:** synthesis failure_matrix. **Evidence:** each negative fixture fails closed with a canonical receipt.
- [ ] 6.3 Taxonomy result: EVIDENCE_DEFICIENT; no operational router, no learned sentinel, no labels even for routing. **Binds:** taxonomy-adversarial-2 + D02. **Evidence:** no taxonomy code/path ships; strict explicit approval continues; unrelated TUI work is not blocked.
- [ ] 6.4 Extension lifecycle first consumer (I-R2-023; requires 0.9(c) hardening + publisher identity/digest verification first): exactly one command plus one status card through host-rendered declarative slots; approval UI and lane/identity/policy replacement forbidden; MCP discovery feeds inspection only with independent exact-scope approval and effect mediation; catalog/marketplace deferred. **Binds:** extension-lifecycle capability, inputs-and-integrations. **Evidence:** first-consumer fixture — load, update with extra scope (blocked pending re-consent), disable/uninstall with verified process-tree termination and no residual UI/code; every deny path offers fast owner resolution (R2-D9).
- [ ] 6.5 Future seam registry (I-R2-025; shares CI machinery with 0.10): record problem/owner/minimal schema/forbidden authority/consumer fixture/versioning rule/compatibility test/security boundary/evidence IDs/review date/deletion-expansion trigger for the relay boundary, offline draft log, graph deep links, memory invariant, extension lifecycle, and web-link feed seams; CI compatibility + deletion tests; reviews end in keep/change/delete only. The registry also carries the day-one socket set (SA-D6): agent orchestration, task management, thread orchestration, messaging/promotion, cognition-reserved (SA-D5), connectors — each registered with name + stable versioned contract + deletion test at its subsystem's first build, enforced by the sockets-first cross-cutting gate. **Binds:** future-seam-registry capability, migration-and-retirement Gitea chain. **Evidence:** deleting each seam breaks nothing claimed (or exposes disguised scope for owner decision); no automatic renewal exists; fast expansion path on a named live consumer works; no major subsystem ships without its registered socket.
- [ ] 7.2 Parity proof harness: side-by-side real-task runs with failure/restart/recovery per retiring capability; parity unit is the authority-preserving action/receipt trace (action IDs, key scopes, focus transitions, breakpoint outcomes, theme tokens, oracle traces), never widget parity; mutant-hardened per 0.11; native executable attested. **Binds:** test harness, live provider proof, migration-and-retirement. **Evidence:** recorded runs linked in the ledger; harness goes RED on every named mutant.
- [ ] 7.3 Python removal waves: obsolete module + dependency removal in the same change as its proven replacement. **Binds:** migration owner only. **Evidence:** removal commit + dependency diff + native parity/restart/failure proof remains green after deletion.
- Visual direction selection runs AFTER the behavior/semantic map is approved (R2-D7; Task 0.0.5).
- First outside connection is the draft/calendar-browser handoff (R2-D8; I-R2-019 — literal URL/account shown, immutable content digest, local timezone + UTC, never claims success, no credential in URL); connector work itself stays governed/deferred per the named-connector + jurisdiction gates (R2-D4; I-R2-018/I-R2-020). When a connector is named, the provider sandbox suite runs first.
- Collaboration beyond the proposal-inbox shape waits on a real malicious-guest attack test as its promotion gate (R2-D3; I-R2-002).
- Accessibility/screen-reader work is deferred (R2-D1): no parity claim, no AT retirement gate; the AT matrix (GAP-BT-01) is a future-if-prioritized research item.
- The no-dead-end amendment (R2-D9) binds every gate below: each deny path pairs with a fast owner-resolution/override path; no rule may permanently block legitimate work.
- The amendment round (SA-D1..SA-D6 + thread addendum): sub-agent orchestration (2.8), the living task tree (2.9), and the thread model + tree view (2.10) build in the visible-operation phase; agent/task-originated messaging adds no new semantics (SA-D3); the sockets-first rule gates every subsystem's first build.
## Cross-cutting gates (every slice)
- [ ] Frozen tests first (red → green), canary per surface per AGENTS.md. **Evidence:** failing-test reference precedes implementation; canary registration visible in CI.
- [ ] Cognitive invariants at memory/skill handoffs. **Evidence:** owner/trigger/authority/provenance/reversibility checklist + negative authority test per handoff.
- [ ] No simulated backend state anywhere in the TUI. **Evidence:** every rendered status carries canonical source/event ID; missing source renders unavailable/degraded, never success.
- [ ] Sockets-first (SA-D6): every major subsystem — agent orchestration, task management, thread orchestration, messaging/promotion, cognitive architecture (reserved, design deferred per SA-D5), connectors — ships its registered socket (name + versioned stable contract + deletion test) at first build under the no-consumer-no-seam rule; no subsystem ships contract-less. **Evidence:** registry row + passing deletion test exists at each subsystem's first-build gate; cognition socket reserved with a design-deferred record and zero architecture work.
- [ ] Your review gate before apply. **Evidence:** approved OpenSpec revision + independent review READY_FOR_NICK_REVIEW.
Loaded 100 of 6138 files, more files were not shown because too many files have changed in this diff.
Show more
Reference in new issue
Block a user
Blocking a user prevents them from interacting with repositories, such as opening or commenting on pull requests or issues. Learn more about blocking a user.