@thebassclef/lite 0.1.0 → 0.1.2

package/substrate/standards/reserved-skill-names.md

@@ -0,0 +1,120 @@
+---
+tier: lite
+description: Bassclef MUST NOT create a skill with a name that Claude Code (the harness) already claims.
+---
+
+# Reserved Skill Names
+
+Bassclef MUST NOT create a skill with a name that Claude Code (the
+harness) already claims. Operator typing `/<name>` resolves to the
+harness built-in, not bassclef's skill — producing silent behavioral
+drift.
+
+This file is the **list**. The rule that references it lives at
+`.claude/rules/reserved-skill-names.md`. Separating the two lets the
+list evolve with Claude Code releases without churning the rule.
+
+## Reserved names (as of 2026-04-18)
+
+Source: Claude Code harness built-in skill registry observed in-session.
+
+### Claude Code operational built-ins
+
+These are always resolved by the Claude Code harness and will never
+reach bassclef's skill registry:
+
+| Name | Purpose (per harness) |
+|------|----------------------|
+| `update-config` | Configure Claude Code harness via settings.json |
+| `keybindings-help` | Keyboard shortcut customization |
+| `simplify` | Review changed code for reuse/quality |
+| `fewer-permission-prompts` | Scan transcripts + prioritize allowlist |
+| `loop` | Recurring prompt / slash-command execution |
+| `schedule` | Scheduled remote agents (triggers) |
+| `claude-api` | Build/debug Claude API / SDK apps |
+
+### Claude Code "FEY" remote built-ins
+
+Sourced from `FEY` array in Claude Code `cli.js`:
+
+| Name | Purpose (per harness) |
+|------|----------------------|
+| `autopilot` | Autopilot mode |
+| `bugfix` | Remote bugfix workflow |
+| `dashboard` | Remote dashboard |
+| `docs` | Docs workflow |
+| `investigate` | Investigation workflow |
+
+### Claude Code init/setup
+
+| Name | Purpose (per harness) |
+|------|----------------------|
+| `init` | Initialize a new CLAUDE.md file |
+| `review` | Review a pull request |
+| `security-review` | Security review of pending changes |
+
+## What the rule enforces
+
+Any new `.claude/skills/<name>/SKILL.md` introduced by a PR MUST NOT
+use a name from this list. The pre-commit hook blocks commits that
+add a colliding directory. See `.claude/rules/reserved-skill-names.md`
+for full enforcement semantics.
+
+## Updating this list
+
+Triggers that justify adding a name:
+
+- New Claude Code release adds a slash-command built-in not listed here
+- Observed behavioral drift where a bassclef skill name was silently
+  overridden by the harness
+- Upstream Anthropic documentation announces a reserved prefix or name
+
+Process:
+
+1. Verify the collision exists (type `/<name>` in a clean session,
+   observe the harness responds without reaching bassclef)
+2. Add the row to the table above with purpose description
+3. Bump the date in the heading ("as of YYYY-MM-DD")
+4. File a bassclef issue if any existing bassclef skill uses the
+   newly-colliding name — that skill MUST be renamed before the rule
+   addition merges
+
+## Verification
+
+Test case for the pre-commit hook lives at
+`.claude/hooks/tests/reserved-names-test.sh`. Run via:
+
+```bash
+bash .claude/hooks/tests/reserved-names-test.sh
+```
+
+Tests:
+- Hook blocks commit staging `.claude/skills/docs/SKILL.md` (collision)
+- Hook permits commit staging `.claude/skills/docs-v2/SKILL.md` (no collision)
+- Hook respects `SKIP_RESERVED_NAMES=1` override
+
+## Override
+
+Rare case: bassclef deliberately wants to shadow a harness built-in
+(e.g., wraps or replaces the built-in). Requires:
+
+1. Explicit operator confirmation in PR body
+2. `SKIP_RESERVED_NAMES=1` env var on the commit
+3. Rationale documented in the skill's SKILL.md frontmatter
+
+The override exists because rules should not be unjudgeable — but the
+friction is deliberately high.
+
+## Relationship to other standards
+
+- `standards/substrate-config-schema.md` — external resource reference
+  conventions (orthogonal)
+- `.claude/rules/reserved-skill-names.md` — the rule that reads this list
+- `.claude/hooks/pre-commit-gate.sh` — mechanical enforcement
+
+## When to retire this list
+
+If Claude Code ships a mechanical API to query reserved names at
+runtime (e.g., `claude --list-builtins --json`), this static list can
+be replaced with a dynamic check. Until then, the list is the
+interface.

package/substrate/standards/scannable-multi-option-output.md

@@ -0,0 +1,261 @@
+---
+tier: lite
+standard: scannable-multi-option-output
+status: accepted
+authoring_luminaries:
+  primary:
+    - don-norman
+    - sophia-prater
+  supporting:
+    - jesse-james-garrett
+    - edward-tufte
+description: Design principles for skills that render multi-option choice surfaces (e.g.
+---
+
+# Scannable multi-option output
+
+Design principles for skills that render multi-option choice surfaces (e.g. `/longrun prep`, `/sprint` Step 7). The principles below apply when the output stacks 3-5 tables covering options + trade-offs + steps and the operator needs to scan + pick fast.
+
+## Sources read
+
+- `.claude/luminaries/don-norman.md` — signifiers + mapping + feedback + constraints
+- `.claude/luminaries/jesse-james-garrett.md` — five planes of UX (strategy + scope + structure + skeleton + surface)
+- `.claude/luminaries/sophia-prater.md` — OOUX (objects first) + progressive disclosure
+- `.claude/luminaries/edward-tufte.md` — data-ink ratio + small multiples + sparklines + glyph encodes data
+- `docs/personas/sam.md` L33 — "I skim first, dig second, bail third."
+- `docs/personas/2026-07-12-bet11c-louis.md` L25 — "Skims group headings first."
+- Ticket #853 — the filing case for this discipline
+- Bet 24e — this extension adds Tufte + Prater + card template + glyph legend + progressive disclosure
+
+## Readers we design for
+
+Two personas set the bar.
+
+- **Sam** has a 15-30 min Saturday budget. He bounces on friction. He skims, digs, bails.
+- **Louis** skims group headings first. He opens a section only when this week's work needs it.
+
+Both punish output that hides structure or repeats content across tables.
+
+## The Norman + Garrett debate
+
+### Norman on signifiers + feedback
+
+Sam bounces on friction. His scan budget cannot afford re-reading the same table twice. Louis skims headings first. Headings ARE the affordance. No heading means no affordance. Signifiers must be OBVIOUS on first scan.
+
+On a refinement, delta rendering IS the feedback loop. Silent rebuild breaks the loop.
+
+Mapping — one anchor for one concern. Never one anchor for three tables.
+
+### Garrett on the five planes
+
+Stacked tables live at the skeleton plane. That is where things are placed.
+
+A first-cut prep output mixes four planes in one visual block. Strategy plus scope plus structure plus skeleton. Mixed planes break the five-planes rule.
+
+Give each plane its own `###` anchor. Reader scans anchors. Reader opens the one they need.
+
+## The Tufte + Prater debate (bet 24e extension)
+
+### Prater on OOUX
+
+Each option is an object. Each object has attributes — Problem, Value, Compounds, Adopter, Risk. Rendering one attribute per table forces the reader to reassemble the object in their head. Schema-mirror UX. The interface should mirror the reader's mental model.
+
+One card per option. Object first. Attributes inline with bold labels. Progressive disclosure — options at first glance; step detail expands only for the option the reader picks.
+
+### Tufte on data density
+
+The 5-table stack is chartjunk. Every cell repeats option labels + carries one axis. Data-ink ratio is low. Same shape repeated per option is small multiples — belongs in one dense structure.
+
+Glyphs encode data, not decoration. Color IS the data (🟢 low / 🟡 medium / 🔴 high). Sparkline analog — a single glyph beats a cell full of prose.
+
+Progressive disclosure serves data-ink too. Do not render step detail for options the operator will not pick.
+
+## Synthesized principles
+
+Twelve principles the four lenses agreed on. Skills that render multi-option surfaces MUST follow them.
+
+1. **One anchor per concern.** `###` header before each block. Anchor names the plane or concern.
+2. **Bold anchor pattern for sub-blocks.** Where an `###` header would be too heavy, use bold anchor plus blank line.
+3. **Delta rendering on refinements.** When operator asks "add column X", render ONLY the new column with reference to the source anchor by name.
+4. **Horizontal rule between planes.** `---` separates strategy from structure from skeleton. Not between every table.
+5. **Whitespace floor.** At least 2 blank lines OR one HR between top-level anchors.
+6. **Recommendation always at end.** One sentence citing compounding sequence + risk class.
+7. **Compact scan-table first** (Tufte). 4-6 columns, one row per option, glyphs encode risk + compounding rate. Reader scans + picks in 20-30 seconds.
+8. **One card per option** (Prater OOUX). Each card carries Problem + Value + Compounds + Adopter + Risk inline with bold labels.
+9. **Steps rendered only for the recommended option** (Prater + Tufte). Progressive disclosure. Not for all 3 options.
+10. **Problem + Value inline in every option card AND every step card.** Names the user pain the option or step addresses.
+11. **Glyphs encode data, not decoration** (Tufte chartjunk rule). Only glyphs that carry a signal ship.
+12. **Delta rendering as inline callout** — "Added: change class (delta on § Options above)" + small table with only the delta cells.
+
+## Card template
+
+Every option card ships in this shape:
+
+```
+### <label> · <scope> · <turns> · <risk glyph> <risk word>
+
+**Problem** — <one sentence naming the user pain this option addresses>
+**Value** — <one sentence naming what the operator gets>
+**Compounds** — <axis 1> · <axis 2> · <axis 3> · <axis 4> · <axis 5>
+**Adopter** — <mechanism> · <visibility> · <action required>
+```
+
+Every step card ships in this shape:
+
+```
+### Step <N> · <slug> · <turns> · <risk glyph> <risk word>
+
+**Problem** — <one sentence naming the pain this step solves>
+**Produces** — <artifact path or decision>
+**Consumes** — <prior step + shared state>
+**Teaches** — <pattern later work reuses>
+```
+
+## Glyph legend
+
+Only glyphs that encode data. No decoration.
+
+| Glyph | Meaning |
+|---|---|
+| 🟢 | low risk |
+| 🟡 | medium risk |
+| 🔴 | high risk |
+| · | axis separator inside an inline value list |
+| § | reference to a named section anchor in delta callouts |
+
+Words carry compounding rate — `per-adopter`, `per-session`, `one-time`, `per-quarter`. Arrows and other decorative glyphs stay OUT.
+
+## Progressive disclosure — the rule
+
+Compact scan-table + per-option cards render for ALL options. Step cards render ONLY for the recommended option.
+
+When operator picks a different option, step cards for that option render on the next turn. On operator ask ("show steps for B and C too"), expand for all.
+
+Rationale — data-ink and reader attention are finite. Rendering steps for options the operator will not pick is chartjunk.
+
+## Delta rendering — the anti-pattern and the cure
+
+Silent rebuild:
+
+> Operator — "add a change-class column"
+> Agent — re-renders all 4-5 tables verbatim plus one new column
+
+Named delta:
+
+> Operator — "add a change-class column"
+> Agent — "Adding column to § Options above:"
+> [renders only the new column with the option labels]
+
+Full re-render is correct only when the operator asks for it explicitly ("show me the full picture again") OR the underlying option set changed.
+
+## When to apply this standard
+
+- `/longrun prep` — Steps 1.4c + 1.4d cite this standard
+- `/sprint` Step 7 — Steps 7a + 7b cite this standard
+- Any future skill that renders 3+ option tables with trade-offs
+
+## Canonical example — recommendation-first shape (per bassclef-web#152)
+
+The example below shows the shape the substrate targets. Reader sees the pick in the first 15 lines. Scan table follows. Card for the recommended option only.
+
+### Anti-pattern — decision buried below 5-axis blocks
+
+```
+[Three-block opener — Problem + Value + Evidence]
+
+## Options
+
+| Option | Scope | Turns | Compounds | Risk |
+|---|---|---|---|---|
+| a | Full six-amendment ship | 150-250 | per-session | med |
+| b | Narrow four amendments | 100-150 | per-session | low |
+| c | Adjacent install.sh | 40-80 | per-adopter | med |
+
+## Compounding value per option
+
+**Option a:** [5-axis block, ~10 lines]
+**Option b:** [5-axis block, ~10 lines]
+**Option c:** [5-axis block, ~10 lines]
+
+## Recommended card for Option a
+
+[Card ~15 lines]
+
+## Steps for Option a
+
+[Step cards ~20 lines]
+
+## Recommendation
+
+Recommend Option a because Y.
+
+Reply a, b, or c.
+```
+
+Reader scrolls past ~80 lines of options + axes + cards + steps before reaching the pick.
+
+### Conformant — recommendation first, cards on demand
+
+```
+[Three-block opener — Problem + Value + Evidence]
+
+## Recommendation
+
+**Recommend:** Option a (six-amendment ship · 150-250 turns · risk 🟡) because per-session compounding beats Option c's per-adopter frequency, and Option b defers /build value by one cycle.
+
+## Options
+
+| Option | Scope | Turns | Compounds | Risk | Why not (non-rec.) |
+|---|---|---|---|---|---|
+| a | Full six-amendment ship | 150-250 | per-session | 🟡 | rec |
+| b | Narrow four amendments | 100-150 | per-session | 🟢 | drops /build value |
+| c | Adjacent install.sh | 40-80 | per-adopter | 🟡 | drops baseline branch |
+
+## Compounding value per option
+
+[5-axis block per option — same as anti-pattern; hook postcondition per compounding-sequence-fresh-analysis.md requires per-option coverage today; hook extension to recommended-only lives at follow-on ticket per bassclef-web#152]
+
+## Recommended · full · 150-250t · 🟡
+
+[Card — Problem / Value / Compounds / Adopter — for Option a only]
+
+## Steps for Option a
+
+[Step cards — for Option a only]
+
+Reply a, b, or c. Ask for "cards for B and C" to expand.
+```
+
+Reader sees the pick in the first 8 lines. Scan table follows for context. Cards + step cards on demand for non-recommended.
+
+### Anchor luminaries for the reshape
+
+- **Sophia Prater (OOUX + progressive disclosure)** — recommended card renders by default; non-recommended cards expand on operator ask
+- **Donald Norman (signifier)** — the recommendation sentence IS the signifier for the decision; place it where the eye lands first
+- **Edward Tufte (data-ink)** — glyphs (🟢/🟡/🔴) encode risk in one character per scan-table cell; drops paragraph prose per option
+- **Jason Fried (say less)** — non-recommended options ship rationale in the `Why not` column; no per-option card
+- **Amazon PR/FAQ (decision at top)** — working-backwards discipline; reader sees "we recommend X because Y" first
+
+### Table character class
+
+Scan-table cells contain plain alphanumerics per `.claude/rules/visual-hierarchy.md` Section 12. Avoid em-dashes, backticks, quotes, or Unicode ellipsis in cells — Claude Code TUI falls back to key-value paragraphs when these characters appear. Cure per character in the sister rule catalog.
+
+## Refs
+
+- Ticket #853 — the filing case
+- `.claude/luminaries/don-norman.md`
+- `.claude/luminaries/jesse-james-garrett.md`
+- `.claude/luminaries/sophia-prater.md`
+- `.claude/luminaries/edward-tufte.md`
+- `docs/personas/sam.md`
+- `docs/personas/2026-07-12-bet11c-louis.md`
+- `.claude/skills/longrun/SKILL.md` Steps 1.4c + 1.4d + 1.5-1.7 (card refactor)
+- `.claude/skills/sprint/SKILL.md` Steps 7a + 7b (parity)
+- ADR-040 Decision 4 (SKILL body template shape — this standard offloads the debate content from SKILL bodies to keep template lean)
+- Bet 24d — original filing (principles 1-6)
+- Bet 24e — this extension (principles 7-12 + card template + glyph legend + progressive disclosure)
+- bassclef-web#152 — recommendation-first canonical example (adopter promote landing 2026-08-25)
+
+## Retirement
+
+Retires only if multi-option surfaces cease to be a bassclef output pattern.

package/substrate/standards/sdlc-gates/typescript.md

@@ -0,0 +1,57 @@
+---
+tier: lite
+description: Stack-specific instantiation of .claude/rules/sdlc-gates.md for TypeScript.
+---
+
+# SDLC Gates — TypeScript
+
+Stack-specific instantiation of `.claude/rules/sdlc-gates.md` for TypeScript. Composed under ARCH-T0 #1133 Path A.
+
+## When this sibling fires
+
+When adopter's `.claude/bassclef-configs.jsonc` has `tech_stack.lang: typescript`. The loader (future ticket) reads this sibling and applies the TypeScript-specific globs in addition to the universal gates in the parent rule.
+
+Until the loader ships, this sibling is discoverable via the cross-reference table in the parent rule. The universal gates fire methodologically regardless of stack.
+
+## TypeScript-specific globs
+
+```yaml
+globs:
+  - src/**/*.ts
+  - src/**/*.tsx
+  - scripts/**/*.ts
+```
+
+These globs scope hook + tooling firing to TypeScript source files. The pre-build temperance + diagnose gates fire on these path matchers; the post-build `/verify` gate runs against these files.
+
+## TypeScript-specific tech_stack_match
+
+```yaml
+tech_stack_match:
+  lang: typescript
+  backend: nodejs
+```
+
+For adopter configs that opt into the per-stack loader, this match field anchors the sibling to the right adopter declaration in `.claude/bassclef-configs.jsonc`.
+
+## TypeScript-specific verify hooks
+
+When the universal `/verify` gate fires post-build (per the parent rule), TypeScript-specific checks include:
+
+- `tsc --noEmit` for type-checking
+- `eslint` for static-analysis
+- `vitest run` for unit tests
+- (Optional, per adopter) `prettier --check` for formatting
+
+The adopter's `package.json` scripts wire these into the `/verify` invocation.
+
+## Composition with universal gates
+
+Apply the universal gates from `.claude/rules/sdlc-gates.md` first; the TypeScript-specific globs above add file-scoping detail. When the two conflict (e.g., a TypeScript-specific check contradicts the universal failure-chain rule), the universal principle wins; file a `/promote` ticket if you believe the convention should be amended.
+
+## Refs
+
+- Parent rule: `.claude/rules/sdlc-gates.md`
+- ARCH-T0 #1133 — operator-stack-leakage audit + remediation
+- bassclef#1311 — this sibling (sdlc-gates Path A WU-7 of bet 2026-06-20e)
+- bassclef#1309 — sister Path A (api-conventions WU-6)

package/substrate/standards/session-board.md

@@ -0,0 +1,256 @@
+---
+tier: lite
+description: The session-board is a session-level coordinator artifact for multi-bet longrun sessions.
+---
+
+# Session-Board Standard
+
+The session-board is a session-level coordinator artifact for **multi-bet
+longrun sessions**. It tracks state across N bets simultaneously so a
+mid-session pickup is resumption from a known state, not reconstruction
+from `gh pr list` plus N stack manifests plus operator memory.
+
+## When required
+
+A session-board MUST exist when **either** holds:
+
+1. **Multi-bet** — ≥2 active iteration goals in the session
+2. **Multi-phase** — ≥2 phases of a single bet active in the same session
+   (rare, but possible when a bet's phase gate clears mid-session and the
+   operator rolls into the next phase without ending the session)
+
+Singleton-bet single-phase sessions do NOT require a session-board. The
+existing primitives are sufficient:
+
+- `docs/whereami.md` — current state snapshot
+- `docs/iteration-bets/<slug>.md` — scope contract
+- `docs/branch-stacks/<slug>.md` (or `docs/stacks/<slug>-stack.md`) —
+  per-bet stack manifest
+
+The session-board adds overhead. If you don't need it, don't write it.
+
+## Why this artifact exists
+
+For multi-bet sessions, today's primitives leave a coordinator gap. If
+an overnight session dies on branch 9 of 17 across 3 bets, the next
+session reconstructs state from `gh pr list` + reading 3 stack manifests +
+trying to remember which bet was active when context was lost.
+
+That's "rebuild map from artifacts" — exactly the failure mode
+`docs/whereami.md` was created to prevent at the project level. The
+session-board is the same prevention at the session level.
+
+The plural `active_sessions:` registry in whereami (proposed in pipeline
+bet Phase A WS-2) is the **index**; the session-board is the **per-session
+detail** the index points to.
+
+## Location
+
+`docs/sessions/<YYYY-MM-DD>-<slug>.md` — one file per session.
+
+The slug describes the session's shape, not its content. Examples:
+- `2026-04-26-longrun.md` — multi-bet longrun
+- `2026-05-03-overnight-pipeline-phase-b.md` — single-bet multi-phase overnight
+
+## Schema
+
+### Frontmatter
+
+```yaml
+---
+session_id: <YYYY-MM-DD>-<slug>
+session_started: <ISO-8601 UTC>
+session_ended: <ISO-8601 UTC OR null while in-flight>
+session_outcome: <short string OR null while in-flight>
+mode: <gating>-<execution>   # e.g. orchestrator-gated-sequential
+operator: <github-username>
+trigger: <one-line reason this session needed a board>
+active_bets:
+  - slug: <bet-slug-without-extension>
+    phase_in_flight: <phase identifier OR "single" for non-phased bets>
+    appetite_turns: <integer>
+    stack_manifest: <path to stack manifest>
+session_turn_budget: <integer — sum of bet appetites + buffer>
+session_warning_threshold: <integer — typically 75% of budget>
+---
+```
+
+### Body sections (all required)
+
+**`# Session board — <slug>`** — top-level heading
+
+**`## Sources read`** — every artifact the session-board reader reads
+during pickup (per `.claude/rules/artifact-ingestion.md`). At minimum:
+each bet, each stack manifest, the survival kit (per
+`.claude/rules/context-management.md`), and any /promote issues filed in
+this session.
+
+**`## Active bets — quick reference`** — table summarizing the goal.,
+their phase, turn budget, and independence relationships:
+
+```markdown
+| Bet | Phase | Turns | Independence |
+|---|---|---|---|
+| <bet> | <phase> | <n> | <how-disjoint-from-others> |
+```
+
+Plus a **scope-disjointness** declaration: list which file paths each
+bet touches. If two bets touch the same paths, they are NOT
+parallel-safe and the session board MUST note the sequencing rule.
+
+**`## Per-WS status`** — table of every workstream across every bet:
+
+```markdown
+| Bet | WS | Branch | Status | PR | Notes |
+|---|---|---|---|---|---|
+| <bet> | <ws-id> | <branch-name> | todo \| in-flight \| pr-open \| merged \| rejected | <#NN OR —> | <one-line> |
+```
+
+This is the **work breakdown across all bets** — the artifact a
+post-compaction or next-session pickup reads first to know what's done
+and what's next.
+
+**`## Compaction anchors`** — checkpoints that drive context-management
+decisions:
+
+- **Last compaction**: ISO-8601 timestamp OR "none yet"
+- **Last `/temperance` firing**: timestamp + scope (kickoff / scope-decision / etc.)
+- **Last phase completed**: bet + phase identifier OR "none"
+- **Survival kit declared**: bullet list of files to re-read after
+  compaction. MUST include this session-board file itself.
+
+**`## Session-level /temperance — anchored at kickoff`** — the
+right-thing / right-way / scope-drift-trigger answers from the kickoff
+firing. Any subsequent `/temperance` re-firings during the session are
+appended in the operator decision log below.
+
+**`## Phase-boundary checkpoints scheduled`** — table of when the
+session will checkpoint:
+
+```markdown
+| When | Action |
+|---|---|
+| <trigger condition> | <what fires: re-temperance / update board / /sprint / etc.> |
+```
+
+**`## Operator decision log`** — chronological record of mid-session
+pivots, scope changes, re-anchors, scope-drift triggers. Each entry is
+ISO-timestamped and one-or-two-sentence:
+
+```markdown
+- <ISO-ts> — <decision summary>
+```
+
+This is the audit trail when the next session asks "why did the operator
+pivot from WS-3 to WS-7 mid-session?"
+
+**`## Closeout audit checklist`** — final checks at session end. Owned
+by `/longrun closeout` when that skill exists; until then, manually run.
+
+**`## Out of scope this session`** — explicit deferrals, with the rule:
+"if any of these activate, fire `/longrun checkpoint --now` and
+re-anchor."
+
+## Lifecycle
+
+| Stage | Trigger | Action |
+|---|---|---|
+| Create | `/longrun prep` (or manual scaffold from template) at session start | Write file with frontmatter + populated bets/WSes |
+| Update | Each WS status change (todo → in-flight → pr-open → merged) | Edit the matching row in `## Per-WS status` |
+| Update | Each compaction event | Append to `## Compaction anchors` |
+| Update | Each operator pivot / scope decision | Append to `## Operator decision log` |
+| Close | `/longrun closeout` at session end | Set `session_ended` + `session_outcome` in frontmatter; run closeout audit checklist |
+
+The board is **append-mostly** — old entries are not edited or
+backfilled. The only mutations are status table cells and frontmatter
+close fields. This preserves audit trail.
+
+## Composition with existing primitives
+
+- **`docs/whereami.md`** — project-state snapshot (load-bearing per
+  `.claude/rules/whereami-load-bearing.md`). Session-board adds
+  session-level detail; whereami stays the project-level index. After
+  the pipeline bet's WS-2 ships, whereami's `active_sessions:` registry
+  will point at session-boards by file path.
+- **`docs/iteration-bets/<slug>.md`** — scope contract per bet. The
+  session-board references each active bet's path; never duplicates the
+  bet's content.
+- **`docs/branch-stacks/<slug>.md`** (or `docs/stacks/<slug>-stack.md`)
+   — per-bet stack manifest. Session-board references each manifest
+  path; the WS table aggregates across bets but each WS row points to
+  the per-bet manifest as authority.
+- **`chronicle/<date>-<slug>.md`** — retrospective narrative. Orthogonal
+  to the session-board (chronicle is what-happened; session-board is
+  what's-happening-now). At session close, the chronicle MAY cite the
+  session-board as evidence; the chronicle does NOT replace it.
+
+## Relationship to `/longrun` skill
+
+The `/longrun` skill (separate /promote, bassclef#274) consumes this
+standard. Specifically:
+
+- **`/longrun prep`** — writes the initial session-board from the
+  template
+- **`/longrun checkpoint`** — updates `## Per-WS status` + appends to
+  `## Operator decision log`
+- **`/longrun closeout`** — runs the audit checklist + sets close
+  frontmatter fields
+
+Until `/longrun` ships (after Phase A0 of the pipeline bet), session
+boards are written and updated manually using the template.
+
+## Anti-patterns
+
+**Don't write a session-board for a singleton-bet session.** It adds
+overhead without coordination value. Singleton-bet pickup uses
+whereami + bet + stack manifest; that's sufficient.
+
+**Don't duplicate bet content into the session-board.** If you find
+yourself copying a bet's scope or risk register into the session-board,
+stop — reference the goal path instead. The session-board is index +
+status, not content.
+
+**Don't silently retire or merge bets without updating the board.** The
+status table is the source of truth for "what's alive." If a WS is
+merged but the table still says `pr-open`, next-session pickup will be
+confused.
+
+**Don't backfill `## Operator decision log` after the fact.** The log is
+append-only and timestamped. If a decision was missed at the time it
+was made, append a current-time entry noting "retrospective: <summary>"
+rather than fabricating a prior timestamp.
+
+## Enforcement
+
+Methodology-level today. The `/longrun` skill, when shipped, will
+enforce session-board presence on `/longrun prep` for any session
+declaring multi-goal scope. Until then, agent self-checks at session
+start: "Am I about to manage ≥2 bets simultaneously? If yes, write a
+session-board before starting work."
+
+## Override
+
+Singleton-bet or single-phase sessions skip this artifact entirely. No
+override needed — the trigger condition (multi-bet OR multi-phase) is
+the only entry. If neither holds, the session-board is not the right
+tool.
+
+## Retirement condition
+
+If multi-bet longrun sessions are abandoned as a pattern (operator
+prefers strict one-bet-per-session discipline), this standard retires
+along with the `/longrun` skill. Until then, this standard is
+load-bearing for any session that triggers the conditions above.
+
+## Relationship to other standards/rules
+
+- `standards/branch-stacking.md` — per-bet stack manifest pattern; this
+  standard adds the session-level layer above it
+- `.claude/rules/whereami-load-bearing.md` — project-level state
+  artifact; this standard is the session-level peer
+- `.claude/rules/artifact-ingestion.md` — the `## Sources read` block
+  pattern this standard's body uses
+- `.claude/rules/context-management.md` — survival kit declaration in
+  `## Compaction anchors` is the post-compaction re-read list
+- bassclef#274 — `/longrun` skill (consumes this standard)
+- bassclef#273 — promotion issue this standard closes