@thebassclef/lite 0.1.0 → 0.1.3

package/substrate/.claude/rules/bootstrap-pair-discipline.md

@@ -0,0 +1,141 @@
+---
+tier: lite
+description: Every substrate primitive ships with its paired bootstrap discipline.
+---
+
+# Bootstrap-Pair Discipline
+
+Every substrate primitive ships with its paired bootstrap discipline. A primitive without its pair is half-shipped — the substrate appears to ship the feature, but adopters hit the missing half as silent breakage at runtime.
+
+This rule names the failure class, enumerates 5 known instances, and gives the discipline a name so future PRs catch the failure at authoring time instead of at adopter-runtime time.
+
+## When this rule fires
+
+Any PR that adds a substrate primitive to bassclef. "Substrate primitive" means any of these surfaces:
+
+- **Hook** — a new file under `.claude/hooks/*.sh`
+- **Rule** — a new file under `.claude/rules/*.md`
+- **Skill** — a new directory under `.claude/skills/<name>/SKILL.md`
+- **Validator / accessor / library** — a new shell library under `lib/*.sh` or a new validator under `scripts/`
+- **Schema** — a new JSON Schema under `standards/state-spine/schemas/*.schema.json`
+- **Standard** — a new standard under `standards/*.md`
+- **ADR** — a new file under `architecture/decisions/ADR-*.md`
+
+The rule passes through (does not fire) on:
+
+- Operator content (chronicles, journals, deferred-actions)
+- Documentation edits without behavior change
+- Bug fixes that touch existing primitives without adding new ones
+- Test edits (covered by sister rules — `.claude/rules/testing-tier-config.md`, `test-list-discipline.md`)
+
+## The 7 known instances
+
+Each row names the primitive being added, the pair it owes, and the failure mode when the pair is missing.
+
+| Building block added | Bootstrap pair owed | Failure mode when missing |
+|---|---|---|
+| **Hook** under `.claude/hooks/*.sh` | The hook is wired in `.claude/settings.json` OR `presence/install/bassclef-sync.template.sh` for adopters | Hook exists on disk but stays silent (dead-letter) — surfaced 5 times during the 2026-04 substrate audit |
+| **Rule** citing a mechanical hook in `## Mechanical Enforcement` | The cited hook exists on disk AND is wired | Rule promises mechanical layer that stays silent; methodology only — surfaced 11 times in WU-5 of bet 2026-06-24c |
+| **Skill** declaring `modes:` / `tiers:` / `sizes:` in frontmatter | The `description:` field names each declared mode inline (per `.claude/rules/skill-description-clarity.md` description-mirrors-modes) | Type-ahead operator menu shows nothing distinguishing — surfaced 3 times in WU-6 of bet 2026-06-24c |
+| **Accessor library** named in a rule (`lib/state.sh`) | The file exists at the named path | Rule's `accessor-library-discipline.md` references a path that 404s — surfaced via #324 (closed via bet 2026-06-25a) |
+| **Schema** under `standards/state-spine/schemas/*.schema.json` | The write-time validation hook is wired (`state-validate.sh` PreToolUse) AND the entity has a storage-shape entry in `standards/state-spine.md` | Schema ships but the spine permits writes that violate it — surfaced via #319 (partial-close via bet 2026-06-25a WU-3) |
+| **Adopter-observable surface change** — new hook / skill / rule / agent / luminary / standard / ADR / schema / sync-template OR edit to an existing one matching `.claude/rules/cold-adopter-harness-discipline.md` § "When this rule fires" | The cold-adopter harness check class covering the new surface exists in `scripts/cold-adopter-harness-sync.sh` AND the CI job `cold-adopter-harness` in `.github/workflows/bassclef-pr-ci.yml` fires on the PR | Substrate ships a change that breaks adopter-observable surface; harness passes with stale coverage OR harness fails with no CI gate to catch it before merge — surfaced via 2026-06-25 /longrun prep audit (Gap 1 + Gap 2 + Gap 3 of 5; closed via bet 25g) |
+| **Release pipeline path change** (added bet 2026-06-29c WU-5) — any PR that adds a new top-level directory (e.g., new `lib/`, `templates/`, `presence/`) OR moves files between substrate directories (`scripts/`, `presence/`, `lib/`, `standards/`) OR adds a new operator-template at `presence/install/` | The release script's `ALLOWED_PATHS` in `scripts/release-to-bassclef.sh` covers the new top-level directory AND any new template at `presence/install/<name>.template.sh` is handled by the release step that ships templates (e.g., `public-bassclef-settings.template.json` copy step) | Release ships everything except the new directory; adopters get partial substrate; hooks reference files that aren't on the public tree — surfaced 4 release iterations in a row on 2026-06-29 (PRs #1372/#1373/#1374/#1375): PR #318 missed `scripts/`; later PRs missed `lib/` + `templates/`; settings template needed its own release-script step. Three sister cures: (a) extending the cold-adopter harness rule-mechanism-claim scanner to recognize `<name>.template.sh` as evidence the hook ships via install template; (b) refining the operator-private-path check filename pattern so it doesn't false-positive on bassclef's own `-review` rule names (out of scope tonight; tracked as follow-on); (c) auto-applying the `bassclef-internal-prose-ok` label on release PRs so the operator-private-path check passes first time (out of scope tonight; tracked as follow-on). |
+
+## What this rule requires
+
+When a PR adds a substrate primitive, the PR body MUST include a `Bootstrap pair shipped` block in the Summary section naming the pair:
+
+```markdown
+## Bootstrap pair shipped
+
+- Building block: `<path>` (e.g., `.claude/hooks/foo.sh`)
+- Pair: `<wiring location>` (e.g., `.claude/settings.json` PreToolUse Edit|Write|MultiEdit) OR `<rationale for no pair>`
+```
+
+If the primitive type is not in the 5-instance table, the author names the pair in plain English ("the pair this primitive owes is X because Y"). The reviewer's job is to verify the pair actually exists in the PR — not just that the author named it.
+
+## Anti-patterns
+
+These shapes fail this rule.
+
+**Ship hook without wiring** — the hook lives on disk but no settings.json registers it. The hook is dead-letter; the failure surfaces silently in adopter sessions.
+
+INSTEAD: ship the wiring in the same PR.
+
+**Cite an unwired hook in a rule's Mechanical Enforcement section** — the rule promises mechanical enforcement but the hook is not wired. The rule operates as methodology-only with no agent-side awareness of the gap.
+
+INSTEAD: either wire the hook in the same PR or rephrase the rule to claim methodology-only enforcement.
+
+**Declare skill modes in frontmatter without naming them inline in the description** — the harness type-ahead shows the skill name but no mode disambiguation; operator has to invoke and discover.
+
+INSTEAD: include each declared mode in the description's 280-character budget.
+
+**Name a file path in a rule that does not exist on the substrate** — adopters reading the rule follow the path and 404.
+
+INSTEAD: verify the path resolves on bassclef-upstream before the PR opens.
+
+**Ship a schema without wiring the write-time validator** — writes that violate the schema land in the spine and corrupt state silently.
+
+INSTEAD: wire `state-validate.sh` in `.claude/settings.json` in the same PR as the schema.
+
+## Override path
+
+`SKIP_BOOTSTRAP_PAIR=1 <command>` — for genuine cases where the pair lands in a separate PR by design AND the separate PR is filed AND the current PR's body cites the follow-on. Logged via trace-helper.
+
+INSTEAD of overriding for routine work: ship the pair in the same PR. The cost is small (one hook line, one settings.json entry, one rule citation) and the discipline compounds across every future primitive.
+
+## Why this rule exists
+
+Five instances of "ship A without paired B" surfaced during the 2026-04 to 2026-06 substrate audit period (WU-10 of bet 2026-06-24c). Each instance was diagnosed individually before the class was named. Diagnosing the class lets future PRs catch the failure at authoring time instead of accumulating as silent debt the next architect-review sweeps surface.
+
+Per `@luminary john-ousterhout` (deep modules): a substrate module is "deep" when its API matches its internal complexity. A bootstrap-paired ship matches the API surface (rule says X exists, hook does Y) with the internal commitment (X is on disk, Y is wired). Half-shipped primitives have shallow APIs that lie about internal state.
+
+Per `@luminary michael-nygard` (stability patterns): bootstrap-pair is the circuit-breaker against incomplete substrate ships. The rule fires at the PR-author boundary; the optional V2 mechanical layer would fire at the pre-commit boundary; both prevent the half-shipped class from reaching adopter machines.
+
+Per `@luminary kent-beck` (test-first): the test for a substrate primitive often IS its bootstrap pair. The hook test ships when the hook ships; the test running confirms the hook fires; the wiring is the bootstrap pair that makes the test reachable from adopter sessions.
+
+Per `@luminary linus-torvalds` (adopter compatibility stance): when bassclef ships an incomplete substrate primitive, the failure is invisible to bassclef-internal tests (which assume bassclef's own environment is intact) but catastrophic at first adopter run (which catches the missing pair). The bootstrap-pair discipline is the bassclef-internal analog of the kernel-compatibility-stance Linus articulated — applied to substrate-internal completeness.
+
+## Mechanical layer (V2 deferred)
+
+V1 of this rule is methodology only. V2 deferred extension: a pre-commit hook that:
+
+1. Detects PRs adding substrate primitives (path matchers per the "When this rule fires" section)
+2. Greps the staged content for the pair (e.g., new hook → grep settings.json staged diff for the hook's path)
+3. BLOCKs when the pair is absent AND the override is absent
+
+Defer to a separate goal when the methodology layer has shipped through enough PRs that the failure modes are stable and the pre-commit logic can mechanize against them confidently.
+
+## Composes with
+
+- `.claude/rules/pr-body-shape.md` — the `Bootstrap pair shipped` block lives in the Summary section per this rule
+- `.claude/rules/we-dont-break-adopters.md` — sister discipline at the adopter-observable surface; this rule extends the discipline to bassclef-internal substrate completeness
+- `.claude/rules/blocked-items.md` — the BLOCK protocol the V2 mechanical layer would fire
+- `.claude/rules/loop-discipline.md` — sister at the construction-cycle level; bootstrap-pair check fires in the per-PR loop discipline
+- `.claude/rules/accessor-library-discipline.md` — the rule that surfaced one instance (#324)
+- `.claude/rules/testing-tier-config.md` — the Tier 0 strict-TDD pattern; the bootstrap pair often IS the test that locks the primitive
+- `architecture/audits/2026-06-24-validator-bootstrap.md` — WU-10 surfaced the 5-instance enumeration
+
+## Distinct from
+
+- `we-dont-break-adopters.md` — that rule covers adopter-observable surfaces. This rule covers substrate-internal completeness. The two compose; both required.
+- `loop-discipline.md` — that rule covers the per-PR construction cycle. This rule covers the per-primitive completeness check WITHIN that cycle.
+- `testing-tier-config.md` — that rule covers WHICH paths require which tier of test enforcement. This rule covers whether the primitive's PAIR ships at all.
+
+## Refs
+
+- bassclef-upstream#328 (this rule's filing ticket)
+- bassclef-upstream#322 (single-instance case that seeded the generalization)
+- bassclef-upstream#319 (hook wiring instance — partial-close via bet 25a WU-3)
+- bassclef-upstream#324 (lib accessor library instance — closed via bet 25a)
+- bassclef-upstream#325 (workflows instance — closed via bet 25b)
+- bassclef-upstream#326 (design + patterns instance — closed via bet 25c)
+- `architecture/audits/2026-06-24-validator-bootstrap.md` (WU-10 of bet 24c)
+- bet 2026-06-25d — this rule's ship vehicle
+
+## Retirement condition
+
+This rule retires only if substrate primitives cease to require paired bootstrap (very unlikely — the half-shipped failure class is inherent to any modular substrate that crosses the bassclef → adopter boundary). The 5-instance enumeration may grow as new primitive types surface (e.g., agent definitions, luminary catalog entries) — extend the table per amendment.
+
+Closes bassclef-upstream#328.

package/substrate/.claude/rules/cold-adopter-harness-discipline.md

@@ -0,0 +1,129 @@
+---
+tier: lite
+description: Substrate changes that touch any adopter-observable surface MUST pass the cold-adopter harness before merge.
+---
+
+# Cold-Adopter Harness Discipline
+
+Substrate changes that touch any adopter-observable surface MUST pass the cold-adopter harness before merge. The harness lives at `scripts/cold-adopter-harness-sync.sh` and runs as a PR-blocking job in `.github/workflows/bassclef-pr-ci.yml`. This rule is the methodology layer; the CI job is the mechanical layer; both load-bearing together close the audit gap that surfaced 2026-06-25 (harness existed but no rule required substrate evolution to drive a check).
+
+## When this rule fires
+
+Any PR that touches a path in the adopter-observable surface set:
+
+- `.claude/hooks/*.sh` — hook scripts adopters symlink into their `.claude/` dirs
+- `.claude/skills/*/SKILL.md` — skill definitions adopters discover by name
+- `.claude/rules/*.md` — rules adopters inherit via `additionalDirectories`
+- `.claude/agents/*.md` — agent definitions adopters dispatch by role
+- `.claude/luminaries/*.md` — luminaries adopters reference in goal docs
+- `lib/*.sh` — shared accessor libraries adopters source from
+- `standards/*.md` — standards adopters cite as reference
+- `standards/state-spine/schemas/*.json` — schemas adopters validate against
+- `presence/install/bassclef-sync.*.sh` — sync templates adopters vendor
+- `architecture/decisions/ADR-*.md` — ADRs adopters read for architecture context
+- `.github/workflows/bassclef-*.yml` — workflows adopters extend (when the change affects shared workflow shape)
+- `scripts/*.sh` — scripts adopters invoke (when classified as adopter-facing per `.claude/rules/testing-tier-config.md`)
+- Any other path under `~/src/sunj-labs/` that adopter sync hooks resolve through
+
+The rule passes through (does not fire) on:
+
+- Operator content (chronicles, journals, deferred-actions, `docs/operator-private/**`)
+- Documentation edits that stay clear of adopter-observable surface (typo in a chronicle)
+- Test edits where the source under test is not adopter-observable
+- Bug fixes where the harness already covers the change class (the harness IS the regression test in that case)
+
+## What the rule requires
+
+When a PR touches an adopter-observable path, the agent OR operator MUST:
+
+1. **Local pre-push run** — execute `bash scripts/cold-adopter-harness-sync.sh --mode sync --target .` from the bassclef-upstream root. Confirm exit 0 (all checks pass) OR explicitly document why a check failure is acceptable.
+2. **CI confirmation** — the `cold-adopter-harness` PR-blocking job in `.github/workflows/bassclef-pr-ci.yml` runs the same command on the PR head. Job must pass before merge.
+3. **PR body acknowledgement** — when the PR body's `Test plan` section is authored, include a line confirming the harness was run locally OR cite the CI job that runs it.
+
+The mechanical layer (CI job) is the load-bearing enforcement. The methodology layer (this rule + the local pre-push step) closes the gap between commit time and CI-fire time.
+
+## What this rule does NOT require
+
+- Running the harness on every commit (only on substrate-affecting paths; the path matcher above is the trigger)
+- Running the harness on operator content (chronicles, journals — pass-through)
+- Re-running the harness when CI already ran it cleanly and no substrate-affecting paths changed in a follow-up commit
+- A separate harness for adopter-facing scripts (the same `scripts/cold-adopter-harness-sync.sh` covers all surfaces)
+- Pre-commit-time enforcement (deferred to follow-on; bet 25g closes the CI + methodology layers; pre-commit hook is Gap 4 follow-on)
+
+## Anti-patterns
+
+These shapes fail this rule.
+
+**Substrate change shipped without running the harness locally.** Author edited `.claude/hooks/<name>.sh`, ran the test suite, pushed. CI catches it but the round-trip cost is one PR cycle wasted.
+
+INSTEAD: run `bash scripts/cold-adopter-harness-sync.sh --mode sync --target .` before pushing. Catches the same class of failure locally; saves the CI round-trip.
+
+**Substrate change shipped + CI green + harness still fails.** The CI job ran but produced a stale result because the harness was not extended to cover the new check class. The author's PR ships; an adopter cloning fresh hits the failure.
+
+INSTEAD: extend the harness check classes in the same PR that introduces the new surface. Per `.claude/rules/bootstrap-pair-discipline.md` — when a new substrate primitive ships, its bootstrap pair includes the harness check class that validates it.
+
+**Author overrides the harness CI job to merge faster.** Operator-merge mode with `SKIP_COLD_ADOPTER_HARNESS=1` set in the workflow environment.
+
+INSTEAD: fix the harness failure OR document the explicit deferral in the PR body's `Out of scope` section with a follow-on ticket reference. Silence is not deferral.
+
+**Adopter-observable change disguised as operator-internal change.** Author edits `presence/install/bassclef-sync.template.sh` (adopter-observable) but commits it as a `chore:` claiming it is internal-only.
+
+INSTEAD: the path-matcher determines adopter-observable status, not the commit message. `presence/install/*` IS adopter-observable; the harness fires.
+
+## Override path
+
+`SKIP_COLD_ADOPTER_HARNESS=1` env var — logged via trace-helper per existing bassclef hook idiom. Use only for:
+
+- One-shot migration scripts that bootstrap state and intentionally produce a harness failure during the migration window (the migration itself fixes the failure)
+- Emergency rescue when the harness itself is broken (substrate-defect recovery; harness must be fixed before next PR)
+- Explicitly-deferred work where the PR body documents the override + cites a follow-on ticket that closes the deferred check
+
+For routine work, run the harness. The cost is ~30 seconds on `--target .` (no live network fetch). The discipline holds across every PR.
+
+## How bassclef channels this discipline
+
+The discipline lives in three layers — pre-commit (operator-side fast-fail), PR-CI (PR-side enforcement), and /verify (operator-side audit) — all firing the same 12-pattern matcher per Saltzer-Schroeder complete mediation:
+
+- `.claude/rules/cold-adopter-harness-discipline.md` — this rule (methodology layer)
+- `.claude/hooks/pre-commit-gate.sh` § "Cold-adopter harness fast-path" — pre-commit layer (operator-side fast-fail; ships via bet 25h WU-2). Detects substrate-affecting staged paths, runs harness in `--mode structural` for fast feedback, BLOCKs the commit on harness failure. Override: `SKIP_COLD_ADOPTER_HARNESS=1 git commit`.
+- `.github/workflows/bassclef-pr-ci.yml` — `cold-adopter-harness` PR-blocking job (PR-CI mechanical layer; ships via bet 25g WU-2)
+- `.claude/skills/verify/SKILL.md` — operator-side audit composition (ships via bet 25h WU-3)
+- `scripts/cold-adopter-harness-sync.sh` — the shape b harness all three layers invoke; extended with workflow-loop checks via bet 25g WU-3; FURTHER extended with Shape d mechanism-fidelity check classes via bet 27c WU-5 (4 new classes: `hook-wiring-presence`, `hook-path-resolution-under-install-class`, `hook-end-to-end-smoke`, `rule-mechanism-claim-fidelity`; V1 ADVISORY → V2 BLOCK after Bet C-pre-2 cures land)
+- `standards/cold-adopter-harness.md` (standard tier — operator + standard adopter reachable) — operational reference for invocation + check semantics; documents Shape d V1 ADVISORY mode per bet 27c WU-5
+- `.claude/rules/bootstrap-pair-discipline.md` — sister rule; amended in bet 25g WU-1 to list cold-adopter validation as a paired bootstrap class
+
+## Composes with
+
+- `@luminary saltzer-schroeder` — complete-mediation principle (every adopter-observable surface validated by the harness; the rule names which surfaces are observable)
+- `@luminary hyrum-wright` — observable behavior becomes load-bearing (the harness pins the observable contract; this rule formalizes that pinning)
+- `@luminary linus-torvalds` — adopter-trust ceiling (CI gate IS the operational form of the adopter-compatibility stance; rule names the discipline)
+- `@luminary michael-feathers` — characterization tests at the adopter boundary (the harness IS the characterization test; this rule mandates the test fires)
+- `.claude/rules/we-dont-break-adopters.md` — sister discipline; this rule is the test-side of the discipline that rule defines
+- `.claude/rules/bootstrap-pair-discipline.md` — sister rule; this rule's "harness check class" IS one of bootstrap-pair's required pairs for adopter-observable primitives
+- `.claude/rules/testing-tier-config.md` — Tier 0 paths the harness validates; sister rule for per-path test enforcement
+- `.claude/rules/loop-discipline.md` — the per-PR cycle this rule fires within (loop's final-validation step composes the harness check)
+- `.claude/rules/blocked-items.md` — BLOCK protocol the CI job fires when the harness fails
+
+## Distinct from
+
+- `.claude/rules/we-dont-break-adopters.md` — that rule names the operator-side discipline (ship within the adopter contract); this rule names the mechanical enforcement (the harness fires on every PR)
+- `.claude/rules/bootstrap-pair-discipline.md` — that rule lists 5 substrate-primitive classes that need paired bootstrap; this rule extends with the adopter-validation pair as a 6th class
+- `.claude/rules/testing-tier-config.md` — that rule names per-path test enforcement tier; this rule names harness-level enforcement that composes with per-path tiers
+- `scripts/release-to-bassclef.sh` — that script publishes substrate downstream; this rule's harness is a pre-publish gate (CI fires before release pipeline runs)
+
+## Refs
+
+- bassclef-upstream#341 — shape c (this rule + the CI job ship together via bet 25g)
+- bassclef-upstream#333 — shape a (harness foundation; closed via 25e)
+- bassclef-upstream#320 — substrate architect-review epic (closed; 24c umbrella still in_flight)
+- bet `docs/iteration-bets/2026-06-25g-cold-adopter-ci-and-discipline.md` — ship vehicle
+- bet `docs/iteration-bets/2026-06-25f-fixes-then-harness.md` — shape b parent
+- ADR-029 release pipeline (CI harness fires before release)
+- ADR-031 (`we-dont-break-adopters` decision) — this rule is the test-side enforcement
+- 2026-06-25 /longrun prep audit — surfaced the 5 wiring gaps this rule + bet 25g close (3 of 5)
+
+## Retirement condition
+
+This rule retires only if bassclef stops having adopters OR the cold-adopter harness retires. The CI mechanical layer may evolve (separate workflow, runner profile change, harness extension) but the discipline of validating adopter-observable surface before merge persists.
+
+Closes audit Gap 2 surfaced at /longrun prep 2026-06-25. Sister gaps 4 + 5 (pre-commit hook, /verify composition) filed as follow-ons during bet 25g closeout.

package/substrate/.claude/rules/compounding-axis-fresh-analysis.md

@@ -0,0 +1,188 @@
+---
+tier: lite
+description: "When /longrun prep proposes scope shapes, each shape's compounding-sequence row comes from fresh analysis."
+---
+
+# Compounding-Axis Fresh Analysis
+
+When `/longrun` prep proposes scope shapes, each shape's compounding-sequence row comes from fresh analysis. Hand-off documents do not satisfy Step 1.5 of the `/longrun` SKILL. That includes `docs/whereami.md`'s `next_longrun_queue` recommended order, an audit doc's `next_pending`, and a prior chronicle's pickup suggestion. Each shape gets its own row from the agent's own analysis at prep time.
+
+This rule is the methodology layer. The mechanical layer is `.claude/hooks/longrun-prep-compounding-sequence-check.sh`. That Stop hook is wired in `.claude/settings.json`. Tests at `.claude/hooks/tests/longrun-prep-compounding-sequence-check.test.sh`.
+
+The hook scans the latest assistant message when `state/markers/turn-prose-surface/longrun_prep_proposal.marker` is touched. It BLOCKs the stop (exit 2) when the compounding-sequence column headers are missing. Hook accepts EITHER shape per PR #1591 (bassclef#1555 PR-1): the new 6-axis frame (default, per plan doc `docs/next-session-plan-2026-09-09-compounding-axis-refactor.md`) OR the legacy 5-axis frame (grace window through 2026-10-31 per ADR-031). Backward compat opt-out: `COMPOUNDING_AXIS_TOGGLE=advisory` reverts to V1 (finding to stderr; exit 0).
+
+**V2 strict landed 2026-06-30.** The first `/longrun` prep after V1 ship surfaced only 3 of 5 columns at the operator-facing table. The hook caught the miss as designed. But it emitted ADVISORY to stderr. The agent could not see its own advisory in conversation. The operator could not see it on mobile. The operator asked "compounding sequence miss intact from the last substrate fix?" — that proved the visibility gap. The hook ships V2 strict as the next calibration step per ADR-035 (substrate-as-system — the mechanism must close the loop).
+
+## Why this rule exists
+
+Bet 30b filed under five catches of one class in 36 hours. The pattern: the agent emits operator-facing assertions without re-reading the data the assertion claims. One catch was that evening's `/longrun` prep. The agent shipped three scope shapes ordered by size rather than by how often each shape's work would fire after shipping. The agent treated whereami's `next_longrun_queue` recommended order as a stand-in for fresh analysis. Operator caught the miss and asked why the analysis step was skipped.
+
+The hook caught nothing. The agent touched the surface marker AFTER writing the proposal, not before. The Stop hook fired at the next Stop event with a different latest assistant message — not the proposal where the column was missing.
+
+This rule extends the discipline beyond hook coverage:
+
+1. **Fresh analysis** — each scope candidate gets a per-shape compounding row authored at prep time, not copied from a hand-off doc
+2. **Marker touch BEFORE the surface** — the marker is the agent's commit to writing the compounding-aware proposal next; touching after defeats the hook's check (cross-reference `.claude/rules/operator-facing-prose.md` Rule 3)
+3. **Marker cleanup AFTER the surface (paired with V2 strict)** — the agent removes the marker once the prep proposal has landed AND the operator has confirmed scope. The marker's purpose is satisfied at that point. Without cleanup under V2 strict, every post-prep Stop event blocks. The hook scans every assistant message. Most post-prep turns (status updates, commit summaries, WU work) do not carry a shape proposal table. Cleanup is the bootstrap pair V1 advisory hid (exit 0 forgave the gap).
+4. **R8 underlying pattern (per bet 30b risk ledger)** — the agent does not label a substrate artifact (risk ledger, decomposition, audit, ADR-consult, sources-read citation) without doing the underlying work that produces it. Naming the artifact ≠ producing it.
+
+## When this rule fires
+
+Every `/longrun` prep that proposes scope shapes:
+
+- `/longrun prep` (operator types) — Step 1.5 compounding-sequence analysis per shape candidate
+- `/sprint` next-work proposals when scope-shape options are surfaced (sister surface; same shape contract)
+- Bet doc authoring — when the goal doc's `## Steps` section enumerates a per-shape table, the same axis applies
+
+The rule does NOT fire on:
+
+- Single-shape continuation prep where the operator has already confirmed scope (no shape PICK happening; per-shape compounding still applies per memory `feedback-compounding-sequence-mandatory-every-prep-surface`)
+- WU-sequencing inside a chosen shape (covered by sister rule `.claude/rules/wu-sequencing-compounds.md` for Step 1.7 INTRA-shape)
+
+## What the rule requires
+
+Before the operator picks a scope shape:
+
+1. **Touch the surface marker FIRST** — `mkdir -p state/markers/turn-prose-surface && touch state/markers/turn-prose-surface/longrun_prep_proposal.marker` BEFORE writing the proposal. The marker tells the Stop hook the next message is a prep proposal subject to the column-presence check.
+2. **Per-option compounding row** — each option candidate carries 6 axes per `/longrun` SKILL Step 1.5 (new default per bassclef#1555). Per `#1193` cure, Step 1.5 prescribes the `### Compounding value per option` section explicitly. The 6 axes read as practical decision fields for Sam (Saturday evaluator) and Louis (context switcher) per plan doc `docs/next-session-plan-2026-09-09-compounding-axis-refactor.md` L36-45.
+
+   The 6-axis default (new; per bassclef#1555 PR-2):
+
+   | Axis | Source | Standard values |
+   |---|---|---|
+   | Deliverable | Plain sentence | What ships when this option lands |
+   | Problem | `/state-a-problem brief` | ≤500 chars; framework implicit |
+   | Value prop | `/value-prop tweet` | ≤280 chars; claim + sharpener |
+   | Turns | Grounded range | Cite past goal actuals per `.claude/rules/turn-estimate-grounding.md` |
+   | Risk | 🟢 / 🟡 / 🔴 | Low / medium / high |
+   | Shipping priority | Q1 / Q2 / Q3 / Q4 or blank | Blank prompts `Run /eisenhower to prioritize?` |
+
+   The 5-axis legacy (grace window through 2026-10-31 per ADR-031; hook accepts both shapes):
+
+   | Plain-English (preferred per ADR-040 D4) | Compressed (grace only) | Standard values |
+   |---|---|---|
+   | Where the payoff shows up | Compounding surface | per-PR / per-release / per-session / per-adopter / per-quarter |
+   | How often it fires | Compounding rate | continuous / frequent / per-session / per-adopter / per-quarter |
+   | What must be true first | Foundation prerequisites | none / specific goal / ticket / config flag |
+   | Does this teach a shape later work reuses | Inverse-dependency | yes (names the later work) / no |
+   | What breaks if we ship this half-done | Risk class | low / medium / high |
+
+   R8 catch preservation: Deliverable + Problem + Value prop force fresh per-option analysis. `/state-a-problem` and `/value-prop` are themselves cognitive tools that resist copy-paste. The distinct-values check per option (bassclef#564) applies to whichever shape the prep uses.
+3. **Fresh analysis** — the column values come from the agent's reading of the shape itself, not from a hand-off doc's recommended order. If the agent reads a hand-off doc and the order matches its own analysis, the row matches by coincidence, not by copy. If the order DOESN'T match, the rule surfaces the conflict to the operator.
+4. **Recommended shape rationale** cites the compounding sequence + adopter-benefit mechanism (per sister rule for Step 1.6 bassclef-upstream#1302) explicitly.
+5. **Remove the surface marker AFTER scope confirmation** — once the prep proposal has landed AND the operator has confirmed scope (or the proposal is being abandoned), remove `state/markers/turn-prose-surface/longrun_prep_proposal.marker`. The marker's purpose is satisfied. Leaving it present makes every post-prep Stop event block under V2 strict default. Most subsequent turns (status updates, commit summaries, WU work) do not carry a shape proposal table.
+
+   ```bash
+   rm -f state/markers/turn-prose-surface/longrun_prep_proposal.marker
+   ```
+
+   This step is mandatory at the prep→execution handoff. Hook auto-cleanup deferred to a follow-on (substrate-evolution ticket) — the rule names the discipline; the agent removes the marker today.
+
+## Postcondition contract (per Hoare)
+
+Per bassclef-upstream#564 + luminary consultation (Ousterhout / Hoare / Feathers / Saltzer-Schroeder / Beck):
+
+**Precondition:** the /longrun prep proposes 2+ candidate shapes, each with a distinct scope.
+
+**Postcondition:** for every option O in the candidate set, for every axis A in the axis list of the shape the prep uses (6-axis default OR 5-axis legacy), the prep output contains a non-empty value V(O, A). The rendering satisfies the postcondition in one of two accepted shapes (per bassclef-upstream#1376):
+
+- **Per-option shape (pre-existing default).** V(O, A) renders under O's section as bullets or table rows. Each option gets a full section. Not only in a header row shared across options.
+- **Per-recommended-only shape (bassclef-upstream#1376 addition).** The prep opens with `**Recommend:** Option X`. V(recommended, A) renders under the recommended option's section as bullets. V(other, A) renders as scan-table row cells — one cell per axis per non-recommended option. Reader lands the recommended card fast; other options stay auditable from the scan-table row.
+
+The 6-axis default is: Deliverable, Problem, Value prop, Turns, Risk, Shipping priority. The 5-axis legacy (grace window through 2026-10-31) is: Where the payoff shows up, How often it fires, What must be true first, Does this teach a shape later work reuses, What breaks if we ship this half-done. Hook accepts either shape per PR #1591.
+
+The postcondition is stronger than the message-level check V2 ships. V2 verifies that the column names appear anywhere in the message. V3 (bassclef-upstream#564; ships with this rule amendment) verifies that each option section carries all axes of the chosen shape as distinct values. A single header row with axis names but no per-option values fails the postcondition. That is the R8 pattern this cure closes.
+
+Per `#1193` cure — the hook regex accepts both `Shape a-c` and `Option a-e` for the per-shape check during the grace window through 2026-10-31 per `.claude/rules/we-dont-break-adopters.md`. After that date only `Option [a-z]` matches. SKILL `#830` renamed the label; the rule postcondition applies equally to both vocabularies.
+
+**When shapes legitimately share an axis value** (e.g., all three shapes have `Risk class: low` because the work is small), the values still render per shape — same text under three sections. Rendering satisfies the postcondition. The check does not flag legitimate convergence.
+
+## Anti-patterns
+
+These shapes fail this rule.
+
+**Agent ships scope shapes WITHOUT compounding-sequence columns.** Tonight's failure (caught by operator). Cure: include the columns; touch the marker BEFORE the proposal.
+
+**Agent ships scope shapes with columns COPIED from whereami's `next_longrun_queue` or an audit's `next_pending`.** The columns are present but the fresh-analysis precondition is violated (R2 Hoare — mechanically unverifiable from output). Cure: re-analyze each shape independently; surface conflict if hand-off order disagrees with fresh order.
+
+**Agent touches the surface marker AFTER writing the proposal.** Tonight's failure mode. The hook fires at the next Stop event with the marker-touch message as the latest assistant message — not the proposal. Cure: touch marker BEFORE proposal.
+
+**Agent leaves the surface marker present after scope confirmation.** Under V2 strict default this blocks every subsequent Stop event because the hook scans every assistant message and most post-prep turns do not carry a shape proposal table. Cure: remove the marker at the prep→execution handoff per step 5 above.
+
+**Agent labels a "risk ledger" / "decomposition" / "audit" / "sources-read" without doing the underlying work (R8 underlying pattern).** The label is the assertion; the work that produces it is the data the assertion claims. Tonight's risk-ledger catch by operator. Cure: cite the file path of the produced artifact in agent output; not just the label.
+
+INSTEAD of any of these: do the work first; touch the marker; write the proposal with the compounding row populated from fresh analysis; cite produced artifacts by file path.
+
+## Hand-off documents that do NOT satisfy
+
+These all carry useful context but do not substitute for fresh analysis:
+
+- `docs/whereami.md` `next_longrun_queue` — operator + prior session's pickup suggestion; not compounding-derived
+- audit doc `next_pending` field — sequenced by audit author; may not match current compounding priorities
+- prior chronicle's "next pickup" suggestion — operator-facing handoff narrative; not analysis
+- prior goal doc's `next_bet` field — sequencing intent; not analysis
+- memory entry `feedback_*` — prior discipline; relevant context but not a substitute for the per-shape row
+
+Agent reads all of these for context. Agent then writes fresh compounding analysis per shape. The two activities are distinct.
+
+## Override
+
+`SKIP_COMPOUNDING_AXIS_CHECK=1 <command>` — bypass the hook for one call (already exists; logged via trace-helper). The rule's methodology layer has no override — fresh analysis is the precondition; without it, the proposal is incomplete.
+
+For trivial single-shape continuation prep where the operator has already confirmed scope: the rule applies but cost is small (one row in the goal doc); no override needed.
+
+## Composes with
+
+- `.claude/rules/wu-sequencing-compounds.md` — sister at Step 1.7 INTRA-shape (per-step produces/consumes)
+- `.claude/rules/operator-facing-prose.md` Rule 3 — marker touch BEFORE the named surface (this rule's mechanism precondition)
+- `.claude/rules/blocked-items.md` — BLOCKED protocol the hook fires under V2 strict
+- `.claude/rules/substrate-as-system.md` — every rule has a mechanism + every mechanism has a rule; this rule pairs the existing `longrun-prep-compounding-sequence-check.sh` mechanism with its rule body
+- `.claude/hooks/longrun-prep-compounding-sequence-check.sh` — the mechanical layer
+- `.claude/hooks/tests/longrun-prep-compounding-sequence-check.test.sh` — Tier 0 tests pinning the hook
+- `.claude/skills/longrun/SKILL.md` Step 1.5 — the procedure surface the rule serves
+- `@luminary jerome-saltzer-and-michael-schroeder` — complete mediation principle
+- `@luminary tony-hoare` — pre/postcondition contracts (R2 fresh-analysis is precondition, mechanically unverifiable)
+- `@luminary michael-feathers` — characterization tests pin REAL prep prose (R3 follow-on)
+- `@luminary kent-beck` — Tier 0 strict TDD on the hook (R4 follow-on covers each umbrella ticket instance)
+
+## Refs
+
+- sunj-labs/bassclef-upstream#540 — umbrella ticket; this rule closes 1 of 5 sub-cures
+- `docs/iteration-bets/2026-06-30b-substrate-anchoring-cure.md` — goal doc; WU-E ships this rule
+- `docs/risk-ledgers/2026-06-30b-substrate-anchoring-cure.md` — 8 lens pre-mortem + R8 meta-catch
+- bassclef-upstream#1299 (Step 1.5 INTER-shape compounding-sequence) — sister filing ticket if it exists
+- bassclef-upstream#1302 (Step 1.6 INTER-shape adopter-benefit) — sister rule shape
+- bassclef-upstream#1304 (turn-prose-surface marker discipline) — operator-facing-prose Rule 3
+- memory `feedback-compounding-sequence-mandatory-every-prep-surface` — fires at every prep surface, including single-shape continuation
+- memory `feedback-architect-review-audit-is-authoritative` — audits override `next_longrun_queue` for next-pickup
+- ADR-035 substrate-as-system — the tenet this rule operationalizes at Step 1.5
+- ADR-040 Decision 4 (planning-skill body template) — plain-English axis names shipped in PR #743 (goal 17a). Per #745, the sister rule + hook accept both shapes during the grace window through 2026-10-31.
+
+## Deferred to follow-on
+
+The bet 30b risk ledger named these add-to-scope dispositions for WU-E; they ship in a follow-on goal:
+
+- **R3 (Feathers)** — extend Tier 0 tests with 3 characterization tests against REAL `/longrun` prep messages (tonight's + 2 from prior goal prep chronicles)
+- **R4 (Beck)** — extend Tier 0 tests with cases for each instance under umbrella #540 (release recommendation skip, cleanup proposal skip, visual-compare skip, session-orientation skip)
+- **R6 (Linus)** — cold-adopter harness check for session-reflection.d/05-active-bet.sh fragment presence (sister to WU-B)
+- **R7 (Norman)** — extend `longrun-prep-compounding-sequence-check.sh` to ALSO scan for proof-of-read line from `/longrun` Step 0.4 (sister to WU-B cure 3)
+
+The rule body is complete without these; the hook coverage extension is a separate ship vehicle.
+
+## Per-WU coverage (bassclef-upstream#597 extension)
+
+Per-WU compounding-sequence rendering carries the same 5 axes at the step layer, alongside the produces/consumes table.
+
+When a `/longrun` prep proposal contains 2+ WU rows in the produces/consumes table (per Step 1.7), the proposal MUST also carry per-step compounding-sequence rendering — either a `## Compounding value per step` section OR per-step 5-axis bullets under each step.
+
+Anti-pattern that fails: shape-level 5 axes rendered per Step 1.5, WU produces/consumes rendered per Step 1.7, per-step compounding-sequence skipped. This shape passed as convention for weeks. It got displaced when PR #567 tightened Step 1.5 to per-shape distinct values, which shifted agent attention to shape-level. INSTEAD of trusting convention: mechanize the per-step coverage so sibling discipline tightening does not crowd it out.
+
+Correct shape: same 5 axes rendered per step with distinct values — plain-English names preferred per ADR-040 D4 (Where the payoff shows up / How often it fires / What must be true first / Does this teach a shape later work reuses / What breaks if we ship this half-done). Compressed forms accepted during the grace window through 2026-10-31.
+
+Mechanical layer: `.claude/hooks/longrun-prep-compounding-sequence-check.sh` extended with per-step check (V1 strict — BLOCK on missing per-step axes when 2+ WU rows present). Toggle `COMPOUNDING_AXIS_TOGGLE=advisory` retains backward-compat.
+
+Sister to Step 1.5 per-shape check (bassclef-upstream#564). Same discipline shape at a different layer.
+
+## Retirement condition
+
+This rule retires only if `/longrun` Step 1.5 stops requiring per-shape compounding analysis. Mechanical extensions (V2 BLOCK flip, additional column types, additional surfaces) may evolve; the discipline of fresh analysis per shape persists.