@windyroad/itil 1.2.0 → 2.0.0-preview.1111

package/skills-codex/update-upstream/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "WR ITIL: Update Upstream"
+  short_description: "Post governed lifecycle updates upstream."

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

@@ -0,0 +1,160 @@
+---
+name: wr-itil:work-problem
+description: Pick the highest-WSJF open or known-error problem ticket and work it — investigate, implement, commit, and release per the standard manage-problem workflow. Selection is framework-mediated (WSJF + documented tie-break ladder per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule); singular variant; distinct from /wr-itil:work-problems (plural AFK orchestrator). Use this when the user asks to "work the next problem", "work the top of the queue", or "grind through one ticket".
+allowed-tools: Read, Write, Edit, Bash, Glob, Grep, request_user_input, Skill, Agent
+---
+
+<!-- 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.
+
+
+# Work Problem — Pick-and-Run
+
+Pick the highest-WSJF ticket from the current backlog and work it end-to-end. This is the **singular** entry point — one ticket per invocation. Selection is **framework-mediated** per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule's Framework-Mediated Surface (Prioritisation row): the agent applies the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule tier partition (Critical-bypass → Inbound-reported → Internal) then the WSJF formula + documented within-tier tie-break ladder mechanically, and reports the chosen ticket + its tier + the rung that decided. The user retains direct override via `/wr-itil:work-problem <NNN>` invocation and via mid-flow correction (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 6).
+
+This skill is the "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem phased-landing split of `/wr-itil:manage-problem work` per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended Skill Granularity rule: one skill per distinct user intent. The original `/wr-itil:manage-problem work` subcommand route remains as a thin-router forwarder during the deprecation window but is scheduled for removal in `@windyroad/itil`'s next major version.
+
+## Name distinction (work-problem vs work-problems)
+
+- **`/wr-itil:work-problem`** (singular, this skill) — one ticket per invocation. Framework-mediated selection (WSJF + tie-break ladder). Intended for a user who wants to dispatch the next-highest ticket and then stop. User-override path: `/wr-itil:work-problem <NNN>` to pin a specific ticket.
+- **`/wr-itil:work-problems`** (plural, AFK orchestrator) — loops through the backlog by WSJF, delegating each iteration to this skill (via the native Codex subagent tool, per the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule + the "Problem 077: work-problems Step 5 does not delegate iterations to a subagent, so context pressure accumulates in the orchestrator's main turn" problem). Intended for AFK batch runs; non-interactive selection; stops only when nothing actionable remains.
+
+Both names coexist intentionally per the "Problem 071: Argument-based skill subcommands are not discoverable in Codex autocomplete" problem's out-of-scope note on the naming coexistence. The plural orchestrator uses this skill as its per-iteration unit.
+
+## Scope
+
+**In scope:**
+- Read `docs/problems/README.md` when fresh; otherwise delegate the refresh to `/wr-itil:review-problems` first (never re-implement the re-scoring logic locally — same anti-fork discipline as the list-problems cache path).
+- Pick the highest-priority ticket via the framework-mediated selection: first by the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule **tier** (Tier 0 Critical-bypass [Severity Very High ≥17 OR security-classified OR incident-linked] → Tier 1 Inbound-reported [`**Origin**: inbound-reported`] → Tier 2 Internal), then within the highest non-empty tier by the tie-break ladder (Known Error > Open; smaller effort first; older reported date; ticket number ascending) per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule Framework-Mediated Surface. Report the chosen ticket + its tier + the rung that decided. No `request_user_input` fires for selection.
+- Honour the user-override path `/wr-itil:work-problem <NNN>` — when the user names a ticket directly, skip the ladder and proceed to Step 3 with the named ticket.
+- Delegate the actual work to `/wr-itil:manage-problem <NNN>` via the installed skill invocation so the investigation / known-error transition / fix / closure flow stays hosted on a single authoritative workflow (the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule thin-router discipline applied to the work path).
+- Scope-expansion prompt (the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 1; the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category-2 deviation-approval surface) when the selected ticket's effort grows during work — same three-option structure as `/wr-itil:manage-problem`'s Working a Problem section.
+
+**Out of scope:**
+- Batch looping over multiple tickets — that's `/wr-itil:work-problems` (plural). This skill runs exactly one ticket per invocation.
+- Backlog re-ranking / Verification Queue prompt / README.md refresh — that's `/wr-itil:review-problems`. This skill reads the ranking; it does not rewrite it.
+- Ticket creation — that's `/wr-itil:manage-problem` (no-args form).
+- Status transitions other than those driven by the delegated `/wr-itil:manage-problem <NNN>` flow.
+
+## Steps
+
+### 1. Ensure the ranking is fresh
+
+Check the `docs/problems/README.md` cache with the same git-history-based freshness test as `/wr-itil:list-problems` and `/wr-itil:review-problems` (per the "Problem 031: `manage-problem work` incorrectly determines cache is fresh" problem — filesystem mtime is unreliable in worktrees and fresh checkouts, so git history is the authoritative staleness signal):
+
+```bash
+readme_commit=$(git log -1 --format=%H -- docs/problems/README.md 2>/dev/null)
+if [ -z "$readme_commit" ] || \
+   git log --oneline "${readme_commit}..HEAD" -- 'docs/problems/*.md' 'docs/problems/*/*.md' ':!docs/problems/README.md' 2>/dev/null | grep -q .; then
+  # Pathspec pair `'docs/problems/*.md' 'docs/problems/*/*.md'` is the
+  # the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design dual-tolerant transitional shape — covers BOTH the flat
+  # layout (`docs/problems/<NNN>-<title>.<state>.md`) AND the per-state
+  # subdir layout (`docs/problems/<state>/<NNN>-<title>.md`). T6 drops
+  # the flat half post-T5 verification.
+  echo "stale"
+fi
+```
+
+- **Cache fresh** (no output): read `docs/problems/README.md` and use the cached WSJF Rankings table for Step 2.
+- **Cache stale** (prints "stale") or `README.md` missing: **delegate to `/wr-itil:review-problems`** via the installed skill invocation to refresh the ranking before proceeding. Do NOT re-implement the re-scoring logic here — that would fork the review path and break the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem's canonical-cache-writer contract. The review skill's Step 4 verification prompt runs on this refresh path (the "Problem 048: manage-problem does not surface Fix Released problems as verification candidates when the fix path has been exercised" problem Candidate 1: Verification Queue prompts always fire so pending verifications don't accumulate off-ledger).
+
+### 2. Select the ticket (framework-mediated)
+
+Read the WSJF Rankings table from the now-fresh `docs/problems/README.md`. Apply the framework's tie-break ladder mechanically to pick the next ticket — selection is **framework-mediated** per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule's Framework-Mediated Surface (Prioritisation row). The agent picks, reports the choice + the tie-break rung that decided, and proceeds. **No `request_user_input` fires for selection** — the WSJF formula + tie-break ladder already resolve the decision.
+
+**User-override path** — when the user invokes `/wr-itil:work-problem <NNN>` (ticket ID supplied as an argument, e.g. `/wr-itil:work-problem 042`), skip the ladder entirely and proceed to Step 3 with the named ticket. This is the documented escape hatch for the user to bypass the framework-mediated selection. Mid-flow correction (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category 6 / the "Problem 078: Assistant does not offer to capture a problem ticket when the user delivers strong-signal correction" problem surface) is the long-tail catcher when the agent's pick was wrong in a way the framework couldn't anticipate.
+
+**Tie-break ladder** (applied in order; same logic the plural orchestrator's Step 3 uses, per the "Problem 077: work-problems Step 5 does not delegate iterations to a subagent, so context pressure accumulates in the orchestrator's main turn" problem + the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule):
+
+1. **WSJF score** (descending) — highest WSJF wins.
+2. **Status** — Known Error before Open. Verification Pending tickets are not in this queue (handled by `/wr-itil:review-problems` Step 4 verification prompt).
+3. **Effort** — smaller effort first (S < M < L < XL).
+4. **Reported date** — older reported date wins (FIFO discipline for tied tickets at this rung).
+5. **Ticket number** — ascending (final deterministic break).
+
+When a single ticket is the strict top, rungs 2-5 are not consulted. When multiple tickets are tied at the top, walk down the ladder until a rung decides.
+
+**Report shape (the "Restore Service Fast with an Audit Trail" user outcome audit-trail)** — after picking, the agent reports the chosen ticket + the rung that decided, with citations to the WSJF inputs. Example: *"Selected the "Problem 042: Changesets does not sync plugin manifest version" problem: <title> (WSJF 12.0; tied with the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem at WSJF; tie-break rung: 'Known Error > Open' — the "Problem 042: Changesets does not sync plugin manifest version" problem is Known Error, the "Problem 057: `git mv` + Edit + `git add` staging-ordering trap drops content edits from the commit" problem is Open)"*. This citation makes the selection reproducible from the README state at the time of the report and is the audit surface the "Restore Service Fast with an Audit Trail" user outcome requires.
+
+**No prose-ask fallback** — never present the selection as prose "(a)/(b)/(c)" or "which would you like?" (regression guard for the "Structured User Interaction for Governance-Skill Decisions" architecture rule Confirmation grep). Selection is mechanical; the agent picks and reports.
+
+**No AFK / interactive split** — selection is mechanical in both interactive and AFK modes. The prior asymmetry between AFK (mechanical) and interactive (`request_user_input`-driven) was the lazy-deferral surface the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule was written to close; converging both modes to the same algorithm is the alignment. The plural orchestrator (`/wr-itil:work-problems`) Step 3 also uses this ladder, so all entry surfaces resolve to one selection algorithm (no AFK-vs-interactive divergence to maintain).
+
+### 3. Delegate the work to `/wr-itil:manage-problem <NNN>`
+
+Invoke `/wr-itil:manage-problem <NNN>` via the installed skill invocation with the selected ticket's ID as the argument. The delegated skill runs the full Working a Problem flow appropriate to the ticket's status:
+
+- **Open ticket**: investigate root cause; document findings; create reproduction test; identify workaround; auto-transition to Known Error when root cause + workaround are documented; if the fix is small, proceed straight into implementation.
+- **Known Error**: traverse problem `## Fix Strategy` → referenced RFCs → each RFC's frontmatter `stories:` array (ordered per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule line 259) → pick first not-done story (status `accepted` or `in-progress`, skipping `done`). **Per the "A story cannot be implemented while in draft — implementation requires accepted" architecture rule a `draft` story is NOT silently skipped**: if the first not-done story is `draft`, refuse-and-route — surface `accept STORY-<NNN> via /wr-itil:manage-story <NNN> accepted first (it runs the INVEST + RFC-trace gates + ratification)` and (under AFK) queue it to `outstanding_questions` rather than skipping past it or implementing it (the itil-no-implement-draft-gate blocks the implementing commit regardless) → implement the picked story scope. An empty `stories: []` is a legacy/back-fill state (per **the "Every RFC has at least one story" architecture rule** every RFC has ≥1 story — the empty-stories atomic fallback is removed): back-fill a story onto the RFC, don't fall back to a per-RFC atomic dispatch. No-RFC Fix Strategy (Phase 1-shape legacy problems) falls back to direct fix implementation. Each commit carries `Refs: STORY-<NNN>` (or `Refs: RFC-<NNN>` for cross-cutting RFC work with no single story / `Refs: P<NNN>` for legacy direct path). Stories auto-transition `accepted → in-progress` on the first implementing commit (draft → in-progress REMOVED per the "A story cannot be implemented while in draft — implementation requires accepted" architecture rule — a draft story is blocked from implementation); auto-transition `in-progress → done` on all-criteria-ticked + linked RFC closed. When all stories under all referenced RFCs are done, include the Known Error → Verification Pending `git mv` in the final commit per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule. The full traversal contract lives in `/wr-itil:manage-problem` § Working a Problem → Known Error subsection (post-Phase-2 rewrite per the "Problem-RFC-Story framework with mandatory problem-trace and unified problem ontology" architecture rule lines 300-320).
+
+**Why delegate rather than re-implement:** the full investigation / transition / fix / release pipeline is a long-lived, policy-governed flow that must stay on a single authoritative workflow. Re-hosting it on a sibling skill would fork the ownership contract and compound maintenance cost. The split skill (this file) owns the *selection* of the next ticket; `/wr-itil:manage-problem <NNN>` owns the *execution*.
+
+### 4. Scope-expansion check (the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 1; the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category-2 deviation-approval)
+
+If the delegated `/wr-itil:manage-problem <NNN>` reports that the ticket's effort expanded during investigation or architect review (e.g. S → L, or L → XL), fire the standard scope-change `request_user_input` prompt. **Effort growth IS the contradicting evidence** against the WSJF score that ranked this ticket at the top — this is the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule **category-2 (deviation-approval)** surface. The 3-option vocabulary below is the work-item-tactical analog of the framework-tactical 5-option vocabulary (Approve+amend / Approve+supersede / Approve+one-time / Reject / Defer); the user is the right authority for the shape, so the `request_user_input` is genuine, not lazy.
+
+- Option 1: `Continue with expanded scope` — keep working this ticket at its new size.
+- Option 2: `Update problem and re-rank` — save findings to the problem file, re-score WSJF, and re-run the framework-mediated selection to surface the new top of queue.
+- Option 3: `Pick a different problem` — park this one and work something else.
+
+Use `header: "Scope change"` and `multiSelect: false`. This is the same structure `/wr-itil:manage-problem`'s Working a Problem section documents; the split lifts it without modification.
+
+**AFK / non-interactive branch (the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6)**: same fallback as `/wr-itil:work-problems` — save findings + the new Effort/WSJF lines to the ticket file and skip to the next iteration. The orchestrator owns the re-selection loop.
+
+### 5. Post-work housekeeping
+
+After the delegated `/wr-itil:manage-problem <NNN>` completes:
+
+1. If the ticket status changed (Open → Known Error, Known Error → Verification Pending), the delegated skill already committed the change per the "Governance Skills Commit Their Own Completed Work" architecture rule + the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule and updated `docs/problems/README.md` per the "Problem 062: `manage-problem` does not refresh `docs/problems/README.md` on single-ticket transitions; fast-path cache goes stale silently" problem. This skill does NOT re-commit or re-refresh; it reports what happened.
+2. Report the outcome: ticket ID, action taken (investigated / transitioned / fix-released), commit SHA(s), and next-recommended action (typically "run `/wr-itil:work-problem` again for the next ticket" or "stop — all actionable tickets worked").
+3. **Do NOT loop automatically.** This is the singular skill. If the user wants to continue, they invoke `/wr-itil:work-problem` again, or switch to `/wr-itil:work-problems` (plural) for the AFK orchestrator loop.
+
+## Ownership boundary
+
+`work-problem` (singular) owns:
+- Reading the WSJF Rankings from `docs/problems/README.md`.
+- Applying the framework-mediated tie-break ladder for selection (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule Prioritisation row).
+- Reporting the chosen ticket + the tie-break rung that decided (the "Restore Service Fast with an Audit Trail" user outcome audit-trail).
+- Honouring the user-override path `/wr-itil:work-problem <NNN>` (skip the ladder; proceed with the named ticket).
+- Delegating one execution iteration to `/wr-itil:manage-problem <NNN>`.
+- Firing the scope-expansion `request_user_input` on effort drift (the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule category-2 deviation-approval surface).
+
+`work-problem` does NOT:
+- Fire `request_user_input` for the ticket selection itself — selection is framework-mediated per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule.
+- Refresh the README.md cache directly — defers to `/wr-itil:review-problems`.
+- Loop over multiple tickets — that's `/wr-itil:work-problems` (plural).
+- Commit the ranking refresh or the per-ticket work — delegated skills commit per the "Governance Skills Commit Their Own Completed Work" architecture rule.
+
+## Goal anchor for headless runs (the "agent ends the work-problems loop (emits ALL_DONE) prematurely while actionable Tier-2 backlog remains, by rationalising the remainder as out-of-scope / interactive-gated" problem / the "AFK loops anchor completion with the native `/goal` external evaluator" architecture rule)
+
+A headless single-ticket run can anchor its completion with Codex's native `/goal` external evaluator (≥ v2.1.139), so a fresh model — not the working agent — judges whether the ticket genuinely reached an end state: `native Codex subagent "/goal Run /wr-itil:work-problem to work the top ticket. Complete when the report printed in the conversation shows a committed outcome (with commit SHA) or a recorded blocker for the selected ticket."` (No turn-bound: trust the goal — the loop stops only at its real end states: a committed outcome, a recorded blocker, or quota exhaustion.) There is no programmatic mid-session surface for setting a goal (probed 2026-07-06, v2.1.201) — interactive users type `/goal` themselves; the skill proceeds identically either way. The plural orchestrator's anchor contract (canonical condition, printed-evidence rule, one-directional semantics) lives at `/wr-itil:work-problems` Step 0e.
+
+## 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 3 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).
+- **the "alignment audit — sweep all unaudited skills/hooks/agents/ADRs/JTBDs/READMEs against the framework-resolution boundary (master ticket)" problem** (`docs/problems/136-adr-044-alignment-audit-master.open.md`) — the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule alignment audit master; this skill is the Phase 2 first audit target (work-problem singular).
+- **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 amended** (`docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md`) — Rule 1 amended in the "Decision-delegation contract — agents over-apply Rule 1's interactive default to framework-resolved decisions; codify the framework-resolution boundary + AFK loop's batched-questions-as-deliverable + lazy-request_user_input measurement" problem to defer to the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule for framework-resolution boundary. Step 4 scope-expansion is the only Rule-1 surface this skill retains; Rule 6 covers Step 4's AFK fallback.
+- **the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule** (`docs/decisions/044-decision-delegation-contract.proposed.md`) — Decision-Delegation Contract; this skill's Step 2 selection is framework-mediated per the ADR's Prioritisation row. Step 4 scope-expansion is a category-2 (deviation-approval) surface per the ADR's 6-class taxonomy.
+- **the "Governance Skills Commit Their Own Completed Work" architecture rule** — governance skills commit their own work. The delegated `/wr-itil:manage-problem <NNN>` owns the per-ticket commit; this skill does not re-commit.
+- **the "Inter-iteration release cadence for AFK loops" architecture rule** — release cadence. AFK orchestrator owns release cadence; this skill does NOT auto-release.
+- **the "Governance skill invocation patterns — foreground + background with deferred-question resumption" architecture rule** — governance skill invocation patterns. `/wr-itil:work-problems` delegates iterations via the native Codex subagent tool; this singular skill is the canonical execution unit.
+- **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 031: `manage-problem work` incorrectly determines cache is fresh" problem** — git-history freshness check rationale (mtime unreliable in worktrees). Applies to the README cache this skill reads.
+- **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. This skill defers to it for refreshes.
+- **the "Problem 077: work-problems Step 5 does not delegate iterations to a subagent, so context pressure accumulates in the orchestrator's main turn" problem** — `/wr-itil:work-problems` Step 5 delegates iterations via the native Codex subagent tool. The delegated subagent invokes this skill's execution unit per iteration.
+- **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:work-problem` rather than remembering the `manage-problem work` 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 thin-router forwarder for the deprecated `manage-problem work` form; also the delegated execution target for each ticket.
+- `<itil-plugin-root>/skills/review-problems/SKILL.md` — sibling refresh skill; this skill defers to it when the cache is stale.
+- `<itil-plugin-root>/skills/list-problems/SKILL.md` — sibling read-only display skill; same cache read contract.
+- `<itil-plugin-root>/skills/work-problems/SKILL.md` — plural AFK orchestrator; uses this skill as its per-iteration execution unit.
+
+$ARGUMENTS

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

@@ -0,0 +1,3 @@
+interface:
+  display_name: "WR ITIL: Work Problem"
+  short_description: "Work the highest-priority actionable problem."

package/skills-codex/work-problems/SKILL.md

@@ -0,0 +1,58 @@
+---
+name: wr-itil:work-problems
+description: Drain the ITIL problem backlog in WSJF order using native Codex subagents, governed commits, pushes, and releases.
+---
+
+<!-- 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.
+
+
+# Work Problems in Codex
+
+Continuously work the highest-priority actionable problem until the backlog is drained, the user stops, or a real governance dependency requires human direction. Use Codex's native subagent tools. Never invoke `codex exec`, start a nested Codex CLI, or implement process/PID polling.
+
+## Preflight
+
+1. If `docs/problems/` is absent, direct the user to `/wr-itil:scaffold-intake` and stop.
+2. Run the installed ITIL maintenance commands required by the repository, including layout migration, README reconciliation, catch-up scanning, stale upstream-cache checks, and unresolved-response checks. Resolve them from the plugin's bundled `bin/`; do not use source-repository paths.
+3. Preserve unrelated working-tree changes. Revert only changes created by a failed preflight.
+4. If the task has a persistent Codex goal, keep it active until this drain reaches a genuine terminal state. A slow tool or subagent is not a blocker.
+
+## Loop
+
+1. Read the problem index and current ticket files. Select the highest WSJF problem in the highest non-empty actionable tier. Use the documented tie-break rules.
+2. Skip tickets whose required JTBD, decision, risk, or story-map oversight is unconfirmed. Record one structured outstanding question for each genuinely user-answerable dependency; do not ask mid-loop.
+3. Run the relevance and stop-condition checks. Before declaring `ALL_DONE`, run the repository's unconditional pre-completion gates and rescan the backlog.
+4. Spawn one native Codex subagent for the selected ticket. Give it the exact checkout, ticket, applicable decisions, and this contract:
+   - invoke `/wr-itil:manage-problem` for the ticket and follow its lifecycle rules;
+   - make only in-scope changes and preserve unrelated work;
+   - run focused tests and the required architecture/risk checks;
+   - create the required changeset for shippable plugin behavior;
+   - commit the completed iteration, but do not push or release;
+   - return one `ITERATION_SUMMARY` JSON object containing ticket, action, commits, tests, risks, outstanding questions, and remaining work.
+5. Wait for that same subagent. Do not cancel, replace, retry, or fan out merely because Cruise or normal model execution makes the call slow. When it completes, consume its summary and close it.
+6. Validate the summary with `<itil-plugin-root>/bin/wr-itil-verify-iter-summary`. If the subagent failed after changing the checkout, inspect and safely complete or revert only its own partial work before continuing.
+7. Run inter-iteration verification. If the iteration produced committed shippable work, complete the repository's governed push and release cadence when risk is within appetite. Above-appetite risk is a remediation instruction: reduce scope or split the change; never ask the user to approve risk above appetite.
+8. Report only material progress, then rescan and repeat.
+
+## Fix Proposal Rule
+
+A fix proposal is a release row on an existing story map, never a new file under `docs/rfcs/`. The row has an identity from `<itil-plugin-root>/bin/wr-itil-next-rfc-id`, at least one story card, and a story whose `problems:` list names the driving problem. Creating a new map, activity column, job, or uncovered architectural choice requires a queued human decision rather than a silent edit.
+
+## Questions and Stop Conditions
+
+- Batch outstanding questions at loop end with `request_user_input`, no more than four per call. Brief substance before IDs.
+- Continue past skipped tickets when another actionable ticket exists.
+- Stop only for an explicit user stop, a fully drained backlog, a governance dependency that blocks every remaining ticket, or an unrecoverable tool/repository failure.
+- Never describe a delayed native tool or subagent as unavailable, hung, or blocked without an actual error or terminal failure.
+
+## Final Report
+
+Report completed and skipped tickets, commits, tests, push/release outcomes, remaining backlog, and outstanding design questions. Preserve the distinction between committed, pushed, released, and production-verified states.

package/skills-codex/work-problems/agents/openai.yaml

@@ -0,0 +1,3 @@
+interface:
+  display_name: "WR ITIL: Work Problems"
+  short_description: "Drain actionable problems with governed Codex subagents."

package/templates/story-map.css

@@ -48,7 +48,7 @@ body { font-family: system-ui, sans-serif; color: var(--fg); background: var(--b
 h1 { font-size: 1.5rem; margin: 0 0 .5rem; }
 p { max-width: 74ch; }
 /* The underline is the channel; the colour is not. Reference links render
-   INSIDE runs of prose ("closes P160, P424", "Traces: STORY-018"), and those
+   INSIDE runs of prose ("closes the "Ship quota-pacing surface to prevent weekly-quota exhaustion — advisory or blocking nudge when burn rate exceeds sustainable pace, so users retain Claude tokens for non-Claude-Code surfaces (chat, cowork) for the full week" problem, the "Governance tooling emits U+2014 em-dashes in generated output, breaking adopter no-em-dash Edit/Write hooks" problem", "Traces: the ": Capture the problem in seconds, mid-flow" delivery story"), and those
    runs sit in --muted containers (.t-ref, .s-problems, .traces) — so the real
    comparison is --focus against --muted: 1.58:1 light and 1.09:1 dark, against
    the 3:1 that technique G183 wants before colour alone may carry a link. In

package/bin/wr-itil-mark-rfc-capture-gate

@@ -1,51 +0,0 @@
-#!/usr/bin/env bash
-# Generated by scripts/sync-shim-wrappers.sh from
-# packages/shared/lib/shim-wrapper-template.sh. DO NOT EDIT individual
-# shim files in packages/*/bin/wr-* directly; edit the template + run
-# `npm run sync:shim-wrappers` to regenerate.
-#
-# Resolution (ADR-080):
-#   1. If the wrapper's parent dir is semver-shaped, treat as installed-
-#      cache execution and resolve to the highest-version sibling's
-#      scripts/ entry below.
-#   2. Otherwise (parent dir is e.g. `architect`), treat as source-
-#      monorepo execution and dispatch to own scripts/. The source-repo-
-#      guard `exec` is the anchor parsed by
-#      packages/retrospective/scripts/check-tarball-shipped-shims.sh.
-#   3. If the cache parent contains zero semver-shaped siblings, exit
-#      127 with a stderr message naming the cache parent (per SQ-080-2).
-#
-# @adr ADR-080 (highest-version-wins shim wrapper plugin scaffold)
-# @adr ADR-049 (plugin-bundled scripts resolve via bin/ on $PATH — amended)
-# @problem P343 (mid-session staleness window)
-
-set -euo pipefail
-
-SHIM_DIR="$(cd "$(dirname "$0")" && pwd)"
-OWN_VERSION_DIR="$(dirname "$SHIM_DIR")"
-OWN_VERSION_NAME="$(basename "$OWN_VERSION_DIR")"
-CACHE_PARENT="$(dirname "$OWN_VERSION_DIR")"
-
-SEMVER_RE='^[0-9]+\.[0-9]+\.[0-9]+([-+][0-9A-Za-z.-]+)?$'
-
-# Source-repo guard: own parent dir is NOT semver → dispatch to own scripts/.
-if ! [[ "$OWN_VERSION_NAME" =~ $SEMVER_RE ]]; then
-  exec "$SHIM_DIR/../scripts/mark-rfc-capture-gate.sh" "$@"
-fi
-
-# Cache execution: pick the highest-semver sibling under CACHE_PARENT.
-HIGHEST=""
-while IFS= read -r dir; do
-  name="$(basename "$dir")"
-  [[ "$name" =~ $SEMVER_RE ]] || continue
-  if [[ -z "$HIGHEST" ]] || [[ "$(printf '%s\n%s\n' "$HIGHEST" "$name" | sort -V | tail -1)" == "$name" ]]; then
-    HIGHEST="$name"
-  fi
-done < <(find "$CACHE_PARENT" -mindepth 1 -maxdepth 1 -type d 2>/dev/null)
-
-if [[ -z "$HIGHEST" ]]; then
-  printf 'wr-shim: no cached versions in %s\n' "$CACHE_PARENT" >&2
-  exit 127
-fi
-
-exec "$CACHE_PARENT/$HIGHEST/scripts/mark-rfc-capture-gate.sh" "$@"

package/scripts/mark-rfc-capture-gate.sh

@@ -1,32 +0,0 @@
-#!/usr/bin/env bash
-# wr-itil — write the RFC-tier create-gate marker (P119) under every candidate
-# session SID (P260 / ADR-050 Option C). Adopter-safe sibling of
-# wr-itil-mark-create-gate (P317 / RFC-009): resolves its libs relative to the
-# script location, not cwd. SKILLs (capture-rfc / manage-rfc) invoke it by name
-# via the `wr-itil-mark-rfc-capture-gate` PATH shim (ADR-049) before writing a
-# docs/rfcs/RFC-*.proposed.md file.
-#
-# The RFC tier has no `_candidates` helper in create-gate.sh (only the single
-# `mark_rfc_capture_complete`), so this script loops the candidate set itself —
-# the RFC-tier analogue of `mark_step2_complete_candidates`.
-set -uo pipefail
-
-LIB="$(cd "$(dirname "${BASH_SOURCE[0]}")/../hooks/lib" 2>/dev/null && pwd)" || {
-  echo "wr-itil-mark-rfc-capture-gate: cannot locate hooks/lib next to the script" >&2
-  exit 2
-}
-
-# shellcheck source=/dev/null
-source "$LIB/session-id.sh"
-# shellcheck source=/dev/null
-source "$LIB/create-gate.sh"
-
-count=0
-while IFS= read -r sid; do
-  [ -n "$sid" ] || continue
-  mark_rfc_capture_complete "$sid"
-  count=$((count + 1))
-done < <(get_candidate_session_ids)
-
-# Fail-closed parity with mark_step2_complete_candidates: non-zero if no SID.
-[ "$count" -gt 0 ]