@windyroad/itil 0.57.3-preview.933 → 0.58.0-preview.939

package/.claude-plugin/plugin.json

@@ -497,5 +497,5 @@
     }
   },
   "name": "wr-itil",
-  "version": "0.57.3"
+  "version": "0.58.0"
 }

package/hooks/hooks.json

@@ -37,6 +37,10 @@
         "matcher": "Bash",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/p057-staging-trap-detect.sh" }]
       },
+      {
+        "matcher": "Bash",
+        "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/itil-no-implement-draft-gate.sh" }]
+      },
       {
         "matcher": "Bash",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/itil-bash-polling-antipattern-detect.sh" }]

package/hooks/itil-commit-trailer-transition-advisory.sh

@@ -17,7 +17,8 @@
 #   - is NOT the artefact's capture commit (subject does not start with
 #     `docs(rfcs): capture RFC-` / `feat(itil): capture STORY-`), AND
 #   - the referenced artefact is in a pre-in-progress status
-#     (RFC: .proposed/.accepted ; story: .draft) on disk.
+#     (RFC: .proposed/.accepted ; story: .accepted — per ADR-096 a draft
+#     story is blocked from implementation, not advised to advance) on disk.
 # → emit a stderr advisory naming the transition command. Silent otherwise.
 #
 # Advisory-only (ADR-013 Rule 6 fail-open; ADR-045 ≤300-byte band; exit 0).
@@ -69,9 +70,14 @@ while IFS= read -r id; do
       ;;
     STORY-*)
       [ -d "./docs/stories" ] || continue
-      shopt -s nullglob; files=(./docs/stories/draft/${id}-*.md ./docs/stories/${id}-*.draft.md); shopt -u nullglob
+      # ADR-096: a draft story is NEVER implementable — the PreToolUse
+      # itil-no-implement-draft-gate blocks a commit referencing a draft story.
+      # So this advisory now fires for an ACCEPTED story carrying its first
+      # implementing commit: advise accepted -> in-progress (draft -> in-progress
+      # no longer exists; a draft story must be accepted first).
+      shopt -s nullglob; files=(./docs/stories/accepted/${id}-*.md); shopt -u nullglob
       [ ${#files[@]} -gt 0 ] || continue
-      advise "${id} carries a non-capture commit but is still draft. It should advance to in-progress — run /wr-itil:manage-story ${id} in-progress. Bypass: BYPASS_TRANSITION_ADVISORY=1."
+      advise "${id} carries a non-capture implementing commit and is accepted. It should advance to in-progress — run /wr-itil:manage-story ${id} in-progress. Bypass: BYPASS_TRANSITION_ADVISORY=1."
       ;;
   esac
 done <<< "$TRAILERS"

package/hooks/itil-no-implement-draft-gate.sh

@@ -0,0 +1,69 @@
+#!/bin/bash
+# wr-itil — PreToolUse:Bash gate (ADR-096 / P404). A story in `draft` is NEVER
+# implementable. Blocks a `git commit` whose `Refs: STORY-NNN` trailer names a
+# story still in docs/stories/draft/ — implementation requires `accepted` (where
+# the INVEST + RFC-trace gates + ADR-090 ratification fire). Capture commits are
+# exempt (they CREATE the draft story). Bootstrap-exempt commits bypass
+# (ADR-060 A4). Fail-open on every abnormal path (ADR-013 Rule 6).
+#
+# This is the enforcement locus the architect named as the ONLY one that catches
+# the exact P404 bypass — a direct implementing commit against a draft story,
+# whether from the orchestrator or by hand.
+#
+# Bypass: BYPASS_NO_IMPLEMENT_DRAFT=1.
+#
+# @adr ADR-096 (no-implement-while-draft) ADR-060 (lifecycle) ADR-013 (Rule 6)
+#      ADR-095 (sibling capture-time gates) ADR-052 (bats)
+# @problem P404
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/command-detect.sh
+source "$SCRIPT_DIR/lib/command-detect.sh" 2>/dev/null || exit 0
+
+INPUT=$(cat)
+TOOL_NAME=$(printf '%s' "$INPUT" | python3 -c "import sys,json
+try: print(json.load(sys.stdin).get('tool_name',''))
+except: print('')" 2>/dev/null || echo "")
+[ "$TOOL_NAME" = "Bash" ] || exit 0
+
+COMMAND=$(printf '%s' "$INPUT" | python3 -c "import sys,json
+try: print(json.load(sys.stdin).get('tool_input',{}).get('command',''))
+except: print('')" 2>/dev/null || echo "")
+command_invokes_git_commit "$COMMAND" || exit 0
+[ "${BYPASS_NO_IMPLEMENT_DRAFT:-}" = "1" ] && exit 0
+
+# Capture commits create the draft story — exempt. Bootstrap migrations bypass.
+case "$COMMAND" in
+  *"capture STORY-"*) exit 0 ;;
+  *"bootstrap-exempt"*) exit 0 ;;
+esac
+
+# Extract `Refs: STORY-NNN` trailers from the command text (present literally
+# regardless of -m / heredoc form).
+STORIES=$(printf '%s' "$COMMAND" | grep -oE 'Refs:[[:space:]]*STORY-[0-9]{3}' | grep -oE 'STORY-[0-9]{3}' | sort -u)
+[ -n "$STORIES" ] || exit 0
+
+git rev-parse --is-inside-work-tree >/dev/null 2>&1 || exit 0
+[ -d "./docs/stories" ] || exit 0
+
+deny() {
+  cat <<JSON
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "$1"
+  }
+}
+JSON
+  exit 0
+}
+
+while IFS= read -r id; do
+  [ -n "$id" ] || continue
+  shopt -s nullglob; draftfiles=(./docs/stories/draft/${id}-*.md); shopt -u nullglob
+  if [ ${#draftfiles[@]} -gt 0 ]; then
+    deny "BLOCKED (ADR-096 / P404): this commit references ${id} via a Refs: trailer, but ${id} is still in draft. A draft story cannot be implemented — accept it first via /wr-itil:manage-story ${id} accepted (it runs the INVEST + RFC-trace gates + ratification), then re-commit. Bypass: BYPASS_NO_IMPLEMENT_DRAFT=1."
+  fi
+done <<< "$STORIES"
+
+exit 0

package/hooks/test/itil-no-implement-draft-gate.bats

@@ -0,0 +1,82 @@
+#!/usr/bin/env bats
+# Behavioural tests for itil-no-implement-draft-gate.sh (ADR-096 / P404).
+# PreToolUse:Bash — reads a JSON envelope on stdin, emits permissionDecision:deny
+# (exit 0, deny in the JSON) when a commit references a DRAFT story.
+# @adr ADR-096  @adr ADR-052  @problem P404
+
+setup() {
+  HOOK="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)/itil-no-implement-draft-gate.sh"
+  TMP="$(mktemp -d)"; cd "$TMP"; git init -q .
+  mkdir -p docs/stories/draft docs/stories/accepted
+}
+teardown() { cd /; rm -rf "$TMP"; }
+
+# write env.json carrying the given command string
+env_cmd() { python3 -c 'import json,sys; open("env.json","w").write(json.dumps({"tool_name":"Bash","tool_input":{"command":sys.argv[1]}}))' "$1"; }
+
+@test "blocks a commit referencing a DRAFT story" {
+  touch docs/stories/draft/STORY-042-foo.md
+  env_cmd 'git commit -m "fix: thing
+
+Refs: STORY-042"'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  echo "$output" | grep -q '"permissionDecision": "deny"'
+  echo "$output" | grep -q 'STORY-042'
+}
+
+@test "allows a commit referencing an ACCEPTED story" {
+  touch docs/stories/accepted/STORY-042-foo.md
+  env_cmd 'git commit -m "fix: thing
+
+Refs: STORY-042"'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}
+
+@test "exempts a capture commit even for a draft story" {
+  touch docs/stories/draft/STORY-042-foo.md
+  env_cmd 'git commit -m "feat(itil): capture STORY-042 foo
+
+Refs: STORY-042"'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}
+
+@test "bootstrap-exempt commit bypasses" {
+  touch docs/stories/draft/STORY-042-foo.md
+  env_cmd 'git commit -m "migrate
+
+Refs: STORY-042
+bootstrap-exempt: STORY-MAP-001"'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}
+
+@test "non-commit command is a no-op" {
+  touch docs/stories/draft/STORY-042-foo.md
+  env_cmd 'echo Refs: STORY-042'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}
+
+@test "commit with no story trailer is a no-op" {
+  env_cmd 'git commit -m "fix: no story ref"'
+  run bash -c "bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}
+
+@test "BYPASS env allows the commit" {
+  touch docs/stories/draft/STORY-042-foo.md
+  env_cmd 'git commit -m "fix
+
+Refs: STORY-042"'
+  BYPASS_NO_IMPLEMENT_DRAFT=1 run bash -c "BYPASS_NO_IMPLEMENT_DRAFT=1 bash '$HOOK' < env.json"
+  [ "$status" -eq 0 ]
+  ! echo "$output" | grep -q 'deny'
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/itil",
-  "version": "0.57.3-preview.933",
+  "version": "0.58.0-preview.939",
   "description": "ITIL-aligned IT service management for Claude Code (problem, and future incident/change skills)",
   "bin": {
     "windyroad-itil": "./bin/install.mjs"

package/skills/capture-story/SKILL.md

@@ -1,12 +1,12 @@
 ---
 name: wr-itil:capture-story
-description: Lightweight story-capture skill for aside-invocation during foreground work — mandatory leading problem-trace AND JTBD-trace per ADR-060 I6 + I9 invariants, optional `--rfc` and `--story-map` flag args (I7 + I8 enforce at `accepted` transition not at capture), skeleton story file at `docs/stories/draft/STORY-NNN-<slug>.md`, single commit per capture, no inline README refresh. Defers full INVEST shape + acceptance transition to /wr-itil:manage-story. Use when the user (or agent) wants to capture a story quickly with clear problem + JTBD anchoring. For full lifecycle management, use /wr-itil:manage-story.
+description: Lightweight story-capture skill for aside-invocation during foreground work — mandatory leading problem-trace AND JTBD-trace per ADR-060 I6 + I9 invariants, mandatory `--story-map` trace (I8 enforced AT CAPTURE per ADR-095, refuse-and-route if absent) + optional `--rfc` (I7 at accepted) + real user-value + >=1 acceptance criterion at capture (I10 content subset / ADR-095), skeleton story file at `docs/stories/draft/STORY-NNN-<slug>.md`, single commit per capture, no inline README refresh. Defers full INVEST shape + acceptance transition to /wr-itil:manage-story. Use when the user (or agent) wants to capture a story quickly with clear problem + JTBD anchoring. For full lifecycle management, use /wr-itil:manage-story.
 allowed-tools: Read, Write, Edit, Bash, Grep, Glob
 ---
 
 # Capture Story Skill
 
-Capture an INVEST-shaped story ticket quickly during foreground work. Lightweight aside-invocation surface that complements the heavyweight `/wr-itil:manage-story` flow. Mirrors `/wr-itil:capture-rfc` shape per ADR-032 lightweight + heavyweight skill split, extended for the story tier's stricter trace-mandate (both problem AND JTBD at capture; RFC AND story-map deferred to accepted).
+Capture an INVEST-shaped story ticket quickly during foreground work. Lightweight aside-invocation surface that complements the heavyweight `/wr-itil:manage-story` flow. Mirrors `/wr-itil:capture-rfc` shape per ADR-032 lightweight + heavyweight skill split, extended for the story tier's stricter trace-mandate (problem, JTBD, AND story-map at capture — I8 enforced at capture per ADR-095; RFC deferred to accepted).
 
 This skill is one half of the capture-then-manage story framework introduced by ADR-060 (Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology, accepted 2026-05-05; Phase 2 amendment 2026-05-12 introducing the story tier). The other half is `/wr-itil:manage-story` (heavyweight intake + INVEST-gated lifecycle management).
 
@@ -15,8 +15,8 @@ This skill is one half of the capture-then-manage story framework introduced by
 ## When to invoke
 
 - **Slicing an RFC into INVEST-shaped sub-workstreams**: agent / user has captured an RFC and is now decomposing its scope into the ordered `stories:` array per ADR-060's working-the-problem flow (line 300-320). Each slice on a story-map's backbone → ribs → slices grid becomes one story.
-- **Capturing a story before its placement on a story-map**: per ADR-060 line 291, RFC + story-map traces are optional at capture; I7 / I8 enforce only at the `draft → accepted` transition. Draft stories may exist with NO `rfcs:` and NO `story-maps:` until the design firms up.
-- **Retrospective bootstrap migration** (Slice 15 of P170 Phase 2): extracting existing slices from `docs/plans/170-rfc-framework-story-map.md` into individual story files. The bounded-escape carve-out for I7 / I8 enforce-at-accepted permits the retrospective sequence (capture draft, design fills in `rfcs:` + `story-maps:`, manage-story <NNN> accepted gate fires).
+- **Placing a story on its map at capture**: per ADR-095 a story is born on a story map — `--story-map` is MANDATORY at capture (I8 refuse-and-route if absent). `--rfc` stays optional (I7 enforces at the `draft → accepted` transition); a draft story may exist with NO `rfcs:` until the design firms up, but NEVER with an empty `story-maps:`.
+- **Retrospective bootstrap migration** (Slice 15 of P170 Phase 2): extracting existing slices from `docs/plans/170-rfc-framework-story-map.md` into individual story files. The bootstrap-exempt marker (ADR-060 A4 / ADR-053) permits the retrospective sequence to bypass the capture-time I8 hard-block for migration stories ONLY; `rfcs:` still fills in before the manage-story <NNN> accepted gate (I7).
 - **Forward dogfood capture**: a new story for in-flight work, captured at the start of implementation, runs to `done` via `Refs: STORY-NNN` trailer detection + acceptance-criteria all-ticked.
 
 **Use `/wr-itil:manage-story` instead** when:
@@ -153,21 +153,25 @@ jtbd_file=$(ls docs/jtbd/*/JTBD-<NNN>-*.md 2>/dev/null | head -1)
 
 JTBD lifecycle states (`.proposed.md` / `.accepted.md` / `.archived.md`) all pass silently — a story may anchor on a proposed JTBD per the dogfood pattern (Phase 2 itself is being captured against proposed JTBDs).
 
-### 2.6. Validate optional `--rfc` and `--story-map` traces
+### 2.6. Validate story-map trace (I8 hard-block AT CAPTURE per ADR-095) + optional `--rfc`
 
-If `$rfc_trace` is non-empty, for each `RFC-<NNN>`:
+**I8 story-map membership is enforced at CAPTURE (ADR-095) — a story is born on a map.** `--story-map` is MANDATORY:
+
+- **`--story-map` absent**: hard-block with **refuse-and-route** (parity with the I6/I9 mandatory-trace gates). Do NOT scaffold `story-maps: []`. Emit the deny log (`reason: missing-story-map-trace`) and halt with:
+  > `/wr-itil:capture-story` requires a story-map trace (ADR-095 / I8): every story is born on a story map. Create a map first via `/wr-itil:capture-story-map` (or extend one via `/wr-itil:manage-story-map`), then re-invoke capture-story with `--story-map STORY-MAP-<NNN>`.
+
+  AFK orchestrators author the map first (born `human-oversight: unconfirmed` per ADR-090, drained later), then capture the story onto it — nothing halts silently; the map is a prerequisite step.
+- **`--story-map` present**: for each `STORY-MAP-<NNN>`, existence check `ls docs/story-maps/*/STORY-MAP-<NNN>-*.html 2>/dev/null`. Malformed or unresolved → hard-block (`reason: unresolved-story-map-trace`). Lifecycle advisory-warn on `draft` / `in-progress` maps; pass silently on `accepted` / `completed`.
+- **Bootstrap exemption (ADR-060 A4 / ADR-053)**: a capture carrying the inline `<!-- bootstrap-exempt: ... -->` marker bypasses the I8 hard-block for migration stories ONLY. A **non-bootstrap** capture carrying the marker is rejected (the marker is not a general capture-time escape hatch — behavioural test asserts).
+
+`--rfc` stays **OPTIONAL** at capture (I7 enforces at the `accepted` transition — a story can legitimately precede its RFC firming up):
 
 ```bash
 rfc_file=$(ls docs/rfcs/RFC-<NNN>-*.md 2>/dev/null | head -1)
 [ -z "$rfc_file" ] && unresolved_rfcs+=("RFC-<NNN>")
 ```
 
-- Token absent: skip (the "optional" path).
-- Token present but malformed (`--rfc RFC-99`, etc.) OR resolves to no file: hard-block. Emit deny log with `reason: unresolved-rfc-trace`. The optional-vs-malformed distinction is load-bearing — absence is permitted, malformed input is not.
-
-Same shape for `--story-map`. Story-maps are HTML; existence check uses `ls docs/story-maps/*/STORY-MAP-<NNN>-*.html 2>/dev/null`.
-
-Lifecycle classification on resolved files: advisory-warn on `proposed` / `draft` / `in-progress` states (the design isn't firm yet — captured story will reference work that may itself drift); pass silently on `accepted` / `closed` / `verifying` states.
+- `--rfc` token absent: skip (the optional path). Present-but-malformed OR resolves to no file: hard-block (`reason: unresolved-rfc-trace`).
 
 ### 3. Compute next STORY ID
 
@@ -200,7 +204,7 @@ decision-makers: [<git config user.name>]
 problems: [P<NNN>, P<NNN>, ...]
 jtbd: [JTBD-<NNN>, JTBD-<NNN>, ...]
 rfcs: [<RFC-<NNN>, ...> or empty]
-story-maps: [<STORY-MAP-<NNN>, ...> or empty]
+story-maps: [<STORY-MAP-<NNN>, ...>]     # >=1 REQUIRED at capture (I8 / ADR-095)
 estimated-effort: <S|M|L|XL — derived at capture per ADR-067 (real best-effort value, no deferral marker)>
 human-oversight: unconfirmed
 ---
@@ -212,16 +216,16 @@ human-oversight: unconfirmed
 **Problems**: <P<NNN> [, P<NNN>, ...]>
 **JTBD**: <JTBD-<NNN> [, ...]>
 **RFCs**: <RFC-<NNN> [, ...]> or (none — populate at accepted transition per I7)
-**Story Maps**: <STORY-MAP-<NNN> [, ...]> or (none — populate at accepted transition per I8)
+**Story Maps**: <STORY-MAP-<NNN> [, ...]> (>=1 required at capture — I8 / ADR-095)
 **Estimated effort**: <S|M|L|XL> — derived at capture as a real best-effort value (P375 / ADR-032 amendment 2026-06-24; ADR-067 silent-derivation). NO `deferred` default and no "not estimated" marker — those are deferrals (user correction 2026-06-24). Confirmed/refined at the accepted transition per I10 INVEST Estimable.
 
 ## User value (required, INVEST Valuable)
 
-(populate at /wr-itil:manage-story accepted transition — one-paragraph user-facing value statement)
+<REQUIRED at capture (I10 Valuable subset / ADR-095): a real one-paragraph value-first user-facing statement — NOT a placeholder. "In order to <value>, as a <persona>, I want <capability>.">
 
 ## Acceptance criteria (accepted-gate, INVEST Testable)
 
-- [ ] (populate at /wr-itil:manage-story accepted transition — observable behavioural criteria)
+- [ ] <REQUIRED at capture (I10 Testable subset / ADR-095): >=1 real observable behavioural acceptance criterion — NOT a placeholder>
 
 ## Driving problem trace (required — I6 invariant)
 
@@ -335,7 +339,7 @@ The trailing pointer is **not optional** — it is the user-visible signal that
 | Problem-trace I6 enforcement | Re-validated at every lifecycle transition | Hard-block at capture-time; deny logged to `logs/story-capture-denials.jsonl` |
 | JTBD-trace I9 enforcement | Re-validated at every lifecycle transition | Hard-block at capture-time |
 | RFC-trace I7 enforcement | Hard-block at `accepted` transition (allows draft stories to exist before RFC reference firms up) | Advisory-warn at capture-time if `--rfc` provided and resolves to draft/proposed lifecycle |
-| Story-map-trace I8 enforcement | Hard-block at `accepted` transition | Same advisory-warn pattern at capture-time |
+| Story-map-trace I8 enforcement | Hard-block AT CAPTURE — refuse-and-route to `/wr-itil:capture-story-map` if absent (ADR-095) | direction-setting (caller must supply or author a map first) |
 | INVEST shape (I10) | Behavioural checks at `accepted` transition | Out of scope: capture produces a skeleton with deferred-placeholder sections |
 | Skeleton-fill | Full-intake; AskUserQuestion for User value + Acceptance criteria + Estimated effort | Deferred-placeholder pattern; one optional taste prompt only |
 | Status transitions | Step 7 owns draft → accepted → in-progress → done | Out of scope (creation only) |
@@ -373,4 +377,4 @@ The two skills share the `/tmp/wr-itil-story-capture-grep-${SESSION_ID}` create-
 
 ## Phase-out-of-order note
 
-This skill ships BEFORE `/wr-itil:capture-story-map` (Slice 3 of P170 Phase 2) due to the voice-tone-hook-on-HTML blocker documented at P170 line 297. Building capture-story first is structurally permitted per ADR-060 line 291 (story-map traces optional at capture; I8 enforce only at accepted transition). When Slices 3-6 eventually ship the story-map skills, `manage-story <NNN> accepted` will validate the I8 invariant against the then-existing story-map corpus. The deviation from ADR-060's recommended commit-grain order (line 449-454 — sub-slice 3 story-map skills then sub-slice 4 story skills) is auditable here and in this commit's Slice 7 commit message.
+This skill ships BEFORE `/wr-itil:capture-story-map` (Slice 3 of P170 Phase 2) due to the voice-tone-hook-on-HTML blocker documented at P170 line 297. Building capture-story first was structurally permitted at the time (story-map traces were then optional at capture). **Superseded by ADR-095** — I8 now hard-blocks at capture, and `/wr-itil:capture-story-map` has since shipped, so a map must exist before a story is captured. When Slices 3-6 eventually ship the story-map skills, `manage-story <NNN> accepted` will validate the I8 invariant against the then-existing story-map corpus. The deviation from ADR-060's recommended commit-grain order (line 449-454 — sub-slice 3 story-map skills then sub-slice 4 story skills) is auditable here and in this commit's Slice 7 commit message.

package/skills/capture-story/test/capture-story-behavioural.bats

@@ -197,7 +197,7 @@ decision-makers: [Test]
 problems: [P170]
 jtbd: [JTBD-008]
 rfcs: []
-story-maps: []
+story-maps: [STORY-MAP-001]
 estimated-effort: M
 ---
 
@@ -212,6 +212,27 @@ EOF
   done
 }
 
+@test "capture-story: I8-at-capture invariant — a valid captured story has a NON-EMPTY story-maps: (ADR-095)" {
+  mkdir -p docs/stories/draft
+  cat > docs/stories/draft/STORY-001-mapped.md <<EOF
+---
+status: draft
+story-maps: [STORY-MAP-002]
+---
+EOF
+  run grep -E '^story-maps: \[STORY-MAP-[0-9]' docs/stories/draft/STORY-001-mapped.md
+  [ "$status" -eq 0 ]
+  run grep -E '^story-maps: \[\]' docs/stories/draft/STORY-001-mapped.md
+  [ "$status" -ne 0 ]
+}
+
+@test "capture-story: SKILL prescribes refuse-and-route on a missing story-map trace (I8/ADR-095)" {
+  run grep -E 'I8 hard-block AT CAPTURE|refuse-and-route|missing-story-map-trace' "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -E 'story-map traces are optional at capture' "$SKILL_FILE"
+  [ "$status" -ne 0 ]
+}
+
 @test "capture-story: captured story file lands at docs/stories/draft/ per ADR-060 lines 145-147" {
   # Story-maps use HTML and lifecycle subdirs (draft/accepted/in-progress/
   # completed/archived); stories use markdown and lifecycle subdirs