@thebassclef/lite 0.0.1 → 0.1.2

package/substrate/.claude/skills/requirement/SKILL.md

@@ -0,0 +1,98 @@
+---
+name: requirement
+description: "Produce Cockburn use cases plus INVEST user stories for a feature in one pass. Sam writes formal use cases for a spec. Louis writes INVEST stories for a backlog. You get both from one operator input. Combines /use-case + /user-stories."
+problem: "Features get built from a one-line ticket. Corners get cut. Acceptance drifts from what the persona needs."
+value: "Cockburn use cases plus INVEST user stories in one pass. Written for a Sam-style persona."
+inputs: [A feature name or ticket ref]
+outputs: [Fully-dressed use cases, INVEST user stories with acceptance criteria]
+tier: lite
+user_invocable: true
+disable_model_invocation: false
+modes: [both, use-case-only, story-only]
+composes_with: [use-case, user-stories, personas]
+---
+
+# /requirement — Cockburn use cases + INVEST stories in one pass
+
+## What you get
+
+You describe a feature in a paragraph. `/requirement` returns two artifacts.
+
+<!-- FKGL-EXEMPT: structured shape enumeration; the parentheticals name the artifact fields -->
+- One Cockburn-style use case (main success scenario + extensions + preconditions + postconditions)
+- One or more INVEST-shape user stories (Independent + Negotiable + Valuable + Estimable + Small + Testable)
+<!-- /FKGL-EXEMPT -->
+
+You pick which one lands. Or both.
+
+## When to use
+
+Type `/requirement` when a feature needs both a spec and a backlog item. Common cases:
+
+- New feature under `/longrun` scope — spec first, stories second
+- Ticket in the queue that needs shape — story alone is thin; add the use case for edge cases
+- Adopter demo — Louis wants a story for the pitch; Sam wants a use case for the build
+
+## When NOT to use
+
+- Only a bug fix — INSTEAD go to `/diagnose` at lite
+- Pure architecture decision — INSTEAD go to `/spec` at lite
+- Formal system contract only — INSTEAD go to `/use-case` at lite
+
+## Cluster shape
+
+`/requirement` sits inside the /longrun cluster as a strategy helper. Its own cluster:
+
+- Upstream: `/personas` names who the feature is for. `/state-a-problem` frames the pain.
+- Downstream: `/spec` bundles use case + stories into a buildable spec.
+- Helpers: `/use-case` writes Cockburn shape. `/user-stories` writes INVEST shape.
+
+## Composes
+
+`/requirement` combines 2 single-purpose skills. Both stay at lite for direct dispatch.
+
+<!-- FKGL-EXEMPT: structured shape names -->
+- `/use-case` — Cockburn scenarios; main success plus numbered extensions
+- `/user-stories` — INVEST shape; per-story acceptance list
+<!-- /FKGL-EXEMPT -->
+
+Per canvas `docs/canvases/2026-08-02-porcelain-plumbing-reframe.md` — Cockburn plus Beck consensus: shape names matter. `/requirement` combines without hiding the single-purpose skills. Sam and Louis can still call each one directly when they want one shape only.
+
+## Modes
+
+- `both` (default) — writes both a use case and INVEST stories
+- `use-case-only` — dispatches `/use-case` alone; skips story authoring
+- `story-only` — dispatches `/user-stories` alone; skips use case authoring
+
+## Procedure
+
+1. Parse the operator's feature paragraph. Extract the actor, the goal, the pain point.
+2. Load persona context via `/personas`. Default to operator when personas are not defined.
+3. If mode is `both` or `use-case-only`: dispatch `/use-case`. Author `docs/use-cases/UC-<slug>.md`.
+4. If mode is `both` or `story-only`: dispatch `/user-stories`. Author `docs/user-stories/<slug>.md`.
+5. Cross-link: the use case cites the stories. The stories cite the use case.
+6. Print artifact paths to the operator.
+
+## What lands on disk
+
+- One use case at `docs/use-cases/UC-<slug>.md` (unless mode is `story-only`)
+- One or more stories at `docs/user-stories/<slug>.md` (unless mode is `use-case-only`)
+- Cross-references between the two
+
+## Rules
+
+- MUST cite the persona the feature is for (Sam or Louis or a project persona).
+- MUST cross-link the use case and the stories.
+- MUST match Cockburn shape for use cases. MUST match INVEST shape for stories.
+- MAY skip stories or use case per mode.
+
+## Refs
+
+- Canvas `docs/canvases/2026-08-02-porcelain-plumbing-reframe.md`
+- Ticket #1050 + comment 5160626302 (Cockburn + Beck consensus)
+- Goal doc `docs/iteration-bets/2026-08-04g-porcelain-plumbing-reframe.md`
+- `.claude/skills/use-case/SKILL.md` — atomic Cockburn shape
+- `.claude/skills/user-stories/SKILL.md` — atomic INVEST shape
+- `.claude/skills/personas/SKILL.md` — persona load
+- @luminary alistair-cockburn
+- @luminary kent-beck

package/substrate/.claude/skills/retro/SKILL.md

@@ -0,0 +1,117 @@
+---
+tier: lite
+name: retro
+description: "Reflect at session close. Names what worked, what didn't, and what to change next time. Feeds candidate follow-on tickets."
+problem: "Sessions end and the lessons vanish. What worked and what broke \u2014 nowhere written."
+value: "A short retro that names what to keep and what to change next session."
+inputs: [Optional session or goal ref]
+outputs: [Kept and Changed and Learned sections, Follow-on ticket candidates]
+user_invocable: true
+disable_model_invocation: false
+---
+
+# Retro — Session Retrospective
+
+Reflect on the current session and capture learnings.
+
+## Runs at every tier — deep module
+
+This skill uses only mechanical inputs. It reads `git log`. It reads files. The agent reflects on the session. No paid API. No LLM call beyond the agent's own turn output.
+
+Same procedure runs at lite, standard, and ultra. Lite adopters get the full retrospective. Per canvas 2026-07-19-bassclef-lite Q6 Option E.
+
+Closes bassclef-upstream#1383 (sister flip to `/roadmap-reconcile`).
+
+## Steps
+
+1. Review what was accomplished this session:
+   - `git log --oneline --since="today"` for commits
+   - Check for modified files and new artifacts
+2. Identify:
+   - What went well (approaches that worked, decisions validated)
+   - What was harder than expected (and why)
+   - What should change for next session
+3. List substrate observations from this session (see next section).
+4. Check for open threads that need to carry forward.
+
+## Substrate observations — file each as /promote (bassclef-web#96)
+
+Before writing the retro, list what came up. Categories:
+
+- Missing skill or hook that would have helped
+- Hook fires wrong OR misses when it should fire
+- Rule gap or drift
+- Prereq surprise — a skill assumed X existed; it did not
+- Adopter-visible friction (Sam or Louis lens)
+
+For each observation, run three steps:
+
+1. **Dedup check.** Run `gh issue list --repo <current-repo> --state open --label bassclef-evolution --search "<close-title-match>"`. When a match exists, comment on it. Do not file a new ticket.
+2. **File /promote.** When no match, dispatch `/promote` with pre-filled title + body. The operator reviews before submit. The ticket lands with `bassclef-evolution` label in the current repo. Bassclef pulls via session-reflection hook per memory `feedback_promote_files_locally_not_upstream`.
+3. **Record disposition.** Append a line to the marker file at `state/markers/retro-substrate/<session-id>.marker`. Use the session-id from `state/markers/session-timing/`. Fall back to `YYYY-MM-DD-<slug>` when that is missing.
+
+Marker format:
+
+```
+# Retro substrate observations — <session-id>
+- date: YYYY-MM-DD
+- session: <session-id>
+- observations:
+  - promoted: <one-line title> — filed as <repo>#<ticket>
+  - deferred: <one-line title> — <reason>
+  - rejected: <one-line title> — <reason>
+  - dedup: <one-line title> — commented on <repo>#<ticket>
+```
+
+Silence in this section is not deferral. List observations OR state "no substrate observations this session" explicitly.
+
+## Output
+
+When a session log exists for today, append a `## Retrospective` section to it.
+When no session log exists, create one first via `/session-log` format. Then add the retro.
+
+<!-- FKGL-EXEMPT: markdown template exemplar; adopter copies verbatim -->
+```markdown
+## Retrospective
+
+### Went well
+- ...
+
+### Harder than expected
+- ...
+
+### Change for next time
+- ...
+
+### Substrate observations promoted
+- <title> — filed as <repo>#<ticket>
+- <title> — dedup: commented on <repo>#<ticket>
+- (or: "no substrate observations this session")
+
+### Open threads for next session
+- ...
+
+### Bassclef promotes this session
+- agent-self-proposed: N
+- agent-user-proposed: M
+- total: N plus M
+
+When M is much larger than N, the agent missed patterns the operator caught. When N is high but bassclef closes none, the agent files too broadly.
+```
+<!-- /FKGL-EXEMPT -->
+
+**Proposer counting**: count bassclef-evolution issues from session
+date window:
+
+```bash
+gh issue list --label bassclef-evolution --state all \
+  --search "created:>=$(date -v-1d +%Y-%m-%d) created:<=$(date +%Y-%m-%d)" \
+  --json number,title,labels | jq '[.[] | {n: .number, t: .title,
+  kind: (if (.labels | map(.name) | index("agent-user-proposed")) then
+  "user" elif (.labels | map(.name) | index("agent-self-proposed"))
+  then "self" else "unlabeled" end)}]'
+```
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.

package/substrate/.claude/skills/riff/SKILL.md

@@ -0,0 +1,114 @@
+---
+name: riff
+description: "Produce 2-3 clickable mock alternatives for a UI surface. Each mock uses a different luminary lens. Louis picks a marketing variant. Sam picks a direction before building. Combines /interpret-input + /luminary + /stage + /visual-review."
+problem: "Design directions get one variant and no comparison. Operator picks blind. Rework is huge."
+value: "Two or three clickable mocks per UI surface. Each mock pins a different luminary lens."
+inputs: [A UI surface intent or design goal]
+outputs: [2-3 clickable mock variants, Luminary lens per variant]
+tier: lite
+user_invocable: true
+disable_model_invocation: false
+composes_with: [interpret-input, luminary, visual-review]
+---
+
+# /riff — Vary a UI surface by luminary lens
+
+## What you get
+
+You get 2-3 clickable mock alternatives for a UI surface. Each mock uses a different luminary lens. You pick the one that fits.
+
+Louis picks a marketing variant. Sam picks a direction before building.
+
+## When to use
+
+Type `/riff` when you have a UI or marketing surface. You want 2-3 options before building.
+
+- Marketing page — try 3 luminary lenses on the same headline
+- App feature UI — pick between minimal, dense, or modal
+- Landing page hero — bake off options before design lock-in
+
+## When NOT to use
+
+- Single-variant work — INSTEAD go to `/frontend-design` at standard
+- Full prototype pipeline with direct step control — INSTEAD use `/stage` at standard
+- Buildable spec plus variants — INSTEAD use `/launch` at standard
+
+## Tier gate
+
+`/visual-review` and `/stage` ship at `tier: standard`. Lite adopters get graceful degrade — variants ship without the review check; the pipeline dispatches directly. Resolve tier via `lib/tier-check.sh`.
+
+Per canvas 2026-07-19-bassclef-lite Q6 Option E — one SKILL.md file, same name in both tiers, body carries runtime tier awareness with graceful degrade.
+
+## Tier and dispatch
+
+`/riff` sits at bassclef lite. It is a porcelain verb — Git's word for the small set of verbs a user types. Sam or Louis types `/riff` and the pipeline runs underneath.
+
+The plumbing (Git's word for the deeper steps a verb runs) sits at standard tier. When lite adopters type `/riff`, the skill dispatches:
+
+1. `/interpret-input` — parse the operator's input
+2. `/luminary` picker — pick 2-3 lenses that fit the intent
+3. Per lens: author a static HTML mock
+4. Assemble a gallery — one page listing every variant with screenshots and luminary tags
+5. `/visual-review` — screenshot each variant and check against luminary discipline
+
+Standard adopters can bypass `/riff`. They invoke `/stage` directly for the full pipeline with more control. Ultra adopters get `/pick-luminaries` cosine plus judge for tighter lens matching.
+
+## Cluster shape
+
+`/riff` sits inside the /longrun cluster. It is a helper for marketing and UI direction work. Its own cluster:
+
+- Upstream: `/interpret-input` parses input into an artifact
+- Downstream: picked variant flows into `/build` at standard or `/launch` at standard
+- Helpers: `/luminary` picks lenses. `/visual-review` checks each variant. `/frontend-design` is Anthropic's baseline.
+
+## Consolidates
+
+`/riff` consolidates 2 prior skills at the lite entry:
+
+- `/stage` — prototype pipeline. Stays at standard so you can call each step directly.
+- `/riff-prototypes` — deprecated per ADR-020 in favor of `/stage`. Absorbed here at lite.
+
+Per canvas `docs/canvases/2026-08-02-porcelain-plumbing-reframe.md` — 10 of 10 luminaries agreed on the reframe.
+
+## Procedure
+
+1. Parse the operator's input via `/interpret-input`. Output: normalized InputArtifact.
+2. Pick 2-3 luminary lenses. Either operator-named or via `/luminary` picker.
+3. For each lens: author a static HTML mock. Path: `docs/prototypes/YYYY-MM-DD-riff-<slug>-variant-N/index.html`. Stubbed data. Include a `<h2>` naming the lens.
+4. Screenshot each variant via Playwright MCP. Save under `.playwright-mcp/`.
+5. Assemble a gallery page. Link every variant. Show screenshots inline. Show luminary tags.
+6. Run `/visual-review` on each variant. Report findings per variant.
+7. Present the gallery URL to the operator. Operator picks. Picked variant flows into `/build` or `/launch` at standard.
+
+## Baseline composition
+
+`/riff` builds on top of Anthropic's `frontend-design` defaults. Adopters firing plain Claude get those defaults. `/riff` adds luminary discipline. It also adds bassclef design tokens.
+
+## What lands on disk
+
+- One HTML mock per variant under `docs/prototypes/`
+- One screenshot per variant under `.playwright-mcp/`
+- One gallery page linking every variant
+- One PR to a feature branch (not main)
+
+## Rules
+
+- MUST produce a PR. Push to a feature branch, not main.
+- MUST run on a feature branch.
+- MUST screenshot every variant via Playwright MCP. BLOCK if MCP not enabled.
+- MUST tag each variant with its luminary lens in the HTML.
+- MUST report per-variant `/visual-review` findings with the gallery link.
+
+## Refs
+
+- Canvas `docs/canvases/2026-08-02-porcelain-plumbing-reframe.md`
+- Ticket #1050 + comment 5160626302
+- ADR-020 (prototype skill family consolidation)
+- Goal doc `docs/iteration-bets/2026-08-04g-porcelain-plumbing-reframe.md`
+- `.claude/skills/stage/SKILL.md` — atomic pipeline at standard
+- `.claude/skills/frontend-design/SKILL.md` — Anthropic baseline
+- `.claude/skills/visual-review/SKILL.md` — per-variant review
+- `.claude/skills/luminary/SKILL.md` — lens picker
+- `.claude/luminaries/bill-buxton.md` — variant discipline anchor
+- @luminary bill-buxton
+- @luminary alan-cooper

package/substrate/.claude/skills/roadmap-reconcile/SKILL.md

@@ -0,0 +1,163 @@
+---
+tier: lite
+name: roadmap-reconcile
+description: "Audit canvas LR-N tables and roadmap entries against recent chronicles, merged PRs, and freshly-filed tickets. Surface drift via --dry-run. Apply edits with --apply. Runs at /longrun prep and /sprint as pre-flight."
+problem: "Canvas roadmap tables get stale. Shipped work sits marked pending. Sequencing drifts from reality."
+value: "Diffs the roadmap against merged PRs plus fresh session logs. Applies edits so the canvas matches reality."
+inputs: [Optional --dry-run or --apply flag, Roadmap path or canvas ref]
+outputs: [Diff report of drift, Applied edits when --apply, Status per row]
+user_invocable: true
+disable_model_invocation: false
+---
+
+# /roadmap-reconcile — True up canvases against shipping reality
+
+## Runs at every tier — deep module (per canvas 2026-07-19-bassclef-lite Q6 Option E)
+
+This skill uses only mechanical inputs — `git log`, `gh pr list`, `gh issue list`, grep across canvas + goal doc files. No paid API. No LLM dispatch. Same procedure runs identically at lite, standard, and ultra. Lite adopters get the full drift check.
+
+The `lib/tier-check.sh` gate reads adopter tier from `.claude/bassclef-configs.jsonc`. This skill's body has no tier branch — one procedure serves every reader. Future extension (LLM-based semantic drift) would add a tier branch at the point of divergence; today no branch is needed.
+
+Closes bassclef-upstream#1383.
+
+The recurring substrate primitive that closes the stale-canvas trap. As operator ideates in a session, surfaces shift; the canvases holding LR-N sequencing tables stay frozen at the last commit. Without reconciliation, /longrun prep reads pre-detour next-goals and dispatches against work that's no longer on the critical path.
+
+This skill enumerates roadmap surfaces, diffs them against shipping reality (chronicles + PRs + tickets), and produces edits — inline by default, or as a dry-run report for operator review.
+
+INSTEAD of relying on operator-and-agent ad-hoc canvas review at every prep: dispatch this skill as a pre-flight gate; it returns either "no drift" (proceed) or a specific diff (resolve before scope commit).
+
+## When to invoke
+
+- **Auto at /longrun prep Step 0.5**: dry-run mode runs before scope confirmation; surfaces drift; operator confirms reconciled state before WU-0
+- **Auto at /sprint**: dry-run output appended to /sprint surface so operator sees roadmap drift alongside ticket-level orientation
+- **Standalone**: operator dispatches `/roadmap-reconcile` after a substantive ideation session that didn't land in canvas updates yet
+- **Composer fallback**: any composer detecting ticket-vs-canvas drift can dispatch this skill instead of failing silently
+
+## Procedure
+
+1. **Enumerate roadmap surfaces:**
+   - Substrate canvases under `strategy/canvases/` — grep for `LR-N` rows in Stage 3 build sequence + Operator priorities tables
+   - Typed roadmap entities under `docs/roadmaps/*.md` — read via `state_roadmap_get` accessor when present (per bassclef#337, #480 once shipped)
+   - Active iteration goal under `docs/iteration-bets/` — extract `next_bet:` field
+   - Whereami `next_bet:` field at `docs/whereami.md`
+2. **Read shipping reality:**
+   - `git log --since=14days --pretty=oneline -- 'chronicle/*.md' 'docs/chronicle/*.md'` — sessions that shipped
+   - `gh pr list --state all --json number,title,state,mergedAt --limit 30` — PR truth
+   - `gh issue list --state open --search 'created:>=2-weeks-ago' --json number,title,labels,body` — recently filed tickets
+   - `git log --since=14days --pretty=format:'%h %s' -- 'docs/iteration-bets/*.md'` — bets opened or closed
+3. **Build a diff** — for each LR-N row in canvas tables:
+   - Status mismatch: canvas says "in progress" but a CLOSED goal ships its scope, OR canvas says "next" but a bet's already opened
+   - Sequencing mismatch: a recently-filed ticket names itself as "blocking LR-N+1" or "load-bearing for LR-N" but doesn't appear in any LR-row
+   - Reference rot: canvas references a ticket that's been closed or superseded
+4. **Produce output:**
+   - **--dry-run mode (default at /longrun prep + /sprint):** markdown diff report — what's stale, what to edit, what to add
+   - **--apply mode (operator opt-in):** inline edits to canvas files via Edit tool; commit with `docs(roadmap): reconcile <slug>`
+   - **--json mode:** structured output for downstream skills/hooks
+5. **Surface output** to caller (operator or composer); caller decides resolve / defer / amend.
+
+## What NOT to do
+
+- **Don't fabricate LR-N rows for tickets that aren't ready to be sequenced.** INSTEAD: surface the ticket as "candidate for next sequencing decision" without inserting; operator decides at /longrun prep.
+- **Don't auto-apply edits without --apply opt-in.** INSTEAD: --dry-run is the default; operator reviews the diff before any canvas write.
+- **Don't reach inside canvas Stage 1/2 (Thesis, Shape) content.** INSTEAD: only edit Stage 3 build sequences + Operator priorities tables + status overlays; the upstream thesis stays operator-owned.
+- **Don't reconcile against draft tickets or WIP goals.** INSTEAD: filter to merged PRs + closed/active goals; tickets in `draft` state or PRs in `draft` are noise.
+- **Don't run during /longrun execution mid-step.** INSTEAD: only at prep + closeout windows; mid-execution reconciliation creates scope-drift triggers.
+
+## Output format (--dry-run)
+
+```markdown
+## /roadmap-reconcile dry-run — <timestamp>
+
+### Surfaces enumerated
+
+- canvas: strategy/canvases/2026-05-03-bassclef-platform-primitive.md (8 LR-N rows)
+- canvas: strategy/canvases/2026-05-04-hud-on-brownfield-repo.md (10-step build sequence)
+- typed roadmap: <path> OR (none — bassclef#480 not yet shipped)
+- whereami next_bet: 2026-05-XX-LR6-your-app-refactor-dispatch
+
+### Drift detected
+
+**Canvas <path>:**
+- LR-N row <N> says "in progress" but goal <slug> is CLOSED (per chronicle <ref>); should be "✅ shipped"
+- LR-N row <N+1> references bassclef#XXX which has been closed as superseded; should reference replacement #YYY
+- bassclef#ZZZ filed 3 days ago names itself as "blocks LR-N+2"; doesn't appear in canvas table
+
+**Whereami next_bet:**
+- Names LR6 = POA dispatch; canvas Operator priorities row also says LR6 = POA dispatch — aligned
+
+### Recommended edits
+
+1. Update canvas <path> Operator priorities row N: status → "✅ shipped 2026-05-04"
+2. Update canvas <path> Stage 3 row M: replace "#XXX" with "#YYY"
+3. Insert new row in canvas <path> at LR-N+2: "#ZZZ — <description from ticket>"
+
+### To apply
+
+`/roadmap-reconcile --apply` (operator-confirms before commit)
+```
+
+## Output format (--json)
+
+```json
+{
+  "timestamp": "2026-05-04T...",
+  "surfaces": [
+    {"type": "canvas", "path": "...", "rows": 8},
+    {"type": "typed-roadmap", "path": null, "note": "bassclef#480 not yet shipped"}
+  ],
+  "drift": [
+    {
+      "surface": "canvas:strategy/canvases/...",
+      "row": "LR-4",
+      "claim": "in progress",
+      "reality": "shipped",
+      "evidence": "chronicle/2026-05-04d-...md",
+      "edit": "row LR-4 status: shipped"
+    }
+  ]
+}
+```
+
+## Acceptance
+
+- SKILL.md scaffolds with verb-first description (≤280 chars; per `.claude/rules/skill-description-clarity.md`)
+- Tests in `scripts/tests/roadmap-reconcile.test.sh` cover:
+  - Enumeration: skill detects all canvas LR-N tables in `strategy/canvases/`
+  - Drift detection: stale canvas + recent shipped chronicle → drift surfaces
+  - Drift detection: freshly-filed ticket marked as "blocks LR-N" → drift surfaces
+  - Output formats: --dry-run produces markdown; --json produces valid JSON
+  - Negative test: clean roadmap (no drift) → "no drift" output
+- Integration: /longrun prep SKILL.md procedure adds Step 0.5 reference
+- Integration: /sprint SKILL.md composes-with table updated
+
+## Composes with
+
+- `/longrun prep` (composes-into Step 0.5) — pre-flight reconciliation gate
+- `/sprint` (composes-into output) — surface drift alongside ticket-level orientation
+- `/whats-the-plan` (referenced) — declares the chain; this skill refreshes the plan source
+- `/promote` — when reconciliation surfaces a missing typed roadmap entity, file as substrate-evolution ticket (mirrors LR4 WU-0 → bassclef#480 pattern)
+- `state_roadmap_get` accessor — read at Step 1 once bassclef#480 ships; until then, canvas-grep is the surface
+
+## Distinct from
+
+- `/sprint` — ticket-level (what's next on the backlog); this is goal-level (what's next in the sequenced roadmap)
+- `/whereami` — point-in-time snapshot reader; this skill EDITS the source canvases that whereami summarizes
+- `/promote` — files new tickets when patterns surface; this skill updates how filed tickets are sequenced
+
+## Sources read
+
+- bassclef#479 (ticket body) — procedure spec
+- `strategy/canvases/2026-05-03-bassclef-platform-primitive.md` — Operator priorities table is the load-bearing surface
+- `strategy/canvases/2026-05-04-hud-on-brownfield-repo.md` — Stage 3 build sequence is the second load-bearing surface
+- `docs/iteration-bets/2026-05-04d-catalog-substrate-roadmap-reconnect.md` WU-0 — manual instance this skill automates
+- `chronicle/2026-05-04d-catalog-substrate-roadmap-reconnect.md` — discoveries section names the meta-loop pattern
+- bassclef#480 (ticket body) — typed roadmap entity gap; this skill bridges to it
+- `.claude/rules/blocked-items.md` — drift surfaces follow the BLOCKED protocol when /longrun prep can't proceed without resolution
+
+## Closes
+
+Filed in iteration-goal `2026-05-04e-LR5-enforcement-and-content` (LR5) WU-1. Closes bassclef#479. The skill itself is the substrate primitive that retires the manual-WU-0 pattern from LR4 onward.
+
+## Output discipline
+
+Dispatch `/kiss words --rewrite` on your skill output before you return it. See `standards/skill-output-discipline.md` for the contract.