/weave

At convergence, fan out deep cross-session mining, then prove each finding turned into a real change — or kill it.

/weave is an orchestrator skill. The orchestrator wields it and relays the mining sub-tasks to workers; workers do not self-invoke it. It operates across sessions and repos at the moment the fleet goes quiet, catching the cross-cutting issues no single worker ever sees — recurring frustrations, skill gaps, anti-patterns, what-worked-vs-what-hurt — and routes each into a ledger that makes waste visible.

The defining feature is not the fan-out. It is the action-ledger that makes token-waste impossible to hide. Anyone can fan out N agents and produce nice docs; the ledger is what forces every finding to a disposition and reports conversion-to-change.

⚠️ This skill, and batch-session-miners before it, were lost once because they lived as untracked WIP in gitignored docs.local/. A weave run's harness, ledger, and retro are committed artifacts. Never leave them untracked. That discipline is the whole reason this skill exists as a skill.

Triggers — arm vs fire

1. Convergence gate (why it can't fire mid-flight)

A multi-way deep-mining fan-out next to the live Opus fleet = OOM + token contention. The weave fires ONLY at convergence. All four must be true:

1. 0 open PRs across golems + brainlayer + voicelayer.
2. All worker panes idle.
3. No in-flight Codex.
4. Etan has SEEN + APPROVED the demo.

Plus a RAM gate (same lesson as content-demo's ram-gate.sh — quiesce first).

bash scripts/convergence-gate.sh            # checks 1–3 + RAM; #4 needs operator ack
bash scripts/convergence-gate.sh --ack-demo # operator asserts demo approval → can PASS

Condition #4 is not script-checkable — the gate stays BLOCKED until the operator passes --ack-demo (or WEAVE_DEMO_ACK=1). Human/orchestrator in the loop; never auto-fire. "weave now" is the only path that skips the gate.

2. The engine — session-mining fan-out

The weave mines the recent Claude + Codex session JSONLs (~/.claude/projects/**

• ~/.codex/sessions/**). "Web" = weaving a web across sessions, NOT web-search. For Claude sessions it leans on the /skill-creator mining engine (the deterministic parser session-miner.py — Claude-only — + the session-miner sub-agent). Codex sessions have a different log shape and are NOT parsed by session-miner.py; this skill's own prepare-mine-context.py handles both formats (digest-if-present + keyword-grep excerpts), so a miner reads a uniform context file regardless of source. The whole thing is wrapped by this skill's reproducible harness:

# WD = the SCRATCH run dir. digests/ + findings/ + mine-context/ are BULKY and
# fully REGENERABLE (re-run discover/prepare), so they may live in gitignored
# docs.local/. They are NOT the durable artifact — do not rely on them surviving.
WD=~/Gits/orchestrator/docs.local/weave-$(date +%F)
 
python3 scripts/weave-run.py discover --hours 24 --workdir "$WD"   # → corpus-manifest.json (centerpieces ★ first)
python3 scripts/weave-run.py prepare  --workdir "$WD"              # → digests/ + mine-context/ (compact per-session)
python3 scripts/weave-run.py batches  --workdir "$WD" --size 5     # → batch-manifest.json (one miner per session)
#   ... dispatch one miner agent per session per batch (see §3) ...
python3 scripts/weave-run.py aggregate --workdir "$WD" --tokens <N> # → ACTION-LEDGER.md + ledger.json + conversion-to-change
#   ... synthesize the forward-plan from the ledger ...
#   ... THEN the MANDATORY red-team fact-check closing stage (§4b) before anything is trusted ...

⚠️ The durable artifact is NOT the scratch WD. The bulky digests/findings are regenerable; what must be committed (so it can't be lost like the original weave) is the conclusions: the conversion-to-change metrics + the high-importance routed findings + the retro. Commit those into the private records repo at ~/Gits/orchestrator/weave-records/retros/<date>.md (and brain_store them). Never leave the conclusions only in docs.local/. retros + registry contain operator comms — they live in the private records repo.

• Centerpieces first. The orchestrator's own session JSONLs hold the night's decisions/corrections/failures. discover tags them ★ and orders them first; mine them deepest (references/topology.md).
• One miner = one session (not five shards of one). Parallelism = N sessions at once, batches of ~5. Loop-until-dry, cap ~9 rounds — stop when a round surfaces nothing new (don't burn the cap).
• Miners read the compact mine-context/<label>.md (digest + grep excerpts), then grep the raw JSONL only to quote verbatim. They never read a whole MB-scale JSONL into context.

Mine-context line cites — jsonl_line=N NOT digest §N

prepare-mine-context.py emits jsonl_line=N for grep excerpts — these are raw JSONL line numbers (1-based enumerate over the file). Session-miner digest §N / event indices are NOT jsonl lines — misciting them produces false evidence (singles#2). Miners grep the raw JSONL by jsonl_line= only.

Dispatch brief validation (before send)

Run scripts/validate-dispatch-brief.py on every rendered §EDITS worker brief before dispatch. It checks required sections (Scope, Sources, Mechanics) and that the findings JSON schema fence is intact — one brief shipped truncated (singles#3).

Briefs that point workers at skill files MUST use the real path: skills live at ~/Gits/golems/skills/golem-powers/ (registered via ~/.claude/skills/ symlinks); ~/Gits/golem-powers does not exist — a brief pointing there strands the worker.

§EDITS worker evidence greps — scope to cited files/ranges

Worker prompts MUST scope evidence verification to the files and line-ranges the ledger already cites — never directory-wide rg over ~/.claude/projects or the whole weave run dir. Unscoped greps burned one worker to compaction before edits started (09-59-00#6).

Delta wave — sessions keep writing while the weave runs (Etan, 2026-06-09: "make sure there is an extra weave of sessions currently in sesssion, so we dont loose whats in progress")

The corpus freezes at discover; live sessions keep appending during mining. Standing step:

1. At pass-1 launch, snapshot per-session line counts → <WD>/delta-baseline.json.
2. At convergence (fleet quiet / operator close), snapshot the grown files (stable copies); any session grown >20 lines → a tail miner scoped [baseline−200 .. end] (overlap dedups at aggregate); any session born mid-run → full miner. Suffix outputs __delta.jsonl, same schema/rubric.
3. Re-aggregate after the delta wave so the ledger covers the whole run window. (Gen-15 proof: the delta caught orc's PR-sweep/close era — 83 findings pass-1 would have lost.)

Miner-prompt hygiene — counter/footer leak guard

Agents inheriting global CLAUDE.md rules append CLAUDE_COUNTER: N to returns and occasionally into findings files. Keep the "reply exactly: WEAVE_MINE_DONE …" contract AND scrub findings files before aggregation (drop non-JSON lines) — weave-ledger.py counts them malformed otherwise (one leaked line scrubbed in gen-15).

Harvest sweep + placement pass — research artifacts (standing, Etan 2026-06-10)

Before synthesis: sweep ~/Desktop + ~/Downloads (Claude-side: compass_artifact_<UID>*, hand-pasted .rtf/.rtfd) + the Drive route (Gemini-side) for research artifacts in the run window; save text exports to <WD>/reports/, brain_store conclusions. At close: the placement pass — every research gets its own folder with its owning context (large-plan/design-doc/sprint), moves are deliberate (verify destination first), Desktop originals surfaced to Etan before removal. See claude-desktop-research's OUTPUT-PLACEMENT CONTRACT.

Context-file hygiene — standing weave step (Etan via orc, 2026-06-09: "Whenever we do the weave, this might be something we send to the skillCreator who does the weave")

Every weave checks whether context files need surgical improvement and routes it: audit the CLAUDE.md/AGENTS.md hierarchy against the 3-layer model (Letter ≤~50 lines intent prose / path-scoped .claude/rules/ / BrainLayer episodic), flag accumulation-bloat violations, and promote recurring registry families (recurring=true, BROKEN-OPEN) into .claude/rules/ files at §4c — Theo's "only encode repeated mistakes," mechanized. Findings route through the ledger like everything else.

Corpus discovery — deliberate self-exclusion + orcui attribution

• discover --exclude-self <stem> records the exclusion in corpus-manifest.json → deliberate_exclusions[] with reason (not silent skip).
• orcui-LEAD sessions may write into the orchestrator projects dir — attribute sessions by prompt identity / session stem, not repo path alone.
• Gemini-side artifacts (Etan-fired in UI) are a future corpus modality — note in manifest when excluded from JSONL discovery.

3. The miner contract (per session)

Each miner emits a findings JSONL — one object per line — at <WD>/findings/<label>.jsonl:

{"id":"<label>#N","title":"...","detail":"...","evidence":"verbatim — source ref [line N]","type":"correction|frustration|anti-pattern|skill-gap|skill-candidate|decision|residual-bug|what-worked","track":"cmuxLayer|BrainLayer|VoiceLayer|MCL|MCP-layer|skill-creator|dashboard|plans|collab|cross-cutting","disposition":"MERGED-PR|PR-FILED|PR-FIX|SKILL-NEW|SKILL-EDIT|DEEP-RESEARCH|FOLLOW-UP|REJECTED|PARKED|KEEP|DUPLICATE","importance":1-10,"recurring":true|false}

Disposition → conversion class (what weave-ledger.py enforces): converged = MERGED-PR/PR-FILED/PR-FIX/SKILL-NEW/SKILL-EDIT; open = DEEP-RESEARCH/FOLLOW-UP; dropped (reason REQUIRED) = REJECTED/PARKED/DUPLICATE; confirmation (excluded from the refined denominator) = KEEP. (PR-FILED = PR opened but not yet merged; FOLLOW-UP-FILED is accepted as an alias of FOLLOW-UP.)

Rules (inherit /never-fabricate + the session-miner discipline): verbatim evidence with a [line N] or digest §N cite; no brain_store (files only); dedup; suppress loop/cron noise; an empty session → an empty findings file, never an invented one.

Dispatch (the bridge between batches and aggregate): spawn ONE miner per session per batch (≤5 concurrent), centerpieces first. Two equivalent mechanisms:

• Workflow (preferred for staged mode): a pipeline/parallel of agent() calls, each given the miner prompt below + a findings JSON schema; the workflow writes each result to <WD>/findings/<label>.jsonl.
• session-miner sub-agent / Task calls from a skillCreator session (the sub-agent is skill-creator-scoped): dispatch N Agent(subagent_type="session-miner", …) in one message.

Miner prompt skeleton:

Mine ONE session for the weave. Read your context file <WD>/mine-context/<label>.md
(digest + grep excerpts). For verbatim quotes, grep the raw JSONL by **jsonl_line=N**
from the Grep excerpts section — never read the whole file. Digest §N is NOT a jsonl
line. Emit findings (the JSON schema above), one per line, to
<WD>/findings/<label>.jsonl. Files only — no brain_store. Empty session → empty file.
Return: WEAVE_MINE_DONE <label> <count>.

VERIFY ON DISK — do not trust the agent's word (the weave's own thesis, applied to itself). A miner may report success in its return value yet never have written the file (observed live: a forced structured-output return competed with the Write step, so ~70% of a 102-agent run self-reported wrote_file:true with no file on disk). The findings FILE is authoritative, not the agent's claim. After every batch run weave-run.py status --workdir "$WD" (it checks the actual files), and re-mine any session with no file — with the file-Write as the terminal deliverable and NO competing return schema. Loop batches until dry. (If you mine via a Workflow with schema:, the agent often stops at the schema call and skips the Write — prefer "Write the file, then reply WEAVE_MINE_DONE <label> <count>" with no schema, and verify on disk.)

4. The action-ledger + conversion-to-change

scripts/weave-ledger.py aggregates all findings into ACTION-LEDGER.md + ledger.json and computes the metric that decides if the weave was worth it. Two denominators are reported — both, always:

• conversion-to-change (spec §4, the headline) = converged ÷ TOTAL findings. This is the anti-waste number from the original spec ("0% conversion is token-waste, full stop") — it keeps KEEP confirmations in the denominator so the ratio can't be flattered by reclassifying findings as "not actionable."
• conversion-to-change (refined) = converged ÷ ACTIONABLE, where actionable = converged + open (DEEP-RESEARCH,FOLLOW-UP) + dropped (REJECTED,PARKED, DUPLICATE); KEEP is excluded because you can't "convert" a validated what-worked. The refined number is informative, but the strict ÷-total number is the one that governs the SHIP/RETIRE decision (see EVAL.md). (converged = MERGED-PR+PR-FILED+PR-FIX+SKILL-NEW+SKILL-EDIT.)
• token cost per acted-on finding = weave tokens ÷ converged (--tokens N).
• Routing is mandatory. --strict exits non-zero if any finding has an unknown disposition or is DROPPED without a reason. Route EVERY finding.

A weave with 0% conversion is token-burn — the ledger surfaces that instead of letting "we produced N nice docs" pass for progress.

4b. Red-team fact-check — MANDATORY closing stage (anti-hallucination guard)

After synthesis, before ANY finding is trusted or acted on, a red-team workflow verifies every load-bearing fact in the ledger + synthesis against the raw JSONLs. This is non-negotiable — it is the anti-hallucination guard for the L0 memory problem: a wrong fact that reaches the plan or brain_store poisons every downstream decision. (Proven valuable: the 2026-05-29 weave's red-team caught a wrong WhatsApp number for Etan plus several other wrong facts that would otherwise have been acted on.)

Anchor on the highest-trust ground truth — what the OPERATOR said and did:

1. "What Etan SAID" — every verbatim Etan quote / correction in the window. Re-grep the cited JSONL line; confirm the quote is verbatim (not paraphrased) and the number / name / path / PR# is exactly right. Cite raw type:user turns only. Do not cite relays, queue-operation, last-prompt, task-notification, worker summaries, or assistant brain_store paraphrases as Etan evidence. If the quote appears in both a relay and a raw user turn, cite the raw user turn. If no raw user turn exists, mark the claim as relay-only and do not treat it as verified operator speech.
2. "What Etan FIXED" — his decisions/corrections this window. Confirm the finding's claim about what was decided matches what the JSONL actually shows.
3. Then sweep the high-importance (≥8) findings: every cited [line N] must resolve to the quoted text; every attribution (who did what, which repo, which PR) must hold.

Mechanism (a fan-out workflow): one verifier per batch of claims, each re-greps the raw JSONL and returns {claim, verbatim_match, correct_attribution, corrected_value, verdict}. Any claim that fails is corrected in place or dropped with a reason in the ledger before the plan/retro/brain_store are trusted. Default to skeptical: if a fact can't be confirmed against the JSONL, treat it as unverified and flag it. (Same discipline as /never-fabricate + the session-miner GAP-REPORT.)

A weave's findings are only as trustworthy as this stage makes them. No weave output is "done" until the red-team fact-check has run and its corrections are folded back into the ledger.

Correction-propagation sweep — runs after CORRECTIONS compiles (Fix-10)

A strike that doesn't reach ALL copies is laundering with a delay: the 2026-06-07 run struck its confessed-invented "47 sessions staged" at the origin, a verbatim copy survived in the retirement dump, and the successor generation's boot read the laundered count (specimen S31 / B1-F7). The 2026-05-29 prototype red-team did this sweep by hand once (the APPLY-everywhere table) and it was never encoded — this encodes it.

As soon as the run's CORRECTIONS doc is compiled, run the sweep:

python3 skills/golem-powers/weave/scripts/correction-sweep.py \
  <run-dir>/CORRECTIONS.md <orchestrator-root> [<other-root>...]

For every §1 strike row it extracts the struck literal strings, greps them exactly across the target trees — weave doc, S-docs, collab, findings, boot prompts, plans, dashboards — and emits a patched/not-patched table (file [line] | struck-string | ANNOTATED-or-RAW), exiting non-zero while any un-annotated copy survives. It is REPORT-only: it never edits. Strikes stay human-applied — strikethrough + pointer, never a silent edit.

Gate: RAW (not-patched) rows reach ZERO — or each carries an explicit defer note in the weave doc — before §4c closes. A surviving raw copy is exactly the carrier the next generation boots on.

Scope limit, stated honestly (B-adversary Fix-10 ruling): the sweep catches LITERAL-COPY laundering only. Derived-number laundering ("~14 merges" → 22 → 42, or a struck count re-worded into a new sentence) escapes exact-literal grep by construction; the sweep surfaces such rows as NO-LITERAL for manual review but cannot clear them. The derived half is closed by the canonical-source rule: every load-bearing number cites its source artifact (ledger.json, a gh command, a pinned grep method) — a figure with no source cite is challengeable on sight even when no grep can find it.

4c. §EDITS APPLICATION — MANDATORY final phase (capture ≠ convergence)

A weave that only captures is a diary, not convergence.

After the red-team pass, the run is NOT complete until every SKILL-EDIT or SKILL-NEW item in the weave doc's skill-candidates/edits section (the §3-style "SKILL CANDIDATES / EDITS" list) is in exactly one of three discharge states:

No fourth state. "Captured for later" is the failure mode this phase exists to kill: the gen-10 weave captured 9 behavioral fixes that were never applied — gen-11 then re-violated them and Etan received the SAME lead-topology correction again (2026-06-05). The weave doc + retro MUST include the discharge table (item → state → proof). Do not count TRACKED as APPLIED in conversion-to-change; the point is to prevent loss without pretending every suggestion became a code or skill change.

TRACKED satisfies §4c when the doctrine says to observe before editing. Etan's raw type:user doctrine, typo preserved: "we can use pheonix to track it or the ledger... suggestions are possible, not always taken as necessary" (orchestrator ce4072bf:[4960]). Use TRACKED for skill-behavior suggestions that need evidence across sessions or divergent agents; promote TRACKED -> APPLIED only when the evidence matures into a multi-instance or unambiguous failure.

The orchestrator running the weave owns this phase. If an item's owner is another LEAD, DISPATCHED requires the dispatch to have actually landed (collab ack or monitor loop armed) — not a parking-lot note (orc C7: dispatch now, not later).

4d. FULL-RELAY standard — the successor reads EVERYTHING

Etan (2026-06-05, verbatim): "Everything should be moved from the weaving from the previous session to the new session, not just the top things. Everything should be relayed so we get a very good next orc."

The successor orc's boot MUST require:

1. Reading the ENTIRE weave doc — not a curated highlights subset.
2. A brain_search tag sweep of ALL stored corrections from the closing session (orc-correction + frustration-capture stores), read in full.
3. Item-by-item ACK on (a) the §EDITS application table and (b) the corrections list — the successor states each item and its current state in its own words.

Boot docs may summarize for orientation, but the summary MUST link the full weave doc and MANDATE the full read + ACK. A boot doc that relays only "the top things" is a relay failure — the dropped tail is exactly where re-violations come from.

4e. Stale-at-write guards — facts go stale between audit and doc-write

Two self-defects across consecutive runs, same class: a number or state that was true when audited but false when written (5 of 17 claims stale-at-write in one re-score). Three rules, all enforced at the moment a doc is WRITTEN:

1. Re-poll every terminal-state claim at doc-write. Any "MERGED" / "OPEN" / "CI green" line in a ledger, retro, dashboard, or status board gets a fresh gh pr view at the moment the doc is written — not at audit time. Never relabel an earlier audit snapshot as "snapshot at doc-write".
2. Day-counts close with the UTC day. Publish a day-total (merges, PRs, sessions) only after the UTC day closes — or carry an explicit "as of HH:MMZ" label. A "22 merges" day-total snapshot-true at ~22:18 was 42 by actual close.
3. Status-board lines are OUTPUTS, not plans (specimen #0). Never write a checked box, a DONE line, or a result number before the step actually ran. The weave seat itself wrote "DONE 18:04 / 47 sessions" from the plan, not the output — struck in place. If the weave seat does this under no pressure at all, every status line needs the output in hand before the line exists.

5. What the weave EMITS (it's the front of a snowball, not a report)

/weave → next-gen large-plan → orchestrator runs parallel tracks → ship → re-weave. The ledger is the compounding instrument across loops.

Deliverable 2 is the highest-priority emit (Etan emphatic 3×), even though Deliverable 1 is the terminal artifact. If you can only land one, land the gate.

1. The next-gen large-plan (terminal artifact). A /large-plan covering up to 5 parallel tracks, each track populated by mined findings, not invented. Big initial collab = modularize/componentize first, then 4–5 LEAD orchestrators (one per track). The spec's named tracks:
   • cmuxLayer — fix deterministic pane placement (the recurring pain).
   • BrainLayer — engine/package split; BrainBar = its own package.
   • VoiceLayer.
   • MCL (Meta-Comms Layer) — its own secure repo, cmux-adjacent, all AI reviewers enforced; a deep-research candidate.
   • MCP-layer. Per the project-OS vision, each track's plan is owned by that domain LEAD; the orchestrator owns its own large-plan; everything coordinates through collab files (+ Google Drive + BrainLayer + MCL as a 4th channel), and the conductor is a clickable drill-down (track → that domain's large-plan).
2. The self-QA-before-handoff gate (HIGHEST priority). Formalize the rule that closes the verify-gap: ship = build → FUNCTIONAL self-QA against the fix-list → comparison artifact → THEN handoff. "Generated" ≠ "verified"; "merged" ≠ "converged into one verified build." Mechanical checks (PID running, commit-matches) are NOT a functional pass. Concretely: gate merges on Codex computer-use — actually click/screenshot/verify the UI (BrainBar / VoiceBar / dashboard) before merge. (Same family as /never-fabricate + the /qa-video method-attribution rule.)
   • Use CODEX for the CU pass, not Claude. Codex is strong at computer-use and has driven the BrainBar menu-bar app before; Claude CU is weak at it. So route visual/functional QA of menu-bar apps to Codex CU.
   • Known gotcha (not a hard block): a CU session can hit a "BrainBar (not installed) / 0 apps" grant dialog for the LSUIElement menu-bar app — that's a grant/focus state, not an impossibility. Fallbacks when it blocks direct CU: screencapture CLI + coordinate clicks, or an in-app PNG-export affordance (qa-video hotspot #13).

5b. Name-claim protocol — collab channels (standing rule)

Born: 2026-06-11 gen-16 night — 6 ephemeral worker identities in one night broke @-mentions and monitor targeting (voicebarClaude-builder/-pass2/ dashboard-audio-agent/dashboard-v2-regen/graphify-pilot/-rollout). Etan (verbatim): "Agents need to claim names in colabs and use them to monitor and communicate with eachother, so its not flappy."

Every channel the weave coordinates through (§5 item 1: collab files + Drive + BrainLayer + MCL) runs name-claims:

1. CLAIM-ON-ENTRY. A seat's first post in any collab channel begins with a grep-stable claim line: > CLAIM name=<name> role=<lead|worker|weaver|orc> monitor=<task-id|none> monitor=none is an explicit contract: "no delivery guarantee — nudge me."
2. STABILITY. The name is immutable for the channel's life; post headers are ### <claimed-name> (<ts>), byte-identical to the claim. Rename only via > CLAIM name=<new> supersedes=<old> (rare, loud).
3. WORKERS INHERIT. Workers are named <lead-claim>-w<N>, assigned at spawn by the lead, claimed by the lead on the worker's behalf. Never ad-hoc per-post identities.
4. ADDRESSING. @-mentions use claimed names ONLY; mentioning an unclaimed name is the mentioner's comms error. Channel monitors anchor on claimed names (@<name>|### <name>) — only safe because of 1–2.

Roster query: grep '^> CLAIM' <channel-file>.

5c. Monitor-on-arm law — the weaver/leads are NEVER idle-and-blind (Etan top priority)

Born: 2026-06-14 — a lead finished its lane, posted "Back to silent 👋" with no monitor armed; dashboard work routed to it via collab was a silent no-op. Etan: "leads and orchestrators should all have very, very good rules about monitors."

The weaver coordinates through collab channels (§5 item 1) — so it lives and dies by the same monitor law it enforces on every lead it seeds:

1. ARM AN INBOUND MONITOR AS FIRST ACTION. Persistent native Monitor on the channel (^### |BLOCKED|@<your-name>, exclude own posts) BEFORE any mining/dispatch. Post your > CLAIM … monitor=<task-id> only with the real task id from that monitor. This is what makes the monitor=<task-id> field in §5b TRUE instead of aspirational.
2. NEVER IDLE-AND-BLIND. Lane/weave done → either pick up monitor-surfaced work or post ✅ DONE … standing by, monitor ARMED and keep it running. A stopped/never-armed monitor on a "standing by" seat is THE failure.
3. VERIFY ENGAGEMENT WHEN YOU ROUTE. When the weave routes an action @some-lead (§4/§5 conversion-to-change), confirm the lead actually engaged (read_screen/get_agent_state shows it on the NEW task) — a route to a monitor-less lead is a dropped action, and dropped actions are exactly what the weave exists to prevent. Flag monitor-suspect leads in the action-ledger.
4. SEED IT DOWNSTREAM. Every lead-boot brief the weave emits (§5) MUST include "arm a persistent collab monitor as your FIRST action" as a gate, not a suggestion.

Canonical law + Monitor command pattern: /cmux-agents → "LEAD/ORCHESTRATOR MONITOR LAW"; orchestrator framing: /orc → "THE SECOND CARDINAL RULE".

6. The snowball — retros make the next weave better

After each run, write ~/Gits/orchestrator/weave-records/retros/<date>.md (private records repo): what we learned, what to improve next time (better miner prompts, better disposition routing, what got missed), what the red-team fact-check (§4b) caught and corrected (the wrong facts that would otherwise have shipped), the §4c application table (every edit item APPLIED or DISPATCHED with links), and a delta vs the prior weave. brain_store the conclusions. The next weave starts from the last retro — that's the compounding. (The reason this never snowballed before: the weave was never built or committed. Fixed here, permanently.)

6b. Future dimension — model-change-tracking (weave-owned)

A planned weave dimension (don't block the first run on it): whenever a new model drops, the weave should auto-surface skill-relevance actions. Research agents track what changed between the new model and the prior one (thinking/capability deltas, what it now does natively), and for each skill the weave proposes: still needed? · model now smart enough → RETIRE · or make it LEANER? · what changed in the model's reasoning that affects it? This ties straight into /skill-creator's capability-uplift vs encoded-preference classification: capability-uplift skills obsolesce as models improve; encoded-preference skills endure. Routing these proposals through the ledger turns each model bump into more conversion-to-change. (Fold into a future iteration / retro — not the first build.)

7. The RULE REGISTRY — stable IDs + lifecycle states (~/Gits/orchestrator/weave-records/registry/RULES.md)

Born 2026-06-07 (Phase-2 Fix-7; adversary verdict KEEP with the named-owner amendment). The problem it kills: "E-numbers are PER-RUN namespaces, not stable rule IDs… Rules without stable identity cannot accumulate enforcement history" (A1 header) — E09 meant three different things across three runs while prose carried it as the passivity identity at 4+ generations.

~/Gits/orchestrator/weave-records/registry/RULES.md (private records repo — retros + registry contain operator comms) is the durable, committed carrier for rule FAMILIES: one row per family with a stable R-### ID, born-event (date + cite), every encoding, every break event, current lifecycle state, and a revisit trigger. States: HELD / BROKEN-OPEN / ENCODED-UNTESTED / RETIRED / SUPERSEDED (/-UNRESOLVED) / LOST.

The contract (binding on every weave run):

1. The weave cites registry IDs, not per-run E-numbers. Per-run E-numbers stay what they are — discharge-table keys local to one run (§4c). Any finding, ledger row, or weave-doc claim about a known rule family carries its R-###. New families get a new appended row (IDs never reused). The alias map in ~/Gits/orchestrator/weave-records/registry/RULES.md resolves historical E-number usage.
2. Re-score writes state transitions. The §re-score stage (the prior-run audit) re-verifies every registry row touched by the window and records transitions in the row — dated, cited, append-style. Never delete history.
3. Recurrence reopens — mechanically. Any recurrence of a HELD / RETIRED / ENCODED-UNTESTED family flips it to BROKEN-OPEN with the break event appended. No judgment call, no "probably fine."
4. Two clean weaves retire. A family retires only on 2 consecutive clean weaves with its enforcement substrate live — the R-006 (E35 pane-churn / T08) precedent, the corpus's one formal evidence-based retirement.
5. Supersession requires a cited raw type:user turn. An operator reversal without a citable raw turn is SUPERSEDED-UNRESOLVED and MUST be surfaced to Etan (standing example: R-010 squash-ban, inverted in practice with no recorded ruling). Latest raw operator turn wins (the 05-29 prototype arbitration rule, A4 §c.3).

OWNER (the adversary's named-owner amendment): the weave seat owns the registry at each run close — a run whose window contains a break/encoding/ retirement of a registered family and doesn't write it has failed this section. Between weaves, the orc boot-gate ACKs the BROKEN-OPEN rows item-by-item (extends §4d's ACK) and surfaces SUPERSEDED-UNRESOLVED rows. "A registry nobody updates is carrier decay with better formatting" (B-ADV Fix-7).

Validate after any edit: bash registry/validate-registry.sh ~/Gits/orchestrator/weave-records/registry/RULES.md (asserts: zero per-run E-number row keys; E09 resolves to ONE stable ID; the R-006 retire path; valid states; the supersession contract).

Files

Wiring (Etan's "right places")

• Invoked by the orchestrator at sprint close (the /orc convergence step).
• The ledger output feeds the next sprint's backlog / the gen-N large-plan.
• The mining engine is /skill-creator (session-miner + session-miner.py); /weave is the orchestrator wrapper that arms it, gates it on convergence, and routes its findings through the action-ledger. (batch-session-miners was folded into /skill-creator — single source of truth for mining; /weave is the only batch-mining orchestrator skill.)

Integration with other skills

• /skill-creator — the mining engine (mine-session, session-miner sub-agent, the parser).
• /large-plan — the weave's top output is a large-plan; tracks come from findings.
• /never-fabricate — every finding cites verbatim evidence; no invented ledger rows.
• /pr-loop — converting a SKILL-EDIT/PR-FIX finding to MERGED-PR goes through it.
• /orc — convergence detection + dispatch of miners; surfaces the ledger to Etan.