git:20260901.ef2d814 to git:20260903.5d56b50

159 added, 274 removed. Audit A to A.

---

name: retrospective

- description: "Turn a finished run into a change to what you know: surprises, belief updates, preserved anomalies, named primitives, bounded architecture mutations. Writes the beliefs/patterns/anomalies/questions ledgers. Triggers: retrospective, reflect, what did we learn, patterns, synthesis, post-mortem."

+ description: "Audit whether prior learnings actually fired, then convert this run's recurrences into installed mechanisms. Refuses to emit a finding without an install path and a firing test. Triggers: retrospective, reflect, what did we learn, patterns, synthesis, post-mortem, why does this keep happening."

user-invocable: true

allowed-tools: Read, Write, Edit, Bash, Grep, Glob

kernel:

kind: state_transition

- version: 2

+ version: 3

side_effects: writes_repo

confirmation: on_side_effect

produces:

- - kernel.retrospective-result/v1

+ - kernel.retrospective-result/v2

---

- "What went well / badly / next time" extracts operational hygiene, not intelligence. The better

- question: **what did this work teach us that we did not know we were learning?**

+ This skill was redesigned 2026-09-03 because it was measurably not working.

- This is not a summary artifact, it is a memory-update process:

+ A follow-through audit of every retrospective, chronicle, plan and report in the Vaults counted

+ **24 promised fixes: 15 live, 9 dead or never built.** The worst mistake class, unverified claims

+ reaching a human, had been written up **11 separate times**, and both of its proposed fixes were

+ still unbuilt. Meanwhile `improvement-gate.sh`, the hook that enforced "every run improves the

+ system that does the work", was retired 2026-07-28 and nothing ever replaced it.

- `evidence -> surprises -> belief changes -> patterns -> unresolved anomalies -> reusable

- primitives -> new questions -> bounded architecture mutations`

+ The old version of this skill was not badly reasoned. Its nine lenses were sharp. It failed for

+ one structural reason: **every output was a ledger row, and a ledger row enforces nothing.** A

+ lesson written to a ledger that nothing reads at the moment of action is a gravestone with better

+ formatting.

- Each run CHANGES the accumulated model, rather than adding one more markdown gravestone. It does

- that by comparing against prior runs and writing four evolving ledgers, so a lesson learned twice

- is caught, a pattern with enough evidence is promoted, and a belief that no longer holds is retired.

+ So version 3 inverts what this skill is for.

- Anti-convergence rule, load-bearing: models are eager to explain everything. Sometimes the

- highest-value move is keeping a weird result alive, unexplained, until three future runs reveal

- what it means. Do not resolve an anomaly you cannot yet explain; preserve it.

+ | | v2 | v3 |

+ |---|---|---|

+ | primary question | what did we learn | did the last learnings actually fire |

+ | output | ledger rows | installed mechanisms, or an explicit accepted-no-mechanism row |

+ | when learning happens | here, at end of run | at error time, by `error-loop.py`; here only for what error time cannot see |

+ | a finding with no mechanism | acceptable | REFUSED, or recorded as explicitly accepted with a reason |

- Every phase below emits an artifact. A phase that produced only prose did not run.

+ **This skill is no longer the primary learning mechanism, and must not be treated as one.**

+ Error-time closing belongs to `_meta/services/error-loop.py`, which opens a defect the moment a

+ gate we own fails and refuses the next commit until a lesson or a waive is recorded. That catches

+ the single instance while the cause is still warm.

+ What error-time closing structurally CANNOT see is recurrence across runs: the same mistake in

+ different clothes, three independent reinventions of one missing primitive, a guard that has been

+ quietly dead for six weeks. That, and only that, is what this skill is for.

+ Proportionality is a hard rule, not a preference. Aria has named the failure out loud:

+ "overengineering the fuck out of this". A retrospective longer than the work it describes is a

+ defect. If phase 0 finds nothing dead and phase 2 finds no recurrence, the correct output is four

+ lines saying so.

</purpose>

<on_start>

- agentdb read-start # prior learnings seed the analysis

- agentdb query "SELECT id, type, insight, evidence, hit_count, load_count, ts, last_hit FROM learnings ORDER BY ts DESC"

- for L in beliefs patterns anomalies questions; do tail -40 "_meta/ledgers/$L.jsonl" 2>/dev/null; done

- ls -t _meta/reports/retrospective-*.json 2>/dev/null | head -3 # compare, do not re-derive

+ agentdb read-start

+ agentdb recall "<the run's concrete nouns: files, symbols, error text>"

+ for L in beliefs patterns anomalies questions; do tail -20 "_meta/ledgers/$L.jsonl" 2>/dev/null; done

+ python3 _meta/services/error-loop.py list # anything still open from error time?

+ ls -t _meta/reports/retrospective-*.json 2>/dev/null | head -3

</on_start>

-

-

- <phase id="1_evidence" name="Gather the run's real evidence">

- Reason from what happened, never from the tidy story of it. Pull `git log`, the diff, reverted

- commits and abandoned branches, commit messages, failed test runs, escalations, receipts and

- verdicts, and the AgentDB learnings from the query above.

- OUTPUT: a quotable evidence list. A claim that cannot be traced to a commit, a log line, a receipt

- or a recorded decision is marked `inference`, not `finding`.

- </phase>

-

-

+

- <phase id="2_intelligence" name="Extract what you did not know you were learning">

- Run the lens that BITES for this run, not all nine. Three are mandatory: surprise, belief-update,

- anomaly. Answer in one or two lines with evidence, and emit the named artifact. A lens with no

- artifact is narration: drop it from the report rather than padding it.

- <lens id="surprise" mandatory="true">

- What surprised me? What should have surprised me and did not? Where was my prediction most wrong?

- What looked hard but was easy, or easy but hard?

- OUTPUT: `intelligence.surprises[]` entries, each `prediction -> reality -> evidence`. A surprise

- that contradicts a stored belief also goes to the belief-update lens.

- </lens>

- <lens id="belief_update" mandatory="true">

- What do I believe less now? What got stronger? Which assumption survived only because nobody

- tested it? What would "me before this run" reject that I now think is true?

- OUTPUT: one `beliefs.jsonl` write per answer (`op: create|modify|weaken|retire`) with confidence

- and the contradicting or confirming evidence, plus `agentdb learn pattern "<belief>" "<evidence>"`

- when it should fire during future work rather than only at the next retrospective.

- </lens>

- <lens id="anomaly" mandatory="true">

- What result does not fit my explanation? What happened once that deserves investigation rather

- than dismissal? What did the system do that nobody designed? Where did two supposedly equivalent

- approaches diverge?

- OUTPUT: an `anomalies.jsonl` entry with `preserve_until_condition`. Never an explanation you had

- to reach for. See the anti-convergence rule.

- </lens>

- <lens id="hidden_knowledge">

- What do I now know how to do that I could not easily explain? What did I repeatedly notice before

- I had words for it? What knowledge lives only in commits, debugging and rejected attempts and

- would vanish if everyone forgot it tomorrow?

- OUTPUT: `agentdb learn gotcha|pattern "<what>" "<why>"`, so it fires at the moment of action.

- </lens>

- <lens id="counterfactual">

- Restarting with what I know now, what would I delete? What would I do 10x earlier? Which

- constraint was actually useful? What almost worked, and under what changed condition might it win?

- OUTPUT: a `questions.jsonl` entry with `candidate_experiment`, or an `anomalies.jsonl` entry when

- the near-miss is unexplained.

- </lens>

+ <phase id="0_followthrough" name="Did the last learnings fire?" mandatory="true">

- <lens id="abstraction">

- What general principle hides inside this specific problem, and where else does it appear? What did

- I build manually that is secretly a reusable primitive? What must be true for the lesson to

- generalize?

- OUTPUT: a named `patterns.jsonl` entry with `instances[]`, plus `intelligence.primitives_named[]`.

- Under-evidenced generalizations go to `questions.jsonl`, not `patterns.jsonl`.

- </lens>

+ A run that adds a new promise while an old one lies dead has made the problem worse, so this

+ phase runs first and cannot be skipped.

- <lens id="novelty_mining">

- What side discovery is more interesting than the thing we built? What problem did solving this

- expose underneath it? What capability now makes a previously impossible idea cheap?

- OUTPUT: a `questions.jsonl` entry naming the next experiment and what would make it worth running.

- </lens>

+ 1. Read the previous retrospective's `mechanisms[]` and the last 20 rows of each ledger.

+ 2. For each promised mechanism, resolve a verdict. **LIVE requires two facts: the file exists AND

+ something invokes it.** Prove the second with a grep, never by reading the file.

+ - wired into a `settings.json` hook chain, or

+ - a `jobctl` registry entry that `launchctl list` actually shows loaded, or

+ - a git hook, or

+ - a script another live script calls.

+ 3. Any mechanism whose file exists but which nothing invokes is **DEAD**, not live. Say so in

+ those words. A file nobody runs is indistinguishable from a file nobody wrote.

+ 4. Any mechanism that was retired: find its replacement and verify the replacement is LIVE. A

+ retirement with no live successor is a **REGRESSION** and outranks every new finding this run.

+ 5. Count: promised, LIVE, DEAD, NEVER BUILT. That ratio is the headline of the report.

- <lens id="negative_space">

- What never became a problem despite expecting it to? What received suspiciously little attention?

- What important thing is absent from our metrics? What would an outsider find bizarre here?

- OUTPUT: either a `questions.jsonl` entry or a phase-3 architecture proposal. Absence with no

- artifact is not a finding.

- </lens>

+ OUTPUT: `followthrough[]`, one row per prior mechanism with `{name, verdict, invoked_by, evidence}`,

+ plus the four counts. A phase 0 with no counts did not run.

- <lens id="trajectory" note="highest long-term value">

- Compare the last 5 runs, not this one. What keeps recurring? Which mistakes are one mistake in

- different clothes? Which discoveries keep reappearing independently? What am I repeatedly building

- around because the missing primitive has no name yet?

- OUTPUT: `intelligence.recurrences[]` plus a `patterns.jsonl` promotion when the same structure was

- invented independently 3+ times, which is the strongest promotion evidence a pattern can have.

- </lens>

+ STOP CONDITION: if anything is DEAD or a REGRESSION, fixing or formally retiring it takes priority

+ over every new lesson below. Report that and act on it first.

</phase>

-

+

- <phase id="3_architecture" name="What should change about how the system is built" domain="software|architecture|infra">

- For architecture, infra or agent-runtime work, ask questions that can MUTATE the system. Draw the

- ones that bite; each answer must reach a proposal or a `questions.jsonl` entry.

- - **Autonomy boundary.** What human intervention should have been deterministic? What decision was

- escalated that should have been local, or local that should have been gated? Where did autonomy

- add risk without speed, or a safety constraint add friction without protection?

- - **Information and state.** What did an agent need but lack at decision time? What was retrieved

- repeatedly and should be persistent context, or loaded repeatedly and almost never useful? What

- became the real source of truth despite the architecture naming another one?

- - **Verification and failure.** Where did an agent guess instead of verify? Where did verification

- cost more than the task? What failure was detectable earlier, or only by another agent? What did

- "done" actually mean, and could it have been mechanically checked?

- - **Coordination.** Where did two agents duplicate work, or parallelism reduce quality? What

- coordination happened conversationally that should be protocol? What protocol do agents route

- around, which is the signal the protocol is wrong?

- - **Intelligence vs structure** (the deepest lens). What rule belongs in code, what in prompting,

- what in evaluation? What behavior are we solving with ever-longer prompts? Where is intelligence

- compensating for missing structure, or structure for something models now handle? What model call

- could become retrieval, grep, cache or deterministic code?

- - **Memory.** What should expire and what should compound? What did one agent learn that the others

- needed? What propagates globally vs stays task-local?

- - **Proactivity and observability.** What could have run before anyone asked, on what trigger? What

- observability would have shortened this most? What can telemetry not currently explain?

- - **Complexity honesty.** Which component earned its complexity? Which exists for a problem we no

- longer have? If we deleted one layer tomorrow, which would we test first?

- <synthesis>

- Force the answers into AT MOST 3 proposals; fewer is better. Each: `evidence | root cause | change |

- would prove this wrong`.

- ANTI-OVERENGINEERING GATE, mandatory, applied before any proposal is recorded:

+ <phase id="1_evidence" name="Gather the run's real evidence">

- > Is this a recurring architectural signal, or one unusual instance? Find evidence across previous

- > runs (ledgers, prior retrospectives, git history) BEFORE recommending permanent infrastructure.

- > One occurrence is an anomaly to preserve, not an architecture to build.

+ Reason from artifacts, never from recollection. Pull `git log` and the diff, reverted commits and

+ abandoned branches, failed test runs, guard refusals, escalations, receipts and verdicts, and the

+ `error-loop.py` entries opened this run.

- A proposal with no cross-run evidence is demoted to a `questions.jsonl` entry with a

- "watch for recurrence" note. It does not become a build. This gate is the counterweight to the

- model's eagerness to generalize from one dramatic instance.

+ Guard refusals are the highest-signal item in that list and the most commonly discarded. A hook

+ that refused something recorded a mistake a machine could already see; that is a finished

+ experiment, free of charge.

- OUTPUT: `intelligence.architecture_proposals[]` and a `mutations[]` row per proposal with

- `artifact_type: architecture` and `status: proposed`. Closes the loop `run -> evidence -> anomaly ->

- root cause -> hypothesis -> cross-run evidence -> bounded mutation -> measure -> keep/revert`, with

- the reverting evidence named in advance.

- </synthesis>

+ OUTPUT: a quotable evidence list. Anything not traceable to a commit, a log line, a receipt or a

+ recorded decision is marked `inference`, never `finding`.

</phase>

-

+

- <phase id="4_ledgers" name="Update the four evolving ledgers">

- Four JSONL ledgers under `_meta/ledgers/`. Compare against them; never re-derive from zero.

- - **`beliefs.jsonl`** - `{id, belief, confidence: 0..1, evidence[], first_seen, last_updated, status: active|weakened|retired, supersedes}`.

- - **`patterns.jsonl`** - `{id, name, structure, instances[], confidence, status: watching|promoted|principle}`. 3+ independent instances is a promotion candidate (phase 5).

- - **`anomalies.jsonl`** - `{id, observation, context, why_unexplained, seen_in[], preserve_until_condition}`. Never deleted to tidy up; retired only when an explanation is earned, and the explanation is recorded.

- - **`questions.jsonl`** - `{id, question, why_interesting, got_more_interesting_when[], candidate_experiment}`. Where under-evidenced generalizations wait for their third data point.

- Then the cross-run comparison, explicitly:

- > What is genuinely NEW? What have we already learned before (recurrence, not discovery)? What

- > CONTRADICTS previous learning? Which pattern now has enough evidence to promote? Which old

- > principle should be WEAKENED or RETIRED?

- A contradicted belief is weakened or retired WITH the contradicting evidence, never silently

- overwritten. A lesson appearing for the Nth time is flagged as recurrence (a lesson learned twice

- was not learned) and escalates toward an enforceable artifact rather than another note.

+ <phase id="2_recurrence" name="What is this the Nth instance of?" mandatory="true">

- Periodically, not every run, ask the long-horizon question and record the answer as a belief:

+ Single instances were already handled at error time. This phase looks ACROSS runs, which is the

+ one thing no error-time hook can do.

- > What architecture is the accumulated evidence trying to turn us into?

+ 1. For each finding, search the ledgers, chronicles and agentdb for prior instances. Search the

+ CONCEPT from a second vocabulary, not just the words this run happened to use: the error code,

+ the table name, the route, the domain noun. A negative grep is evidence about your pattern, not

+ about the world.

+ 2. Count instances and list every date. **Two or more is a recurrence and demands a mechanism.**

+ 3. Ask the question that generalizes: are these one mistake in different clothes? Three

+ independent reinventions of one primitive that has no name yet?

+ 4. Then run at most TWO further lenses, whichever bite for this run. Skip the rest; a lens with no

+ artifact is narration.

+ - **surprise**: where was my prediction most wrong? `prediction -> reality -> evidence`.

+ - **belief-update**: what do I believe less now, and what contradicted it?

+ - **anomaly**: what does not fit my explanation? Preserve it with a

+ `preserve_until_condition`; do NOT resolve an anomaly you had to reach for an explanation

+ for. Anti-convergence is load-bearing: a weird result kept alive unexplained for three runs

+ is worth more than a tidy story now.

+ - **abstraction**: what did I build manually that is secretly a reusable primitive?

- OUTPUT: the ledger writes themselves, each mirrored as a `mutations[]` row in the record.

+ OUTPUT: `recurrences[]` with `{class, instances[], dates[], prior_promises[]}` and at most two

+ lens artifacts.

</phase>

-

+

- <phase id="5_hygiene" name="Housekeeping and artifact promotion">

- Demoted below intelligence, not removed. A promoted pattern that stays a sentence is honor-system;

- an artifact fires on its own.

+ <phase id="3_mechanism" name="Convert every recurrence into a machine" mandatory="true">

- 1. **Clusters, duplicates, contradictions** in AgentDB: group by theme, merge duplicates into the

- strongest form, resolve contradictions with evidence and archive the loser.

+ This phase is why the skill exists. Everything above is input to it.

- 2. **Stale archival, with the protected-set subtraction (do not skip).** Flag only rows whose last

- recall, or `ts` when never recalled, is older than 30 days:

- `COALESCE(last_hit, ts) < datetime('now', '-30 days')`. `last_hit` alone is NOT sufficient to

- delete: an injection rule fires a learning without stamping it, and `agentdb learn`'s dedup path

- bumps `hit_count` and leaves `last_hit` null. Before archiving ANY row, subtract rows referenced

- by a `learning_id` in the project's injection rules, and rows with `hit_count >= 5`. Measured

- 2026-08-27 in Vaults: the bare predicate named 22 rows, 11 protected, including the most-recalled

- row (`hit_count` 125). Archiving on the bare predicate is silent and irreversible. Reference:

- `_meta/services/agentdb-archive-guard.py`.

+ **A recurrence leaves this phase in exactly one of two states. There is no third.**

- 3. **Promote via the artifact ladder**, most enforceable form that fits, never defaulting to prose:

- - **Hook** for a safety property or mechanical check (I0.15). Put the check ON the path the work

- must take: a hook beside the path drifts, a hook on the chokepoint holds.

- - **Agent** for a recurring role with its own judgment.

- - **Skill** for a repeatable HOW.

- - **CLAUDE.md prose** last resort, only for context no mechanism can enforce.

- Scaffold means WRITE THE FILE this session. Promotion needs 2+ instances OR one quiet/expensive

- failure mode, and clears the same anti-overengineering gate as an architecture mutation.

+ 1. **INSTALLED**, with all four fields filled and verified:

+ - `failure_class`: what it refuses, stated as a class not an instance

+ - `install_path`: the real file, and what invokes it, proven by grep

+ - `refusal_condition`: exactly when it says no

+ - `firing_test`: the one-line command that makes it fire, RUN, with its output pasted

+ 2. **ACCEPTED**, explicitly: `{class, why_no_mechanism, who_accepted, revisit_when}`. An honest

+ accepted row is a good outcome. A silent omission is not.

- 4. **GitHub layer (non-local profiles only).** On `github`, `github-oss` and `github-production`,

- post the retrospective's verdict as a comment on the cycle's issue and the summary to the Agent

- Logs discussion, via `hooks/scripts/github-integration.sh`. AgentDB and the ledgers are the

- source of truth; GitHub is visibility. Never block on a GitHub API failure, and never auto-close

- an issue.

+ Rules that hold without exception:

- <ask_user>

- Use AskUserQuestion when promotable patterns or prune candidates exist.

- Ask: "Found {N} promotable patterns and {M} architecture proposals. Scaffold / propose which?"

- Prune candidates (dormant skills/agents) always require explicit approval.

- </ask_user>

- </phase>

+ 3. Prose is never a mechanism. Adding a sentence to a CLAUDE.md, a skill, or a reference file

+ does not count and must never be recorded as a fix. Every recurrence class in the audit that

+ was "fixed" in prose recurred.

+ 4. Prefer the machine that refuses at the moment of action over the one that reports afterwards.

+ A gate at Stop is a retrospective wearing a hook's clothes; that is precisely how

+ `improvement-gate.sh` died.

+ 5. Derive authority from something the caller does not control: a pinned precedent commit, a canon

+ document, the deployed artifact, a prior measurement. A gate that grades work against an

+ expectation the caller supplies can never fail.

+ 6. A new mechanism must COMPOSE with the existing ones, never short-circuit past them. Reaching

+ for `continue` in a function that accumulates a verdict is the tell. A new fault state may

+ displace the healthy state and nothing else.

+ 7. Before recommending any checker, RUN it on the current tree. A gate that breaks the build on

+ first run is worse than no gate.

+ 8. Break it on purpose in an isolated copy and confirm the checker catches it. An unfired guard is

+ a guess.

-

-

-

- <phase id="6_record" name="Emit the mutation record">

- Write `_meta/reports/retrospective-{date}.json` per schemas/kernel.retrospective-result.v1.schema.json:

- - identity: {created: ISO 8601, session, scope} - REQUIRED, no top-level `date`.

- - analyzed: learnings/clusters/merged/archived/contradictions_resolved counts.

- - mutations[]: every artifact touched AND every ledger write -

- {op: create|modify|remove|promote|weaken|retire, artifact_type: hook|agent|skill|prose|learning|belief|pattern|anomaly|question|architecture, path, reason, evidence, reinforced, status: applied|scaffolded|proposed|rejected}.

- - intelligence: {surprises[], belief_updates[], anomalies_preserved[], primitives_named[], recurrences[], architecture_proposals[]} - empty arrays allowed, missing keys are not.

- - project_fit: missing[] and dormant[] as arrays of STRINGS.

+ **Test discipline**, measured 2026-09-03: of about 40 test suites examined, 4 had any receipt of

+ ever catching a real defect, and roughly 36 were wired to nothing at all. So a test earns its keep

+ only when BOTH hold: something runs it without a human remembering to, and it names the specific

+ defect class it exists to catch, proven by failing against the broken state first. If you cannot

+ name the observed defect, do not write the test.

- ```bash

- "${CLAUDE_PLUGIN_ROOT:-.}/orchestration/manifest/kernel-manifest" validate _meta/reports/retrospective-{date}.json

- agentdb write-end '{"did":"retrospective","new_beliefs":N,"weakened":N,"anomalies_preserved":N,"patterns_promoted":N,"architecture_proposals":N,"mutation_record":"_meta/reports/retrospective-{date}.json"}'

- ```

+ OUTPUT: `mechanisms[]`, every row INSTALLED with a pasted firing test or ACCEPTED with a reason.

+ A row that is neither is a defect in this report.

</phase>

- <output_format>

- ## Retrospective, {date} - {what this run was}

- ### What is genuinely new

- {discoveries, vs what turned out to be recurrence of a known lesson}

- ### Surprises

- {prediction vs reality, with evidence}

- ### Belief updates

- {believe less / believe more / retired, each with its evidence and ledger id}

- ### Preserved without understanding

- {anomalies kept alive on purpose, and the condition under which to revisit}

- ### Reusable primitives named

- {what was built manually that is secretly a primitive, with the name given to it}

- ### Trajectory

- {what recurs across the last 5 runs; the mistake in different clothes; the unnamed primitive}

- ### Architecture proposals (<=3, or none)

- {each: evidence | root cause | change | benefit | new failure modes | reversibility | cost | confidence | disproving evidence - all past the anti-overengineering gate}

- ### Ledger writes

- - beliefs +{N} / weakened {N} / retired {N} · patterns +{N} / promoted {N}

- - anomalies +{N} preserved · questions +{N}

- ### Hygiene

- - Merged {N}, archived {N} (protected-set subtracted), contradictions resolved {N}

- - Artifacts promoted: {pattern} -> {hook|agent|skill} at {path}

- ### Mutation record

- - `_meta/reports/retrospective-{date}.json` (validated)

- </output_format>

+

+

+

+ <phase id="4_record" name="Record, proportionally">

- <seeds note="founding entries from the 2026-09-01 refusal-runtime session; the ledgers start here">

- beliefs:

- - "Autonomy comes from mechanical refusal on a chokepoint, not from better reasoning." conf 0.9 -

- 234 systems: every one that ran unattended had a scorer outside the agent's authority.

- - "A rule beside the path drifts; a rule on the path holds." conf 0.9 - two guards in a whole stack

- had ever refused anything; both sat on chokepoints. The gate beside the path denied 0 of 1,179.

- - "Knowing a failure class does not prevent committing it; only a check does." conf 0.85 - an author

- shipped three self-authorization defects hours after writing three documents against them.

- - "Frequency is not consent: never expand authority from a count of past behaviour." conf 0.9.

- - "Storage is not retrieval: a lesson recorded and not fired at the moment of action is a cost."

- conf 0.8 - an agentdb learning was relearned as new 81 days after it was written.

+ 1. `_meta/reports/retrospective-<date>.json` as `kernel.retrospective-result/v2`, carrying

+ `followthrough[]`, the four counts, `recurrences[]`, `mechanisms[]`, and the lens artifacts.

+ `mechanisms[]` is what the NEXT run's phase 0 audits, so name each one exactly as installed.

+ 2. Ledger writes only where the row will be read at a moment that matters. A belief nothing

+ consults is not worth a line.

+ 3. `agentdb learn` for anything that must fire during future work rather than at the next

+ retrospective. Concrete nouns; a lesson nobody can recall is not stored.

+ 4. Chronicle at the tier `_meta/services/chronicle-triage.sh` computes. Not the tier you feel.

+ 5. Hard cap: if the report is longer than the work it describes, cut it. Nothing dead in phase 0

+ and no recurrence in phase 2 means the whole output is four lines saying exactly that.

- patterns (watching -> promote on the 3rd independent instance):

- - "theatre has three kinds: by design (vacuous assertion), by wiring (real check never installed),

- by starvation (installed check, no data)." 3 instances (TBS, tooling, lane-ledger).

- - "the human-at-the-wheel corpus is an oracle: (situation, response, verdict) answers both what to

- do next and whether output is good." 1 strong instance; watch for reuse.

- - "seed the real defect into the instrument in an isolated copy before trusting it." recurring

- (test-capability.sh, instrument-breaker, instruction-surface-check).

+ OUTPUT: the report path, the four counts, and the count of mechanisms installed versus accepted.

+ </phase>

- anomalies (preserved, not explained):

- - "catcher ratio held near 1-in-3 mechanical across four independent defect censuses AND on the

- session author's own 8 mistakes. Why that ratio? Unknown. Preserve until a fifth census."

+ <failure_modes>

+ Each of these actually happened. They are not hypotheticals.

- questions:

- - "what architecture is the accumulated evidence trying to turn us into?" - revisit at 5+ runs.

- - "objective generation is unbuilt in all 234 systems and in ours. Genuinely hard, or just gated on

- a grader nobody had? Watch whether the corpus-grader makes it cheap."

- </seeds>

+ 1. **Ledger as gravestone.** A learning written where nothing reads it at the moment of action.

+ 24 promises, 9 dead. Fix: phase 3 or an explicit accepted row.

+ 2. **Prose as fix.** The rule gets a better sentence and recurs anyway. Every prose-only class in

+ the audit recurred.

+ 3. **Enforcement at Stop.** The session has moved on and the nag competes with wrapping up.

+ `improvement-gate.sh`, retired with no successor.

+ 4. **Retirement without replacement.** Three hooks retired 2026-07-28 on a real argument; nothing

+ took over their function. Phase 0 step 4 exists for this.

+ 5. **The guard nobody invokes.** The file is perfect and no chain calls it. Phase 0 step 2 demands

+ the grep for exactly this reason.

+ 6. **Hardening that breaks the thing.** A launcher hardened to a root-owned path that was never

+ installed left an "automated" pipeline unschedulable for nine days while its own status read

+ OK. Always prove the good case still runs after adding a gate.

+ 7. **The report longer than the work.** Buries the two facts that mattered and spends the reader's

+ attention, the scarcest resource here.

+ </failure_modes>

</skill>