@thebassclef/lite 0.0.1 → 0.1.2

package/substrate/.claude/rules/adr-discipline.md

@@ -0,0 +1,120 @@
+---
+tier: lite
+description: "Every load-bearing architectural decision MUST be recorded as an ADR (Architecture Decision Record) per Michael Nygard's lifecycle: proposed → accepted → deprecated → superseded."
+---
+
+# ADR Discipline
+
+Every load-bearing architectural decision MUST be recorded as an ADR (Architecture Decision Record) per Michael Nygard's lifecycle: `proposed` → `accepted` → `deprecated` → `superseded`.
+
+ADR discipline lives at the rule layer (this file) plus the mechanical layer (`.claude/hooks/adr-discipline-check.sh` — PreToolUse hook on architectural-decision paths). Both load-bearing for adopter architecture quality.
+
+## Why this rule exists
+
+ADR discipline previously lived only in the Architect agent persona. Sequential-mode adopter sessions skip Architect role entirely; architectural decisions ship without records.
+
+INSTEAD: this rule mechanizes ADR discipline at the decision boundary via PreToolUse hook. The hook fires regardless of which agent role is active.
+
+Eugene-supplements `apps/web` made 4+ architectural decisions (Postgres over SQLite, Server Actions over Express, Prisma over Drizzle, single-app over monorepo) with zero ADRs. The cost compounds: future maintainers can't reconstruct why; future architectural decisions can't be measured against the original rationale; deprecation requires re-deriving the decision context months later.
+
+## When this rule fires
+
+Any session writing or editing a file matching architectural-decision shape:
+
+- `prisma/schema.prisma` or per-ORM schema equivalent (schema-change)
+- `docker-compose*.yml` or `docker-compose*.yaml` (deployment-topology-change)
+- `src/middleware.ts` or per-stack middleware equivalent (middleware-change)
+- `*/alembic/versions/*.py` / `*/db/migrate/*.rb` / `*/migrations/*.go` (schema-migration)
+- `package.json` / `pyproject.toml` / `Gemfile` / `go.mod` / `Cargo.toml` on Write only (dependency-manifest-change)
+
+When match fires, the hook checks for an ADR marker at `state/markers/adr/<decision-slug>-*.md`. The marker is required — generic ADRs in `docs/adrs/` or `architecture/decisions/` are not sufficient because they may be unrelated to the current decision class. When the marker is absent, the hook BLOCKs with template + writeup prompt.
+
+## Load-bearing definition
+
+A decision is load-bearing when:
+
+- It establishes an invariant future decisions must respect
+- Reversing it would require substantial migration work (>1 day operator time)
+- Multiple parts of the codebase depend on it
+- It crosses a bounded context boundary (per Evans DDD)
+- It changes a cross-cutting concern (auth, logging, multi-tenancy, observability stack)
+
+Non-load-bearing (skip ADR):
+
+- Bug fixes within existing patterns
+- Component-level library choices (icon library, date-picker)
+- Cosmetic refactors (renames, file reorganizations without behavior change)
+- Test additions
+- Documentation edits
+
+When in doubt, write the ADR. Ten-minute cost; high-value record.
+
+## ADR format
+
+Use `standards/adr-template.md`. Required sections:
+
+- Frontmatter: id, title, status, date, supersedes, superseded_by
+- Context — what motivated the decision
+- Decision — the choice + rationale
+- Status — proposed / accepted / deprecated / superseded
+- Consequences — what becomes easier / harder / enables / blocks
+- References — related ADRs, external sources, source incidents
+
+## Marker convention
+
+After writing the ADR, touch the marker:
+
+```bash
+mkdir -p state/markers/adr
+touch state/markers/adr/<decision-slug>-ADR-NNN.md
+```
+
+The marker is the audit trail: the hook reads it; reviewers can grep for it; chronicle Gate Evidence sections can cite it.
+
+## Override path
+
+`SKIP_ADR_CHECK=1 <command>` — logged via trace-helper. Use rarely:
+
+- Trivial revert of a previously-decided architectural change (the revert is reversing the prior decision per its `superseded_by` field)
+- Emergency rescue when the hook itself misclassifies (file substrate-defect)
+- One-shot migration script that touches many architectural files (operator has reviewed externally)
+- Bulk dependency-manifest regen where every dep was already declared in a prior ADR
+
+INSTEAD of overriding for routine work: write the ADR. The ten-minute cost is one of the cheapest substrate disciplines to follow.
+
+## Tech-stack-aware composition
+
+ADR discipline is stack-agnostic. The same template applies across stacks. Per-stack ADR examples may ship as siblings under `standards/adr-examples/<stack>.md` over time, with the discipline itself staying the same across stacks.
+
+## What the rule does NOT cover
+
+- ADR review process (operator + Architect agent collaboration)
+- ADR retirement (status change to `deprecated` or `superseded`; the file stays in place)
+- Cross-project ADR sharing (bassclef's ADRs and adopter's ADRs stay in separate directories)
+- ADR templates for non-software architecture (deployment-process ADRs, team-structure ADRs — out of scope for this rule)
+
+INSTEAD: each of the above lives in a sibling rule or template if it becomes relevant.
+
+## Composition with other rules
+
+- `.claude/rules/testing-tier-config.md` — Tier 0 strict-TDD on hook + tests (this hook + its test file land Tier 0)
+- `.claude/rules/blocked-items.md` — BLOCK protocol the hook fires
+- `.claude/rules/oo-ad-entry-point.md` — `/decompose` evidence is sister discipline at Construction boundary
+- `.claude/rules/schema-management.md` — schema-change ADR aligns with migration-discipline
+- `standards/adr-template.md` — the template the rule references
+
+## Refs
+
+- bassclef#1149 — this rule's filing ticket (T17 of cold-adopter promote drop)
+- bassclef#1134 — ARCH-T1 grandparent (adopter inheritance umbrella)
+- bet 2026-06-20e — WU-11 ships this rule + template + hook
+- `.claude/hooks/adr-discipline-check.sh` — the mechanical implementation
+- `.claude/hooks/tests/adr-discipline-check.test.sh` — Tier 0 test coverage
+- `standards/adr-template.md` — the ADR template
+- `@luminary michael-nygard` — anchor for ADR lifecycle (Cognitect, 2011)
+
+## Retirement condition
+
+This rule retires only if ADRs themselves cease to be a bassclef architecture-record format. The mechanical layer (hook) may evolve to detect more decision shapes; the methodology of recording load-bearing decisions persists.
+
+Closes adopter architecture-record gap surfaced by Eugene-supplements 2026-06.

package/substrate/.claude/rules/api-conventions.md

@@ -0,0 +1,125 @@
+---
+tier: lite
+description: Universal API design principles — REST conventions, response shapes, status codes, auth, validation. Stack-specific globs + helpers live in per-stack siblings under standards/api-conventions/.
+---
+
+# API Conventions
+
+Universal API design principles for any HTTP API surface. Stack-specific instantiations (Next.js App Router, FastAPI, Rails, Express, Go) live in per-stack siblings under `standards/api-conventions/`. The loader (future ticket) reads adopter's `tech_stack.frontend` + `tech_stack.backend` from `.claude/bassclef-configs.jsonc` and loads the matching sibling.
+
+When no sibling exists for the adopter's stack, the universal principles below still apply.
+
+## Universal principles
+
+These hold regardless of stack.
+
+### Route naming
+
+- RESTful: `/api/[resource]` for collections, `/api/[resource]/[id]` for items
+- Nested resources: `/api/[parent]/[parentId]/[child]`
+- Actions (non-CRUD): `/api/[resource]/[id]/[action]` (e.g., `/api/deals/123/archive`)
+- Lowercase, hyphenated: `/api/deal-pipeline`, not `/api/dealPipeline`
+
+### Response shapes
+
+Standard wrapper for successful single-item responses:
+
+```json
+{
+  "data": { ... },
+  "meta": { "timestamp": "2026-04-05T10:00:00Z" }
+}
+```
+
+Standard wrapper for successful collection responses:
+
+```json
+{
+  "data": [ ... ],
+  "meta": {
+    "total": 42,
+    "page": 1,
+    "pageSize": 20,
+    "timestamp": "2026-04-05T10:00:00Z"
+  }
+}
+```
+
+Standard error shape:
+
+```json
+{
+  "error": {
+    "code": "VALIDATION_ERROR",
+    "message": "Human-readable description",
+    "details": [ ... ]
+  }
+}
+```
+
+### HTTP status codes
+
+| Code | When |
+|------|------|
+| 200 | Success (GET, PUT, PATCH) |
+| 201 | Created (POST) |
+| 204 | No content (DELETE) |
+| 400 | Validation error, bad input |
+| 401 | Not authenticated |
+| 403 | Authenticated but not authorized |
+| 404 | Resource not found |
+| 409 | Conflict (duplicate, stale update) |
+| 500 | Unexpected server error |
+
+### Pagination
+
+Default: cursor-based for lists > 20 items. Offset-based acceptable for admin/internal endpoints.
+
+```
+GET /api/deals?cursor=abc123&pageSize=20
+→ { data: [...], meta: { nextCursor: "def456", hasMore: true } }
+```
+
+### Auth
+
+- Every route that modifies data requires auth — no exceptions
+- Read routes may be public if explicitly marked (e.g., `// PUBLIC: [reason]` comment)
+- Auth check happens at the route boundary, not inside handlers
+- Tenant context resolved at the route boundary, passed through to queries
+
+### Validation
+
+- Validate all input at the route handler boundary
+- Use a schema-validation library (Zod, Pydantic, JSON Schema, etc.) for request body validation
+- Never trust client-provided IDs for authorization decisions
+- Use parameterized queries to prevent injection (every ORM has its own mechanism)
+
+## Per-stack siblings
+
+Per ARCH-T0 #1133 Path A — stack-specific instantiations live in their own files. Loader reads adopter's `tech_stack` from `.claude/bassclef-configs.jsonc`.
+
+| Adopter's `tech_stack.frontend` | Sibling loaded |
+|---|---|
+| `nextjs` | `standards/api-conventions/nextjs.md` |
+| `fastapi` | `standards/api-conventions/fastapi.md` *(future — file `/promote` to author)* |
+| `rails` | `standards/api-conventions/rails.md` *(future)* |
+| `express` | `standards/api-conventions/express.md` *(future)* |
+| `none` or unset | universal principles only |
+
+When the matching sibling does not exist, the universal principles above apply; sibling-specific guidance is skipped until the operator declares the stack and a sibling ships.
+
+## Path A treatment
+
+This rule shipped under ARCH-T0 #1133 Path A — additive, no content removed. Existing Next.js App Router specifics (formerly in this file) moved to `standards/api-conventions/nextjs.md`. Adopters following the rule pre-split keep working: the universal principles match what was already documented; the Next.js specifics are still discoverable via the sibling.
+
+Loader infrastructure that reads sibling per `tech_stack` is a future ticket. Until it ships, the cross-reference table above is the discovery path.
+
+## Refs
+
+- ARCH-T0 #1133 — operator-stack-leakage audit + remediation (parent)
+- ARCH-T1 #1134 — Bassclef-as-Platform full adopter inheritance (grandparent)
+- bassclef#1309 — this sub-ticket (api-conventions Path A)
+- bassclef#1150 T18 — sister Path A (migration-discipline)
+- `.claude/rules/schema-management.md` — precedent rule for Path A additive shape
+- `.claude/rules/new-dependency-check.md` — sister precedent
+- `standards/api-conventions/nextjs.md` — Next.js App Router sibling

package/substrate/.claude/rules/artifact-ingestion.md

@@ -0,0 +1,179 @@
+---
+tier: lite
+description: Before producing any substantive generative output (canvas, prototype, spec, proposal, rubric, ADR, variant), the agent MUST read the referenced artifacts and enumerate them in…
+---
+
+# Artifact Ingestion — Read Before You Produce
+
+Before producing any substantive generative output (canvas, prototype,
+spec, proposal, rubric, ADR, variant), the agent MUST read the
+referenced artifacts and enumerate them in the output.
+
+"Pattern-matched on generic X" is a failure, not a shortcut.
+
+## When this rule fires
+
+Fires on any of the following output types when they reference an
+existing artifact the agent could have read:
+
+- **Canvas / spec / ADR** drafts referencing issues, prior canvases,
+  chronicles, or memory entries
+- **Prototype or variant** builds referencing prior prototypes,
+  design tokens, or luminary files
+- **Iteration proposals** referencing active iteration goals (must
+  enumerate every workstream — see `blocked-items.md` for same
+  anti-skim shape)
+- **Gate evaluations** (`/verify`, `/architect-review`) referencing
+  spec or ADR acceptance criteria
+- **Skills producing derivative content** (`/value-prop` from a ticket,
+  `/decompose` from a spec) — must read source, not just the title
+
+## Required format: "Sources read" block
+
+Every output subject to this rule MUST begin with (or include) a
+block like:
+
+```
+## Sources read
+
+- [path or reference]:[line range if applicable] — [what I took from it]
+- …
+
+## What I'm NOT reading (with reason)
+
+- [path] — [deliberate exclusion reason, e.g. out of scope, stale]
+```
+
+If no artifacts were read: state "No prior artifacts; producing from
+scratch because [reason]." Silence is not exemption.
+
+## Anti-patterns that fire this rule
+
+Direct quotes from recent failures:
+
+- "I pattern-matched on generic card UI" — built prototype without
+  reading existing Norman/Prater variant files (2026-04-13)
+- "I didn't study the existing variants before building" — same
+  incident
+- Producing a canvas recommending vendor X without reading memory
+  that flagged vendor Y for evaluation (2026-04-13)
+- Proposing iteration scope covering 1 of 4 workstreams without
+  enumerating the ones being dropped (2026-04-12)
+- Skipping BLOCKED hook output in favor of answering the user's
+  direct question (2026-04-12; third instance in six weeks)
+
+Shape across all four: **training priors substituted for explicit
+artifacts the operator had already staged.**
+
+## Verification cue for the agent (self-check before output)
+
+Before producing the output, ask:
+
+1. Did I Read every file path referenced in the prompt or parent
+   artifact?
+2. Did I enumerate every workstream / variant / section of the parent
+   artifact, including the ones I'm deferring?
+3. Did I check memory for prior evaluations, flagged alternatives, or
+   deferred decisions relevant to this output?
+4. Did I consult the active luminary files for guidance (where the
+   skill or agent definition lists luminaries)?
+
+If any answer is "no," stop. Read first. Then produce.
+
+## Session-start branch — read recent strategic artifacts before substantive work
+
+Before any branch creation OR substantive PR work in a session, the
+agent MUST Read every strategic artifact (canvas / spec / iteration-bet
+/ ADR / decomposition / roadmap) authored OR substantively modified
+within the last 7 days.
+
+**Why this branch exists.** The production-time gate (PreToolUse on
+Write/Edit per `artifact-ingestion-gate.sh`) catches artifact-ingestion
+failures at WRITE time. It does NOT catch the case where an agent runs
+`/sprint`, sees a recently-merged commit in `git log`, treats it as
+background context, and proceeds with substantive work for hours
+before reading the artifact itself. That failure mode was demonstrated
+2026-04-26: 5h triage session opened against canvas-v3 commit listed
+in `/sprint` output without anyone reading the canvas; the canvas
+explicitly named the triage fixes as transition methodology being
+superseded by spine v0. Operator caught it; the cost was 4 PRs of
+short-lifetime work.
+
+**Mechanism.** `.claude/hooks/session-reflection.d/70-recent-strategic-artifacts.sh`
+fires at SessionStart, runs `git log --since=7-days --diff-filter=AM`
+restricted to the strategic-artifact path matcher, emits a `🛑 BLOCKED`
+block listing each path + commit date when results are non-empty.
+Window is configurable via `RECENT_STRATEGIC_DAYS` env (default 7);
+0 disables for that session.
+
+**Resolution per `.claude/rules/blocked-items.md`.** The agent MUST
+either Read each listed artifact this session OR explicitly defer
+("skip recent-artifacts this session"). Silence is not deferral. The
+default is Read. The marker pattern from sibling production gates is
+NOT used here because session-reflection.d/* fragments only fire once
+per SessionStart by design — re-fire suppression is unnecessary.
+
+**Override.** `SKIP_RECENT_ARTIFACTS=1 <command>` (logged to trace) or
+operator-explicit deferral statement.
+
+**Strategic-artifact path matcher** (mirrors production-gate matcher
+minus prototypes which have their own approval workflow):
+
+- `strategy/canvases/*.md`
+- `docs/specs/*.md`
+- `docs/iteration-bets/*.md`
+- `architecture/decisions/ADR-*.md`
+- `docs/decompositions/*.md`
+- `docs/roadmaps/*.md`
+
+Prototypes are deliberately excluded — `prototype-workflow.md` and
+`prototype-production-coupling.md` cover that surface separately.
+
+## Why this rule exists
+
+Operator was QA-ing agent laziness four times in six hours on
+2026-04-12/13 across two agents. Substrate credibility depends on
+agents doing the homework before producing the output. Without this
+rule, every generated artifact requires operator spot-check against
+sources — which defeats the automation thesis.
+
+This rule is enforced by `.claude/hooks/artifact-ingestion-gate.sh`
+(bassclef, 2026-04-13). The hook fires on PreToolUse for Write/Edit
+to matcher paths (canvas, spec, ADR, iteration-bet, prototype html,
+decomposition) and blocks when no "## Sources read" block exists.
+
+The rule stands regardless of hook availability — it belongs in every
+session's loaded context, not in an optional gate. The hook is the
+mechanical backstop; the rule is the reasoning.
+
+## Consumer-repo installation
+
+Bassclef-sync symlinks the hook file into consumer repos automatically.
+To wire it as a gate, add to the consumer repo's `.claude/settings.json`
+under `hooks.PreToolUse`:
+
+```json
+{
+  "matcher": "Edit|Write",
+  "hooks": [
+    { "type": "command", "command": "$CLAUDE_PROJECT_DIR/.claude/hooks/artifact-ingestion-gate.sh" }
+  ]
+}
+```
+
+(If `Edit|Write` matcher already exists with other hooks, append this
+command to its `hooks` array — don't duplicate the matcher entry.)
+
+Override: `SKIP_ARTIFACT_INGESTION=1 <tool-call>` (logged to trace).
+
+## Relationship to other rules
+
+- `blocked-items.md` — same anti-skim shape; blocked items are a
+  specific case of artifact-ingestion failure (skipping hook-surfaced
+  artifacts)
+- `oo-ad-entry-point.md` — analogous pattern for /decompose
+  (evidence required before Construction)
+- `sdlc-gates.md` — pre-build gates; artifact ingestion is the gate
+  *before* temperance and diagnosis
+- `substrate-config-schema.md` — reading `substrate.config.md` is
+  itself an artifact-ingestion obligation

package/substrate/.claude/rules/assert-only-after-verify.md

@@ -0,0 +1,137 @@
+---
+tier: lite
+description: "Plain check: Before I make a claim in this turn, I read the source first and cite it."
+---
+
+# Assert Only After Verify
+
+**Plain check:** Before I make a claim in this turn, I read the source first and cite it. If I cannot cite the source, I do not ship the claim.
+
+---
+
+Every operator-facing assertion carries at minimum three parts: **My claim** (what you are saying), **Evidence** (the source you read, cited inline), and **Why the evidence supports the claim** (one sentence on why the source supports the claim). Two optional parts sharpen the shape: **Qualifier** (confidence + N observations) and **Rebuttal** (what would falsify the claim). Without My claim + Evidence + Why the evidence supports the claim, the assertion does not ship. This rule closes #559 at the class layer — pairs with the UserPromptSubmit hook at `.claude/hooks/assert-verify-steering.sh` per ADR-035 substrate-as-system tenet.
+
+**Vocabulary note (per bet 2026-07-03b WU-4 rename #613):** The working labels are **My claim / Evidence / Why the evidence supports the claim**. Toulmin's original vocabulary (claim / data / warrant) stays as the research citation in `.claude/luminaries/stephen-toulmin.md` — the working vocabulary reads plainer at the moment the operator scans the injected reminder.
+
+## When this rule fires
+
+Every operator-facing assertion the agent authors:
+
+- Audit findings and severity ranks
+- Cure recommendations and root-cause attributions
+- Turn estimates and time budget claims
+- Modal claims (words like "wrong," "broken," "should," "must," "always")
+- Class-level diagnoses ("this is an instance of...")
+- Ticket bodies, PR bodies, commit messages
+- Chronicle entries and journal drafts
+- Scope enumeration from queued tickets (/longrun option composition; /sprint next-work proposals)
+
+Pass-through cases (rule does not add ceremony):
+
+- Direct tool output relayed to the operator (test output, git output). INSTEAD of citing sources for tool relays: preserve the raw output; the tool IS the source.
+- Operator-quoted text preserved verbatim. INSTEAD of citing external sources for quoted operator text: attribution to the operator IS the citation.
+- Small conversational asides that carry no claim ("switching to main now"). INSTEAD of applying the shape to asides: reserve the discipline for assertions carrying a claim.
+
+## What the rule requires
+
+Before shipping any operator-facing assertion:
+
+1. **My claim** — state the assertion in one sentence
+2. **Evidence** — cite the source read inline. Files by path, tickets by number, git commits by SHA, chronicles by filename, standards by section
+3. **Why the evidence supports the claim** — one sentence on why the cited source supports the claim
+
+Optional (sharpen the shape):
+
+4. **Qualifier** — confidence + how many observations back the claim (e.g., "3 catches in one session"; "1 chronicle line"; "grep across 62 rules")
+5. **Rebuttal** — what would falsify the claim (per Popper). A claim that cannot be falsified is steering, not truth
+
+## Anti-patterns
+
+These shapes fail the rule.
+
+**Assertion without cited source.** "The hook is broken." No path, no evidence.
+
+INSTEAD: "The hook at the named path exits 2 when stdin contains no JSON — reproduced with `echo '' | bash <that-hook-path>`." My claim + Evidence + Why the evidence supports the claim.
+
+**Assertion pointing at a source but no warrant.** "Per chronicle 2026-06-30." What in the chronicle? Which line?
+
+INSTEAD: "Per chronicle 2026-06-30d L47 — three catches in one session, all naming R8 pattern." The warrant tells the reader what the source says.
+
+**Severity rank without observation criteria.** "This is a HIGH-severity finding." What was measured? Against what threshold?
+
+INSTEAD: "This is HIGH — audit finding blocks Phase XI Batten Down HIGH-severity discipline per architecture/audits/2026-06-28-adopter-experience.md L23; 2 sibling instances." Evidence + Why the evidence supports the claim.
+
+**Root cause attribution without falsifiability.** "The cause is X."
+
+INSTEAD: "The cause is X — falsified if removing X does not remove the symptom. Test: [name the test]." Rebuttal is Popper's contribution.
+
+**One explanation without alternatives.** "The bug is caused by Y."
+
+INSTEAD: "The bug fits Y (my current explanation), Z (alternative — same symptom, different mechanism), and W (third alternative). Reading source [path] to discriminate." Peirce's contribution — abductive reasoning names multiple candidates before committing.
+
+**Trusting `gh issue view state` as evidence work is undone.** Scope enumeration surfaces (/longrun option tables, /sprint next-work proposals) that read ticket state alone recommend already-done work. Ticket state and shipped state can diverge — work sometimes lands without the ticket getting closed; tickets sometimes stay OPEN as trackers after cures ship.
+
+INSTEAD apply the discipline shape per row of the option table:
+
+1. Read the ticket's acceptance criteria (via `gh issue view <N> --json body`)
+2. Grep or read the source the ticket measures against (the file, the counter, the audit output)
+3. If acceptance criteria are met by the current source — close the ticket in the enumeration itself (do not recommend it as scope)
+4. If not met — proceed with a specific measurement in the option row (what's missing, what's the delta, what's the actual turn cost)
+
+The catch: bet 2026-07-26d /longrun prep surfaced #884 (MEMORY.md prune) as a 20-40 turn scope option; the ticket's acceptance thresholds were already met by the file on disk. Reading `gh issue view state` returned `OPEN`; reading the file measured against the ticket criteria showed all three thresholds already passed. Operator caught the miss. See `feedback_verify_ticket_source_not_just_state.md`.
+
+## The three luminaries anchoring this rule
+
+- **Stephen Toulmin** — argument model. Claim + data + warrant is the minimum shape; qualifier + rebuttal sharpen it. From *The Uses of Argument* (1958)
+- **Karl Popper** — falsifiability. A claim that cannot be falsified is not a scientific claim; it is steering language. From *The Logic of Scientific Discovery* (1959)
+- **Charles Sanders Peirce** — abductive reasoning. Multiple explanations fit the same evidence; naming alternatives before committing catches confirmation bias. From "Deduction, Induction, and Hypothesis" (1878)
+
+Full luminary files ship in bet 2026-07-01b WU-2 at `.claude/luminaries/{stephen-toulmin,karl-popper,charles-sanders-peirce}.md`.
+
+## Why this rule exists
+
+Tonight's session surfaced R8 (assertion without verification) five times in ~5 hours (chronicle `2026-07-01c-r8-cascade-audit-retraction-and-cure-prep.md` names catches 16-20). My audit of `/longrun` was itself R8. I filed 5 tickets on unvalidated claims. I inflated turn estimates 3-4x above WU-2 grounding evidence. I attributed a false root cause during `/diagnose`. Operator caught each instance.
+
+`#559` named the R8 class in June. `#564` shipped one narrow surface cure (compounding-axis columns) but does not steer reasoning at the origin. Anthropic's UserPromptSubmit hook surface enables reasoning-boundary steering — the plain-English steering (per bassclef#790) proves the mechanism works. Every prompt this session carried the grade-10 reminder; my prose landed at grade 10 without conscious effort. Same physics applies to assertion discipline.
+
+The paired hook injects Toulmin's argument shape (labeled in bassclef as My claim + Evidence + Why the evidence supports the claim; Toulmin's original terms are claim + data + warrant per `.claude/luminaries/stephen-toulmin.md`) into every prompt. This rule is the methodology; the hook is the mechanism per ADR-035.
+
+## Composes with
+
+- `.claude/hooks/assert-verify-steering.sh` — the paired UserPromptSubmit hook this rule commits to
+- `.claude/rules/context-engineering.md` — foundational rule; this rule extends context engineering with argument shape
+- `.claude/rules/plain-english-discipline.md` — sister rule at prose surface; both fire per prompt
+- `.claude/rules/artifact-ingestion.md` — "read before produce" is the data-source discipline this rule extends to assertions
+- `.claude/rules/blocked-items.md` — assertions calling something BLOCKED must cite the block-source
+- `.claude/rules/stuck-signal-diagnostic.md` — assertion of "stuck" requires 3-session data
+- `.claude/luminaries/stephen-toulmin.md` — primary anchor (bet 2026-07-01b WU-2)
+- `.claude/luminaries/karl-popper.md` — supporting anchor (bet 2026-07-01b WU-2)
+- `.claude/luminaries/charles-sanders-peirce.md` — supporting anchor (bet 2026-07-01b WU-2)
+- Memory `feedback_verify_ticket_source_not_just_state.md` — the discipline the scope-enumeration anti-pattern encodes; verify tickets against source before scoping, not `gh` state alone
+- `.claude/skills/longrun/SKILL.md` prep — the surface where the scope-enumeration extension fires (Step 1 pre-flight through Step 1.7)
+- `.claude/skills/sprint/SKILL.md` — sister surface (next-work proposals)
+- ADR-035 substrate-as-system — the tenet this rule operationalizes at reasoning boundary
+
+## Override
+
+`SKIP_ASSERT_VERIFY_STEERING=1 <command>` on the hook — logged via trace-helper. The rule itself has no per-call override; the shape is minimum baseline. Use only when quoting verbatim external content that contains an unverified claim.
+
+INSTEAD of overriding for routine work: cite the source. The cost is a filename + one warrant sentence; the discipline compounds across every future assertion in every consumer repo.
+
+## Refs
+
+- bassclef-upstream#559 — R8 mechanization umbrella (this rule closes at class level)
+- bassclef-upstream#582 — parent ticket for this rule + hook
+- bassclef-upstream#564 — narrow-surface precedent (compounding-axis columns)
+- ADR-035 substrate-as-system tenet — rule + mechanism paired
+- `chronicle/2026-07-01c-r8-cascade-audit-retraction-and-cure-prep.md` — 5+ R8 catches this session; audit retraction pattern named
+- `chronicle/2026-06-30d-post-session-end-appendix.md` — 5 prior R8 catches
+- `chronicle/2026-07-26d-cures-2-3-5-shipped.md` — surfaced the scope-enumeration miss (#884 already-done recommended as 20-40 turn work); motivates the extension shipped in bet 2026-07-26g
+- bassclef-upstream#916 — this rule's scope-enumeration extension ticket
+- Toulmin — *The Uses of Argument* (Cambridge, 1958)
+- Popper — *The Logic of Scientific Discovery* (Hutchinson, 1959)
+- Peirce — "Deduction, Induction, and Hypothesis" (*Popular Science Monthly*, 1878)
+
+## Retirement condition
+
+This rule retires only if R8 (assertion without verification) stops reproducing across sessions. The mechanical layer (UserPromptSubmit hook) may evolve — additional detection heuristics, PR-body scan extensions, retroactive audit sweeps — but the discipline of My claim + Evidence + Why the evidence supports the claim (Toulmin's shape) at reasoning origin persists.