@windyroad/itil 1.2.0 → 2.0.0-preview.1111

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

@@ -0,0 +1,438 @@
+---
+name: wr-itil:capture-problem
+description: Lightweight problem-capture skill for aside-invocation during foreground work — minimal duplicate-check, skeleton ticket file, single commit per capture (covers new ticket + inline README refresh per the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem per the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem Option 2 amendment 2026-06-05). Defers full duplicate analysis to /wr-itil:review-problems. Use this when the user (or agent mid-iter) wants to capture an observation quickly without disrupting current task flow. For full-intake new-problem creation, use /wr-itil:manage-problem.
+allowed-tools: Read, Write, Edit, Bash, Grep, Glob, request_user_input
+---
+
+<!-- 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.
+
+
+# Capture Problem Skill
+
+Capture a problem ticket quickly during foreground work. Lightweight aside-invocation surface that complements the heavyweight `/wr-itil:manage-problem` flow. See `REFERENCE.md` in this directory for rationale, edge cases, contract trade-offs, and the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule foreground-lightweight-capture amendment.
+
+This skill is the foreground-lightweight-capture variant of `/wr-itil:manage-problem`'s new-problem path per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule (the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem amendment, 2026-05-03). The deferred background-capture variant named in the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule's original taxonomy remains deferred per the "Problem 088: run-retro cannot see the full session context when invoked as a subagent, subprocess, or from any non-parent-session surface — 's fix is partially blind" problem settlement.
+
+## Output Formatting
+
+When referencing problem, JTBD, ADR, or RFC IDs in prose output (stderr advisories, capture-report messages), always include the human-readable title or substance on first mention. Use the format `the ": Enforce Governance Without Slowing Down" user outcome (Enforce Governance Without Slowing Down)`, not bare `the ": Enforce Governance Without Slowing Down" user outcome`.
+
+**Brief-before-ID discipline at the Step 1.5b low-confidence interview surface (the "agent surfaces decisions to user using opaque IDs (P-numbers, ADR-numbers, JTBD-numbers) without explaining what they mean — empathy gap" problem).** Per the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem correction the low-confidence path does NOT surface candidate `JTBD-NNN` / `persona-slug` IDs at all — it **interviews** the human about *who* hits the problem and *what job* they are trying to get done, in plain language, so the brief-before-ID discipline is satisfied by construction (no ID is a carrier of meaning). If any option or prose in the interview references an existing job/persona for context, it MUST inline the job statement + the persona's key constraint BEFORE any ID. The user reads the prompt without project filesystem access (mobile clients, accessibility tooling, notification surfaces) and cannot follow links into `docs/jtbd/`. Mirrors the canonical `/wr-architect:create-adr` Step 5 § 5a Rule 3 ("No IDs as explainers"). See also session memory `feedback_brief_before_id.md`.
+
+## When to invoke
+
+- **Mid-iter sibling-finding**: agent observes a tangential ticket-worthy issue while working on a different problem and cannot afford the 10-turn `/wr-itil:manage-problem` ceremony.
+- **User-initiated rapid capture**: user says "btw, this is broken too — capture it" during retros, code reviews, or correction conversations.
+- **AFK orchestrator main turn captures**: orchestrator captures user-driven mid-loop observations without breaking the iter cadence.
+
+**Use `/wr-itil:manage-problem` instead** when:
+- The user wants to walk the full intake flow (priority discussion, multi-concern split, immediate WSJF placement).
+- The capture is large enough that deferred-investigation placeholders are unhelpful (the description IS the full ticket body).
+- The capture needs to ride alongside an immediate fix (`fix(scope): ... (closes P<NNN>)` shape — manage-problem's Step 7 transition + Step 11 commit handles this; capture-problem does not).
+
+## Rule 6 audit (per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule + the "Structured User Interaction for Governance-Skill Decisions" architecture rule)
+
+This skill has **one direction-setting request_user_input surface — the low-confidence persona/JTBD elicitation interview (fired only when derivation is weak; it may span more than one question to elicit who + why), plus the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem human-ratify surface when the elicited who/why warrants a NEW persona/JTBD**. Each potentially-interactive decision is framework-mediated per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule:
+
+| Decision | Resolution |
+|----------|-----------|
+| Duplicate-check | Mechanical 3-keyword title-only grep; matches listed in report; capture proceeds regardless. False-positives are cheaper than false-negatives (the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem line 24). |
+| Hang-off arbitration (the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem Phase 3) | Mechanical pre-filter (≤5 candidates by shared ADR/RFC/SKILL/file signal) + fresh-context `wr-itil:hang-off-check` subagent dispatch (the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule 5th invocation pattern). Verdict-acts: `HANG_OFF: P<NNN>` halts capture + routes orchestrator to amend parent; `PROCEED_NEW` continues + appends rationale to `## Related`. AFK safe-default: ambiguous → PROCEED_NEW per subagent Rule 6 contract. the "Report a Problem Without Pre-Classifying It" user outcome firewall: maintainer-side only. |
+| Priority (Impact × Likelihood) | **Derived at capture** silently from the description per Step 4a (the ": Cost-based WSJF effort — capture time + cost actuals, tally per ticket, retro-driven RMS calibration (tally-first)" architecture rule silent-derivation + the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule grounding/sentinel; the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule honest-likelihood). No deferred placeholder, no false-low. Category-4 silent-framework per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule. |
+| Effort | **Derived at capture** silently per Step 4a (the ": Cost-based WSJF effort — capture time + cost actuals, tally per ticket, retro-driven RMS calibration (tally-first)" architecture rule t-shirt buckets + the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule grounding/sentinel). No deferred placeholder. |
+| Multi-concern split | Out of scope: capture-problem creates one ticket per invocation. Multi-concern observations route to `/wr-itil:manage-problem` (its Step 4b owns the split). |
+| Empty `$ARGUMENTS` | Halt-with-stderr-directive: print "capture-problem requires a description in $ARGUMENTS — invoke /wr-itil:manage-problem instead for the full intake flow" and exit. AFK orchestrators MUST NOT invoke capture-problem with empty arguments — caller-side contract. |
+| JTBD-trace + persona derivation (I12 derive → interview-on-low-confidence → classify → ratify-creation-only — the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 as corrected by the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem 2026-06-29/2026-07-02) | **Derive-first per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 4 (silent-framework); interview + creation-ratify per category 1 (direction-setting).** Step 1.5b runs lexical detection (`\bJTBD-[0-9]+\b`) + flag pre-resolution (`--jtbd=` / `--persona=`) + cited-JTBD persona derivation. **Derive-success** → silent-proceed with derived values + stderr advisory. **Low-confidence** → **INTERVIEW** the human to elicit the real who/why (substantive non-leading questions, NOT propose an ID) → the agent classifies: elicited job/persona matches an EXISTING artefact → map + proceed autonomously; NO existing fit → human ratifies the **creation** of a new persona/JTBD (the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem) → map + proceed. **A real problem is NEVER discarded over anchoring uncertainty.** Scope-rejection (elicited who/why out of scope) is **external-report-only** at `/wr-itil:manage-problem` ingestion — never here. |
+| AFK low-confidence (`--no-prompt`) — preserve the finding | **Create-with-unconfirmed-anchoring + queue the elicitation per the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem never-discard + the ": Progress the Backlog While I'm Away" user outcome save-and-continue.** When invoked with `--no-prompt` (AFK mode marker) AND derivation fails (no JTBD-NNN citations + no `--persona=` flag + no `--jtbd=` flag, OR cited-JTBD persona-disagreement) → do NOT fire `request_user_input`, do NOT shoehorn a best-fit, do NOT auto-create a new artefact. Capture the ticket with the greppable `(unconfirmed — elicitation queued)` anchoring sentinel + stderr advisory, and queue the elicitation interview for the next interactive session (the AFK orchestrator surfaces it via `outstanding_questions`). the ": Confirm a decision's substance before building dependent work on it" architecture rule is preserved by the existing downstream oversight gates (the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem, the "Story maps and stories carry a drift-invalidated human-oversight marker" architecture rule, the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule I13), not by refusing the capture. AFK orchestrators still SHOULD pre-resolve persona+JTBD via flags to skip the sentinel path entirely. |
+
+**the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem / the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 — type-classification retired + I12 hard-block replaced with derive-then-ratify**: the maintainer-side type-classification dispatch (technical vs user-business) was REMOVED per twice-confirmed user direction (2026-05-25 the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem base + 2026-06-02 the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule amendment substance — *"I12 hard-block was wrong. Replacement: the persona and jtbd should be derived by the LLM. And if a persona/jtbd cannot be found then it should be proposed for User ratification. If the user rejects the persona or job to be done then that is should be treated as a rejection of the problem; corrections to the persona or job to be done are treated as acceptance and acceptance is treated as acceptance. Applies to ALL problems."*). The redundant type axis was already covered by RFC/Story persona-anchoring per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Phase 4. The original I12 hard-block (type-keyed JTBD-required halt) was REPLACED wholesale in the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 with the derive-then-ratify contract codified in Step 1.5b below. The contract applies to ALL problems (no type-keyed gating; the type axis itself is GONE). **the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem supersession (2026-06-29/2026-07-02):** the 2026-06-02 amendment's *"reject of the proposed persona/JTBD = rejection of the problem; no ticket created"* clause (quoted above) is REVERSED — low-confidence now interviews to elicit the real who/why (never proposes an ID), the agent classifies existing-vs-new, the human ratifies only the CREATION of a new persona/JTBD, and a real problem is NEVER discarded over anchoring uncertainty; scope-rejection is external-report-only. See the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem supersession note in Step 1.5b.
+
+Per the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 fail-safe: every decision above resolves without interactive user input in non-interactive contexts. The low-confidence **interview** fires only on derivation-failure (interactive surface) AND only when `--no-prompt` is absent; under `--no-prompt` the AFK path captures with the unconfirmed-anchoring sentinel + queues the elicitation (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem) — never silently shoehorning a best-fit or discarding the finding.
+
+**the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 carve-out audit (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, 2026-06-06 amendment; corrected by the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem 2026-06-29/2026-07-02)**: the universal AFK default is **queue-and-continue** (queue the decision, continue the loop). The AFK low-confidence path now **conforms** to that default rather than carving out from it: it captures the ticket with the `(unconfirmed — elicitation queued)` anchoring sentinel and queues the elicitation interview — the finding is preserved (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem never-discard + the ": Progress the Backlog While I'm Away" user outcome "save findings and move to the next problem"), NOT refused. the ": Confirm a decision's substance before building dependent work on it" architecture rule (Confirm decision substance before building dependent work) is still honoured, but by a different tactic than the retired no-ticket halt: the ticket's anchoring is **explicitly unconfirmed** (a greppable sentinel, never a shoehorned best-fit masquerading as confirmed — that would be the "external-comms agent silently goes dormant on the credibility axis — no nudge to author the missing RISK-POLICY section" problem harm), and dependent RFC/story/fix work stays gated on anchoring confirmation via the existing downstream oversight markers — **the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem** (a new persona/JTBD needs human ratification before it exists), **the "Story maps and stories carry a drift-invalidated human-oversight marker" architecture rule** (story maps/stories carry a drift-invalidated oversight marker), and the **the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule I13** propose-fix RFC-trace guard. Until the deferred `/wr-itil:work-problems` caller-side wiring lands (route the queued elicitation into the orchestrator's `outstanding_questions` batch — tracked on the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem), that downstream protection rests on those existing markers, not on refusing the capture. (The Empty `$ARGUMENTS` halt remains a genuine caller-contract halt — there is no description to capture.)
+
+## Steps
+
+### 0. README reconciliation preflight (the "`docs/problems/README.md` drifts from filesystem truth across sessions despite (refresh-on-create) and (refresh-on-transition) both Closed" problem)
+
+Same as `/wr-itil:manage-problem` Step 0 — diagnose-only check. Halt-and-route on Exit 1 (committed cross-session drift); INLINE_REFRESH carve-out (the "`/wr-itil:manage-problem` Step 0 reconcile halt-on-drift directive doesn't distinguish uncommitted-rename-rooted drift (same-session pending) from committed cross-session drift — should refresh inline rather than halt for the former case" problem) preserved. capture-problem itself does NOT refresh README.md (see Step 6); the preflight is purely a fail-fast on pre-existing drift.
+
+```bash
+<itil-plugin-root>/bin/wr-itil-reconcile-readme docs/problems > /tmp/wr-itil-drift-$$.txt
+reconcile_exit=$?
+if [ "$reconcile_exit" -eq 1 ]; then
+  <itil-plugin-root>/bin/wr-itil-classify-readme-drift /tmp/wr-itil-drift-$$.txt docs/problems
+  classify_exit=$?
+  rm -f /tmp/wr-itil-drift-$$.txt
+  # classify_exit 0 (INLINE_REFRESH): proceed (no inline refresh in this skill).
+  # classify_exit 1 (HALT_ROUTE_RECONCILE): halt; invoke /wr-itil:reconcile-readme.
+  # classify_exit 2 (parse error): conservative halt-and-route.
+fi
+```
+
+### 1. Parse the description and flags from `$ARGUMENTS`
+
+`$ARGUMENTS` may carry up to two leading flags before the free-text description (caller-side pre-resolution per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule silent-proceed shape):
+
+| Flag | Effect on Step 1.5b |
+|------|-------------------|
+| `--jtbd=JTBD-NNN[,JTBD-NNN...]` | Pre-resolves the JTBD-trace value. Step 1.5b skips JTBD-trace derivation. Comma-separated list of JTBD IDs (no spaces). |
+| `--persona=<value>` | Pre-resolves the persona value. Step 1.5b skips persona derivation. Value MUST be one of the directory names under `docs/jtbd/*/` (the adopter's real persona corpus — e.g. `maintainer`, `smb-owner` in adopter repos), falling back to the home-repo set `{developer, tech-lead, plugin-developer, plugin-user}` only when no `docs/jtbd/` directories exist. the "capture-problem `--persona` enum hardcoded to home-repo personas; rejects valid adopter personas (+ JTBD-M-NNN predicate gap)" problem — never hardcode the home-repo enum (the "Published skills reference repo-relative script paths — adopter `bash` invocations hard-fail at Step 0" problem/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 adopter-portability). |
+| `--no-prompt` | **AFK mode marker** (REVIVED 2026-06-02 per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02; behaviour corrected by the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem 2026-06-29/2026-07-02). Suppresses the low-confidence interview. When set AND derivation fails (no JTBD-NNN citations + no `--persona=` flag + no `--jtbd=` flag, OR cited-JTBD persona-disagreement) → capture the ticket with the `(unconfirmed — elicitation queued)` anchoring sentinel + stderr advisory and queue the elicitation (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem never-discard) — it no longer halts-refuses. AFK orchestrators (`/wr-itil:work-problems` capture-on-correction sub-flow, agent-mid-iter `capture-problem` invocations) SHOULD still pass this flag PLUS pre-resolved `--persona` + `--jtbd` flags to skip the sentinel path entirely. |
+
+Strip recognised leading flags from `$ARGUMENTS`; the remainder (after flags) is the free-text description. Unknown leading flags halt-with-stderr-directive: print "capture-problem: unknown flag '<flag>' — recognised flags: --jtbd=JTBD-NNN, --persona=<value>, --no-prompt" and exit.
+
+**the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem + the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 note**: `--type=technical` and `--type=user-business` are RETIRED (the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem, 2026-06-02 — type-classification axis removed). `--no-prompt` was retired in the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem base alongside the type-axis removal AND is now REVIVED 2026-06-02 per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule amendment's I12 derive-then-ratify contract — its semantic is now the AFK-mode marker for the persona/JTBD request_user_input fallback, NOT the historical type-classification suppress.
+
+Empty description (post-flag-strip) halts per the Rule 6 audit above.
+
+Derive a kebab-case title slug from the first 8-10 non-stopword tokens of the description (matching the existing `manage-problem` slug derivation pattern).
+
+### 1.5b JTBD-trace + persona dispatch — I12 derive → interview-on-low-confidence → classify (the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02, corrected by the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem)
+
+Per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule § Phase 3 + Phase 4 in-scope amendment (2026-05-13), as amended by the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem (2026-06-02 base — type-classification retired), by the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 (I12 hard-block REPLACED with derive-then-ratify; applies to ALL problems; no type-keyed gating), AND by the **the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem correction (user direction 2026-06-29, sharpened 2026-07-02)** — the low-confidence path is now **interview-to-elicit-who/why**, NOT propose-candidate-IDs-for-ratification; and a real problem is **never discarded** over anchoring uncertainty. Fires UNCONDITIONALLY. Both `jtbd_trace_value` and `persona_value` are REQUIRED on every captured ticket.
+
+**The corrected contract (one principle, both fields):**
+
+1. The agent **derives** persona + JTBD from the description.
+2. **Confident** → map to the existing persona/JTBD and **proceed autonomously** (no human — the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category-4 silent-framework).
+3. **Not confident** → do **NOT** shoehorn into the nearest existing ID, and do **NOT** ask *"is it JTBD-XXXX?"*. **Interview** the human (`request_user_input`, the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 1 structured form; may be more than one question) with substantive, non-leading questions about *who* hits this and *what they are trying to get done* — requirements elicitation of the real persona/job, **not** ratification of a guessed ID (this is *more* brief-before-ID-compliant than the old prompt — the "agent surfaces decisions to user using opaque IDs (P-numbers, ADR-numbers, JTBD-numbers) without explaining what they mean — empathy gap" problem — since no ID is surfaced at all).
+4. From the elicited who/why the **agent classifies**: matches an **existing** persona/JTBD → map and proceed (autonomous — the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule boundary applies only to *creation*, not mapping); **no existing fit** → a **new** persona/JTBD is warranted → route the **creation** to the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem human-ratify surface (`/wr-jtbd:update-guide` then `/wr-jtbd:confirm-jobs-and-personas`); on ratification, map to the new ID and proceed.
+
+The human is involved only for **substance** — the interview when derivation is weak, and ratifying the **creation** of a genuinely new persona/JTBD — never to bless an ID. **A real problem is NEVER discarded over anchoring uncertainty**; anchoring uncertainty is resolved by elicitation, not by rejecting the problem. Scope-rejection (deciding the elicited who/why is out of scope to support) is an **external-report-only** decision handled at `/wr-itil:manage-problem` ingestion — maintainer-side captures here always anchor to an existing or a new job. This is the same `covered → agent proceeds / uncovered → human ratifies a new artefact` boundary the "RFC-first: a problem's fix implements its RFC; no implementation without a pre-existing RFC" architecture rule draws for the fix-approach axis, applied to the who/why axis.
+
+> **the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem supersession note (user direction 2026-06-29 / 2026-07-02).** This reverses the 2026-06-02 the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule amendment substance that framed *"REJECT of the proposed persona/JTBD = rejection of the problem; no ticket created."* That framing shoehorned problems into the nearest ID and discarded legitimate problems over anchoring uncertainty. The reversal is deliberate and user-directed, NOT drift. The corresponding **the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule body amendment** and the **the "RFC-first: a problem's fix implements its RFC; no implementation without a pre-existing RFC" architecture rule additive symmetric-escalation note** are **queued on the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem** for the interactive ratification drain (per the "User direction is not substance ratification — agent must brief-and-ratify AFTER changes are complete (sibling-class to on the user-direction code path)" problem — user direction is not itself ADR-body-substance ratification); until they land, this SKILL leads and the ADR bodies follow — the same governed trade-off as the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem type-axis retirement (see the `## Related` note below). The AFK caller-side wiring in `/wr-itil:work-problems` (route the queued elicitation into its `outstanding_questions` batch) is likewise queued on the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem.
+
+**Resolve `jtbd_trace_value`** (an ORDERED list of JTBD IDs) via the following derive → interview-on-low-confidence → classify dispatch:
+
+1. **If `--jtbd=JTBD-NNN[,JTBD-NNN...]` was set in Step 1**: parse comma-separated list; assign to `jtbd_trace_value`; do NOT run the lexical detector; do NOT fire `request_user_input` (silent-framework per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 4). Caller pre-resolved.
+2. **Else** run the **lexical JTBD-trace detector** against the description: `grep -oE '\bJTBD-[0-9]+\b' | sort -u`. If ≥1 match found, set `jtbd_trace_value` to the matched IDs (de-duplicated, sorted ascending) and emit stderr advisory: `capture-problem: derived jtbd-trace=<id-list> from description JTBD-NNN citations; re-invoke with --jtbd= to override`. Do NOT fire `request_user_input` (silent-framework).
+3. **Else (no flag, no lexical detection — low-confidence path)**: do **NOT** shoehorn a best-fit JTBD and do **NOT** propose candidate `JTBD-NNN` IDs for ratification. **Interview** the human via `request_user_input` (may span who + why in one dispatch shared with the persona resolution below) with substantive, non-leading questions about *what job* the affected user is trying to get done. From the elicited answer the **agent classifies**:
+   - **Elicited job matches an existing JTBD** → set `jtbd_trace_value` to that ID and proceed (autonomous mapping — no further ratification; the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule human-oversight boundary applies only to *creation*).
+   - **No existing JTBD fits** → a new JTBD is warranted → route the **creation** to the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem human-ratify surface (`/wr-jtbd:update-guide` then `/wr-jtbd:confirm-jobs-and-personas`); on ratification, set `jtbd_trace_value` to the new ID and proceed.
+   - **The problem is never discarded** over anchoring uncertainty. (Scope-rejection — deciding the elicited who/why is out of scope to support — is an external-report-only decision at `/wr-itil:manage-problem` ingestion, never here.)
+4. **AFK (the `--no-prompt` branch) — preserve the finding, queue the elicitation**: if `--no-prompt` was set in Step 1 AND control reaches step 3 (no flag + no lexical detection) → SKIP the `request_user_input`, do **NOT** shoehorn a best-fit ID, and do **NOT** auto-create a new JTBD. Set `jtbd_trace_value` to the greppable unconfirmed-anchoring sentinel `(unconfirmed — elicitation queued)`, capture the ticket, and **queue the persona/JTBD elicitation interview** for the next interactive session (the AFK orchestrator surfaces it via its `outstanding_questions` batch). Emit stderr advisory `capture-problem: JTBD low-confidence under AFK; ticket captured with unconfirmed anchoring; elicitation queued — do not build dependent RFC/story/fix work until anchoring is confirmed`. The ticket IS created (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem never-discard + the ": Progress the Backlog While I'm Away" user outcome save-and-continue); the ": Confirm a decision's substance before building dependent work on it" architecture rule's "don't build on unconfirmed substance" is preserved by the existing downstream oversight gates (the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem new-persona/JTBD ratification; the "Story maps and stories carry a drift-invalidated human-oversight marker" architecture rule story-oversight; the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule I13 propose-fix RFC-trace guard), NOT by refusing the capture.
+
+**Resolve `persona_value`** (a scalar persona value — validated against the **adopter's persona corpus**: the directory names under `docs/jtbd/*/`, falling back to the home-repo set `{developer, tech-lead, plugin-developer, plugin-user}` only when no `docs/jtbd/` directories exist; the "capture-problem `--persona` enum hardcoded to home-repo personas; rejects valid adopter personas (+ JTBD-M-NNN predicate gap)" problem, never hardcode the home-repo enum — the "Published skills reference repo-relative script paths — adopter `bash` invocations hard-fail at Step 0" problem/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 adopter-portability) via the following derive → interview-on-low-confidence → classify dispatch:
+
+1. **If `--persona=<value>` was set in Step 1**: validate `<value>` against the persona corpus (the `docs/jtbd/*/` directory names, or the home-repo fallback set when no jtbd dirs exist — e.g. `ls -d docs/jtbd/*/ | xargs -n1 basename`); halt-with-directive if invalid; otherwise assign and proceed silently. Caller pre-resolved.
+2. **Else if `jtbd_trace_value` is non-empty AND cited JTBDs agree on a single persona**: derive `persona_value` from the cited JTBDs' `persona:` (and optionally `secondary-persona:`) frontmatter; emit stderr advisory: `capture-problem: derived persona=<value> from cited JTBD <id> frontmatter`; proceed silently.
+3. **Else (no flag + (no cited JTBDs OR cited-JTBD persona-disagreement) — low-confidence / ambiguity path)**: do **NOT** shoehorn a best-fit persona and do **NOT** propose candidate persona IDs for ratification. **Interview** the human via `request_user_input` (share the dispatch with the JTBD-trace interview above — one elicitation covers *who* + *what job*) with substantive, non-leading questions about *who* actually hits this problem. From the elicited answer the **agent classifies**:
+   - **Elicited persona matches an existing persona** (a `docs/jtbd/*/` directory) → assign `persona_value` to it and proceed (autonomous mapping — the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule boundary is creation-only).
+   - **No existing persona fits** → a new persona is warranted → route the **creation** to the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem human-ratify surface (`/wr-jtbd:update-guide` then `/wr-jtbd:confirm-jobs-and-personas`); on ratification assign `persona_value` to the new persona and proceed.
+   - **The problem is never discarded** over persona uncertainty. Scope-rejection remains external-report-only (`/wr-itil:manage-problem` ingestion).
+4. **AFK (the `--no-prompt` branch) — preserve the finding, queue the elicitation**: if `--no-prompt` was set in Step 1 AND control reaches step 3 → SKIP the `request_user_input`, do **NOT** shoehorn a best-fit persona, and do **NOT** auto-create a new persona. Set `persona_value` to the greppable unconfirmed-anchoring sentinel `(unconfirmed — elicitation queued)`, capture the ticket, and queue the elicitation interview for the next interactive session. Emit stderr advisory `capture-problem: persona low-confidence under AFK; ticket captured with unconfirmed anchoring; elicitation queued — do not build dependent RFC/story/fix work until anchoring is confirmed`. The ticket IS created (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem never-discard); the ": Confirm a decision's substance before building dependent work on it" architecture rule preserved via the existing downstream oversight gates, not by refusing the capture.
+
+**the "Report a Problem Without Pre-Classifying It" user outcome scope preservation**: this dispatch fires on the maintainer-side `/wr-itil:capture-problem` only. Plugin-user-side `.github/ISSUE_TEMPLATE/problem-report.yml` MUST NOT prompt for JTBD trace or persona — preserves the "Report a Problem Without Pre-Classifying It" user outcome firewall per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule P4.3 maintainer-side / plugin-user-side asymmetry clarifier. Triage during `/wr-itil:manage-problem` ingestion assigns both fields from the reporter's symptom signals (per the "Report a Problem Without Pre-Classifying It" user outcome maintainer-side-complement extension, amended 2026-06-02 to remove the type-axis residue).
+
+**the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule authority taxonomy**: silent-framework (category 4) on the derive-success paths (flag pre-resolution, lexical detection, cited-JTBD agreement) AND on the agent's existing-vs-new classification of the elicited who/why (mechanical framework resolution — the agent maps the elicited job to an existing artefact without a consent gate); **direction-setting (category 1)** on the low-confidence **interview** (requirements elicitation of the real persona/job) and on the human ratification of the **creation** of a new persona/JTBD (per the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem) — NOT a taste preference between equally-valid options, and NOT ratification of a guessed ID (the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem).
+
+### 2. Minimal-grep duplicate check (3-keyword title-only) + hang-off-check subagent dispatch (the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem Phase 3 amendment, 2026-05-31)
+
+**Sub-step 2a — title-only grep (pre-existing minimal duplicate check)**
+
+Extract up to **3 distinct kebab-cased non-stopword keywords** from the description. Grep the **filenames** of `docs/problems/*.md` AND `docs/problems/<state>/*.md` (NOT bodies — title-only is the conservative threshold per architect verdict on Q1; dual-tolerant per the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design migration window):
+
+```bash
+match_count=$(ls docs/problems/*.md docs/problems/*/*.md 2>/dev/null \
+              | grep -ciE 'kw1|kw2|kw3' || true)
+```
+
+The **3-keyword cap** is a hard-coded constant. Do NOT make it env-overridable — the conservative threshold rationale (the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem line 24) is structural to the design, not a tunable knob.
+
+**Title-only**: file bodies are intentionally NOT scanned. Body-content matches would either (a) over-prompt (capture-problem has no request_user_input to surface them) or (b) get silently swallowed. Title-only matches preserve the conservative-threshold contract.
+
+If matches are found: list them in the final report. **Do NOT halt or branch.** Capture proceeds. The user can resolve duplicates at the next `/wr-itil:review-problems` invocation (or invoke `/wr-itil:manage-problem` directly if the duplicate-check shape needs a structured branch).
+
+**Sub-step 2b — hang-off-check via fresh-context subagent (the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem Phase 3; the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule 5th invocation pattern)**
+
+The 3-keyword title-only grep at sub-step 2a is conservative: it catches narrow shape-overlap on titles but misses the wider class of hang-off candidates — parent tickets where the new capture's scope belongs as an Investigation Tasks expansion / Phase N section rather than as a sibling ticket. The wrongly-captured the "Phase 2 — extend `evaluate-relevance.sh` with 4 more evidence shapes + fix Phase 1 file-no-longer-exists false-positive class" problem sibling of the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem on 2026-05-31 is the canonical regression: the main agent (mid-iter, with rich session context) pattern-matched the existing capture flow and missed that the new spec belonged inside the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem as Phase 3.
+
+Sub-step 2b adds a **mechanical pre-filter + fresh-context subagent dispatch** that closes this gap without re-introducing the main agent's session-context bias. The subagent runs in isolation (no parent-session context) and emits a structured verdict the SKILL acts on deterministically.
+
+**Mechanical pre-filter** — grep `docs/problems/open/*.md` + `docs/problems/verifying/*.md` BODIES for tokens shared with the description: any `ADR-NNN` reference, `RFC-NNN` reference, `JTBD-NNN` reference, SKILL path (`/wr-<plugin>:<skill>` or `packages/<plugin>/skills/<skill>/`), file path (`packages/...`, `docs/...`, `.github/...`, `bin/...`, `scripts/...`), or named feature word the description cites. Collect candidates that share **≥1** signal.
+
+```bash
+# Extract candidate signals from the description (post-flag-strip).
+adr_refs=$(echo "$description" | grep -oE 'ADR-[0-9]{3}' | sort -u)
+rfc_refs=$(echo "$description" | grep -oE 'RFC-[0-9]{3}' | sort -u)
+skill_refs=$(echo "$description" | grep -oE '/wr-[a-z-]+:[a-z-]+' | sort -u)
+file_refs=$(echo "$description" | grep -oE '(packages|docs|\.github|bin|scripts)/[a-zA-Z0-9_./-]+' | sort -u)
+signals="$adr_refs"$'\n'"$rfc_refs"$'\n'"$skill_refs"$'\n'"$file_refs"
+signals=$(echo "$signals" | grep -v '^$' | sort -u)
+
+# If no signals extractable from description, skip the dispatch entirely
+# (the title-only grep at 2a is the only duplicate check this capture gets).
+[ -z "$signals" ] && SKIP_HANG_OFF_CHECK=1
+
+# Otherwise: pre-filter candidates from open/ + verifying/ that share ≥1 signal.
+candidates=()
+if [ -z "$SKIP_HANG_OFF_CHECK" ]; then
+  for f in docs/problems/open/*.md docs/problems/verifying/*.md; do
+    [ -f "$f" ] || continue
+    for sig in $signals; do
+      if grep -qF "$sig" "$f"; then
+        candidates+=("$f")
+        break
+      fi
+    done
+  done
+fi
+```
+
+**Candidate-cap short-circuit (latency-bound per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule + the ": Enforce Governance Without Slowing Down" user outcome's 60s flow budget)**: if `${#candidates[@]} -gt 5`, **skip the subagent dispatch** and record the candidate list in the captured ticket's `## Related` section for review-time re-evaluation by `/wr-itil:review-problems`. Wide candidate sets blow the lightweight-capture latency budget; the safe default is "skip + defer to cluster pass."
+
+**Empty-candidates short-circuit**: if `${#candidates[@]} -eq 0` (no shared signals), skip the dispatch and proceed to the marker step. The mechanical pre-filter found nothing to arbitrate.
+
+**the "Report a Problem Without Pre-Classifying It" user outcome firewall** — sub-step 2b fires on maintainer-side `/wr-itil:capture-problem` invocations ONLY. Plugin-user-side `.github/ISSUE_TEMPLATE/problem-report.yml` MUST NOT carry an equivalent dispatch (plugin-user descriptions do not carry the same authorial intent; a plugin-user describing their friction in maintainer vocabulary could plausibly trigger a wrong-parent HANG_OFF). Triage during `/wr-itil:manage-problem` ingestion stays user-judgement per the "Report a Problem Without Pre-Classifying It" user outcome. Mirrors the Step 1.5b JTBD-trace firewall above.
+
+**AFK safe-default**: the hang-off-check subagent verdict is non-interactive by construction (no `request_user_input`), and ambiguous-multi-parent cases collapse to `PROCEED_NEW` per the subagent's Rule 6 contract. This satisfies the ": Progress the Backlog While I'm Away" user outcome's "Decisions normally requiring my input are resolved using safe defaults" without dependency on the retired `--no-prompt` flag.
+
+**Dispatch** — when the candidate set is non-empty and ≤5, delegate to `wr-itil:hang-off-check` via the native Codex subagent tool with a structured input payload:
+
+```
+SURFACE: capture-problem-step-2b
+
+<new-capture>
+<description verbatim, post-flag-strip>
+</new-capture>
+
+<candidates>
+P<NNN1> | <title1> | <path1> | shared-signals: <signal1, signal2, ...>
+P<NNN2> | <title2> | <path2> | shared-signals: <signal1, signal3, ...>
+...
+</candidates>
+```
+
+The subagent reads the candidate ticket bodies in full as needed (via its own Read tool), reasons about absorb-vs-proceed, and returns one of:
+
+- `HANG_OFF: P<NNN>` with **Rationale**, **Signals matched**, **Where to absorb** sections.
+- `PROCEED_NEW` with **Rationale** and **Per-candidate explanation** for each surfaced candidate.
+
+**Act on verdict:**
+
+- **HANG_OFF: P<NNN>**: **halt** capture-problem. Emit a structured halt directive to the calling orchestrator agent naming (a) the parent ticket file path, (b) the new scope to amend in, (c) the `Where to absorb` directive from the subagent verdict. The orchestrator agent owns the parent-ticket edit + commit per the standard ticket-edit flow (do NOT amend the parent ticket from inside capture-problem — capture-problem creates new tickets; ticket-body amendments are manage-problem's surface). Record the hang-off decision + rationale in stderr for the audit trail.
+
+- **PROCEED_NEW**: continue to the marker step below. Capture the subagent's rationale + per-candidate explanation in a transient note (stderr) and append it to the new ticket's `## Related` section so the next reviewer sees what was considered. This is the audit-trail contract per the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule grounding + the "Restore Service Fast with an Audit Trail" user outcome audit-trail completeness.
+
+**After the grep + (optional) hang-off-check completes**, write the per-session create-gate marker so the `PreToolUse:Write` hook (the "Agent bypasses `/wr-itil:manage-problem` Step 2 duplicate-check by writing tickets directly to `docs/problems/`" problem) permits the subsequent Write of the new ticket file under `docs/problems/open/`. Per **the "create-gate marker race between concurrent Codex sessions via shared runtime-sid file" problem / the "Capture the runtime stdin session_id via a PreToolUse hook so the create-gate marker binds to the same SID the runtime hook will see" architecture rule Option C**, write it under EVERY recent candidate session SID (not just one) so a concurrent orchestrator+subprocess race cannot land the marker under the wrong UUID:
+
+```bash
+<itil-plugin-root>/bin/wr-itil-mark-create-gate
+```
+
+`<itil-plugin-root>/bin/wr-itil-mark-create-gate` is the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule `$PATH` shim that internalises the former inline `source <itil-plugin-root>/hooks/lib/{session-id,create-gate}.sh` + `get_candidate_session_ids | mark_step2_complete_candidates`. It resolves those `hooks/lib` siblings 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) — so it works in adopter installs. NEVER `source packages/...` repo-relative from a SKILL; those paths only resolve in the source monorepo, not where the plugin is installed.
+
+The marker is shared between `manage-problem` and `capture-problem` per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule amendment — same `/tmp/manage-problem-grep-${SESSION_ID}` path, idempotent across cross-skill ordering. Internally the command enumerates the `get_current_session_id` pick (the "`/wr-itil:manage-problem` Step 2 substep 7 session-id discovery is brittle — agent has no env var, must scrape marker filenames" problem) plus every recent `/tmp/<system>-announced-<UUID>` UUID within a 24h mtime window, and writes the marker under each — so whichever SID the hook reads from the Write's stdin, a matching marker exists. This closes the "create-gate marker race between concurrent Codex sessions via shared runtime-sid file" problem create-gate race that fires when the orchestrator main turn captures a ticket while a backgrounded iter subprocess holds the per-machine runtime-sid marker (last-writer-wins). The candidate set is bounded to recent same-machine markers — not a global fail-open (the "Agent bypasses `/wr-itil:manage-problem` Step 2 duplicate-check by writing tickets directly to `docs/problems/`" problem audit invariant holds: each marker still records that THIS session ran the duplicate-check grep). See `/wr-itil:manage-problem` Step 2 substep 7 for the full mechanism.
+
+### 3. Compute the next ID
+
+Same the "Problem 056: Ticket-creator next-ID lookup greps blob SHAs, producing wrong `origin_max` values" problem-safe local_max + origin_max formula as `/wr-itil:manage-problem` Step 3:
+
+```bash
+# Dual-tolerant ticket enumeration (the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design migration window). Both
+# halves of the OR contribute to next-ID compute — flat-layout 104 +
+# per-state 204 BOTH appear in `local_max` so the next-ID compute
+# never re-allocates an already-taken ID. Architect finding 2 (the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design
+# T2) — capture-problem's next-ID surface is a separate the "Problem-ticket directory layout — per-state subdirectories under `docs/problems/`" architecture rule
+# contract from generic enumeration; missing the per-state half
+# regresses ID allocation. The `git ls-tree -r` recursive flag
+# extends the same coverage to the origin tree.
+local_max=$(ls docs/problems/*.md docs/problems/*/*.md 2>/dev/null | sed 's|.*/||' | grep -oE '^[0-9]+' | sort -n | tail -1)
+origin_max=$(git ls-tree -r --name-only origin/main docs/problems/ 2>/dev/null | sed 's|.*/||' | grep -oE '^[0-9]+' | sort -n | tail -1)
+next=$(printf '%03d' $(( 10#$(echo -e "${local_max:-0}\n${origin_max:-0}" | sort -n | tail -1) + 1 )))
+```
+
+Log the renumber decision in the operation report if origin and local diverged.
+
+### 4. Skeleton-fill the ticket
+
+**File path**: `docs/problems/open/<NNN>-<kebab-title>.md` (per the "Problem-ticket directory layout — per-state subdirectories under `docs/problems/`" architecture rule per-state-subdir layout)
+
+**Template** (deferred-placeholder pattern — flag every section the capture didn't fill):
+
+```markdown
+# Problem <NNN>: <Title>
+
+**Status**: Open
+**Reported**: <YYYY-MM-DD>
+**Priority**: <Severity = Impact × Likelihood> (<band>) — Impact: <1-5> × Likelihood: <1-5> — derived at capture from the description per Step 4a
+**Origin**: internal
+**Effort**: <S|M|L|XL> — derived at capture per Step 4a
+**JTBD**: <jtbd_trace_value_as_comma_separated_list_OR_omit_line_when_empty>
+**Persona**: <persona_value_OR_omit_line_when_empty>
+
+## Description
+
+<full description from $ARGUMENTS, with leading recognised flags stripped>
+
+## Symptoms
+
+(deferred to investigation)
+
+## Workaround
+
+(deferred to investigation)
+
+## Impact Assessment
+
+- **Who is affected**: (deferred to investigation)
+- **Frequency**: (deferred to investigation)
+- **Severity**: (deferred to investigation)
+- **Analytics**: (deferred to investigation)
+
+## Root Cause Analysis
+
+### Investigation Tasks
+
+- [ ] Investigate root cause
+- [ ] Create reproduction test
+
+## Dependencies
+
+- **Blocks**: (none)
+- **Blocked by**: (none)
+- **Composes with**: (none)
+
+## Related
+
+(captured via /wr-itil:capture-problem; expand at next investigation)
+```
+
+**Rate at capture, do not defer (the "Repo conflates a "named re-entry point" with a self-firing cadence — deferrals not transitively reachable from an automatic trigger rot" problem / the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule amendment 2026-06-24).** The Priority (Impact × Likelihood) and Effort fields are **derived at capture** per Step 4a below — a real best-effort rating, ALWAYS. No `(deferred — re-rate…)` placeholder and **no "not estimated" / "no prior data" marker** — those are deferrals wearing a different hat (user correction 2026-06-24: *"that's just another deferral"*). The old deferred-placeholder default was the single largest uncadenced-deferral rot generator (the "Repo conflates a "named re-entry point" with a self-firing cadence — deferrals not transitively reachable from an automatic trigger rot" problem): nothing self-fired `review-problems`, and the `Likelihood: 1` false-low buried every capture at the bottom of WSJF. Estimation under uncertainty produces an estimate, not a deferral: a thin description still gets a real number (rough is fine). `/wr-itil:review-problems` re-rates the whole backlog when it runs — captures need no per-ticket re-rate flag.
+
+### 4a. Derive the rating at capture (the "Repo conflates a "named re-entry point" with a self-firing cadence — deferrals not transitively reachable from an automatic trigger rot" problem / the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule amendment; the ": Cost-based WSJF effort — capture time + cost actuals, tally per ticket, retro-driven RMS calibration (tally-first)" architecture rule + the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule + the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule)
+
+Derive Priority and Effort from the description **silently** — NO `request_user_input` (the ": Cost-based WSJF effort — capture time + cost actuals, tally per ticket, retro-driven RMS calibration (tally-first)" architecture rule item 1 silent-derivation, category-4 silent-framework per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule; preserves the lightweight 3-4-turn capture cost shape). This is one inference over text the agent has already read, NOT the `/wr-itil:manage-problem` ceremony.
+
+1. **Impact (1-5)** and **Likelihood (1-5)** — read the description against `RISK-POLICY.md`'s impact bands and assess how often / how broadly the harm manifests. `Severity = Impact × Likelihood`; `Priority` band follows the standard matrix. Likelihood is **honest field-risk only** — never inflate it to lift WSJF rank (the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule).
+2. **Effort (S/M/L/XL)** — derive from the described scope (files touched, cross-package, migration-heavy → larger), per the ": Cost-based WSJF effort — capture time + cost actuals, tally per ticket, retro-driven RMS calibration (tally-first)" architecture rule's t-shirt buckets.
+3. **Always a real value (the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule grounding without deferral)** — when a comparable prior ticket informs the estimate, cite it inline (e.g. `— cf. P<NNN>`). When no comparable prior exists, **still commit to a real best-effort number** grounded in the description's own signals — do NOT append "not estimated" / "no prior data" or any other re-rate flag (that is a deferral; user correction 2026-06-24). A rough estimate from a thin description is honest estimation; a marker that says "I didn't really estimate this" is the rot this brick removes.
+
+Write the derived values into the template's `**Priority**` and `**Effort**` lines (replacing the `<…>` placeholders). Every captured ticket leaves Step 4a with a real Impact × Likelihood and a real Effort bucket — never a placeholder, never a deferral marker.
+
+### 5. Write the file
+
+Single `Write` to `docs/problems/open/<NNN>-<kebab-title>.md` (per the "Problem-ticket directory layout — per-state subdirectories under `docs/problems/`" architecture rule per-state-subdir layout). The "Agent bypasses `/wr-itil:manage-problem` Step 2 duplicate-check by writing tickets directly to `docs/problems/`" problem PreToolUse hook permits the Write because Step 2 set the marker.
+
+### 6. Commit per the "Governance Skills Commit Their Own Completed Work" architecture rule — single commit, inline README refresh (the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem)
+
+**the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem / Option 2 amendment (2026-06-05).** This step previously skipped the README refresh and emitted a `RISK_BYPASS: capture-deferred-readme` trailer to clear the "README-refresh enforcement gap — iter subprocess commits can land a `.verifying.md` rename without staging the corresponding Verification Queue row in `docs/problems/README.md`" problem README-refresh gate. The user-directed Option 2 resolution (recorded 2026-05-31 on the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem) kills the deferred-README-refresh contract: capture-problem now stages `docs/problems/README.md` inline, mirroring `/wr-itil:manage-problem` Step 5 the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem (refresh-on-create) + the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem (last-reviewed rotation). The trailer is dropped from the commit; the allow-list entry in `<itil-plugin-root>/hooks/lib/readme-refresh-detect.sh::_README_REFRESH_BYPASS_TRAILERS` is retained as inert dead code (minimal-change discipline — future adopters that registered against the token continue to work). Authority: the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem Option 2 user direction + the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule amendment + the "Governance Skills Commit Their Own Completed Work" architecture rule bypass-token-table amendment (same single coherent commit).
+
+#### README.md refresh on new ticket (the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem)
+
+After writing the new `.open.md` file at Step 5, regenerate `docs/problems/README.md` to insert the new ticket's row into the WSJF Rankings, and stage the refreshed README in the same commit as the new ticket. The mechanism is **inline at this execution site per the "transition-problem SKILL Step 7 Last-reviewed rotation silently skipped across iters" problem** — not deferred via cross-reference — so a single-pass agent reading Step 6 does not silently skip the archive step (the canonical the "transition-problem SKILL Step 7 Last-reviewed rotation silently skipped across iters" problem silent-skip regression).
+
+**Mechanism**: use the same rendering rules as `/wr-itil:manage-problem` Step 5 the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem / Step 7 the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem (glob `docs/problems/*.open.md` / `*.known-error.md` / `*.verifying.md` / `*.parked.md` AND the per-state-subdir layout `docs/problems/open/*.md` / `docs/problems/known-error/*.md` / `docs/problems/verifying/*.md` / `docs/problems/parked/*.md`; rank open/known-error by WSJF; list verifyings in the Verification Queue ordered by Released date ASC per the "docs/problems/README.md Verification Queue rendered newest-first contradicts section header "Ranked by release age, oldest first"" problem; list parkeds in the Parked section). The refresh is a **render, not a re-rank** — existing WSJF values on the other ticket files are trusted 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 established discipline. Only the new ticket's own (deferred-placeholder) WSJF is consumed from its freshly-written file. **WSJF Rankings tier + tie-break sort** (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 "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule) and **Verification Queue sort direction** (the "docs/problems/README.md Verification Queue rendered newest-first contradicts section header "Ranked by release age, oldest first"" problem) and **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) all follow the canonical render rules — see `/wr-itil:manage-problem` Step 5 the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem block for the full prose; drift here re-opens those tickets.
+
+**the "`docs/problems/README.md` line 3 narrative-blob accumulator bloat — sibling to (briefing tier 3) on a different surface" problem last-reviewed rotation** — inline at this execution site (not deferred to a § subsection) per the "transition-problem SKILL Step 7 Last-reviewed rotation silently skipped across iters" problem silent-skip discipline. MUST execute IN ORDER:
+
+1. **Read** line 3 of `docs/problems/README.md`: `awk 'NR==3' docs/problems/README.md`.
+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 **P<NNN> captured** — <one-line title> (lightweight aside via /wr-itil:capture-problem)`. 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.
+4. **Stage all three** — `git add docs/problems/open/<NNN>-<kebab-title>.md 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 captures the new ticket + refreshed README + (when line-3 displaced) history. Omit `README-history.md` from the stage list when no line-3 displacement occurred (no untracked diff). Canonical rationale anchor: `/wr-itil:manage-problem` § 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) subsection.
+
+```bash
+git add docs/problems/open/<NNN>-<kebab-title>.md docs/problems/README.md
+# If line-3 was rotated above, also:
+git add docs/problems/README-history.md
+```
+
+Satisfy the commit gate per the "Governance Skills Commit Their Own Completed Work" architecture rule — same two-path pattern as manage-problem Step 11:
+
+- **Primary**: delegate to subagent type `wr-risk-scorer:pipeline` via the native Codex subagent tool.
+- **Fallback**: invoke `/wr-risk-scorer:assess-release` via the installed skill invocation when the subagent type is unavailable in the current tool surface.
+
+Land the commit in one Bash call so the risk assessment cannot leave a partially re-staged index:
+
+```bash
+git add -- docs/problems/open/<NNN>-<kebab-title>.md docs/problems/README.md
+if git diff --cached --quiet --exit-code; then exit 1; fi
+git commit -m "docs(problems): capture P<NNN> <title>"
+# Add docs/problems/README-history.md to the git add list when it changed.
+```
+
+The `capture` verb in the message is the audit signal that this ticket landed via the lightweight aside path (vs. `open` for manage-problem's full intake). The "README-refresh enforcement gap — iter subprocess commits can land a `.verifying.md` rename without staging the corresponding Verification Queue row in `docs/problems/README.md`" problem README-refresh-discipline hook now allows the commit naturally because the README is staged — no `RISK_BYPASS` trailer needed.
+
+### 7. Report
+
+After the commit, report:
+
+- The new ticket file path and ID.
+- The list of duplicate matches found (if any). If matches found, name them and remind the user to merge at next `/wr-itil:review-problems` if appropriate.
+- **Trailing pointer (conditional shape per the "`/wr-itil:review-problems` not auto-fired when needed — user has to remember to run it" problem)**: invoke `<itil-plugin-root>/bin/wr-itil-check-deferred-placeholder-staleness "$PWD"` to read the deferred-placeholder + README-cadence staleness signal. The pointer shape switches on the helper's five-outcome enum:
+
+  ```bash
+  preflight_reason="$(<itil-plugin-root>/bin/wr-itil-check-deferred-placeholder-staleness "$PWD")"
+  ```
+
+  See `/wr-itil:work-problems` SKILL.md Step 0c for the canonical contract on the two-axis trigger (count ≥ 3 ungrounded-rating tickets — the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule `not estimated` sentinel — AND README age > 7 days); the threshold constants live in the helper. <!-- DEFERRED-PLACEHOLDER-STALENESS-CONTRACT-SOURCE: <itil-plugin-root>/lib/check-deferred-placeholder-staleness.sh -->
+
+  | `preflight_reason`                                | Trailing-pointer shape                                                                                |
+  |---------------------------------------------------|--------------------------------------------------------------------------------------------------------|
+  | `no-deferred-placeholders` / `below-threshold ...` / `fresh-readme ...` | Default (low-priority) pointer: *"Run `/wr-itil:review-problems` next to re-rate the ungrounded (`not estimated — no prior data`) ratings."* (README is now refreshed inline at Step 6 per the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem Option 2 — the pointer no longer names a README-refresh action in the default shape.) |
+  | `no-readme count=<N>`                              | **Highlighted (actionable) pointer**: *"⚠ `<N>` ungrounded-rating ticket(s) (the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule `not estimated` sentinel) have accumulated AND `docs/problems/README.md` is missing/malformed — run `/wr-itil:review-problems` NOW to rebuild the README and re-rate placeholders."* (Fires only when README is genuinely missing/malformed despite this skill's inline refresh — a drift class the helper still surfaces.) |
+  | `stale-readme count=<N> age=<X>s threshold=<Y>s`   | **Highlighted (actionable) pointer**: *"⚠ `<N>` ungrounded-rating ticket(s) (the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule `not estimated` sentinel) have accumulated AND the WSJF Rankings cadence is `<X>` days stale (> 7-day threshold) — run `/wr-itil:review-problems` NOW to re-rate placeholders."* (Inline refresh at Step 6 freshens the README mtime on every capture, so this shape now fires only when captures are absent for > 7 days — a real cadence-stale signal, not capture-driven drift.) |
+
+  **Why conditional, not auto-dispatch** (the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule + the ": Enforce Governance Without Slowing Down" user outcome): capture-problem is intentionally lightweight per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem amendment. Auto-dispatching review-problems from capture would re-introduce the ~10-turn ceremony the lightweight aside is engineered to avoid. The conditional pointer surfaces the signal "ungrounded-rating backlog has grown AND the cadence axis hit threshold" when both axes fire. The user picks when to absorb the re-rate cost.
+
+  **Fail-soft**: any error in the helper invocation MUST NOT block the report — fall back to the default pointer shape.
+
+The trailing pointer is **not optional** — it is the user-visible signal for ungrounded-rating re-rating cadence (the "Repo conflates a "named re-entry point" with a self-firing cadence — deferrals not transitively reachable from an automatic trigger rot" problem re-point: the count is now the "Agent output grounding — no fabricated quantitative estimates, cite + persist + uncertainty" architecture rule `not estimated` sentinels, not blanket deferred placeholders). The conditional highlight (the "`/wr-itil:review-problems` not auto-fired when needed — user has to remember to run it" problem) escalates the signal when the ungrounded-rating backlog AND the cadence axis both hit threshold. Drift here re-opens the "`/wr-itil:review-problems` not auto-fired when needed — user has to remember to run it" problem.
+
+<!-- @jtbd the ": Enforce Governance Without Slowing Down" user outcome (Enforce Governance Without Slowing Down — conditional highlight escalates the signal without forcing a flow break) -->
+
+## Composition with manage-problem
+
+| Concern | manage-problem | capture-problem |
+|---------|----------------|-----------------|
+| Duplicate-check | Wide-net grep + request_user_input branch on matches | 3-keyword title-only grep, list-only (no branch) |
+| Multi-concern split | Step 4b request_user_input | Out of scope (one ticket per invocation) |
+| Skeleton-fill | Full-intake; request_user_input for missing fields | Deferred-placeholder pattern; low-confidence persona/JTBD → interview-to-elicit-who/why (never propose an ID; never discard the problem) |
+| Type-tag prompt | RETIRED (the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem, 2026-06-02) | RETIRED (the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem, 2026-06-02) — the technical/user-business axis was removed as redundant with RFC/Story persona-anchoring per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Phase 4 |
+| JTBD-trace + persona | Step 4-equivalent ingestion path | Step 1.5b derive → interview → classify dispatch (the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule Amendment 2026-06-02 as corrected by the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem) — flag pre-resolution (`--jtbd=` / `--persona=`) silent-proceeds; lexical detection of JTBD-NNN citations silent-proceeds; cited-JTBD persona derivation silent-proceeds; low-confidence → INTERVIEW to elicit who/why (not propose an ID) → agent classifies existing:map+proceed / no-fit:human-ratifies-CREATION (the ": JTBD + persona human-oversight marker + `/wr-jtbd:confirm-jobs-and-personas` drain (sibling of )" architecture rule/the "New Jobs To Be Done and new personas need human-oversight confirmation (sibling of )" problem); problem NEVER discarded over anchoring; AFK `--no-prompt` → capture with unconfirmed-anchoring sentinel + queue elicitation |
+| request_user_input authority | Multiple branches (deviation-approval / direction-setting / taste / mechanical) | Direction-setting (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 1) on the low-confidence interview + on the new-artefact creation-ratify; silent-framework (category 4) on derive-success paths AND on the agent's existing-vs-new classification of the elicited who/why |
+| README refresh | the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem inline (regenerate + stage in same commit) | the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem inline (regenerate + stage in same commit) — the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem Option 2 amendment 2026-06-05; previously deferred to next `/wr-itil:review-problems` |
+| Status transitions | Step 7 owns Open → Known Error → Verifying → Closed | Out of scope (creation only) |
+| Commit grain | One commit per intake (or per split-concern set) | One commit per capture |
+| Use case | Full-intake new problem; user wants to walk the flow | Aside-invocation; capture-and-continue |
+
+The two skills share the `/tmp/manage-problem-grep-${SESSION_ID}` create-gate marker per the "Agent bypasses `/wr-itil:manage-problem` Step 2 duplicate-check by writing tickets directly to `docs/problems/`" problem — calling either skill's Step 2 grep + mark sequence permits new ticket Writes for the rest of the session, regardless of which skill landed first.
+
+## Related
+
+- **the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem** (`docs/problems/closed/155-ship-capture-problem-skill.md`) — driver ticket.
+- **the "Problem 014: No lightweight aside invocation for governance skills (problems, retros, ADRs)" problem** (`docs/problems/open/014-aside-invocation-for-governance-skills.md`) — parent / master tracker.
+- **the "Problem 078: Assistant does not offer to capture a problem ticket when the user delivers strong-signal correction" problem** — capture-on-correction OFFER pattern; depends on capture-problem shipping.
+- **the "Agent bypasses `/wr-itil:manage-problem` Step 2 duplicate-check by writing tickets directly to `docs/problems/`" problem** — manage-problem create-gate hook; capture-problem composes with the same marker.
+- **the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem** (`docs/problems/verifying/199-...md`) — Option 2 amendment 2026-06-05: kill the deferred-README-refresh contract; Step 6 now stages README inline per the "Problem 094: `/wr-itil:manage-problem` does not refresh `docs/problems/README.md` on ticket creation" problem. User direction recorded 2026-05-31 in the ticket. This SKILL change rides with the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule + the "Governance Skills Commit Their Own Completed Work" architecture rule amendments in the same coherent commit.
+- **the "README-refresh hook conflicts with capture-problem SKILL's deferred-README-refresh contract — hook wins; SKILL needs update OR hook needs carve-out" problem** (closed) — the "README-refresh enforcement gap — iter subprocess commits can land a `.verifying.md` rename without staging the corresponding Verification Queue row in `docs/problems/README.md`" problem README-refresh-discipline hook conflicted with this skill's previous deferred-README-refresh contract. The prior workaround was the `RISK_BYPASS: capture-deferred-readme` allow-list token. Superseded by the "capture-problem → manage-problem same-session halts at Step 0 reconcile (HALT_ROUTE_RECONCILE on deferred-refresh seam)" problem Option 2 (2026-06-05) — capture-problem now stages README inline and the trailer is no longer emitted. The allow-list entry in `<itil-plugin-root>/hooks/lib/readme-refresh-detect.sh::_README_REFRESH_BYPASS_TRAILERS` is retained as inert dead code (minimal-change discipline; adopter compatibility).
+- **the "hook does not recognise `RISK_BYPASS: adr-031-migration` trailer — blocks Step 0a auto-migrate" problem** — the RISK_BYPASS-trailer allow-list mechanism in `readme-refresh-detect.sh`. Still in force for the `adr-031-migration` token; the `capture-deferred-readme` entry is now inert (no live emitter) but registered for adopter compatibility.
+- **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** (`docs/problems/known-error/170-problem-tickets-strain-as-fixes-decompose-into-multiple-coordinated-changes-need-rfc-framework.md`) — RFC framework driver; Slice 4 B7.T3 / item 8c historically authored the type-classification prompt at Step 1.5 (RETIRED by the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem, 2026-06-02).
+- **the "Agent-side I2 (no type-branching) coverage gap — SKILL.md type-branching invariant not behaviourally testable until skill-invocation harness lands" problem** — agent-side I2 (no type-branching) coverage gap on the SKILL.md surface. the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem retires the type axis altogether; the regression guard is preserved under `<itil-plugin-root>/scripts/test/no-type-regression-guard.bats` (asserting the `**Type**:` field is GONE from skeleton templates).
+- **the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem** (`docs/problems/.../287-remove-technical-user-business-type-classification-from-problems-redundant-with-rfc-persona-anchoring.md`) — the user direction (twice-confirmed 2026-05-25 + 2026-06-02) that retired Step 1.5 Type classification; the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule amendment substance (I12 replacement, Phase-4 rework) queued for user re-confirmation per the ": Confirm a decision's substance before building dependent work on it" architecture rule.
+- **the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule** (`docs/decisions/032-governance-skill-invocation-patterns.proposed.md`) — foreground-lightweight-capture variant amendment (the "Ship `/wr-itil:capture-problem` skill — lightweight aside-invocation surface for problem capture during foreground work" problem); 5th invocation pattern amendment (the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem Phase 3, 2026-05-31) codifies the hang-off-check sub-step 2b dispatch as the canonical fresh-context-subagent-as-decision-arbiter shape.
+- **the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem** (`docs/problems/.../346-...md`) — backlog-flow-control master ticket; Phase 3 deliverable lands the hang-off-check dispatch at sub-step 2b above.
+- **the ": backlog flow control multi-phase" release design** (`docs/rfcs/the ": backlog flow control multi-phase" release design-...proposed.md`) — traces the "`/wr-itil:review-problems` has no path to close tickets that are no longer relevant (evidence-based, NOT age-based) — structural outflow gap drives monotonic backlog growth" problem Phases 1+2+3 per the "Every fix goes through an RFC" architecture rule unconditional Problem→RFC trace.
+- **`<itil-plugin-root>/agents/hang-off-check.md`** — the fresh-context subagent invoked by sub-step 2b; reads only the structured input payload; emits HANG_OFF: P<NNN> or PROCEED_NEW with rationale + signals + absorb directive.
+- **the "Progressive disclosure + once-per-session budget for UserPromptSubmit governance prose" architecture rule** — progressive-disclosure pattern (SKILL.md + REFERENCE.md split).
+- **the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule** — decision-delegation contract. Persona derivation (Step 1.5b) is **derive-first**: silent-framework per category 4 when cited JTBDs agree on persona; taste per category 5 fallback only on cited-JTBD-persona disagreement. JTBD-trace itself is purely category 4 (lexical detection or `--jtbd=` flag pre-resolution). The retired Step 1.5 Type classification was a derive-first dispatch too (RETIRED by the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem, 2026-06-02).
+- **the "`/wr-itil:capture-problem` asks a classification question (technical vs user-business) that it can answer itself from the description's observable evidence" problem** — `/wr-itil:capture-problem` historical: asked a classification question (type) it could answer itself; the Step 1.5 derive-first refactor (lexical-signal classifier + stderr advisory) shipped the fix in 2026-05-15. the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem then retired the entire surface in 2026-06-02 as the classification axis itself was redundant with RFC/Story persona-anchoring.
+- **the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule** — bin/ on PATH; capture-problem reuses the existing `<itil-plugin-root>/bin/wr-itil-reconcile-readme` shim.
+- **the "Behavioural-tests-default for skill testing" architecture rule** — behavioural-tests-default for skill testing; SKILL.md I2 surface coverage gap is named, not silent (the "Agent-side I2 (no type-branching) coverage gap — SKILL.md type-branching invariant not behaviourally testable until skill-invocation harness lands" problem + the "Behavioural-tests-default for skill testing" architecture rule § Surface 2).
+- **the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule** (`docs/decisions/060-...accepted.md`) — body currently encodes the type-tag schema (Decision Outcome item 1, I2 type-uniformity, I12 hard-block, Phase-4 persona+jtbd machinery keyed on `type:user-business`) AND the 2026-06-02 amendment's REJECT=discard clause. the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem retires the SKILL implementation of the type clauses unilaterally per twice-confirmed user direction; **the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem (2026-06-29/2026-07-02) reverses the REJECT=discard clause to interview-on-low-confidence + never-discard + ratify-creation-only** (see the Step 1.5b supersession note). Both ADR body amendment substances (the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem type rework; the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem I12 reshape) plus the **the "RFC-first: a problem's fix implements its RFC; no implementation without a pre-existing RFC" architecture rule additive symmetric covered→agent / uncovered→human-ratifies-new-persona/JTBD escalation note** are queued for user re-confirmation per the ": Confirm a decision's substance before building dependent work on it" architecture rule/the "User direction is not substance ratification — agent must brief-and-ratify AFTER changes are complete (sibling-class to on the user-direction code path)" problem. Until they land, the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule/the "RFC-first: a problem's fix implements its RFC; no implementation without a pre-existing RFC" architecture rule bodies and SKILL implementation are intentionally inconsistent — the same governed SKILL-leads-ADR-follows trade-off the user accepted for the "Remove the technical/user-business type classification from problems — redundant with RFC/Story persona-anchoring (amends )" problem.
+- **the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem** (`docs/problems/open/401-capture-persona-jtbd-shoehorns-or-discards-instead-of-interviewing.md`) — the driver: the old propose-candidate-IDs + REJECT=discard flow shoehorned problems into the nearest persona/JTBD and discarded legitimate problems over anchoring uncertainty. This SKILL amendment lands the corrected interview-based shape; the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule/the "RFC-first: a problem's fix implements its RFC; no implementation without a pre-existing RFC" architecture rule body amendments + the `/wr-itil:work-problems` AFK caller-side wiring (route the queued elicitation into `outstanding_questions`) remain tracked on the "Capture/RFC persona-JTBD anchoring shoehorns (or discards the problem) instead of interviewing the human to elicit the real who/why" problem's Investigation Tasks.
+- **the "Report a Problem Without Pre-Classifying It" user outcome** (`docs/jtbd/plugin-user/the "Report a Problem Without Pre-Classifying It" user outcome-...md`) — plugin-user no-pre-classification persona constraint; the Step 1.5b maintainer-side scope guard preserves the firewall on the JTBD-trace + persona axis. The type-axis firewall is moot (axis retired).
+- `<itil-plugin-root>/skills/manage-problem/SKILL.md` — heavyweight intake counterpart.
+- `<itil-plugin-root>/skills/review-problems/SKILL.md` — re-rates the deferred placeholders + refreshes README.md.
+- `<itil-plugin-root>/scripts/test/no-type-regression-guard.bats` — pure-bash regression guard that the `**Type**:` field stays GONE from skeleton templates + ticket bodies. Replaces the historical `i2-no-type-branching.bats` (which asserted no-control-flow-branch-on-type; with the type axis retired, the branch-protection invariant is vacuous, but the field-absence regression guard preserves the audit trail per architect-review verdict 2026-06-02).
+
+$ARGUMENTS

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

@@ -0,0 +1,3 @@
+interface:
+  display_name: "WR ITIL: Capture Problem"
+  short_description: "Record a problem ticket with traceable evidence and risk."