@windyroad/itil 1.2.0 → 2.0.0-preview.1111

package/skills-codex/transition-problem/SKILL.md

@@ -0,0 +1,371 @@
+---
+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. Hosts the transition execution inline (pre-flight checks, the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem staging-trap handling, the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem external-root-cause detection, the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem README refresh, the "Governance Skills Commit Their Own Completed Work" architecture rule commit) per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended "Split-skill execution ownership". Use when the user asks to "transition", "close", "mark known-error", or "release" a specific ticket.
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, request_user_input, Skill
+---
+
+<!-- Generated from the runtime-neutral skill source. Do not edit. -->
+
+> Codex runtime note: use `request_user_input` only where this contract
+> explicitly requires a human decision. Resolve `<itil-plugin-root>` from
+> this installed `SKILL.md`: it is two directories above the skill
+> directory. Run bundled commands from `<itil-plugin-root>/bin/`; do not
+> search the adopter repository or rely on those commands being on `PATH`.
+> Spawn `wr-itil:hang-off-check` with the native Codex subagent tool, wait
+> for it, and close that same agent.
+
+
+# Transition Problem — Lifecycle Advance
+
+Advance a specific problem ticket along the ITIL lifecycle: Open → Known Error → Verification Pending → Closed. The skill is the **authoritative executor** for the user-initiated transition path — it identifies the ticket and the destination status, then executes the transition inline: pre-flight checks, external-root-cause detection (the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem), `git mv` + Status edit with staging re-stage (the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem), `## Fix Released` section write for the `verifying` destination, README.md refresh (the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem), and the "Governance Skills Commit Their Own Completed Work" architecture rule commit.
+
+This skill is phase 4 of the "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem phased-landing split of `/wr-itil:manage-problem <NNN> <status>` per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule's amended Skill Granularity rule (one skill per distinct user intent). Per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule's "Split-skill execution ownership" rule (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem), the skill does **not** re-invoke `/wr-itil:manage-problem` to run Step 7 (no round-trip); the deprecation-window forwarder on manage-problem routes one-way to this skill and returns its output verbatim. The in-skill Step 7 block on manage-problem remains in place for in-skill callers (Step 9b auto-transition, Parked path, Step 9d closure inside review) — "copy, not move" per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended.
+
+The deprecated `/wr-itil:manage-problem <NNN> known-error` subcommand route remains as a one-way 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 identified AND workaround documented; fix not yet proposed — per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule corrected semantics; the fix proposal draws a release row on a story map).
+  - `verifying` — Known Error → Verification Pending (fix released, awaiting user verification per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule).
+  - `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 "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem split rule (the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule 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).
+- Execute the transition inline: pre-flight checks, the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem external-root-cause detection (for the Open → Known Error destination), `git mv` to the new suffix, Status field edit, `## Fix Released` section write (for the Known Error → Verification Pending destination), the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem staging re-stage, the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem README.md refresh, the "Governance Skills Commit Their Own Completed Work" architecture rule commit.
+- Report the outcome (new filename, new Status, commit SHA).
+
+**Out of scope:**
+- 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 the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem external-root-cause detection for `upstream-blocked` reasons).
+- Auto-transitions fired inside `/wr-itil:review-problems` Step 9b (Open → Known Error when root cause + workaround are documented) — those use manage-problem's in-skill Step 7 block per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended "Split-skill execution ownership" ("copy, not move").
+
+## 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 — dual-tolerant lookup spans both the flat layout (`docs/problems/<NNN>-<title>.<state>.md`) AND the per-state subdir layout (`docs/problems/<state>/<NNN>-<title>.md`) per the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design migration window:
+
+```bash
+ls docs/problems/<NNN>-*.md 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. Run pre-flight checks
+
+Destination-specific pre-flight checks gate the transition. If any check fails, report which ones and stop — do not auto-remediate.
+
+**Open → Known Error** (`<status>` = `known-error`) requires:
+
+- [ ] Root cause is documented in the Root Cause Analysis section (not just "Preliminary Hypothesis")
+- [ ] At least one investigation task is checked off
+- [ ] A reproduction test exists or is referenced
+- [ ] A workaround is documented (even if "feature disabled")
+- [ ] Effort bucket re-rated against the now-documented fix strategy; if the bucket changed since creation, update the Effort / WSJF lines and note the reason (the "Problem 047: WSJF effort buckets are coarse and not re-rated at lifecycle transitions" problem — creation-time estimates drift as scope clarifies)
+- [ ] Status multiplier re-rated from Open 1.0 to Known Error 2.0; recompute WSJF with the post-transition status and current Effort (the "WSJF uses the pre-transition status multiplier" problem)
+
+**Known Error → Verification Pending** (`<status>` = `verifying`) requires:
+
+- [ ] The fix has been implemented (the transition typically rides with the `fix(<scope>): ... (closes P<NNN>)` commit)
+- [ ] A release marker is available (version, commit SHA, or date) so the `## Fix Released` section can name it
+- [ ] **Conditional-deferral check (the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem)** — see the dedicated subsection below; halt the transition if any conditional deferral has lifted with unticked work remaining
+
+#### Conditional-deferral check on K→V (the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem) — copy-not-move sibling
+
+This subsection is the **copy-not-move sibling** of `/wr-itil:manage-problem` SKILL.md Step 7's "Conditional-deferral check BEFORE the rename (the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem)" block per [the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule](../../../docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md) amended "Split-skill execution ownership" rule (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem). Both surfaces must carry the check; drift between the two copies re-opens the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem's silent-loss failure mode on whichever surface lacks the check.
+
+BEFORE the `git mv` to `.verifying.md`, scan the `.known-error.md` ticket body for **phase-tracking sections with unticked checkboxes whose deferral conditions have now lifted**. Conditional-deferral language ("Phase N SHIP deferred to post-Phase-M-graduation" / "deferred-pending-X-graduation" / "Phase N deferred until Y") names a CONDITION — it is NOT terminal. When the gating condition fires (Phase M graduates, dependency Y ships), the conditionally-deferred work is back IN SCOPE; transitioning K→V while it remains unticked silently loses the work. the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem's driver case (the "Problem tickets strain as fixes decompose into multiple coordinated changes — need an RFC framework that ties all changes back to problems (and unifies technical with user/business problems)" problem Phase 2 SHIP deferred to post-Phase-1-graduation) is the canonical regression — the agent's NLP parsed "deferred" as terminal without checking the conditional clause and would have lost the Phase 2 work if the user hadn't asked an orthogonal question.
+
+**Detection** (run in order):
+
+1. Grep the ticket body for phase-tracking section headers — regex `^### (Phase|Slice|Tier) [0-9]+` covers the canonical shapes.
+2. For each detected section, count the unticked `- [ ]` checkboxes inside it (up to the next `^### ` boundary or EOF).
+3. Grep the body for conditional-deferral markers: `deferred (?:to|pending|until) (?:post-)?[A-Za-z0-9-]+(?:-graduation)?`, `Phase [0-9]+ (?:SHIP )?deferred`, `deferred-pending-[a-z-]+`.
+4. For each conditional-deferral marker, resolve whether the **gating condition** has fired — check whether the named phase/ticket/RFC has reached `.closed.md` / `.verifying.md` (for tickets) or `closed` lifecycle (for RFCs / stories per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule).
+
+**Halt-and-route** (when ANY conditional deferral has lifted with unticked work remaining):
+
+Emit a structured report naming each deferred section + the lifted condition + the unticked task count, then **halt the transition**. Per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 2 (deviation-approval), this is NOT a per-transition lazy ask — it is a class-of-behaviour deviation surface that the user owns.
+
+- **Interactive**: fire `request_user_input` with `header: "Conditional deferral lifted"` + three options: (1) re-open Phase N and work the deferred tasks now (recommended; revert to Known Error); (2) confirm Phase N is permanently out of scope (proceed with K→V; append `<!-- the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem: user-confirmed Phase N permanently OOS -->` marker to suppress re-detection); (3) split Phase N into a new ticket (halt K→V; route to `/wr-itil:capture-problem`).
+- **AFK** (per the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 + the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem queue-and-continue): queue an `outstanding_questions` entry naming the local ticket ID + the lifted-condition citation + the unticked task count + the three options. **Do NOT auto-transition.** Brief the substance BEFORE referencing IDs per `feedback_brief_before_id.md`.
+
+**Proceed silently** (no halt) when no phase-tracking sections exist, every task in such sections is ticked, the deferral marker explicitly states "permanently out of scope" / "won't fix" / "rejected" without a conditional clause, OR the section carries the `<!-- the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem: user-confirmed Phase N permanently OOS -->` marker from a prior surfacing.
+
+**Why halt-and-route not silent-default-with-marker**: the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem's failure mode is "work silently lost if user doesn't notice"; the halt-and-route shape catches the failure at the transition surface where the loss occurs. Driver: user direction in the "Agent treats conditionally-deferred work (deferred-pending-X-graduation) as permanently out of scope — prematurely transitions parent ticket when X graduates" problem Workaround section — *"explicitly ask the user 'is Phase N still deferred or is it now in-scope?' before transitioning when the ticket body shows phase-tracking sections."*
+
+This check fires BEFORE the "derive-release-vehicle helper requires pre-edit of ticket changeset reference — three-touch when one-touch would suffice" problem Release-vehicle seed step in Step 6 — halt-on-conditional-deferral is the outer gate, seed-and-rename is the inner mechanic.
+
+**Verification Pending → Closed** (`<status>` = `close`) requires:
+
+- [ ] The user has explicitly confirmed the fix works in production (this skill never auto-closes on inference — only on explicit user confirmation or orchestrator-supplied `close` argument)
+
+### 5. External-root-cause detection (the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem — Open → Known Error only)
+
+Fires on the Open → Known Error transition only. Parking with the `upstream-blocked` reason reuses the same mechanism but is handled by `/wr-itil:manage-problem`'s Step 7 (this skill does not park).
+
+**Strict detection tokens** (any of the following within the Root Cause Analysis section counts as a hit):
+
+- Literal label words: `upstream`, `third-party`, `external`, `vendor`.
+- Scoped npm package pattern: `@[\w-]+/[\w-]+` (e.g. `@anthropic/claude-code`, `@windyroad/itil`).
+
+Bash heuristic:
+
+```bash
+if grep -iE '\b(upstream|third-party|external|vendor)\b|@[[:alnum:]_-]+/[[:alnum:]_-]+' "$problem_file"; then
+  external_root_cause_detected=1
+fi
+```
+
+Detection is intentionally **strict** (explicit label or scoped-npm package only) to avoid prompt fatigue (the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem Direction decision). A passing reference to a bare package name (`gh`, `npm`) does NOT trigger the prompt.
+
+**Already-noted check** — before firing the prompt, grep the ticket for the stable marker `- **Upstream report pending** --` (canonical ASCII form per the "work-problems SKILL.md AFK-fallback marker wording uses em-dash, forces consumer-side whitespace surgery" problem) or the legacy em-dash variant `- **Upstream report pending** —` (written by option 2 / the AFK fallback below; the grep MUST match BOTH variants for backward compatibility) or `- **Reported Upstream:**` / a `## Reported Upstream` section (written by `/wr-itil:report-upstream` Step 7 back-write per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule Confirmation criterion 3a). If any of those are already present, skip the prompt — the detection has already fired on a prior run.
+
+**If the detection fires and nothing has been noted yet** (per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule framework-resolution boundary): the agent applies the AFK fallback default WITHOUT firing `request_user_input`. Per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule, this decision IS framework-resolved — the safe action is "defer and note marker", and the user can correct via authentic-correction (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 6) if a manual `/wr-itil:report-upstream` invocation is wanted instead. Per-transition `request_user_input` for upstream-detection is sub-contracting framework-resolved decisions back to the user (lazy deferral per Step 2d Ask Hygiene Pass classification).
+
+**Default behaviour (silent agent action, per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule)**: append the pending-upstream-report line to the ticket's `## Related` section using the stable marker:
+
+```
+- **Upstream report pending** -- external dependency identified; invoke /wr-itil:report-upstream when ready
+```
+
+ASCII `--` per the "work-problems SKILL.md AFK-fallback marker wording uses em-dash, forces consumer-side whitespace surgery" problem — ASCII-only in machine-parseable identifiers; em-dash permitted in pure narrative prose. The legacy em-dash variant is matched by the already-noted check for backward compatibility.
+
+The marker wording is fixed so subsequent runs (and the work-problems `upstream-blocked` skip path) can detect "already noted" without re-firing. The transition proceeds normally after the marker is appended.
+
+**Recovery / override paths** (user-initiated, not asked-per-transition):
+
+- If the detection misfired (false positive — not actually upstream), user appends `- **Upstream report pending** -- false positive; detection misfire` directly to the ticket's `## Related` section (ASCII `--` per the "work-problems SKILL.md AFK-fallback marker wording uses em-dash, forces consumer-side whitespace surgery" problem; legacy em-dash variant remains matched for backward compatibility). The next detection-pass observes the marker and skips firing again.
+- If the user wants to invoke `/wr-itil:report-upstream` immediately rather than deferring, they invoke it directly (`/wr-itil:report-upstream <NNN> <upstream-repo-url>`). The skill writes the `## Reported Upstream` appendage per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule.
+
+**AFK and interactive modes use identical behaviour** — the silent-default-with-recovery-path shape is the framework-resolution boundary application; there's no `request_user_input`-vs-fallback differentiation.
+
+### 6. Rename the file, edit content, and re-stage (the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem staging trap)
+
+Per destination, run the rename + edit + explicit re-stage sequence. The explicit re-stage after `Edit` is mandatory — without it the content edit leaks into the next commit and the audit trail breaks.
+
+> **Staging trap (the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem).** `git mv` stages only the rename — it does NOT pick up subsequent `Edit`-tool content changes. After the `Edit` tool modifies the renamed file (Status field, `## Fix Released` section, etc.), re-stage it explicitly: `git add <new>`. Without the explicit re-stage, the transition commit captures the rename-only change and the content edit leaks into the next commit, corrupting the audit trail.
+
+**Open → Known Error**:
+
+```bash
+git mv docs/problems/open/<NNN>-<title>.md docs/problems/known-error/<NNN>-<title>.md
+# ... use the Edit tool to update the Status field to "Known Error" ...
+git add docs/problems/known-error/<NNN>-<title>.md
+```
+
+**Known Error → Verification Pending** (per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule, on release):
+
+**Seed `Release vehicle` reference BEFORE the rename (the "derive-release-vehicle helper requires pre-edit of ticket changeset reference — three-touch when one-touch would suffice" problem).** BEFORE the `git mv` to `.verifying.md`, edit the `.known-error.md` ticket body to append a `**Release vehicle**: .changeset/<name>.md` paragraph at the END of the `## Fix Strategy` section (create the section if absent). The `<name>.md` is the kebab-case slug of the changeset file the fix commit authored under `.changeset/` (e.g. `<itil-plugin-root>/bin/wr-itil-p330-option-b.md`). The seed makes the `<itil-plugin-root>/bin/wr-itil-derive-release-vehicle <NNN>` helper invocation below exit 0 deterministically on first call (the helper greps the ticket body for `.changeset/<name>.md` and exits 2 when absent — Option B-codified per the "derive-release-vehicle helper requires pre-edit of ticket changeset reference — three-touch when one-touch would suffice" problem closes that exit-2 routing on standalone K→V iters). The exit-2 fallback in the routing table below remains as the legacy-ticket recovery path for tickets shipped before the "derive-release-vehicle helper requires pre-edit of ticket changeset reference — three-touch when one-touch would suffice" problem's codification. Mirrors the `/wr-itil:manage-problem` Step 7 seed step (copy-not-move per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended / the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem).
+
+> **Two the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem staging-trap windows on K→V (seed + rename).** The seed Edit on `.known-error.md` is the FIRST the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem window; the Edit that updates Status / writes `## Fix Released` AFTER the `git mv` is the SECOND. Consolidate staging into a SINGLE `git add docs/problems/verifying/<NNN>-<title>.md` AFTER both Edits + the `git mv`. `git mv` operates on the index entry — the body content the index references at rename time is the post-seed content, so the seed Edit's content is carried across the rename automatically; the single final `git add` re-stages the post-rename file with the post-`Edit` Status + `## Fix Released` content. The seed step does NOT introduce a separate `git add` of the `known-error/` path — staging discipline stays single-call by riding the rename's index entry.
+
+```bash
+# Step 1 — seed `**Release vehicle**: .changeset/<name>.md` in the Fix Strategy section
+# ... use the Edit tool to append the seed paragraph to docs/problems/known-error/<NNN>-<title>.md ...
+
+# Step 2 — rename
+git mv docs/problems/known-error/<NNN>-<title>.md docs/problems/verifying/<NNN>-<title>.md
+
+# Step 3 — update Status to "Verification Pending" AND add the `## Fix Released` section
+# ... use the Edit tool on docs/problems/verifying/<NNN>-<title>.md ...
+
+# Step 4 — single re-stage covers both Edit windows (the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem + the "derive-release-vehicle helper requires pre-edit of ticket changeset reference — three-touch when one-touch would suffice" problem)
+git add docs/problems/verifying/<NNN>-<title>.md
+```
+
+The `## Fix Released` section contains: release marker (version, commit SHA, or date), one-sentence fix summary, "Awaiting user verification" line, and any exercise evidence from the releasing session. The `.verifying.md` suffix signals to every downstream consumer (work-problems classifier, review step 9d, README rendering) that the remaining work is user-side verification — no file-body scan needed.
+
+When this transition is folded into a `fix(<scope>): ... (closes P<NNN>)` commit (the common case), the `git mv` + `Edit` + re-stage + README refresh all join that single commit — never split across commits.
+
+**Release-vehicle citation (the "Codify `derive-release-vehicle.sh` helper for K→V release-cycle citation" problem)**: derive the release marker deterministically — never hand-type it from `git log` browse output. Hand-typed citations are fragile to wrong-release-cited errors when a session pre-applies transitions for multiple sibling tickets before working any of them (origin: 2026-05-18 session 7 iter 1 — the "work-problems Step 6.5 "≤3 within appetite — no drain" clause defers low-risk releases, encoding accumulation" problem's K→V cited the "run-retro Step 3 Tier 3 Branch B "leave-as-is" encodes fictional defer — sibling to evidence-based criterion" problem's release refs). Invoke the helper:
+
+```bash
+<itil-plugin-root>/bin/wr-itil-derive-release-vehicle <NNN>
+```
+
+`<itil-plugin-root>/bin/wr-itil-derive-release-vehicle` is the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule `$PATH` shim (adopter-safe — resolves the canonical `derive-release-vehicle.sh` relative to the script, NOT cwd; the "capture-problem / capture-rfc / manage-problem Step 2 create-gate marker step sources repo-relative `<itil-plugin-root>/hooks/lib/*.sh` — fails in adopter installs (recurring published-path class: //)" problem/the ": Adopter-safe path resolution in shipped SKILLs ( — 24 repo-relative references)" release design) that reads the ticket body for the `.changeset/<name>.md` reference, walks `git log --diff-filter=D` for the deletion commit (`chore: version packages`), resolves the merge PR via the first-parent ancestry-path merge commit (or `gh pr list` fallback when available), and emits a structured citation block on stdout:
+
+```
+RELEASE_VEHICLE:
+  changeset: .changeset/<name>.md
+  version-packages-commit: <SHA>
+  pr: #<N>
+  merge-commit: <SHA>
+  release-date: <YYYY-MM-DD>
+```
+
+Use the structured values verbatim when authoring the `## Fix Released` section's release marker (e.g. `Released in @windyroad/itil@<version> (merge commit <merge-commit>, PR #<N>, released <release-date>)`). The helper is **mechanical** per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule framework-resolution — no `request_user_input` per transition.
+
+**Helper exit-code routing**:
+
+- Exit 0 (full citation emitted): use the values in the `## Fix Released` section.
+- Exit 1 (ticket file not found): the upstream ticket-discovery step (Step 2) should have caught this; if it fires here, halt and report.
+- Exit 2 (no `.changeset/<name>.md` reference in ticket body): add the changeset reference to the ticket's Fix Strategy section, OR cite the release marker manually with explicit `<!-- no-changeset-reference -->` comment so a future review can audit the gap.
+- Exit 3 (changeset still in working tree — unreleased): the fix has not yet been released to npm. Halt the transition — `.known-error.md` → `.verifying.md` requires a shipped release per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule. The orchestrator's Step 6.5 drain should fire first.
+- Exit 4 (deletion commit found but no merge PR resolvable): direct-to-main commit (no PR), or `gh pr list` unavailable + first-parent walk did not match. Cite the deletion commit SHA manually in the `## Fix Released` section with an explicit `<!-- no-pr -->` comment.
+
+**Verification Pending → Closed**:
+
+```bash
+git mv docs/problems/verifying/<NNN>-<title>.md docs/problems/closed/<NNN>-<title>.md
+# ... use the Edit tool to update the Status field to "Closed" ...
+git add docs/problems/closed/<NNN>-<title>.md
+```
+
+### 7. Refresh docs/problems/README.md (the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem)
+
+Every Step 7 status transition regenerates `docs/problems/README.md` and stages it in the same commit so the dev-work table, Verification Queue, Parked section, and "Last reviewed" line never lag the on-disk ticket inventory. Without this step, README.md accumulates staleness between review invocations.
+
+The refresh uses the same rendering rules as `/wr-itil:review-problems` Step 9e (glob `docs/problems/*.open.md` / `*.known-error.md` / `*.verifying.md` / `*.parked.md`; rank open/known-error by WSJF; list verifyings in the Verification Queue ordered by release age; list parkeds in the Parked section) but skips the full re-scoring pass — existing WSJF values on the ticket files are trusted. The refresh is a render, not a re-rank.
+
+**Verification Queue sort direction (the "docs/problems/README.md Verification Queue rendered newest-first contradicts section header "Ranked by release age, oldest first"" problem)**: Verification Queue rows are sorted by `Released date ASC` (oldest at row 1; same-day releases tiebreak by ID ASC) per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule + the "Problem 048: manage-problem does not surface Fix Released problems as verification candidates when the fix path has been exercised" problem user-task semantics — older entries are the most likely-verified candidates the user wants to surface first when closing the queue. <!-- VQ-SORT-DIRECTION: oldest-first per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule --> Drift here re-opens the "docs/problems/README.md Verification Queue rendered newest-first contradicts section header "Ranked by release age, oldest first"" problem.
+
+**Likely-verified cell shape (the "VQ `Likely verified?` column uses age-based heuristic (≥14 days = yes) instead of session-observed evidence — sibling proxy-for-evidence anti-pattern to" problem)**: the `Likely verified?` column carries an **evidence-first** cell — `yes — observed: <evidence>` / `no — not observed` / `no — observed regression`. On a Known Error → Verification Pending transition the refresh writes `no — not observed` as the default (no observed evidence yet at the moment of release). On a Verification Pending → Closed transition the closing commit's session-observed evidence should populate the cell as `yes — observed: <evidence>` before the row exits the queue. <!-- LIKELY-VERIFIED-CELL-SHAPE: evidence-based per the "VQ `Likely verified?` column uses age-based heuristic (≥14 days = yes) instead of session-observed evidence — sibling proxy-for-evidence anti-pattern to" problem --> Drift on the cell shape re-opens the "VQ `Likely verified?` column uses age-based heuristic (≥14 days = yes) instead of session-observed evidence — sibling proxy-for-evidence anti-pattern to" problem.
+
+**Mechanism:**
+
+1. After renaming + Editing + `git add`-ing the transitioned ticket file (per the staging-trap rule above), regenerate `docs/problems/README.md` in-place reflecting the new filename set and the transitioned ticket's new Status.
+2. `git add docs/problems/README.md` — stage the refreshed README with the same commit as the transition.
+3. Update the "Last reviewed" line per the **inline the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem rotation mechanism** below. The mechanism is inlined here at the execution site (not deferred via cross-document reference to `manage-problem` SKILL.md Step 5) so a single-pass agent reading this Step 7 does not silently skip the archive step. **Skipping the BEFORE-rewrite archive step destroys the displaced fragment and re-opens the "transition-problem SKILL Step 7 Last-reviewed rotation silently skipped across iters" problem** (iter-7 + iter-8 of 2026-05-30's AFK work-problems session silently skipped the rotation in 2 of 9 transition-bearing iters under exactly that failure mode). The mechanism MUST execute IN ORDER:
+
+   1. **Read** line 3 of `docs/problems/README.md`: `awk 'NR==3' docs/problems/README.md` (`head -3 | tail -1` or `sed -n '3p'` are acceptable equivalents).
+   2. **Append-if-non-empty (BEFORE step 3, not after)** — if line 3 is non-empty AND not a same-session same-verb near-duplicate of the new fragment, append the existing line 3 verbatim to `docs/problems/README-history.md` under a `## YYYY-MM-DD` heading (creating the heading on first append for that date; subsequent same-day appends nest under the existing heading). Run this BEFORE the Edit-tool rewrite in step 3 — Edit's replace pattern destroys the displaced content otherwise.
+   3. **Rewrite** line 3 of `docs/problems/README.md` with the new fragment of form `> Last reviewed: YYYY-MM-DD **<event>** — <one-line summary>` (e.g. `P<NNN> <status> — <one-line fix summary>`). Soft cap ≤ 1024 bytes per fragment; hard ceiling 5120 bytes per the "Session-start briefing surface — SessionStart hook over tiered directory + indexed README" architecture rule Tier 3 envelope; advisory-only enforcement via `<itil-plugin-root>/scripts/check-problems-readme-budget.sh`.
+   4. **Stage both** — `git add docs/problems/README.md docs/problems/README-history.md` so the same single commit per the "Governance Skills Commit Their Own Completed Work" architecture rule single-commit grain captures both files.
+
+   Canonical rationale anchor: `manage-problem` SKILL.md Step 5 § Last-reviewed line discipline (the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem). The cross-reference is preserved for the "why"; the "what" is inlined above for execution-time legibility per the "transition-problem SKILL Step 7 Last-reviewed rotation silently skipped across iters" problem.
+
+### 7b. Bidirectional upstream lifecycle update (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem — advisory)
+
+After the rename + README refresh land but BEFORE the Step 8 commit, fire the bidirectional lifecycle-update sibling skill so the upstream issue (if any) receives the lifecycle update comment in the SAME commit as the transition per the "Governance Skills Commit Their Own Completed Work" architecture rule single-commit grain. This is the **outbound-lifecycle-update leg** of the reporter loop (the inbound-discovery leg is owned by the "Inbound upstream-report discovery + assessment pipeline (peer of )" architecture rule's assessment pipeline; together they close the reporter relationship per the "Report a Problem Without Pre-Classifying It" user outcome + the "Restore Service Fast with an Audit Trail" user outcome).
+
+The trigger fires **whenever the ticket carries a `## Reported Upstream` section (outbound) OR an `**Origin**: inbound-reported (#NN)` field (inbound, the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem)** — gate the installed-skill-invocation dispatch behind a one-line mechanical pre-check rather than dispatching on every transition. Dispatching unconditionally pays the full `/wr-itil:update-upstream` SKILL.md context load (~14 KB into the calling agent's context) just to hit the sibling skill's no-op exit; the common case is a ticket with neither surface, so the load is wasted (the "Unconditional update-upstream Skill dispatch pays full SKILL.md context load for the common no-op case" problem). The grep IS the trigger: it preserves the fire-whenever-a-surface-exists semantics — an upstream/inbound comment posts iff one of the two surfaces is present — while eliminating the context load for the common no-op case. Authority: [the "SKILL.md runtime budget policy" architecture rule](../../../docs/decisions/054-skill-md-runtime-budget-policy.proposed.md) (SKILL.md runtime-budget policy; [the "Progressive disclosure + once-per-session budget for UserPromptSubmit governance prose" architecture rule](../../../docs/decisions/038-progressive-disclosure-for-governance-tooling-context.proposed.md) progressive-disclosure as the ancestor principle); [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem) for the inbound-origin alternation.
+
+**Pre-check first** (mechanical — no user decision): run `grep -qE '^## Reported Upstream|^\*\*Origin\*\*: inbound-reported \(#' <ticket-file>`. If it does NOT match (NEITHER the outbound `## Reported Upstream` section NOR the inbound `**Origin**: inbound-reported (#NN)` field is present), skip the Skill dispatch entirely, log one line (`no ## Reported Upstream section and no inbound Origin; skipping upstream lifecycle update`), and proceed to Step 8. Only when it matches, invoke the sibling skill via the installed skill invocation:
+
+```
+/wr-itil:update-upstream <NNN>
+```
+
+Behaviour matrix:
+
+- **Neither `## Reported Upstream` section nor inbound `**Origin**` field on the local ticket** → the grep pre-check skips the Skill dispatch (no context load); log `no ## Reported Upstream section and no inbound Origin; skipping upstream lifecycle update` and proceed to Step 8. (The sibling skill retains its own Step 1 no-op exit as defence-in-depth for any path that reaches it directly.)
+- **`**Origin**: inbound-reported (#NN)` present** → the sibling skill runs its inbound-origin verdict dispatch leg (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem): posts the reporter-facing fix-released / closed verdict on the originating own-repo issue through the same external-comms + voice-tone gates, idempotency-guarded, and back-writes a direction-tagged `## Upstream Lifecycle Updates` entry. If BOTH surfaces are present, the outbound and inbound legs fire independently.
+- **`## Reported Upstream` present AND both gates within appetite** → the sibling skill posts via `gh issue comment` (and on Verifying → Closed, also `gh issue close`), back-writes to `## Upstream Lifecycle Updates`, and stages the back-write into the index. The Step 8 commit captures the back-write alongside the transition.
+- **`## Reported Upstream` present AND above-appetite (after silent risk-reduce + re-score)** → the sibling skill saves the drafted comment to `## Queued Upstream Update` and queues an `outstanding_questions` entry. The Step 8 commit captures the `## Queued Upstream Update` appendage alongside the transition. **The orchestrator continues per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem queue-and-continue** — do NOT halt the transition on an above-appetite upstream update.
+
+If `/wr-itil:update-upstream` is not installed (the `@windyroad/itil` package version pre-dates the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem shipping), the installed skill invocation returns a not-found error. Log a one-line warning (`update-upstream skill not available; skipping upstream lifecycle update`) and proceed to Step 8 — do NOT halt the transition.
+
+Per [the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6](../../../docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md) (AFK fail-safe), AFK orchestrators MUST NOT halt this transition path on a queued upstream-update — the queued entry surfaces at the existing batched-`request_user_input` end-of-loop gate.
+
+Authority: [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem) — bidirectional lifecycle-update sibling skill. Per [the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule](../../../docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md) amended "Split-skill execution ownership" (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem), an equivalent advisory subsection ALSO lives in `/wr-itil:manage-problem`'s in-skill Step 7 block ("copy, not move") so the in-skill callers (Step 9b auto-transition, Step 9d closure inside review, the Parked path) fire the same lifecycle update.
+
+### 8. Commit per the "Governance Skills Commit Their Own Completed Work" architecture rule
+
+Governance skills commit their own work. Transition commits include the renamed ticket file + any content edits + the refreshed `docs/problems/README.md`.
+
+**Commit gate** — satisfy via one of two paths (either produces a bypass marker):
+
+- **Primary**: delegate to subagent type `wr-risk-scorer:pipeline` via the native Codex subagent tool.
+- **Fallback**: if `wr-risk-scorer:pipeline` is not available in the current tool set (e.g. this skill is running inside a spawned subagent), invoke `/wr-risk-scorer:assess-release` via the installed skill invocation. Per the "On-Demand Assessment Skills for Governance Plugins" architecture rule it wraps the same pipeline subagent and the `PostToolUse:Agent` hook writes an equivalent bypass marker. Do not silently skip the gate because the primary path is unavailable — the fallback exists specifically to close this gap (see the "Problem 035: manage-problem commit gate has no fallback when subagent delegation is unavailable" problem).
+
+**Land the commit via `wr-risk-scorer-restage-commit`** — atomic re-stage + commit (the "Staged index is cleared after a `wr-risk-scorer:pipeline` Agent delegation — forces a re-`git add` before the commit lands" problem wrapper). The native-Codex-subagent-tool delegation above can silently clear the index; the helper re-adds the renamed + edited ticket file (plus `docs/problems/README.md` + `docs/problems/README-history.md` from Step 7's the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem rotation), asserts non-empty staging, then runs `git commit` with the supplied `-m` args:
+
+```bash
+wr-risk-scorer-restage-commit \
+  -m "<message per convention below>" \
+  -- docs/problems/<dest-state>/<NNN>-<title>.md docs/problems/README.md docs/problems/README-history.md
+```
+
+Omit `docs/problems/README-history.md` from the path list when the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem rotation did NOT append (same-session same-verb near-duplicate suppression). When the transition is folded into a `fix(<scope>): ... (closes P<NNN>)` commit shipping the actual fix, include the source-tree paths the fix touched alongside the ticket file in the `--` path list.
+
+**Commit message conventions**:
+
+- Open → Known Error transition (standalone): `docs(problems): P<NNN> known error — <root cause summary>`
+- Known Error → Verification Pending (folded with fix): `fix(<scope>): <description> (closes P<NNN>)` — per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule, include the rename-to-`.verifying.md` + `## Fix Released` section in the same commit
+- Known Error → Verification Pending (standalone, no fix riding with it): `docs(problems): P<NNN> verification pending — <release marker>`
+- Verification Pending → Closed: `docs(problems): close P<NNN> <title>`
+
+If commit risk is above appetite: auto-apply scorer remediations per **the "Auto-apply scorer remediations to reach within appetite — open action-class vocabulary" architecture rule Rule 1** until residual risk is within appetite, OR halt per the "Auto-apply scorer remediations to reach within appetite — open action-class vocabulary" architecture rule Rule 5 if the scorer cannot converge. **MUST NOT commit above appetite; MUST NOT call `request_user_input` to ask whether to commit anyway** (the "Skills, agents, and hooks override RISK-POLICY appetite instead of applying it" problem/the ": Apply RISK-POLICY appetite faithfully across all surfaces" release design — above-appetite is framework-mediated, not a one-time-override). If `request_user_input` is unavailable (AFK), the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 fail-safe applies as the terminal fallback: skip the commit and report the uncommitted state. This applies only to the risk-above-appetite branch, not to the delegation-unavailable case above.
+
+### 9. Report the outcome
+
+Report: ticket ID, previous Status, new Status, new filename, commit SHA. If the destination was `verifying`, name the `## Fix Released` section's release marker so the user can correlate with the shipped version.
+
+Release draining is owned by the caller — `/wr-itil:manage-problem` Step 12 (interactive) or the `/wr-itil:work-problems` orchestrator (AFK, Step 6.5 cadence). This skill does not invoke `npm run push:watch` / `release:watch` on its own.
+
+## Ownership boundary
+
+`transition-problem` owns (for the user-initiated transition path):
+- Argument parsing (`<NNN> <status>`).
+- Ticket-file discovery via the dual-tolerant lookup `ls docs/problems/<NNN>-*.md docs/problems/*/<NNN>-*.md` (the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design transitional shape; both layouts).
+- Destination-reachability validation (Open → Known Error → Verification Pending → Closed, one step at a time).
+- Pre-flight checks for the supplied destination.
+- the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem external-root-cause detection (Open → Known Error only) — including the AFK fallback that appends the stable `- **Upstream report pending** —` marker.
+- `git mv` rename + Status field edit + (for `verifying`) `## Fix Released` section write + explicit the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem re-stage.
+- `docs/problems/README.md` refresh (the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem) staged alongside the transition.
+- the "Governance Skills Commit Their Own Completed Work" architecture rule commit through the risk-scorer commit gate.
+
+`transition-problem` does NOT:
+- Re-invoke `/wr-itil:manage-problem` to run Step 7 — the deprecation-window forwarder on manage-problem is one-way (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem / the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended "Split-skill execution ownership", no round-trip).
+- Re-rank the backlog — that's `/wr-itil:review-problems`.
+- Create tickets or run the bare-`<NNN>` update flow — those stay on `/wr-itil:manage-problem`.
+- Park tickets — the `.parked.md` suffix has its own path on `/wr-itil:manage-problem` (the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem AFK fallback fires there too).
+- Auto-transition inside review — Step 9b's Open → Known Error auto-transition uses manage-problem's in-skill Step 7 block ("copy, not move").
+- Drain the release queue — `push:watch` / `release:watch` are owned by the caller (`/wr-itil:manage-problem` Step 12, or the `/wr-itil:work-problems` orchestrator).
+
+## Related
+
+- **the "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem** (`docs/problems/071-argument-based-skill-subcommands-are-not-discoverable.open.md`) — originating ticket. This skill is phase 4 of the "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem phased-landing plan (list-problems was phase 1; review-problems was phase 2; work-problem was phase 3).
+- **the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule 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.
+- **the "Structured User Interaction for Governance-Skill Decisions" architecture rule** (`docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md`) — Rule 1 for interactive prompts; Rule 6 for the AFK non-interactive branch.
+- **the "Governance Skills Commit Their Own Completed Work" architecture rule** — governance skills commit their own work. This skill owns the per-transition commit (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem — authoritative executor for the user-initiated path).
+- **the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule** — `.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.
+- **the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule** — governance skill invocation patterns. `/wr-itil:work-problems` may delegate transition iterations to this skill during AFK release orchestration.
+- **the "Skill testing strategy — contract-assertion bats companion to" architecture rule** (`docs/decisions/037-skill-testing-strategy.proposed.md`) — contract-assertion bats pattern applied to this skill.
+- **the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem** — `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.
+- **the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem** — `/wr-itil:review-problems` is the canonical README.md cache writer, but Step 7 transitions also refresh README.md in-place per the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem's mechanism. Named here as a transitive contract.
+- **the "VQ `Likely verified?` column uses age-based heuristic (≥14 days = yes) instead of session-observed evidence — sibling proxy-for-evidence anti-pattern to" problem** — evidence-first `Likely verified?` cell shape (`yes — observed: <evidence>` / `no — not observed` / `no — observed regression`); `<!-- LIKELY-VERIFIED-CELL-SHAPE: evidence-based per the "VQ `Likely verified?` column uses age-based heuristic (≥14 days = yes) instead of session-observed evidence — sibling proxy-for-evidence anti-pattern to" problem -->` marker drives cross-skill drift detection (the "`docs/problems/README.md` WSJF Rankings table row order doesn't match `/wr-itil:work-problems`'s tie-break selection — users assume the orchestrator is broken" problem / the "docs/problems/README.md Verification Queue rendered newest-first contradicts section header "Ranked by release age, oldest first"" problem fix-shape precedent).
+- **the "Problem 063: manage-problem does not trigger /wr-itil:report-upstream when root cause is external" problem** — 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.
+- **the ": Enforce Governance Without Slowing Down" user outcome** (`docs/jtbd/developer/the ": Enforce Governance Without Slowing Down" user outcome-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.
+- **the "Extend the Suite with New Plugins" user outcome** (`docs/jtbd/plugin-developer/the "Extend the Suite with New Plugins" user outcome-extend-suite.proposed.md`) — one skill per distinct user intent.
+- `<itil-plugin-root>/skills/manage-problem/SKILL.md` — hosts the deprecation-window forwarder for the `manage-problem <NNN> <status>` form (one-way to this skill, no round-trip per the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem). Also retains its own in-skill Step 7 block for in-skill callers (Step 9b auto-transition, Parked path, Step 9d closure) per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended "Split-skill execution ownership" — copy, not move.
+- **the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem** (`docs/problems/093-transition-problem-and-manage-problem-circular-delegation-for-nnn-status-args.*.md`) — the circular-delegation ticket that authorised this skill's absorbing the Step 7 block inline.
+- `<itil-plugin-root>/skills/review-problems/SKILL.md` — sibling refresh skill; this skill's transitions trigger the same README.md regeneration mechanism the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem codifies.
+- `<itil-plugin-root>/skills/list-problems/SKILL.md` — sibling read-only display skill; same cache contract.
+- `<itil-plugin-root>/skills/work-problem/SKILL.md` — sibling selection skill; delegates per-ticket execution (including transitions) through `/wr-itil:manage-problem`.
+
+$ARGUMENTS

package/skills-codex/transition-problem/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "WR ITIL: Transition Problem"
+  short_description: "Advance one problem through its lifecycle."