T10: InnerLoop v1.2 — hardening does not converge, so optimize correction

The retrospective question was whether the mechanism set is complete or
each pass still finds a new class. This pass produced both an eighth
instance AND a fourth class, so the answer is the uncomfortable one.

Ledger: 10 instances, 4 classes, across 3 workplans. Every pass has
produced at least one class the previous pass had not seen.

  HDN harness-does-nothing      5   executable assertions
  TA  trusted arithmetic        3   re-derivation
  SSB same-sample blind spot    1   assertions over ALL the data
  DFD duplicated-fact drift     2   NEW -- reading a copy against source

DFD is genuinely distinct: no positive control catches it, because both
copies are internally consistent, and re-derivation does not either,
because the copy faithfully reproduces what it was copied from. Found
when an inlined price sheet went stale within an hour of T11 changing
the real one.

So v1.2 stops trying to enumerate classes in advance. Every error in
three passes was corrected in-session for under ~1% of the pass, so the
stated design goal is now cheap CORRECTION: keep raw data so numbers are
re-derivable, keep artifacts small and committed so a wrong number is
one grep from everywhere quoting it, give every number a command.

Plus the one rule the new class earns: single source of fact.

The original hypothesis is revised rather than confirmed. "A rule that
cannot be executed is not a rule" is wrong -- the two most valuable
corrections in the project came from a decorative rule that cannot be
automated (re-derive inherited numbers). An executable rule fires
reliably and catches one class; a decorative one fires unreliably and
can catch any class, including unnamed ones. Keep both.

Gates this pass: loop-lint caught 3 real violations on first run, then
failed on its own author within the hour when a T07 edit pushed
InnerLoop.md to 407 lines against its own 400 limit.

CB-WP-0003 complete: 11 of 11 tasks done.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

specs/InnerLoop.md

@@ -1,6 +1,13 @@
 # The Inner Loop — Assimilate and Surpass
 
-Status: **v1.1** — corrected from CB-WP-0002 (cost accounting) on
+Status: **v1.2** — corrected from CB-WP-0003 (loop hardening) on
+2026-07-31. Changes from v1.1: single source of fact; review targets the
+harness and states its sampling limit; correction vs retarget; the chaos
+roll's calibration window; the live cost budget. The design goal is now
+stated: **optimize for cheap correction, not for exhaustive prevention.**
+Rationale: `history/260731-loop-hardening-retrospective.md`.
+
+v1.1 — corrected from CB-WP-0002 (cost accounting) on
 2026-07-31. Changes from v1.0: the instrument must exist and emit its own
 target; inherited numbers are re-derived before use; every reporting tool
 exposes `--self-test`; cost is in the definition of done. Rationale:
@@ -14,7 +21,25 @@ evidence state what it does not support. Rationale and the failures behind
 each: `history/260731-inner-loop-retrospective.md`.
 
 Normative process for building every Clay-Borg capability. Referenced by
-all workplans. The loop's own optimization target is **agentic efficiency**:
+all workplans.
+
+**Design goal (v1.2).** Three passes produced ten error instances across
+four classes, and every pass produced a class the previous one had not
+seen — prevention is not converging. Every one of those errors was
+corrected inside the same session for under ~1% of the pass. The loop
+therefore optimizes for **cheap correction**: keep the raw data so numbers
+can be re-derived, keep artifacts small and committed so a wrong number is
+one grep from everywhere that quotes it, and give every reported number a
+command so re-running is free.
+
+> **Single source of fact.** A number, rate, or target lives in exactly
+> one place; everywhere else links to it. Where a copy is unavoidable it
+> is generated by a command, not typed. *(v1.2: a price sheet inlined into
+> a spec went stale within the hour of the real sheet changing, and one
+> acceptance figure had to be chased across three artifacts each time it
+> moved. No positive control catches this — both copies are internally
+> consistent — and re-derivation does not either, because the copy
+> reproduces whatever it was copied from.)* The loop's own optimization target is **agentic efficiency**:
 every artifact it produces must be small enough to load whole, structured
 enough to act on without interpretation, and falsifiable enough that an
 agent can judge its own work without a human in the iteration.