@thebassclef/lite 0.1.0 → 0.1.2

package/substrate/.claude/rules/turn-estimate-grounding.md

@@ -0,0 +1,134 @@
+---
+tier: lite
+description: "Plain check: Before I ship a turn estimate to an adopter, I cite a past bet's actuals + write a range + name the shape."
+---
+
+# Turn-Estimate Grounding
+
+**Plain check:** Before I ship a turn estimate to an adopter, I cite a past bet's actuals + write a range + name the shape. Ungrounded numbers do not ship.
+
+---
+
+Every turn estimate that lands in adopter-facing prose (goal docs, PR bodies, canvases, ticket bodies) carries three parts:
+
+1. **Source** — cite a past bet's closeout actuals with comparable scope shape (WU count, test-heavy vs docs-heavy, defect diagnosis interludes)
+2. **Range not point** — write a range (e.g., "40-80 turns") not a point ("60 turns")
+3. **Plain-language framing** — name the shape driving the number in one sentence
+
+Ungrounded turn estimates do not ship to adopter-facing prose. This rule extends the argument shape from `.claude/rules/assert-only-after-verify.md` to numeric claims. It applies at the same reasoning surface — the moment a number gets written down for an adopter to read.
+
+## When this rule fires
+
+Every time budget estimate, turn count, or effort range that lands in prose an adopter will read:
+
+- `docs/iteration-bets/*.md` frontmatter `appetite:` line
+- `docs/iteration-bets/*.md` body when narrative surfaces a number
+- PR body `Test plan` or `Summary` sections when they cite effort
+- `docs/canvases/*.md` sizing sections
+- Ticket body `Estimate` fields (INVEST format uses S/M/L; this rule fires when a turn count appears instead)
+- Chronicle time-budget actuals sections when they cite the filed number
+- Journal drafts when they cite bet actuals for a past bet
+
+Does NOT fire on:
+
+- **Chronicle body actuals** for a past bet (backward-looking; the number IS the source itself)
+- **Operator-only surfaces** — internal chronicles, private strategy docs, session-timing markers
+- **Runtime numbers** at checkpoint or closeout time — those cite what happened, not what will happen
+
+## What the rule requires
+
+Before any turn estimate ships to adopter-facing prose:
+
+1. **Cite a past bet by path** — one or two bets whose closeout actuals inform this estimate. Format: `bet 2026-07-09c (5 WUs; heavy test setup; ~110 turns actual)`. Path optional but preferred when the calibration goal is recent.
+2. **Write a range** — the range spans enough to cover the estimate's uncertainty. A 40-80 turn range signals the shape is well-understood but has natural variance. A 200-600 turn range signals real uncertainty and prompts the operator to consider splitting the goal.
+3. **Name the shape** — one sentence stating what drives the number. Examples: "documentation-heavy; single-file SKILL edit + rule text," "5 WUs riding a shared fixture; each cure ships end-to-end with 10-15 Tier 0 tests," "test-first Beck TDD with 4 substantive WUs sharing a fixture foundation."
+
+## Worked examples
+
+### Anti-pattern (what NOT to do)
+
+```yaml
+appetite: 500-700 turns
+```
+
+Ungrounded. Range too wide. No shape named. Adopter reads this and either dismisses the goal as heavyweight or trusts an ungrounded number.
+
+### Anti-pattern (point estimate)
+
+```yaml
+appetite: 250 turns
+```
+
+Point not range. False precision. No source cited.
+
+### Anti-pattern (source-free range)
+
+```yaml
+appetite: 40-80 turns
+```
+
+Range is fine but ungrounded. Adopter has no way to check if 40-80 is realistic.
+
+### Conformant pattern
+
+```yaml
+appetite: 40-80 turns
+appetite_source: "bet 2026-07-09d (documentation-heavy adopter polish; 2 substantive WUs; ~30 turns actual). Similar shape — single-file SKILL edit + rule text; no new test infrastructure."
+```
+
+Or in narrative form:
+
+> **Appetite:** 40-80 turns. Similar shape to bet 09d (~30 turns actual for 2 WUs of single-file SKILL edits + rule text). This bet adds one more WU so the top of the range widens.
+
+Both forms carry source + range + shape.
+
+## Trivial-fix exception
+
+Fix branches and quick-fix PRs may skip the discipline when the change is under 10 lines AND no goal doc time budget line is being authored. Silence about effort is fine on trivial fixes.
+
+## Adopter-friendly framing
+
+Numbers can be honest AND friendly. Instead of:
+
+> "This goal needs 500-700 turns"
+
+Prefer:
+
+> "This bet groups 5 substantive changes. Past bets of this shape landed around 100-350 turns. The wider top of the range covers defect diagnosis interludes that add 30-50 turns per step when they fire."
+
+The friendly version:
+- Cites a past shape ("bets of this shape landed around 100-350")
+- Names the shape driver ("5 substantive changes")
+- Explains the top-of-range variance ("defect diagnosis interludes")
+
+## Composes with
+
+- `.claude/rules/assert-only-after-verify.md` — parent discipline; this rule extends argument shape to numeric claims
+- `.claude/rules/plain-english-discipline.md` — grade 8 target with grade 10 ceiling; friendly numbers pass the same reading-level test as prose
+- `.claude/rules/pr-body-shape.md` — Test plan and Summary sections that cite effort follow this rule
+- `.claude/rules/pr-title-shape.md` — sister at title surface
+- `.claude/skills/longrun/SKILL.md` Step 1 pre-flight — cites this rule at time budget estimation
+- @luminary stephen-toulmin — argument shape (claim + evidence + why the evidence supports the claim)
+- @luminary karl-popper — falsifiability (grounded estimates check against past actuals; ungrounded ones cannot be checked)
+- Memory `feedback_no_token_estimates.md` — sister at token-estimate surface
+- Memory `feedback_tight_ticket_appetite.md` — calibration for infra tickets
+- Memory `feedback_longrun_appetite_estimates_too_tight.md` — calibration for WU-heavy bets (3-4x off pattern)
+
+## Override
+
+`SKIP_TURN_ESTIMATE_GROUNDING=1` — logged via trace-helper. Use only when quoting an external number verbatim (e.g., citing a Shape Up appetite from Basecamp's book).
+
+INSTEAD of overriding for routine work: cite the past bet. The cost is one sentence; the discipline compounds across every future adopter who reads a goal doc.
+
+## Refs
+
+- sunj-labs/bassclef-upstream#670 — this rule's filing ticket
+- sunj-labs/bassclef-upstream#559 — R8 mechanization umbrella (parent argument-shape work)
+- sunj-labs/bassclef-upstream#582 — assert-verify-steering hook (sister at prose-scan surface)
+- Bet 2026-07-09e — this rule's ship vehicle (eats own dogfood on the time budget line)
+- Toulmin — *The Uses of Argument* (Cambridge, 1958)
+- Popper — *The Logic of Scientific Discovery* (Hutchinson, 1959)
+
+## Retirement condition
+
+This rule retires only if goal docs stop surfacing turn estimates in adopter-facing prose. A mechanical layer (Stop hook that scans goal doc frontmatter for ungrounded time budget lines) may ship as a follow-on when methodology drift is observed. Until then, this rule is methodology; the discipline holds at reasoning origin per ADR-035 substrate-as-system tenet.

package/substrate/.claude/rules/visual-hierarchy.md

@@ -0,0 +1,437 @@
+---
+tier: lite
+description: Long agent responses that mix summary + analysis + enumeration + action become walls of text.
+---
+
+# Visual Hierarchy in Agent Output
+
+Long agent responses that mix summary + analysis + enumeration + action
+become walls of text. Operators scan on mobile and multi-pane desktop;
+walls of text force re-reading. Use markdown primitives to create
+scannable separation.
+
+## When this rule fires
+
+Fires on any agent response that:
+
+- Is longer than ~5 paragraphs, OR
+- Mixes more than one of: summary, analysis, enumeration, actions, questions
+
+Does NOT fire on:
+
+- Short answers (<3 sentences)
+- Single-action replies
+- Tool-output relays
+- Code diffs or file contents
+
+## The conventions
+
+### 1. TL;DR at the top (when response has conclusions before detail)
+
+Set off as a bold callout or blockquote, not a plain paragraph:
+
+```markdown
+> **TL;DR:** one-line conclusion the operator needs even if they read nothing else.
+```
+
+Not every response needs one. Use when the operator benefits from the
+conclusion before the reasoning.
+
+### 2. Section headers for distinct parts
+
+Use `##` with consistent category labels:
+
+```markdown
+## Summary
+## Analysis
+## Actions
+## Next
+```
+
+Pick the labels that match the response shape.
+
+INSTEAD of forcing all four headers when only two apply: use only the
+ones that match (e.g., just `## Summary` and `## Next` for a status
+update; just `## Analysis` for a diagnostic).
+
+### 3. Horizontal rules between large sections
+
+`---` separates major sections visually. Use when sections are long
+enough that the reader would benefit from a clear break.
+
+### 4. Bold category labels in lists
+
+When enumerating buckets (MUST / SHOULD / COULD, Tier 1 / Tier 2,
+Option A / Option B):
+
+```markdown
+**Tier 1 — Must-fix (N)**
+- #NN — title
+- #NN — title
+
+**Tier 2 — Should-fix (N)**
+- #NN — title
+```
+
+Category labels in bold, content under them.
+
+**Prose enumeration shape.** When a paragraph enumerates 3-5 items
+inline (not as a list), each item opens with a bold lead followed
+by an em-dash and the item's expansion. The bold lead names the
+item; the em-dash separates label from body.
+
+**Anti-pattern:** flat prose enumeration with no scan anchors.
+
+```
+The three findings are that CI is stale which means the pipeline
+hasn't run in 48 hours, tests are flaky which produced 5 false
+positives last week, and the marker check is missing which lets
+regressions slip through.
+```
+
+**Conformant:** bold-lead + em-dash per item, blank line between.
+
+```
+- **CI stale** — pipeline hasn't run in 48 hours.
+- **Tests flaky** — 5 false positives last week.
+- **Marker check missing** — regressions slip through.
+```
+
+Same principle as section 10 (bold inline lead for reasoning
+paragraphs). Prose enumeration is a compact form; the bold-lead +
+em-dash carries the anchor without needing full paragraph breaks.
+
+### 5. Code-fence inline quotes and file refs
+
+```markdown
+`.claude/rules/visual-hierarchy.md` — not plain text
+`git status` — not plain text
+```
+
+Consistent across the whole response.
+
+### 6. Questions / confirmation prompts set off from analysis
+
+When the response ends with a question for the operator, separate it
+visually from preceding analysis — a `---` rule, a bold header
+(`**Confirm to proceed?**`), or a short blockquote.
+
+### 7. Bulleted wraps use hanging indent
+
+When a bullet's text wraps to a second or third line, the wrapped text aligns with the first character after the `- ` marker. Not with column 0. Most markdown renderers do this automatically when the source places the bullet at column 0. Agent output that indents wrapped lines to column 0 breaks the signal. The eye reads the wrapped text as a new paragraph, not as part of the bullet.
+
+**Anti-pattern:** continuation text at column 0 — wrapped text
+reads as a new paragraph, not a continuation.
+
+```
+- This is a long bullet whose text wraps to a second line and the
+continuation lands flush left at column 0 which breaks the visual
+signal that it belongs to the bullet above.
+```
+
+**Conformant:** continuation text stays inside the bullet's
+visual column.
+
+```
+- This is a long bullet whose text wraps to a second line, and the
+  continuation stays indented to align with the first character
+  after the `- ` marker. The eye reads it as one bullet.
+```
+
+The rule is about source shape, not render shape. Write markdown source with `-<space>` at column 0. Let the renderer handle wrapping. Do not manually break lines at fixed column widths in ways that put wrapped text at column 0.
+
+**Alignment is the renderer's job too.** Same principle as line-wrap. Terminals left-align by default. That is the right shape. Do not embed CSS, HTML, or padding to force full-justify or center alignment. The rule scopes source shape, not render shape.
+
+### 8. Headers use `##` and `###` for color signals
+
+Most terminal + web markdown renderers give `##` and `###` headers a color or weight signal. Bold plain text (`**Section**:`) does not get the same signal. The color difference is what lets the operator's eye jump between sections on a long response.
+
+**Anti-pattern:** section labels as bold plain text.
+
+```markdown
+**Analysis:** long paragraph here that runs on and on and the
+reader cannot easily spot where the next section starts.
+
+**Recommendation:** more paragraphs.
+```
+
+**Conformant:** section labels as `##` or `###` headers.
+
+```markdown
+## Analysis
+
+Long paragraph here that runs on and on. The `## Analysis` header
+above renders in the harness's header color, giving the eye an
+anchor.
+
+## Recommendation
+
+More paragraphs.
+```
+
+Use `##` for top-level sections in a response; `###` for
+subsections. Do not use `#` (H1) in agent output — that heading
+level is reserved for document titles.
+
+### 9. Skill names and file paths use inline code
+
+Skill invocations (`/luminary`, `/sprint`, `/kiss`) and file paths
+(`.claude/hooks/foo.sh`, `docs/whereami.md`) render distinctly when
+wrapped in inline code spans (backticks). Prose that names them
+without backticks blends into surrounding text.
+
+**Anti-pattern:** skill names and file paths as plain text.
+
+```
+The /luminary skill reads .claude/luminaries/*.md files at every
+session start. Also see the /sprint output and docs/whereami.md.
+```
+
+**Conformant:** skill names and file paths as inline code.
+
+```
+The `/luminary` skill reads `.claude/luminaries/*.md` files at
+every session start. Also see the `/sprint` output and
+`docs/whereami.md`.
+```
+
+Extend the same treatment to:
+
+- **Environment variables** — `ANTHROPIC_BASE_URL`, `HOME`,
+  `SKIP_TURN_PROSE_GRADE`
+- **CLI commands** — `git status`, `gh pr list`, `bash
+  scripts/foo.sh`
+- **Config keys** — `schema_version`, `tier`, `install-class`
+- **Ticket references in code shape** — `#940`, `bassclef#559`
+  (only when quoted verbatim from a source; plain prose can drop
+  the backticks)
+
+Composes with ### 5. Extend ### 5's principle to every skill
+name (with slash prefix), every file path (relative or absolute),
+every env var, every CLI command, and every config key in
+operator-facing prose.
+
+### 10. Bold inline lead for reasoning paragraphs and lists
+
+When a response has 2 or more paragraphs of reasoning, each
+paragraph opens with a **short bold lead phrase** (2-4 words)
+that names the paragraph's point. Blank line separates
+paragraphs. The bold lead renders in the terminal's accent color
+— bassclef gold (`--bc-gold` per `design-tokens.css`) or the
+renderer's chosen highlight. The exact shade is renderer-controlled;
+the source shape is `**bold**`.
+
+Applies when:
+- Paragraph runs 2+ sentences of reasoning
+- Response has 2+ such paragraphs stacked
+- **Numbered or bulleted list items carry multi-sentence reasoning
+  (not one-line items)** — the bold lead sits at the head of each
+  item, followed by an em-dash or a period + space, then the body
+
+Skips:
+- Single-sentence answers (no anchor needed)
+- Yes/no confirmations
+- One-line list items (they are already their own anchor)
+- Tables (they have their own anchors)
+- Code blocks
+
+**Anti-pattern:** wall of reasoning text with no scan anchors.
+
+```
+The subject matter is already structured which lets the description
+inherit that structure. You asked sharp questions which forced short
+answers. There was no hedging pressure so the writing stayed direct.
+```
+
+**Conformant:** bold inline lead per paragraph, blank line between.
+
+```
+**Subject matter already structured.** Bassclef has explicit layers.
+When the thing being described has clear structure, the description
+inherits it.
+
+**Sharp questions.** You cut to the decision, not the background.
+That forces short answers because the right answer actually is short.
+
+**No hedging pressure.** You pushed back on advice. That established
+that correctness matters more than validation. That removes the padding.
+```
+
+**Conformant for lists carrying reasoning:** bold lead on each item.
+
+```
+1. **Ishikawa fishbone earned its keep.** Going broad across 6M
+   categories before five-whys caught the launchd-dead-file
+   mechanism that direct five-whys would have missed.
+
+2. **Operator pause before kickoff was essential.** The 5-lens
+   luminary consult grounded the plan; would have wasted the whole
+   /longrun otherwise.
+
+3. **Linus lens applied honestly to the cross-OS question.** Forced
+   the ADR frame. Producer pays cost. No adopter left behind.
+```
+
+Composes with ### 8 (colored `##` and `###` headers) and ### 4
+(bold category labels in lists). Bold lead phrases work at the
+paragraph scale the way `##` headers work at the section scale.
+Same principle — give the eye a scan anchor.
+
+### 11. Arrow-indent for call chains and pipelines
+
+When describing a sequence of steps that flow into each other (a
+tool chain, a pipeline, a call graph), use the `→` arrow prefix
+with two-space indent for sub-steps. Plain text — no code fence.
+The arrow renders in the same accent color as bold leads on most
+terminals.
+
+**Anti-pattern:** pipeline as flat prose.
+
+```
+The dispatcher fetches the source config then reads the settings
+then reads the sync template then runs the sync then loads the
+skills.
+```
+
+**Conformant:** arrow-prefixed steps, two-space nest for sub-steps.
+
+```
+→ fetch `.bassclef-source.json`
+→ read `.claude/settings.json`
+  → merge project + operator settings
+→ read `presence/install/bassclef-sync.template.sh`
+→ run the sync
+  → symlink skills
+  → symlink rules
+  → symlink hooks
+```
+
+Applies when:
+- Response describes a call chain, pipeline, or sequence of at
+  least 3 steps
+- Sub-steps nest below a parent step
+- The order matters and the reader needs to trace flow
+
+The arrow prefix is a data glyph (per Tufte). It carries the flow
+direction. Composes with ### 5 (inline code for filenames) and
+### 9 (env vars, CLI commands, config keys in inline code).
+
+### 12. Tables + special characters — prefer card format when in doubt
+
+The Claude Code TUI (and some other markdown renderers) has post-processing after markdown parse that can mangle specific characters inside table cells. Standard GFM parsers (pandoc, cmark-gfm) handle these characters cleanly — verified 2026-08-06 with 6-fixture pandoc test on control + apostrophes + escaped pipes + backticks + HTML entities + quotes + backslash. The break happens downstream of GFM, in the renderer itself.
+
+Suspect character class (per operator observation + #966 comment thread hypothesis + #1144 filing):
+
+- Apostrophe `'` — reported to collapse rows or drop cells in the Claude Code TUI; unconfirmed at markdown-parse layer
+- Raw pipe `|` — will always split a cell unless escaped `\|`; that IS a spec-level defect the author must handle
+- Backtick `` ` `` — starts inline code; if unbalanced across a cell, cascades into neighboring cells
+- HTML entities (`&lt;`, `&gt;`, `&amp;`) — safe at GFM layer but some renderers do double-decode
+- Angle brackets `<>` — some renderers treat as HTML fragments if not entity-encoded
+
+**Defensive stance** — three options in order of preference:
+
+1. **Prefer cards for content with special chars.** Per ### 12 sister-rule sections (#966 wide-table cure + #959 prep density card format), authoring-time card format sidesteps the whole class. Use `**Label** — value.` bullets instead of a table when cells contain apostrophes, quotes, or code.
+2. **If a table is the right shape, escape the suspect chars.** `\|` for pipe, `` `\`` `` for backtick, HTML entities for `<>&`. Apostrophes: try `&#39;` if the TUI break reproduces.
+3. **Keep tables narrow AND alphanumeric-first.** Per ### 12 sister-rule (#966), tables past 4 columns collapse. Combined with special-char break, wide-plus-special-char is the worst case.
+
+**Anti-pattern:** ships a wide table (5+ cols) with cells containing apostrophes.
+
+**Conformant:** narrow (≤4 cols) table with alphanumerics only, OR card format for anything with special chars.
+
+**INSTEAD-block — per-character cure recipes** (per #1144 body step 3):
+
+- Apostrophe `'` in cell text — write as `&#39;` (HTML entity) OR replace with typographic apostrophe `'` (U+2019) OR move content to card
+- Straight double quote `"` in cell text — write as `&quot;` OR replace with typographic quotes `""` (U+201C / U+201D) OR move to card
+- Raw pipe `|` — always write as `\|` inside cells; unescaped pipes split cells at GFM parse time (spec-level)
+- Backslash `\` in cell text — safe when not preceding a pipe; when followed by pipe use `\\|` to keep the backslash literal
+- Angle brackets `<` `>` — write as `&lt;` and `&gt;`; raw brackets sometimes parse as HTML fragments in TUI post-processing
+- Backtick `` ` `` — balance inside cells; unbalanced backticks cascade inline-code state into neighboring cells; when carrying literal backticks use HTML entity `&#96;`
+- Combined `'` + `"` in the same cell — worst case; move to card. Contractions plus quoted phrases collapse rows in the Claude Code TUI per operator screenshots (whereami L30 of 2026-08-13a session)
+
+The reproducer at `#1144` characterizes which classes trigger flatten in the current Claude Code TUI. When operator observation surfaces a new class beyond this list, extend the block via a follow-on PR.
+
+Composes with sister rules — #966 (wide-column threshold), #967 (section-anchor spacing), #959 (prep density card format).
+
+## What NOT to do
+
+- Terminal color codes (renderer-dependent — breaks in different UIs)
+- **Decoration emoji** — do not use emoji for ornament (✨, 🎉, 🚀
+  at the head of sections)
+- Nested bold-inside-header (visual noise, no added signal)
+- More than one `#` heading level per response (start at `##`)
+- **Do not embed CSS, HTML, or padding to force alignment or
+  justification.** Renderers left-align by default; that is the
+  correct shape. Full-justify and center are not source-level
+  markdown signals.
+
+**Data glyph carve-out** (per Tufte). A glyph that carries data is
+allowed, even encouraged. Examples:
+
+- Risk glyphs in tables — `🟢 low` / `🟡 med` / `🔴 high` (encodes
+  data on a shared axis)
+- Gate signals emitted by hooks — `🛑 BLOCKED:`, `⚠ ADVISORY:`
+  (encodes state)
+- Flow arrows — `→` in call chains (encodes direction)
+
+The rule is Tufte's — data-ink is welcome; decoration ink is not.
+A `🎉` at the head of a section is decoration. A `🟢` inside a
+risk column is data.
+
+INSTEAD: use plain markdown primitives (bold, italics, blockquotes,
+code fences) for emphasis; let the operator's renderer decide visual
+treatment. Reserve emojis for gate signals the hook itself emits or
+for data glyphs that encode information the reader needs to scan.
+
+## Why this rule exists
+
+Captured from operator feedback across multiple sessions (memory entry `feedback_visual_hierarchy.md`). Agent responses with headers like "Key design choices worth calling out" and "Skill summary" blended into surrounding text. On mobile screenshots the eye could not jump to sections. The operator re-read the whole response to find the one they wanted.
+
+Visual hierarchy is not cosmetic. It is what makes long responses usable on the surfaces operators actually work on.
+
+Sections 7-9 landed 2026-07-26 per ticket #914. Two mobile screenshots the operator shared in session `chronicle/2026-07-26d-cures-2-3-5-shipped.md` motivated the extension. The reference output showed hanging-indent bullets, colored `##` headers, and inline-code skill names as scannable anchors. Bassclef's agent output was missing those three signals. The extension prescribes them at the source shape so any conforming renderer produces the same scannability.
+
+Section 10 (bold inline lead) landed 2026-07-27 per ticket #936. Sections 4 (prose enumeration shape), 9 (env vars + CLI + config keys), 10 (numbered and bulleted list reasoning), 11 (arrow-indent pipelines), and the "What NOT to do" data-glyph carve-out landed the same day. Six operator-shared screenshots showed the target output shape — bold leads at paragraph heads, arrow-indent pipelines, inline code for env vars and paths. Bassclef renderers use the accent color from `design-tokens.css` — `--bc-gold` (#F5B83D) for warm highlight, `--bc-orange` (#E85D04) for the master burnt orange. The exact shade is the renderer's choice. The source shape is `**bold**` and inline code fences.
+
+## Applies to
+
+- Session-end summaries
+- PR descriptions generated by the agent
+- `/sprint`, `/whereami`, `/whats-the-plan` outputs
+- `/value-prop`, `/feynman`, `/kiss` outputs
+- `/diagnose`, `/architect-review`, `/pattern-review` reports
+- Any gut-check or status report longer than a few sentences
+
+## Does NOT apply to
+
+- Short answers (<3 sentences) — keep single-line answers single-line
+- Tool-output relays (commit messages, test output) — don't reformat
+- Code content — never decorate diff blocks
+- When the operator explicitly asks for "just the bullet" / "one line"
+
+INSTEAD for the exempt cases: pass the content through verbatim
+(tool output) or match the requested format (operator-specified).
+Visual hierarchy is a tool, not a mandate.
+
+## Relationship to other rules
+
+- `commit-conventions.md` — commit messages have their own format
+  discipline; this rule doesn't override them
+- `session-artifacts.md` — chronicle + journal entries have their own
+  templates; this rule applies to the agent's conversational output
+  around them, not the artifacts themselves
+- `artifact-ingestion.md` — "Sources read" blocks satisfy the
+  structured-output requirement; they're already compliant with this
+  rule
+
+## Enforcement
+
+Methodology-level. No hook today. If agent output consistently ignores
+the rule across sessions, a post-response lint could be added as a
+Stop hook — but the first line of defense is the rule loading into
+every session via `additionalDirectories`.
+
+## Override path
+
+None needed. The rule prescribes a style; operator may request
+alternative formatting per-response ("just give me the bullet list")
+and the agent complies without rule violation.