@windyroad/itil 0.11.0-preview.148 → 0.12.0-preview.150

package/.claude-plugin/plugin.json

@@ -1,5 +1,5 @@
 {
   "name": "wr-itil",
-  "version": "0.11.0",
+  "version": "0.12.0",
   "description": "ITIL-aligned IT service management for Claude Code"
 }

package/package.json

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

package/skills/manage-problem/SKILL.md

@@ -125,9 +125,10 @@ What "work" means depends on the problem's status:
 ### 1. Parse the request
 
 Determine the operation from `$ARGUMENTS`:
-- If arguments start with a number (e.g., "011"), this is an update or transition
+- If arguments start with a number (e.g., "011") **followed by a status word** (`known-error`, `verifying`, or `close`), **delegate to `/wr-itil:transition-problem`** via the Skill tool. See "Deprecated-argument forwarders" below.
+- If arguments start with a bare number (e.g., "011" with no status word after it), this is an update flow — handled inline by the ticket-body edit steps (Step 6).
 - If arguments contain "list", **delegate to `/wr-itil:list-problems`** via the Skill tool. See "Deprecated-argument forwarders" below.
-- If arguments contain "work", run a **review** first (step 9), then begin working the highest-WSJF problem
+- If arguments contain "work", **delegate to `/wr-itil:work-problem`** via the Skill tool. See "Deprecated-argument forwarders" below.
 - If arguments contain "review", **delegate to `/wr-itil:review-problems`** via the Skill tool. See "Deprecated-argument forwarders" below.
 - Otherwise, this is a new problem creation
 
@@ -151,7 +152,23 @@ When `$ARGUMENTS` contains the word `review` as a top-level argument (not inside
 
 The forwarder does NOT re-implement the review logic locally — it invokes the Skill tool with `wr-itil:review-problems` and returns the new skill's output verbatim. Duplicating the Step 9 re-scoring / auto-transition / verification-prompt / README-refresh stack would harden the deprecation window into a permanent fork.
 
-Forwarders for `work`, `<NNN> known-error`, and `<NNN> close` land in subsequent P071 phased-landing slices (see P071 ticket's "Split proposal" section for the full plan). Until those slices land, the corresponding Step-2+ branches continue to execute inline.
+**Forwarder for `work`** (P071 split slice 3 — new skill `/wr-itil:work-problem`, singular):
+
+When `$ARGUMENTS` contains the word `work` as a top-level argument (not inside a ticket body edit), delegate to `/wr-itil:work-problem` via the Skill tool and emit this systemMessage verbatim:
+
+> `/wr-itil:manage-problem work is deprecated; use /wr-itil:work-problem directly. This forwarder will be removed in @windyroad/itil's next major version.`
+
+The forwarder does NOT re-implement the selection logic locally — it invokes the Skill tool with `wr-itil:work-problem` and returns the new skill's output verbatim. Duplicating the freshness-check / AskUserQuestion selection / delegate-to-`manage-problem <NNN>` stack would harden the deprecation window into a permanent fork. Note the singular/plural distinction: the forwarder targets `/wr-itil:work-problem` (singular, one ticket per invocation), NOT `/wr-itil:work-problems` (plural AFK orchestrator). The two names coexist intentionally per P071.
+
+**Forwarder for `<NNN> <status>` transitions** (P071 split slice 4 — new skill `/wr-itil:transition-problem`):
+
+When `$ARGUMENTS` starts with a three-digit ticket ID followed by a status word (`known-error`, `verifying`, or `close`), delegate to `/wr-itil:transition-problem` via the Skill tool and emit the canonical deprecation notice verbatim, naming the specific argument form the user supplied:
+
+> `/wr-itil:manage-problem <NNN> <status> is deprecated; use /wr-itil:transition-problem <NNN> <status> directly. This forwarder will be removed in @windyroad/itil's next major version.`
+
+The parser must distinguish a **bare `<NNN>`** (update flow — handled inline by Step 6) from a **`<NNN> <status>` pair** (transition — delegated). The status-word tokens that trigger the transition forwarder are fixed: `known-error`, `verifying`, `close`. Any other suffix after `<NNN>` routes to the inline update flow per Step 6. This preserves the two legitimate shapes the original subcommand carried while splitting the transition intent out cleanly.
+
+The forwarder does NOT re-implement the Step 7 transition logic locally — it invokes the Skill tool with `wr-itil:transition-problem` and returns the new skill's output verbatim. Duplicating the pre-flight-checks / P063-external-root-cause-detection / P057-staging-trap / P062-README-refresh stack would harden the deprecation window into a permanent fork. The delegated `/wr-itil:transition-problem` skill then re-invokes `/wr-itil:manage-problem <NNN> <status>` to run the authoritative Step 7 block — but routed through the clean-split skill's data-parameter contract, not the deprecated subcommand path. Lifecycle completeness (known-error + verifying + close) is covered per ADR-022's three-status mandate.
 
 ### 2. For new problems: Check for duplicates FIRST
 

package/skills/manage-problem/test/manage-problem-transition-forwarder.bats

@@ -0,0 +1,96 @@
+#!/usr/bin/env bats
+# Contract assertions for manage-problem's `<NNN> <status>` transition forwarder (P071 split slice 4).
+#
+# Per ADR-010 amended (Skill Granularity section) + P071 phased plan:
+# `/wr-itil:manage-problem <NNN> known-error` (and the sibling close
+# form) delegates to the new `/wr-itil:transition-problem` skill via
+# a thin-router forwarder. Original skill already carries
+# `deprecated-arguments: true` frontmatter from slice 1; this file
+# asserts the transition-forwarder-specific contract.
+#
+# Note on shape: the transition forwarders are the trickiest of the
+# P071 phased set because the argument is `<NNN> <word>` (data +
+# verb). The parser must route on the PRESENCE of the verb token
+# (`known-error` / `verifying` / `close`) AFTER the data parameter
+# `<NNN>`. A bare `<NNN>` remains the legitimate update flow — it
+# must NOT forward. This test locks the distinction in.
+#
+# Structural assertion — Permitted Exception to the source-grep ban
+# (ADR-005 / P011 / ADR-037 contract-assertion pattern).
+#
+# @problem P071
+# @jtbd JTBD-001 (enforce governance without slowing down)
+# @jtbd JTBD-101 (extend the suite with clear patterns)
+#
+# Cross-reference:
+#   P071: docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md
+#   ADR-010 amended — split naming + forwarder contract + deprecated-arguments flag
+#   ADR-013 Rule 1 — structured user interaction (forwarder emits systemMessage, not AskUserQuestion)
+#   ADR-022 — Verification Pending is a first-class status; .verifying.md suffix on release
+#   ADR-037 — contract-assertion bats pattern
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+}
+
+@test "manage-problem Step 1 forwards '<NNN> known-error' argument to /wr-itil:transition-problem (P071 slice 4)" {
+  # The forwarder names the target skill explicitly so the router is
+  # legible at the contract level. ADR-010's canonical shape: "invokes
+  # the new named skill via the Skill tool, not via re-prompting the
+  # user".
+  run grep -inE "/wr-itil:transition-problem" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 emits the canonical known-error transition deprecation notice (ADR-010 amended)" {
+  # ADR-010's canonical deprecation-notice template:
+  # "/wr-<plugin>:<old> <arg> is deprecated; use /wr-<plugin>:<new>
+  #  directly. This forwarder will be removed in <plugin>'s next major
+  #  version."
+  # The notice MUST be emitted as a systemMessage (not AskUserQuestion)
+  # because deprecation is informational, not decisional (ADR-013
+  # Rule 1 scope). The transition-forwarder notice is distinct from
+  # list + review + work forwarders; all four must co-exist verbatim.
+  run grep -inE "is deprecated.*use /wr-itil:transition-problem|deprecated.*transition-problem|removed in .* next major version" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 transition-forwarder does not re-implement Step 7 transition logic (P071 regression guard)" {
+  # The forwarder must not duplicate the transition logic — it must
+  # delegate. Per ADR-010: "thin-router forwarder re-invokes the new
+  # named skill via the Skill tool". If the forwarder grows its own
+  # pre-flight + P057 + P063 + P062 stack, the deprecation window
+  # will harden into a permanent fork.
+  run grep -inE "delegate.*transition-problem|Skill tool.*transition-problem|transition-problem.*Skill tool" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 parser distinguishes bare <NNN> (update) from <NNN> <status> (transition)" {
+  # Critical safety rule: a bare `<NNN>` argument must REMAIN the
+  # update flow — it must not accidentally forward to
+  # transition-problem. Only the `<NNN> <status>` shape (where
+  # <status> ∈ {known-error, verifying, close}) triggers the
+  # transition forwarder. The parser block must name both branches
+  # so the distinction is legible at the contract level.
+  run grep -inE "known-error|verifying|close" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  # And the bare-NNN update path is still documented.
+  run grep -inE "bare .NNN.|update flow|<NNN>.*update" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem transition-forwarder covers known-error, verifying, and close (lifecycle completeness)" {
+  # ADR-022 codifies three transition destinations: known-error,
+  # verifying (Verification Pending), and closed. All three must
+  # appear in the forwarder contract so users can rely on the
+  # forwarder for the full lifecycle during the deprecation window.
+  # Missing any destination would force users back onto inline
+  # execution for that one case.
+  run grep -inE "known-error" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "verifying|verification.pending" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "\bclose\b" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}

package/skills/manage-problem/test/manage-problem-work-forwarder.bats

@@ -0,0 +1,88 @@
+#!/usr/bin/env bats
+# Contract assertions for manage-problem's `work` subcommand forwarder (P071 split slice 3).
+#
+# Per ADR-010 amended (Skill Granularity section) + P071 phased plan:
+# `/wr-itil:manage-problem work` delegates to the new
+# `/wr-itil:work-problem` (singular) skill via a thin-router forwarder.
+# Original skill already carries `deprecated-arguments: true` frontmatter
+# from slice 1; this file asserts the work-forwarder-specific contract.
+#
+# CRITICAL naming distinction: the forwarder target is singular
+# `/wr-itil:work-problem` — NOT the plural `/wr-itil:work-problems`
+# (the AFK orchestrator that already exists). Name coexistence is a
+# P071-acknowledged trade-off.
+#
+# Structural assertion — Permitted Exception to the source-grep ban
+# (ADR-005 / P011 / ADR-037 contract-assertion pattern).
+#
+# @problem P071
+# @jtbd JTBD-001 (enforce governance without slowing down)
+# @jtbd JTBD-101 (extend the suite with clear patterns)
+#
+# Cross-reference:
+#   P071: docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md
+#   ADR-010 amended — split naming + forwarder contract + deprecated-arguments flag
+#   ADR-013 Rule 1 — structured user interaction (forwarder emits systemMessage, not AskUserQuestion)
+#   ADR-037 — contract-assertion bats pattern
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+}
+
+@test "manage-problem Step 1 forwards 'work' argument to /wr-itil:work-problem singular (P071 slice 3)" {
+  # The forwarder names the target skill explicitly so the router is
+  # legible at the contract level. ADR-010's canonical shape: "invokes
+  # the new named skill via the Skill tool, not via re-prompting the
+  # user". Target is the SINGULAR name.
+  run grep -inE "/wr-itil:work-problem\b" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 work-forwarder target is singular, not plural (name collision guard)" {
+  # The forwarder target MUST be /wr-itil:work-problem (singular).
+  # The plural /wr-itil:work-problems already exists as the AFK
+  # orchestrator and has a completely different semantics (batch loop
+  # vs single ticket). A forwarder that routed 'work' to the plural
+  # orchestrator would subtly break interactive invocations — the user
+  # would get an AFK-mode iteration loop when they wanted one ticket.
+  #
+  # Assert the forwarder block explicitly names 'singular' so the
+  # distinction is legible at the contract level.
+  run grep -inE "/wr-itil:work-problem.*singular|singular.*work-problem" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 emits the canonical work deprecation notice (ADR-010 amended)" {
+  # ADR-010's canonical deprecation-notice template:
+  # "/wr-<plugin>:<old> <arg> is deprecated; use /wr-<plugin>:<new>
+  #  directly. This forwarder will be removed in <plugin>'s next major
+  #  version."
+  # The notice MUST be emitted as a systemMessage (not AskUserQuestion)
+  # because deprecation is informational, not decisional (ADR-013 Rule 1
+  # scope). Work-forwarder notice is distinct from list + review
+  # forwarders; all three must co-exist verbatim.
+  run grep -inE "is deprecated.*use /wr-itil:work-problem|deprecated.*work-problem|removed in .* next major version" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem Step 1 work-forwarder does not re-implement selection logic (P071 regression guard)" {
+  # The forwarder must not duplicate the selection logic — it must
+  # delegate. Per ADR-010: "thin-router forwarder re-invokes the new
+  # named skill via the Skill tool". If the forwarder grows its own
+  # freshness-check + AskUserQuestion + delegate stack, the
+  # deprecation window will harden into a permanent fork.
+  run grep -inE "delegate.*work-problem\b|Skill tool.*work-problem\b|work-problem\b.*Skill tool" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "manage-problem work-forwarder Step 1 parser delegates, does not run inline (P071 slice 3)" {
+  # Slice 3's defining behaviour: Step 1's `work` branch must delegate,
+  # not run the review+select flow inline. The parser line must say
+  # "delegate to /wr-itil:work-problem", matching the shape the list
+  # and review forwarders use. A stale "run a review (step 9) first"
+  # line would indicate the forwarder was added without updating the
+  # parser (common slip per slice 2's lesson).
+  run grep -nE "^- If arguments contain \"work\", \*\*delegate to \`/wr-itil:work-problem\`\*\*" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}

package/skills/transition-problem/SKILL.md

@@ -0,0 +1,133 @@
+---
+name: wr-itil:transition-problem
+description: Advance a problem ticket's lifecycle status — Open → Known Error, Known Error → Verification Pending (verifying), Verification Pending → Closed. Renames the ticket file, updates the Status field, and refreshes docs/problems/README.md in the same commit. Delegates the execution to /wr-itil:manage-problem so the pre-flight checks, P057 staging-trap handling, P063 external-root-cause detection, and P062 README refresh stay on a single authoritative workflow. Use when the user asks to "transition", "close", "mark known-error", or "release" a specific ticket.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion, Skill
+---
+
+# Transition Problem — Lifecycle Advance
+
+Advance a specific problem ticket along the ITIL lifecycle: Open → Known Error → Verification Pending → Closed. The skill is a **thin-router selection surface** — it identifies the ticket and the destination status, then delegates the actual transition execution to `/wr-itil:manage-problem <NNN>` (which hosts the authoritative Step 7 transition block). This preserves the single-workflow ownership of the pre-flight checks, external-root-cause detection (P063), staging-trap handling (P057), and README.md refresh (P062).
+
+This skill is phase 4 of the P071 phased-landing split of `/wr-itil:manage-problem <NNN> <status>` per ADR-010's amended Skill Granularity rule (one skill per distinct user intent). The original `/wr-itil:manage-problem <NNN> known-error` subcommand route remains as a thin-router forwarder during the deprecation window but is scheduled for removal in `@windyroad/itil`'s next major version.
+
+## Arguments
+
+- `<NNN>` — the ticket ID (data parameter, e.g. `042`). Required.
+- `<status>` — the destination status. One of:
+  - `known-error` — Open → Known Error (root cause confirmed, fix path clear, fix not yet released).
+  - `verifying` — Known Error → Verification Pending (fix released, awaiting user verification per ADR-022).
+  - `close` — Verification Pending → Closed (user has confirmed the fix works in production).
+
+The `<NNN>` and `<status>` tokens are **data parameters**, not word-subcommands. Per the P071 split rule (ADR-010 amended), data parameters (IDs, paths, URLs, enum destinations) are permitted; word-subcommands that name distinct user intents are not. This skill's argument shape is `data + data`, which is the same shape as `/wr-itil:report-upstream <NNN>`.
+
+## Scope
+
+**In scope:**
+- Validate that the ticket file exists and the destination status is reachable from the current status (e.g. an `.open.md` file cannot transition directly to Verification Pending — it must go through Known Error first).
+- Delegate the transition execution to `/wr-itil:manage-problem <NNN> <status>` via the Skill tool so the full Step 7 block runs (pre-flight checks, external-root-cause detection, file rename, Status field edit, staging re-stage per P057, README.md refresh per P062, commit per ADR-014).
+- Report the outcome (new filename, new Status, commit SHA).
+
+**Out of scope:**
+- Re-implementing the Step 7 transition logic inline. Delegation to `/wr-itil:manage-problem` is the anti-fork discipline.
+- Backlog re-ranking — that's `/wr-itil:review-problems`.
+- Ticket creation or bare-update flows — that's `/wr-itil:manage-problem` (no-args form for creation, `<NNN>` bare for update).
+- Parking a ticket — that's a distinct lifecycle move handled by `/wr-itil:manage-problem` directly (the `.parked.md` suffix has its own pre-flight path including P063 external-root-cause detection for `upstream-blocked` reasons).
+
+## Steps
+
+### 1. Parse the arguments
+
+From `$ARGUMENTS`, extract the ticket ID (`<NNN>`, three digits) and the destination status (one of `known-error`, `verifying`, `close`). If either is missing or malformed, emit a usage message and stop:
+
+```
+Usage: /wr-itil:transition-problem <NNN> <status>
+  <NNN>    — three-digit ticket ID (e.g. 042)
+  <status> — one of: known-error, verifying, close
+```
+
+### 2. Discover the ticket file
+
+Locate the ticket file by ID:
+
+```bash
+ls docs/problems/<NNN>-*.md 2>/dev/null
+```
+
+If no file is found, emit: `No ticket found for ID <NNN>` and stop.
+
+If multiple files are found (should not happen — suffix-exclusive lifecycle), emit a warning and list the matches; stop and let the user resolve.
+
+### 3. Validate the transition path
+
+Check the current filename suffix and verify the destination status is reachable in one step:
+
+| Current suffix | Destination argument | Valid? |
+|----------------|----------------------|--------|
+| `.open.md` | `known-error` | yes |
+| `.known-error.md` | `verifying` | yes |
+| `.verifying.md` | `close` | yes |
+| any other pairing | — | no — emit an error and stop |
+
+If the pairing is invalid, emit a clear message naming the current status, the requested destination, and the valid next step. Do not silently skip or auto-correct — invalid transitions are almost always user typos and a clear error is the cheapest recovery.
+
+### 4. Delegate the transition to `/wr-itil:manage-problem <NNN> <status>`
+
+Invoke `/wr-itil:manage-problem` via the Skill tool with the `<NNN> <status>` argument shape. The delegated skill runs its Step 7 transition block, which owns:
+
+- **Pre-flight checks** — root cause documented, investigation tasks checked off, reproduction test referenced, workaround documented, effort re-rated (P047). Any missing check halts the transition with a specific error.
+- **P063 external-root-cause detection** — fires on Open → Known Error (and on the `upstream-blocked` park path). If a strict-token hit appears in the Root Cause Analysis section, the prompt routes the user to `/wr-itil:report-upstream` or defers with a stable marker. The AFK fallback (per ADR-013 Rule 6) appends the deferred-report marker automatically.
+- **Staging trap handling (P057)** — after `git mv` renames the file, the Edit tool writes the Status field and (for the `verifying` destination) the `## Fix Released` section. The re-stage (`git add <new>`) is explicit — without it the content edit leaks into the next commit and the audit trail breaks.
+- **README.md refresh (P062)** — regenerates `docs/problems/README.md` in-place on every transition so the dev-work table, Verification Queue, and Parked section never lag the on-disk ticket inventory. The refresh joins the same commit as the rename + content edit.
+- **Commit per ADR-014** — governance skills commit their own work. Transition commits use the conventions named in the delegated skill's Step 11 block.
+
+**Why delegate rather than re-implement:** the Step 7 block is a policy-governed, multi-concern flow (pre-flight + P063 + P057 + P062 + ADR-014 commit). Re-hosting it on a sibling skill would fork the ownership contract and compound maintenance cost. The split skill (this file) owns the *selection* of ticket + destination; `/wr-itil:manage-problem` owns the *execution*.
+
+### 5. AFK / non-interactive branch (ADR-013 Rule 6)
+
+When this skill is invoked inside an AFK orchestrator (detect via `/wr-itil:work-problems` markers in the invoking prompt — phrases like "AFK", "work-problems", "batch-work", "ALL_DONE"), do NOT emit `AskUserQuestion`. The orchestrator has already selected the transition (commonly Known Error → Verification Pending as part of a release commit) and this skill runs the execution only. The P063 external-root-cause detection's AFK fallback is owned by the delegated `/wr-itil:manage-problem` Step 7 block; this skill inherits that behaviour without re-implementing it.
+
+Interactive mode (no orchestrator markers): the skill proceeds through Steps 1–4 directly. If any pre-flight check fails inside the delegated skill, the delegation returns that error and this skill surfaces it verbatim.
+
+### 6. Report the outcome
+
+After the delegated `/wr-itil:manage-problem <NNN> <status>` completes:
+
+1. Report: ticket ID, previous Status, new Status, new filename, commit SHA.
+2. If the destination was `verifying`, name the `## Fix Released` section's release marker in the output so the user can correlate with the shipped version.
+3. **Do NOT re-commit or re-refresh** — the delegated skill already committed the change per ADR-014 and refreshed the README per P062. Re-emitting either would break the single-commit audit trail.
+
+## Ownership boundary
+
+`transition-problem` owns:
+- Argument parsing (`<NNN> <status>`).
+- Ticket-file discovery via `ls docs/problems/<NNN>-*.md`.
+- Destination-reachability validation (Open → Known Error → Verification Pending → Closed, one step at a time).
+- Delegating one transition execution to `/wr-itil:manage-problem <NNN> <status>`.
+
+`transition-problem` does NOT:
+- Run the Step 7 transition block inline — delegates to `/wr-itil:manage-problem`.
+- Fire the P063 external-root-cause detection prompt directly — delegated skill owns it.
+- Refresh `docs/problems/README.md` directly — delegated skill owns the refresh per P062.
+- Commit — delegated skill commits per ADR-014.
+- Park tickets — the `.parked.md` suffix has its own path on `/wr-itil:manage-problem` (P063 AFK fallback fires there too).
+
+## Related
+
+- **P071** (`docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md`) — originating ticket. This skill is phase 4 of the P071 phased-landing plan (list-problems was phase 1; review-problems was phase 2; work-problem was phase 3).
+- **ADR-010 amended** (`docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md` — Skill Granularity section) — canonical skill-split naming + forwarder contract + `deprecated-arguments: true` frontmatter flag.
+- **ADR-013** (`docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md`) — Rule 1 for interactive prompts; Rule 6 for the AFK non-interactive branch.
+- **ADR-014** — governance skills commit their own work. The delegated `/wr-itil:manage-problem <NNN> <status>` owns the per-transition commit; this skill does not re-commit.
+- **ADR-022** — `.verifying.md` suffix on release; Verification Pending is a first-class status distinct from Known Error. Known Error → Verification Pending is the most common transition this skill forwards.
+- **ADR-032** — governance skill invocation patterns. `/wr-itil:work-problems` may delegate transition iterations to this skill during AFK release orchestration.
+- **ADR-037** (`docs/decisions/037-skill-testing-strategy.proposed.md`) — contract-assertion bats pattern applied to this skill.
+- **P057** — `git mv` + Edit staging trap rationale; the delegated Step 7 block implements the re-stage. Named here as a transitive contract so callers can reason about the dependency.
+- **P062** — `/wr-itil:review-problems` is the canonical README.md cache writer, but Step 7 transitions also refresh README.md in-place per P062's mechanism. Named here as a transitive contract.
+- **P063** — external-root-cause detection at Open → Known Error and at the `upstream-blocked` park path. The delegated Step 7 block owns the prompt; this skill inherits the AFK fallback without re-implementing.
+- **JTBD-001** (`docs/jtbd/solo-developer/JTBD-001-enforce-governance.proposed.md`) — discoverable surface via `/wr-itil:` autocomplete. Users type `/wr-itil:transition-problem 042 known-error` rather than remembering the `manage-problem <NNN> known-error` subcommand.
+- **JTBD-101** (`docs/jtbd/plugin-developer/JTBD-101-extend-suite.proposed.md`) — one skill per distinct user intent.
+- `packages/itil/skills/manage-problem/SKILL.md` — hosts the thin-router forwarder for the deprecated `manage-problem <NNN> known-error` form; also the delegated execution target for each transition.
+- `packages/itil/skills/review-problems/SKILL.md` — sibling refresh skill; this skill's transitions trigger the same README.md regeneration mechanism P062 codifies.
+- `packages/itil/skills/list-problems/SKILL.md` — sibling read-only display skill; same cache contract.
+- `packages/itil/skills/work-problem/SKILL.md` — sibling selection skill; delegates per-ticket execution (including transitions) through `/wr-itil:manage-problem`.
+
+$ARGUMENTS

package/skills/transition-problem/test/transition-problem-contract.bats

@@ -0,0 +1,175 @@
+#!/usr/bin/env bats
+# Contract assertions for /wr-itil:transition-problem (P071 split slice 4).
+#
+# This skill hosts the "advance a ticket's lifecycle" user intent
+# previously hidden behind /wr-itil:manage-problem <NNN> known-error
+# (and the sibling <NNN> close form). Transition renames the ticket
+# file, updates the Status field, and refreshes docs/problems/README.md
+# in the same commit per ADR-014 + ADR-022 + P062.
+#
+# Execution is delegated to /wr-itil:manage-problem <NNN> with the
+# status argument — the Step 7 transition block on manage-problem owns
+# the pre-flight checks, the P057 staging-trap handling, the external-
+# root-cause detection (P063), the `## Fix Released` section writes,
+# and the README.md refresh. This skill is a thin-router selection
+# surface; execution stays on the authoritative workflow to avoid
+# forking the transition logic.
+#
+# Structural assertion — Permitted Exception to the source-grep ban
+# (ADR-005 / P011 / ADR-037 contract-assertion pattern).
+#
+# @problem P071
+# @jtbd JTBD-001 (enforce governance without slowing down — discoverable surface)
+# @jtbd JTBD-101 (extend the suite with clear patterns — one skill per distinct user intent)
+#
+# Cross-reference:
+#   P071: docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md
+#   ADR-010 amended (Skill Granularity section) — split naming + forwarder contract
+#   ADR-013 Rule 1 — structured user interaction (tie-break selection, if any)
+#   ADR-013 Rule 6 — AFK non-interactive fallback
+#   ADR-014 — governance skills commit their own work (delegated target owns commits)
+#   ADR-022 — .verifying.md suffix on release; Verification Pending distinct from Known Error
+#   ADR-037 — contract-assertion bats pattern
+#   P057 — git mv + Edit staging trap
+#   P062 — README.md refresh on every transition
+#   P063 — external-root-cause detection at Open → Known Error
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+}
+
+@test "SKILL.md exists and has frontmatter" {
+  [ -f "$SKILL_FILE" ]
+  run head -1 "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  [ "$output" = "---" ]
+}
+
+@test "SKILL.md frontmatter name is wr-itil:transition-problem (P071 + ADR-010 amended)" {
+  # Split naming convention per ADR-010 amendment: <verb>-<object>.
+  # The verb is "transition" (not "resolve", "advance", or
+  # "change-status") because the original subcommand form was
+  # `/wr-itil:manage-problem <NNN> known-error` — a status transition
+  # with a declarative destination. The P071 ticket's split proposal
+  # names this skill explicitly; the test locks the name in.
+  run grep -n "^name: wr-itil:transition-problem$" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter description names the transition intent (P071)" {
+  # Description must name "transition" / "status" / one of the
+  # destination names (known-error / verifying / closed) so Claude Code
+  # autocomplete surfaces the user intent rather than a generic name.
+  run grep -inE "^description:.*(transition|status|lifecycle|advance)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "^description:.*(known.error|verification|closed|verify)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter allowed-tools includes Skill (delegation to manage-problem)" {
+  # Step 3 delegates the per-ticket transition execution to
+  # /wr-itil:manage-problem <NNN> <status> via the Skill tool — the
+  # authoritative Step 7 block (pre-flight + P057 + P063 + P062) must
+  # remain on manage-problem to avoid forking the transition logic.
+  run grep -nE "^allowed-tools:.*Skill" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter allowed-tools includes Bash (ticket-file discovery)" {
+  # Step 1 discovers the ticket file for a given ID by listing
+  # docs/problems/<NNN>-*.md. That's a Bash invocation; without the
+  # tool in allowed-tools, the discovery step cannot run.
+  run grep -nE "^allowed-tools:.*Bash" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents all three lifecycle transition destinations (ADR-022)" {
+  # The canonical lifecycle per ADR-022: Open → Known Error → Verification Pending → Closed.
+  # The skill must name each destination so users can pick the right
+  # transition. Missing any destination would leave a gap in the
+  # split coverage and force users back to the deprecated forwarder.
+  run grep -inE "known.error" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "verifying|verification.pending" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "\.closed\.md|closed" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md delegates transition execution to /wr-itil:manage-problem (anti-fork discipline)" {
+  # Per ADR-010 thin-router: the split skill owns intent selection,
+  # NOT execution. The pre-flight / staging-trap / P063 external-root-
+  # cause / README refresh stack stays on /wr-itil:manage-problem
+  # Step 7. If this skill re-implements the transition inline, the
+  # deprecation window hardens into a permanent fork.
+  run grep -inE "/wr-itil:manage-problem" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "delegate.*manage-problem|Skill tool.*manage-problem|manage-problem.*Skill tool" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md cites the P057 staging-trap rule (transitive contract)" {
+  # The delegated Step 7 block on manage-problem implements the
+  # staging-trap rule (re-stage after git mv + Edit). This skill must
+  # reference P057 so the transitive-contract dependency is legible —
+  # if the manage-problem Step 7 rule changes, this skill's delegation
+  # contract changes with it.
+  run grep -inE "P057|staging.trap|re-stage" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md cites the P062 README.md refresh rule (transitive contract)" {
+  # The delegated Step 7 block refreshes docs/problems/README.md on
+  # every transition. This skill must reference P062 so the
+  # downstream-refresh expectation is legible to callers (and so the
+  # skill does not mistakenly skip the refresh on the assumption that
+  # "the README is someone else's job").
+  run grep -inE "P062|README\.md.*refresh|refresh.*README\.md" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md cites ADR-022 (Verification Pending is a first-class status)" {
+  # Known Error → Verification Pending is the transition most users
+  # will type this skill for (it fires on every released fix). The
+  # skill must cite ADR-022 so the semantic distinction — "Verification
+  # Pending means fix SHIPPED, not fix-path-clear" — stays legible.
+  run grep -inE "ADR-022" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents the AFK non-interactive branch (ADR-013 Rule 6)" {
+  # When /wr-itil:work-problems invokes this skill inside an AFK
+  # subagent iteration, AskUserQuestion is unavailable — the skill
+  # must degrade gracefully. Common case: Known Error → Verification
+  # Pending fires automatically in the release-commit orchestration.
+  run grep -inE "AFK|non-interactive|ADR-013 Rule 6|Rule 6" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md does not carry a deprecated-arguments frontmatter flag (clean-split skill)" {
+  # Architect advisory: transition-problem is a clean-split skill. The
+  # deprecated-arguments flag is only valid on host skills with
+  # forwarder routes — transition-problem is a forwarder TARGET, not
+  # a host. The status argument (known-error / verifying / close) is
+  # a *data parameter*, not a word-subcommand, per the P071 split rule.
+  run grep -E "^deprecated-arguments:" "$SKILL_FILE"
+  [ "$status" -ne 0 ]
+}
+
+@test "SKILL.md cites P071 and ADR-010 amended (traceability per ADR-037)" {
+  # ADR-037 traceability: the skill spec cites the problem it closes
+  # and the ADR that authorises the split.
+  run grep -inE "P071|ADR-010" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents the ticket-ID data-parameter shape (not a word-subcommand)" {
+  # The ticket ID (<NNN>) is a data parameter per P071's split rule.
+  # The status destination (known-error / verifying / close) is ALSO
+  # a data parameter — the user supplies it alongside the ID. This is
+  # the same shape as /wr-itil:report-upstream <NNN>: data parameters
+  # are fine, word-subcommands routing to distinct user intents are not.
+  run grep -inE "<NNN>|ticket.{0,5}ID|ID.*argument|data parameter" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}

package/skills/work-problem/SKILL.md

@@ -0,0 +1,130 @@
+---
+name: wr-itil:work-problem
+description: Pick the highest-WSJF open or known-error problem ticket and work it — investigate, implement, commit, and release per the standard manage-problem workflow. Interactive singular variant; distinct from /wr-itil:work-problems (plural AFK orchestrator). Use this when the user asks to "work the next problem", "work the top of the queue", or "grind through one ticket".
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion, Skill, Agent
+---
+
+# Work Problem — Pick-and-Run
+
+Pick the highest-WSJF ticket from the current backlog and work it end-to-end. This is the **singular, interactive** entry point — one ticket per invocation, driven by an `AskUserQuestion` selection when the WSJF ranking is tied.
+
+This skill is the P071 phased-landing split of `/wr-itil:manage-problem work` per ADR-010 amended Skill Granularity rule: one skill per distinct user intent. The original `/wr-itil:manage-problem work` subcommand route remains as a thin-router forwarder during the deprecation window but is scheduled for removal in `@windyroad/itil`'s next major version.
+
+## Name distinction (work-problem vs work-problems)
+
+- **`/wr-itil:work-problem`** (singular, this skill) — one ticket per invocation. Interactive `AskUserQuestion` selection. Intended for a user who wants to dispatch the next-highest ticket and then stop.
+- **`/wr-itil:work-problems`** (plural, AFK orchestrator) — loops through the backlog by WSJF, delegating each iteration to this skill (via the Agent tool, per ADR-032 + P077). Intended for AFK batch runs; non-interactive selection; stops only when nothing actionable remains.
+
+Both names coexist intentionally per P071's out-of-scope note on the naming coexistence. The plural orchestrator uses this skill as its per-iteration unit.
+
+## Scope
+
+**In scope:**
+- Read `docs/problems/README.md` when fresh; otherwise delegate the refresh to `/wr-itil:review-problems` first (never re-implement the re-scoring logic locally — same anti-fork discipline as the list-problems cache path).
+- Select the highest-WSJF ticket via `AskUserQuestion` (structured-interaction path per ADR-013 Rule 1). Present ties as peer options with per-option rationale.
+- Delegate the actual work to `/wr-itil:manage-problem <NNN>` via the Skill tool so the investigation / known-error transition / fix / closure flow stays hosted on a single authoritative workflow (ADR-010 thin-router discipline applied to the work path).
+- Scope-expansion prompt (ADR-013 Rule 1) when the selected ticket's effort grows during work — same three-option structure as `/wr-itil:manage-problem`'s Working a Problem section.
+
+**Out of scope:**
+- Batch looping over multiple tickets — that's `/wr-itil:work-problems` (plural). This skill runs exactly one ticket per invocation.
+- Backlog re-ranking / Verification Queue prompt / README.md refresh — that's `/wr-itil:review-problems`. This skill reads the ranking; it does not rewrite it.
+- Ticket creation — that's `/wr-itil:manage-problem` (no-args form).
+- Status transitions other than those driven by the delegated `/wr-itil:manage-problem <NNN>` flow.
+
+## Steps
+
+### 1. Ensure the ranking is fresh
+
+Check the `docs/problems/README.md` cache with the same git-history-based freshness test as `/wr-itil:list-problems` and `/wr-itil:review-problems` (per P031 — filesystem mtime is unreliable in worktrees and fresh checkouts, so git history is the authoritative staleness signal):
+
+```bash
+readme_commit=$(git log -1 --format=%H -- docs/problems/README.md 2>/dev/null)
+if [ -z "$readme_commit" ] || \
+   git log --oneline "${readme_commit}..HEAD" -- 'docs/problems/*.md' ':!docs/problems/README.md' 2>/dev/null | grep -q .; then
+  echo "stale"
+fi
+```
+
+- **Cache fresh** (no output): read `docs/problems/README.md` and use the cached WSJF Rankings table for Step 2.
+- **Cache stale** (prints "stale") or `README.md` missing: **delegate to `/wr-itil:review-problems`** via the Skill tool to refresh the ranking before proceeding. Do NOT re-implement the re-scoring logic here — that would fork the review path and break P062's canonical-cache-writer contract. The review skill's Step 4 verification prompt runs on this refresh path (P048 Candidate 1: Verification Queue prompts always fire so pending verifications don't accumulate off-ledger).
+
+### 2. Select the ticket
+
+Read the WSJF Rankings table from the now-fresh `docs/problems/README.md`. Parse the top rows to find the highest-WSJF ticket(s).
+
+**Selection via `AskUserQuestion`** (ADR-013 Rule 1 structured-interaction path):
+
+- **Single top-WSJF ticket** (strictly higher than all others): present as the recommended option:
+  - Option 1: `Work P<NNN>: <title> (Recommended)` — description shows WSJF score, Severity, and Status.
+  - Option 2: `Pick a different problem` — user names a specific ID in the free-form response.
+- **Tied top-WSJF tickets** (two or more tied for the highest WSJF): present each tied ticket as a peer option. Per-option description carries a one-line rationale naming the Status / Effort / concrete next action so the user can pick with context:
+  - One option per tied ticket: `Work P<NNN>: <title>` — description: `WSJF <score> · <status> · <effort> · <one-line rationale>`.
+  - Final option: `Pick a different problem`.
+- Use `header: "Next problem"` and `multiSelect: false`.
+
+**Never present the selection as prose "(a)/(b)/(c)" or "which would you like?"** — always use `AskUserQuestion` so the decision is structured and auditable. This is the same discipline `/wr-itil:manage-problem` Step 9c carries; the split lifts it verbatim.
+
+**AFK / non-interactive branch (ADR-013 Rule 6)**: when this skill is invoked inside an AFK orchestrator (detect via `/wr-itil:work-problems` markers in the invoking prompt — phrases like "AFK", "work-problems", "batch-work", "ALL_DONE"), apply the within-day tiebreak per `/wr-itil:work-problems` Step 1c: Known Error > Open; smaller Effort; older reported date; ticket number ascending. Do NOT emit `AskUserQuestion` in AFK mode — the orchestrator has already selected the iteration and this skill runs the execution only.
+
+### 3. Delegate the work to `/wr-itil:manage-problem <NNN>`
+
+Invoke `/wr-itil:manage-problem <NNN>` via the Skill tool with the selected ticket's ID as the argument. The delegated skill runs the full Working a Problem flow appropriate to the ticket's status:
+
+- **Open ticket**: investigate root cause; document findings; create reproduction test; identify workaround; auto-transition to Known Error when root cause + workaround are documented; if the fix is small, proceed straight into implementation.
+- **Known Error**: read the root cause analysis; implement the fix following the project's standard workflow (plan if needed, architect review, tests, changeset); include the Known Error → Verification Pending `git mv` in the fix commit per ADR-022.
+
+**Why delegate rather than re-implement:** the full investigation / transition / fix / release pipeline is a long-lived, policy-governed flow that must stay on a single authoritative workflow. Re-hosting it on a sibling skill would fork the ownership contract and compound maintenance cost. The split skill (this file) owns the *selection* of the next ticket; `/wr-itil:manage-problem <NNN>` owns the *execution*.
+
+### 4. Scope-expansion check (ADR-013 Rule 1)
+
+If the delegated `/wr-itil:manage-problem <NNN>` reports that the ticket's effort expanded during investigation or architect review (e.g. S → L, or L → XL), fire the standard scope-change `AskUserQuestion` prompt:
+
+- Option 1: `Continue with expanded scope` — keep working this ticket at its new size.
+- Option 2: `Update problem and re-rank` — save findings to the problem file, re-score WSJF, and re-run the work selection to let the user pick from the updated queue.
+- Option 3: `Pick a different problem` — park this one and work something else.
+
+Use `header: "Scope change"` and `multiSelect: false`. This is the same structure `/wr-itil:manage-problem`'s Working a Problem section documents; the split lifts it without modification.
+
+**AFK / non-interactive branch**: same ADR-013 Rule 6 fallback as `/wr-itil:work-problems` — save findings + the new Effort/WSJF lines to the ticket file and skip to the next iteration. The orchestrator owns the re-selection loop.
+
+### 5. Post-work housekeeping
+
+After the delegated `/wr-itil:manage-problem <NNN>` completes:
+
+1. If the ticket status changed (Open → Known Error, Known Error → Verification Pending), the delegated skill already committed the change per ADR-014 + ADR-022 and updated `docs/problems/README.md` per P062. This skill does NOT re-commit or re-refresh; it reports what happened.
+2. Report the outcome: ticket ID, action taken (investigated / transitioned / fix-released), commit SHA(s), and next-recommended action (typically "run `/wr-itil:work-problem` again for the next ticket" or "stop — all actionable tickets worked").
+3. **Do NOT loop automatically.** This is the singular skill. If the user wants to continue, they invoke `/wr-itil:work-problem` again, or switch to `/wr-itil:work-problems` (plural) for the AFK orchestrator loop.
+
+## Ownership boundary
+
+`work-problem` (singular) owns:
+- Reading the WSJF Rankings from `docs/problems/README.md`.
+- Firing the `AskUserQuestion` selection prompt (interactive mode).
+- Delegating one execution iteration to `/wr-itil:manage-problem <NNN>`.
+- Firing the scope-expansion `AskUserQuestion` on effort drift.
+
+`work-problem` does NOT:
+- Refresh the README.md cache directly — defers to `/wr-itil:review-problems`.
+- Loop over multiple tickets — that's `/wr-itil:work-problems` (plural).
+- Commit the ranking refresh or the per-ticket work — delegated skills commit per ADR-014.
+
+## Related
+
+- **P071** (`docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md`) — originating ticket. This skill is phase 3 of the P071 phased-landing plan (list-problems was phase 1; review-problems was phase 2).
+- **ADR-010 amended** (`docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md` — Skill Granularity section) — canonical skill-split naming + forwarder contract + `deprecated-arguments: true` frontmatter flag.
+- **ADR-013** (`docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md`) — Rule 1 for the interactive `AskUserQuestion` selection; Rule 6 for the AFK-orchestrator non-interactive branch.
+- **ADR-014** — governance skills commit their own work. The delegated `/wr-itil:manage-problem <NNN>` owns the per-ticket commit; this skill does not re-commit.
+- **ADR-018** — release cadence. AFK orchestrator owns release cadence; this skill does NOT auto-release.
+- **ADR-032** — governance skill invocation patterns. `/wr-itil:work-problems` delegates iterations via the Agent tool; this singular skill is the canonical execution unit.
+- **ADR-037** (`docs/decisions/037-skill-testing-strategy.proposed.md`) — contract-assertion bats pattern applied to this skill.
+- **P031** — git-history freshness check rationale (mtime unreliable in worktrees). Applies to the README cache this skill reads.
+- **P062** — `/wr-itil:review-problems` is the canonical README.md cache writer. This skill defers to it for refreshes.
+- **P077** — `/wr-itil:work-problems` Step 5 delegates iterations via the Agent tool. The delegated subagent invokes this skill's execution unit per iteration.
+- **JTBD-001** (`docs/jtbd/solo-developer/JTBD-001-enforce-governance.proposed.md`) — discoverable surface via `/wr-itil:` autocomplete. Users type `/wr-itil:work-problem` rather than remembering the `manage-problem work` subcommand.
+- **JTBD-101** (`docs/jtbd/plugin-developer/JTBD-101-extend-suite.proposed.md`) — one skill per distinct user intent.
+- `packages/itil/skills/manage-problem/SKILL.md` — hosts the thin-router forwarder for the deprecated `manage-problem work` form; also the delegated execution target for each ticket.
+- `packages/itil/skills/review-problems/SKILL.md` — sibling refresh skill; this skill defers to it when the cache is stale.
+- `packages/itil/skills/list-problems/SKILL.md` — sibling read-only display skill; same cache read contract.
+- `packages/itil/skills/work-problems/SKILL.md` — plural AFK orchestrator; uses this skill as its per-iteration execution unit.
+
+$ARGUMENTS

package/skills/work-problem/test/work-problem-contract.bats

@@ -0,0 +1,206 @@
+#!/usr/bin/env bats
+# Contract assertions for /wr-itil:work-problem (P071 split slice 3).
+#
+# This skill hosts the "pick the highest-WSJF ticket and work it" user
+# intent previously hidden behind /wr-itil:manage-problem work. Unlike
+# the plural orchestrator (/wr-itil:work-problems — batch AFK loop),
+# this singular skill runs exactly one ticket per invocation and fires
+# the AskUserQuestion selection prompt in interactive mode. Execution
+# is delegated to /wr-itil:manage-problem <NNN> to avoid forking the
+# per-ticket workflow.
+#
+# Structural assertion — Permitted Exception to the source-grep ban
+# (ADR-005 / P011 / ADR-037 contract-assertion pattern).
+#
+# @problem P071
+# @jtbd JTBD-001 (enforce governance without slowing down — discoverable surface)
+# @jtbd JTBD-101 (extend the suite with clear patterns — one skill per distinct user intent)
+#
+# Cross-reference:
+#   P071: docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md
+#   ADR-010 amended (Skill Granularity section) — split naming + forwarder contract
+#   ADR-013 Rule 1 — structured user interaction (AskUserQuestion selection prompt)
+#   ADR-013 Rule 6 — AFK non-interactive fallback
+#   ADR-014 — governance skills commit their own work (delegated target owns commits)
+#   ADR-032 — governance skill invocation patterns (plural orchestrator delegates here)
+#   ADR-037 — contract-assertion bats pattern
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+}
+
+@test "SKILL.md exists and has frontmatter" {
+  [ -f "$SKILL_FILE" ]
+  run head -1 "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  [ "$output" = "---" ]
+}
+
+@test "SKILL.md frontmatter name is wr-itil:work-problem (singular, P071 + ADR-010 amended)" {
+  # Split naming convention per ADR-010 amendment: <verb>-<object>.
+  # CRITICAL: singular "work-problem", NOT plural "work-problems" — the
+  # plural name is reserved for the AFK orchestrator that already exists.
+  # Name coexistence is a P071 acknowledged trade-off.
+  run grep -n "^name: wr-itil:work-problem$" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter name is NOT wr-itil:work-problems (regression guard for name collision)" {
+  # Guard against the easy slip of renaming this skill to match the
+  # plural orchestrator. If the name drifts to plural, `/wr-itil:`
+  # autocomplete shows two plural-looking skills side by side and users
+  # cannot tell which is interactive vs batch.
+  run grep -n "^name: wr-itil:work-problems$" "$SKILL_FILE"
+  [ "$status" -ne 0 ]
+}
+
+@test "SKILL.md frontmatter description names the pick-and-run intent (P071)" {
+  # Description must name "pick" / "work" / "highest-WSJF" so Claude
+  # Code autocomplete surfaces the user intent rather than a generic
+  # name. Also must mention "singular" or distinguish from the plural
+  # orchestrator so users pick the right one.
+  run grep -inE "^description:.*(pick|highest.wsjf|work.*problem)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "^description:.*(singular|one ticket|distinct from.*work-problems)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter allowed-tools includes AskUserQuestion (selection prompt)" {
+  # Step 2 fires AskUserQuestion for the selection in interactive mode
+  # (ADR-013 Rule 1). Without the tool the structured-interaction
+  # contract cannot hold.
+  run grep -nE "^allowed-tools:.*AskUserQuestion" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md frontmatter allowed-tools includes Skill (delegation to manage-problem + review-problems)" {
+  # Step 1 delegates the cache refresh to /wr-itil:review-problems when
+  # stale; Step 3 delegates the per-ticket execution to
+  # /wr-itil:manage-problem <NNN>. Both use the Skill tool per ADR-010's
+  # thin-router discipline.
+  run grep -nE "^allowed-tools:.*Skill" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents the singular-vs-plural naming distinction (P071 coexistence)" {
+  # The most common user confusion will be work-problem vs
+  # work-problems. The SKILL.md must name the distinction explicitly
+  # so `/wr-itil:` autocomplete readers can tell them apart. Without
+  # this, users will pick the wrong one and either run a single ticket
+  # when they wanted the AFK loop or vice-versa.
+  run grep -inE "work-problems.*plural|plural.*work-problems|AFK orchestrator" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md delegates execution to /wr-itil:manage-problem (anti-fork discipline)" {
+  # Per ADR-010 thin-router: the split skill owns selection, NOT
+  # execution. The per-ticket investigate/transition/fix/release flow
+  # stays on /wr-itil:manage-problem <NNN>. If this skill re-implements
+  # the execution inline, the deprecation window hardens into a
+  # permanent fork.
+  run grep -inE "/wr-itil:manage-problem" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "delegate.*manage-problem|Skill tool.*manage-problem|manage-problem.*Skill tool" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md defers README.md cache refresh to /wr-itil:review-problems (P062 ownership)" {
+  # P062 makes /wr-itil:review-problems the canonical README.md cache
+  # writer. This skill reads the cache but must NOT rewrite it —
+  # re-implementing the refresh here would break the one-canonical-
+  # writer invariant.
+  run grep -inE "/wr-itil:review-problems" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "(delegate|defer|refresh).*review-problems|review-problems.*(refresh|delegate|defer)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md reads README.md cache via the git-history freshness test (P031)" {
+  # Same freshness check as list-problems and review-problems — mtime
+  # is unreliable in worktrees per P031. Drift here means false
+  # cache-hit (serving a stale ranking) or false cache-miss (spamming
+  # review refreshes).
+  run grep -inE "docs/problems/README\.md" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "git log.*--format.*README\.md|readme_commit" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md fires the AskUserQuestion selection prompt (ADR-013 Rule 1)" {
+  # Step 2 is the structured-interaction path: single top-WSJF ticket
+  # shown as Recommended, or tied tickets shown as peer options. Never
+  # prose "(a)/(b)/(c)".
+  run grep -inE "AskUserQuestion" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "Next problem|Recommended|tied" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md forbids prose selection fallback (P053 + ADR-013 Rule 1 regression guard)" {
+  # Prose "which would you like?" or "(a)/(b)/(c)" is the anti-pattern
+  # ADR-013 Rule 1 and P053 codify against. The SKILL.md must say
+  # "never" so the contract is legible at the spec level.
+  run grep -inE "never.*prose|never.*\(a\)/\(b\)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents the AFK non-interactive branch (ADR-013 Rule 6)" {
+  # When /wr-itil:work-problems invokes this skill inside an AFK
+  # subagent iteration, AskUserQuestion is unavailable — the selection
+  # has already happened at the orchestrator level. The skill must
+  # degrade gracefully per Rule 6.
+  run grep -inE "AFK|non-interactive|ADR-013 Rule 6|Rule 6" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md documents the scope-expansion AskUserQuestion (3-option shape)" {
+  # Effort drift during investigation or architect review must fire the
+  # standard Continue / Re-rank / Pick-different three-option prompt,
+  # same as /wr-itil:manage-problem's Working a Problem section.
+  run grep -inE "Scope change|scope.expansion" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "Continue with expanded scope|Update problem and re-rank|Pick a different problem" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md runs exactly one ticket per invocation (singular contract)" {
+  # The whole point of the singular skill: one ticket, then stop. The
+  # SKILL.md must say "do not loop automatically" or equivalent so the
+  # contract is explicit. Looping is the plural orchestrator's job.
+  run grep -inE "do not loop automatically|one ticket per invocation|singular" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md does not carry a deprecated-arguments frontmatter flag (clean-split skill)" {
+  # Architect advisory: work-problem is a clean-split skill with no
+  # argument-subcommands itself. ADR-010 amendment's
+  # `deprecated-arguments: true` flag is only valid on host skills with
+  # forwarder routes — work-problem is a forwarder TARGET, not a host.
+  run grep -E "^deprecated-arguments:" "$SKILL_FILE"
+  [ "$status" -ne 0 ]
+}
+
+@test "SKILL.md does not use word-argument subcommand branching (P071 regression guard)" {
+  # The whole point of P071: Claude Code autocomplete does not surface
+  # arguments. A clean-split skill must not reintroduce word-arg
+  # subcommand routing.
+  run grep -inE "If arguments start with|If arguments contain" "$SKILL_FILE"
+  [ "$status" -ne 0 ]
+}
+
+@test "SKILL.md cites P071 and ADR-010 amended (traceability per ADR-037)" {
+  # ADR-037 traceability: the skill spec cites the problem it closes
+  # and the ADR that authorises the split.
+  run grep -inE "P071|ADR-010" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md cites ADR-032 + P077 (AFK orchestrator delegation target)" {
+  # /wr-itil:work-problems Step 5 delegates iterations via the Agent
+  # tool (P077). This skill is the execution unit those iterations
+  # invoke. The cross-reference documents the pair relationship so
+  # future drift to /wr-itil:work-problems doesn't orphan this skill.
+  run grep -inE "P077|ADR-032" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}