@windyroad/itil 1.2.0 → 2.0.0-preview.1111

package/skills-codex/update-upstream/SKILL.md

@@ -0,0 +1,583 @@
+---
+name: wr-itil:update-upstream
+description: Post a lifecycle-update comment to an upstream issue when a local problem ticket transitions. Drafts a transition-specific update (root-cause confirmed / fix released / closed), composes the prose through the external-comms risk gate + voice-tone gate, auto-posts within appetite, queues above-appetite. Reciprocal sibling to /wr-itil:report-upstream — initial-filing vs lifecycle-update split per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem).
+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.
+
+
+<!--
+  @jtbd the "Report a Problem Without Pre-Classifying It" user outcome (Report a Problem Without Pre-Classifying It — reporter feedback loop)
+  @jtbd the ": Enforce Governance Without Slowing Down" user outcome (Enforce Governance Without Slowing Down — no manual policing of upstream issues)
+  @jtbd the "Restore Service Fast with an Audit Trail" user outcome (Restore Service Fast with an Audit Trail — symmetric local/upstream audit trail)
+  @jtbd the "Extend the Suite with New Plugins" user outcome (Extend the Suite with Clear Patterns — downstream adopters inherit bidirectional contract)
+  @problem the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem
+  @adr the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule (amended the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem — bidirectional lifecycle updates; Phase 2 — --catchup migration mode + idempotency)
+  @adr the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule (catchup worklist scanner invoked via <itil-plugin-root>/bin/wr-itil-catchup-scan bin shim)
+  @adr the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule (voice-tone gate on `gh issue comment` / `gh issue close`)
+  @adr the "Structured User Interaction for Governance-Skill Decisions" architecture rule (Rule 1 request_user_input; Rule 6 AFK fail-safe)
+  @adr the "Governance Skills Commit Their Own Completed Work" architecture rule (single-commit grain — transition + back-write + upstream comment)
+  @adr the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended (sibling-skill naming; split execution ownership)
+  @adr the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule (decision-delegation contract — framework-resolution boundary)
+  @adr the ": promptfoo as the behavioural test harness for agent-prose verdicts" architecture rule (Amendment 2026-06-02 — paired promptfoo eval discharges the ": Functional defects in shipped plugin behaviour" standing risk prose floor)
+  @adr the ": promptfoo as the behavioural test harness for agent-prose verdicts" architecture rule (evidence-floor — paired Tier-A/B eval ships in same commit as SKILL)
+-->
+
+# Update Upstream — Lifecycle-Update Skill
+
+Post a lifecycle-update comment to an upstream issue or pull request when the local problem ticket transitions. Reads the local ticket's `## Reported Upstream` section, drafts a transition-specific update from the templates below, composes the draft through the external-comms risk gate (`wr-risk-scorer:external-comms`) and voice-tone gate (`wr-voice-tone:external-comms`), auto-posts via `gh issue comment` or `gh pr comment` when both gates pass within appetite, closes only issue targets on Verifying → Closed, and queues an `outstanding_questions` entry when either gate scores above appetite.
+
+This skill is the **reciprocal sibling** to [`/wr-itil:report-upstream`](../report-upstream/SKILL.md) — that skill files the initial upstream report; this skill keeps the upstream record in sync as the local ticket walks its lifecycle. The split is per [the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule](../../../docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md) amended Skill Granularity rule (one skill per distinct user intent) — initial-filing and lifecycle-update are distinct user intents with distinct autocomplete surfaces.
+
+This skill implements the bidirectional extension to the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule's outbound contract — see the **the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem)** entry in the ADR's `## Amendments` section. The amendment authorises this sibling skill, defines the transition-template shape, and pins the same external-comms + voice-tone gate composition that the post-the "Agent waits for human to initiate upstream report instead of filing on detect — feedback delay class" problem amendment uses for the initial-filing path.
+
+## Invocation
+
+```
+/wr-itil:update-upstream <NNN>          # single-ticket lifecycle update
+/wr-itil:update-upstream --catchup      # batch-retroactive migration (Phase 2)
+```
+
+- `<NNN>`: the three-digit local ticket ID (e.g. `080`). The ticket file is discovered via the same dual-tolerant lookup as [`/wr-itil:report-upstream`](../report-upstream/SKILL.md) (flat layout + per-state subdir per the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design migration window).
+- `--catchup`: one-shot batch-retroactive migration mode (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2 — see [§ Catchup migration mode](#catchup-migration-mode-phase-2)). Walks the existing `.verifying.md` + `.closed.md` corpus and posts the lifecycle update each ticket should have received but did not (because it was reported upstream / transitioned before the per-ticket auto-update path shipped). Idempotent — already-updated tickets are skipped.
+
+The single-ticket form is typically invoked from `/wr-itil:transition-problem` Step 7's advisory subsection when the transitioning ticket carries a `## Reported Upstream` section (per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule Confirmation criterion 3a — the back-write that `/wr-itil:report-upstream` Step 7 writes). User-initiated single-ticket invocation is also supported. The `--catchup` form is user-initiated only (a deliberate one-shot migration, never auto-fired from a transition).
+
+## Scope
+
+**In scope:**
+- Read the local ticket's `## Reported Upstream` section and extract each upstream URL + matched template + disclosure path recorded there (**outbound** direction).
+- Read the local ticket's `**Origin**: inbound-reported (#NN)` field and dispatch a reporter-facing fix-released / closed verdict comment on the originating own-repo issue (**inbound** direction, the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem). See [§ Inbound-origin verdict dispatch (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem)](#inbound-origin-verdict-dispatch-p363).
+- Determine the local ticket's current Status from the filename suffix.
+- Draft a transition-specific lifecycle-update comment per the templates below (Open→KE / KE→Verifying / Verifying→Closed).
+- Compose the drafted prose through `wr-risk-scorer:external-comms` + `wr-voice-tone:external-comms` gates.
+- Within appetite → post via `gh issue comment <n>`, or `gh pr comment <n>` when the disclosure path records a pull request (the "Prefer an upstream pull request over an issue when the upstream accepts pull requests" architecture rule); on Verifying→Closed also run `gh issue close <n>` — **but never `gh pr close`** (see below).
+- Above appetite → request_user_input (interactive) / queue `outstanding_questions` (AFK, per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem queue-and-continue).
+- Back-write a `## Upstream Lifecycle Updates` log entry to the local ticket recording the transition, the matched URL, the posted comment URL, and the disclosure path.
+- **Historical catch-up migration (`--catchup`, the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2)** — one-shot retroactive scan of the existing `.verifying.md` + `.closed.md` corpus; posts the lifecycle update each linked-upstream ticket should already carry. Idempotent — re-running is safe. See [§ Catchup migration mode](#catchup-migration-mode-phase-2).
+
+**Out of scope:**
+- Initial upstream filing — that's `/wr-itil:report-upstream`.
+- Cross-tracker propagation (linking the upstream update back into a different upstream's parallel issue) — out of scope; one local ticket → N upstream URLs is supported, but each URL update is independent.
+
+## Step-0 deferral (the "Governance skill auto-delegation — Step 0 delegates skill workflow to a subagent" architecture rule)
+
+This skill does NOT implement the "Governance skill auto-delegation — Step 0 delegates skill workflow to a subagent" architecture rule's Step-0 auto-delegation pattern. Same rationale as [`/wr-itil:report-upstream`](../report-upstream/SKILL.md) Step-0 deferral: the local ticket and the `## Reported Upstream` extraction must stay in main-agent context for the gate composition and the back-write, so wrapping the flow in a subagent would not reduce main-agent context cost. Trigger to revisit per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule's Reassessment Criteria — if a third skill that reads `## Reported Upstream` lands, factor the read into a Step-0-delegated subagent.
+
+## Voice-tone gate interaction (the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule)
+
+The skill's `gh issue comment` and `gh issue close` calls are **on the gated surface list per [the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule](../../../docs/decisions/028-voice-tone-gate-external-comms.proposed.md)** (Voice-tone gate on external communications). Expected behaviour during these tool calls:
+
+1. The voice-tone gate fires `PreToolUse:Bash` with a deny-plus-delegate response.
+2. The hook delegates to `wr-voice-tone:agent` to review the drafted body for brand-voice + tone alignment against `docs/VOICE-AND-TONE.md`.
+3. Once the agent's marker lands, the same `gh issue comment` or `gh issue close` call retries and proceeds.
+
+The skill should treat this transient deny-plus-delegate as the expected path, not as an error.
+
+If `wr-voice-tone:agent` is not installed in the project, the gate is dormant and the skill proceeds without delegation.
+
+## Steps
+
+### 1. Read the local problem ticket
+
+Dual-tolerant lookup spans flat layout AND per-state subdir layout (the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design migration window):
+
+```bash
+LOCAL_TICKET=$(ls docs/problems/${LOCAL_ID}-*.{open,known-error,verifying,closed,parked}.md docs/problems/*/${LOCAL_ID}-*.md 2>/dev/null | head -1)
+[ -n "$LOCAL_TICKET" ] || { echo "Error: local ticket P${LOCAL_ID} not found in docs/problems/"; exit 1; }
+```
+
+Extract:
+- Title (from H1).
+- Current Status (from filename suffix — `.open.md` / `.known-error.md` / `.verifying.md` / `.closed.md` / `.parked.md`).
+- The `## Reported Upstream` section (zero or more **outbound** upstream entries, each with URL + disclosure path) — the **outbound** direction (a ticket *we* reported up to someone else).
+- The `**Origin**: inbound-reported (#NN)` field (the [the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule](../../../docs/decisions/076-inbound-reported-problems-rank-ahead-via-sort-tier.proposed.md) rank-authoritative on-ticket field) — the **inbound** direction (a ticket someone else reported *against us* on our own repo, `#NN` being the originating issue). Drives the inbound dispatch leg below (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem).
+- For `.verifying.md` tickets: the `## Fix Released` section (release marker, version, commit SHA, PR number).
+- For `.known-error.md` tickets: the `## Fix Strategy` section (planned fix path; cited in KE updates so the reporter knows the direction).
+
+**No-op exit (dual-direction).** If the ticket has NEITHER a `## Reported Upstream` section NOR an `**Origin**: inbound-reported (#NN)` field, exit cleanly with a one-line message: `No ## Reported Upstream section and no inbound Origin in P${LOCAL_ID}; nothing to update.` This is the **no-op exit** — most local tickets are neither reported upstream nor inbound-originated, and the skill's invocation from `transition-problem` Step 7 is unconditional; a missing surface is the common case, not an error. When EITHER surface is present, proceed: the outbound entries route through Steps 2–6; the inbound Origin field routes through the [§ Inbound-origin verdict dispatch (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem)](#inbound-origin-verdict-dispatch-p363) leg below. When BOTH are present, the two legs fire **independently** (each gate-composed, posted, and logged separately).
+
+### 2. Parse each upstream entry
+
+For each `- **URL**: <url>` line under `## Reported Upstream`, extract:
+- The upstream URL.
+- The matched template name (`- **Template used**: <name>`).
+- The disclosure path (`- **Disclosure path**: <path>`).
+- The reported date (`- **Reported**: <YYYY-MM-DD>`).
+
+Skip entries whose disclosure path is `drafted-and-saved (mailbox / out-of-band)` — those reports were never filed via `gh`, so there is no issue to comment on. Log a one-line skip note: `Skipping upstream entry <url> — disclosure path is out-of-band; user follow-up required.` The skip is **not** queued as an `outstanding_questions` entry (the user already owns the out-of-band channel per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule no-infra-for-email constraint).
+
+Multiple `## Reported Upstream` entries are supported (the local ticket may have been filed to multiple upstream trackers). Process each entry independently — the gate composition + post + back-write all run per-entry; one above-appetite entry queues only that entry, the rest proceed.
+
+### 3. Determine the transition that fired this invocation
+
+The skill is typically invoked AFTER the local ticket's filename suffix has changed (the `transition-problem` Step 7 advisory subsection fires AFTER the `git mv` + Status edit + re-stage). Compare the current suffix against the most recent `## Upstream Lifecycle Updates` log entry (if any) to identify which transition just fired:
+
+| Last logged Status | Current suffix | Transition fired |
+|---|---|---|
+| (none) | `.known-error.md` | Open → Known Error |
+| (none) | `.verifying.md` | Open → Known Error (skipped) → Verification Pending |
+| Open | `.known-error.md` | Open → Known Error |
+| Known Error | `.verifying.md` | Known Error → Verification Pending |
+| Verification Pending | `.closed.md` | Verification Pending → Closed |
+| any | matching last logged | no transition since last update — exit no-op |
+
+If the current suffix matches the last logged Status, exit clean: `No transition since last upstream update; nothing to post.` This guards against re-firing on a manage-problem update that doesn't change Status (Priority/Effort/WSJF edits, root-cause refinement edits).
+
+If the current suffix is `.parked.md`, exit clean: `Local ticket is Parked; no upstream lifecycle update applies.` Parking is a transient hold (per the "Problem lifecycle — add a Verification Pending status between Known Error and Closed" architecture rule) and does not warrant an upstream comment.
+
+### 4. Draft the lifecycle-update comment
+
+Per-transition templates. Each template's `<placeholders>` are filled from the local ticket's sections (per Step 1's extraction).
+
+#### Open → Known Error template
+
+```markdown
+Update from <downstream-repo-url>/<local-ticket-relative-path>:
+
+**Status**: Root cause identified (local ticket transitioned to Known Error).
+
+**Investigation findings**:
+
+<one-paragraph synthesis from the local ticket's Root Cause Analysis section — substantive, not just "we found it">
+
+**Planned fix path**:
+
+<from the local ticket's Fix Strategy section, or "Fix path under design" if absent>
+
+**Workaround**:
+
+<from the local ticket's Workaround section, or "None identified yet" if absent>
+
+We'll post here again when the fix releases. Local tracking: P<NNN>.
+```
+
+#### Known Error → Verification Pending template
+
+```markdown
+Update from <downstream-repo-url>/<local-ticket-relative-path>:
+
+**Status**: Fix released (local ticket transitioned to Verification Pending).
+
+**Release**:
+
+- **Package**: `<package>@<version>` (or "see release notes" if not derivable)
+- **Merge PR**: #<N> (or commit SHA if direct-to-main)
+- **Released**: <YYYY-MM-DD>
+
+**Fix summary**:
+
+<one-sentence summary from the local ticket's ## Fix Released section>
+
+Please upgrade and verify when convenient. We'll close this issue after your confirmation OR after a 14-day quiet period (per the "Problem 048: manage-problem does not surface Fix Released problems as verification candidates when the fix path has been exercised" problem default). Local tracking: P<NNN>.
+```
+
+#### Verification Pending → Closed template
+
+```markdown
+Update from <downstream-repo-url>/<local-ticket-relative-path>:
+
+**Status**: Closed locally after user-side verification.
+
+Closing this issue to match. Thanks for the report — your filing is what got this on the queue. Local tracking: P<NNN>.
+```
+
+After posting the Verifying → Closed comment, the skill also runs `gh issue close <n>` (per Step 5b below) so the upstream tracker matches local state.
+
+#### Template-filling rules
+
+- **No invention**: if a section the template cites is absent from the local ticket, write the explicit "absent" phrasing ("Fix path under design", "None identified yet") rather than synthesising content. The risk gate and voice-tone gate cannot guard against invented technical claims; the no-invention rule does.
+- **Source-citation**: every template starts with `Update from <downstream-repo-url>/<local-ticket-relative-path>:` so the upstream maintainer can navigate back to the source ticket without ambiguity. The cross-reference URL uses the same shape as `/wr-itil:report-upstream` Step 5's `## Cross-reference` section.
+- **No "we" assumptions about the upstream maintainer**: the lifecycle templates are written from the downstream-reporter perspective. Use "we" only when referring to the downstream team; do not use it to suggest joint authorship of the upstream fix unless the local ticket's Fix Strategy explicitly records an upstream-collaborative path.
+
+### 5. Compose through external-comms + voice-tone gates
+
+#### 5a. External-comms risk gate
+
+Score the drafted comment body via the `wr-risk-scorer:external-comms` agent (shipped per [the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule](../../../docs/decisions/028-voice-tone-gate-external-comms.proposed.md) — the same agent the post-the "Agent waits for human to initiate upstream report instead of filing on detect — feedback delay class" problem amendment uses for the initial-filing path's pre-fire gate). Invocation: delegate via the native Codex subagent tool with `subagent_type: "wr-risk-scorer:external-comms"` passing the drafted body + the upstream URL + the transition type as context.
+
+The agent returns a structured verdict:
+
+```
+EXTERNAL_COMMS_RISK_VERDICT
+band: Low (<=4/25) | Medium (5..16) | High (17+)
+score: <0..25>
+pass: true | false
+reason: <one-line rationale>
+```
+
+- **`pass: true` AND band ≤ Low (4/25)**: within appetite per RISK-POLICY.md commit-layer. Proceed to 5b (voice-tone).
+- **`pass: false` OR band > Low**: above appetite. Branch to 5c (above-appetite handling).
+
+#### 5b. Voice-tone gate
+
+`gh issue comment` and `gh issue close` are on the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule gated surface list. The PreToolUse:Bash hook fires deny-plus-delegate to `wr-voice-tone:agent`. The agent reads the drafted body against `docs/VOICE-AND-TONE.md` and writes the bypass marker on PASS; the original `gh` call retries automatically.
+
+A FAIL verdict on the voice-tone gate is treated identically to an above-appetite risk verdict — branch to 5c.
+
+#### 5c. Above-appetite handling
+
+The decision policy here is **framework-resolved** per [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) and the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 (AFK fail-safe). No per-transition `request_user_input` for the GATE FIRING — the gate scoring is itself the framework. The above-appetite handling differs by orchestrator context:
+
+- **Interactive context** (per the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 1): use `request_user_input` to surface the drafted comment + the gate verdict + the matched URL, with options:
+  - `Post the comment anyway (Recommended after review)` — user has read the draft and judged the post warranted; the skill bypasses the gate for this single post.
+  - `Risk-reduce and re-score` — invoke a tighter draft (shorter / fewer claims / stricter source-citation) and re-run the gate.
+  - `Queue for later review` — save the draft to `## Queued Upstream Update` on the local ticket; user acts on return.
+  - `Skip this update` — exit no-op for this upstream entry; the next transition's invocation re-considers.
+
+- **AFK / non-interactive context** (per the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 + the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem queue-and-continue): the skill applies **silent risk-reduce + re-score** first — re-draft the comment with tighter source-citation + shorter prose, then re-invoke the external-comms gate. If the re-scored verdict is within appetite, proceed via 5b. Otherwise, save the drafted comment to the local ticket's `## Queued Upstream Update` section (shape below) and queue an `outstanding_questions` entry (category: `deviation-approval`) naming the local ticket ID + the matched URL + the residual band + the risk-reduce attempts taken. **The orchestrator continues per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem** — do NOT halt the loop on an above-appetite upstream update.
+
+The silent risk-reduce step is **mechanical** per the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule framework-resolution boundary — the skill owns the re-draft; per-iter `request_user_input` for risk-reduce vocabulary is the lazy-deferral anti-pattern the "Agents over-ask in interactive sessions — conflating mechanical-stages with user-interactive-stages of multi-stage skill contracts (inverse-)" problem closes.
+
+#### Queued Upstream Update save format
+
+```markdown
+## Queued Upstream Update
+
+- **Drafted**: <YYYY-MM-DD>
+- **Transition**: Open → Known Error | Known Error → Verification Pending | Verification Pending → Closed
+- **Target URL**: <upstream-issue-url>
+- **Halt reason**: above-appetite external-comms gate (band: <verdict band>; score: <verdict score>; reason: <verdict reason>) | above-appetite voice-tone gate (reason: <verdict reason>)
+- **Risk-reduce attempts**: <count, e.g. "1 — tighter source-citation; re-scored band Medium">
+- **Drafted comment body**:
+
+  <the body that would have been posted as a `gh issue comment`, ready for manual review>
+```
+
+Per [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem), the section name `## Queued Upstream Update` is the lifecycle-update analogue of `## Queued Upstream Report` (the initial-filing analogue per the 2026-06-04 second-amendment leaf (c) rename). Same shape; distinct section so a single local ticket can carry both a queued report (initial filing held) and a queued update (lifecycle update held) without collision.
+
+### 5b. (final). Post via gh issue comment
+
+Within-appetite path. Post the drafted comment:
+
+```bash
+gh issue comment "${UPSTREAM_ISSUE_NUMBER}" \
+  --repo "${UPSTREAM_OWNER_REPO}" \
+  --body "${DRAFTED_COMMENT_BODY}"
+```
+
+Capture the returned comment URL (gh prints `https://github.com/<owner>/<repo>/issues/<n>#issuecomment-<id>`).
+
+On the **Verifying → Closed** transition, after posting the comment, also close the upstream issue:
+
+```bash
+gh issue close "${UPSTREAM_ISSUE_NUMBER}" \
+  --repo "${UPSTREAM_OWNER_REPO}" \
+  --comment "" \
+  --reason completed
+```
+
+`--comment ""` suppresses gh's own auto-comment (we already posted the closing comment above); `--reason completed` matches the `.closed.md` semantics.
+
+If the issue is already closed upstream (someone else closed it manually), `gh issue close` returns a benign error — capture the existing state and continue to Step 6 with `closed-already-upstream` recorded in the back-write disclosure path.
+
+#### Pull-request targets never get closed (the "Prefer an upstream pull request over an issue when the upstream accepts pull requests" architecture rule)
+
+When the `## Reported Upstream` disclosure path records a **pull request**, post the comment with `gh pr comment` and **stop there**. Do not run `gh pr close`, on this transition or any other.
+
+A merged pull request closes itself, so closing is redundant. An unmerged one is still work we authored and offered; closing it is a hostile act against our own contribution and withdraws it from the maintainer's queue without saying so. The local ticket reaching `.closed.md` means *we* consider the problem resolved locally — it does not mean the upstream has finished deciding.
+
+Record `posted-pr-comment` in the back-write disclosure path. On a pull-request target `posted-comment-and-closed` is unreachable by construction.
+
+### 6. Back-write to local ticket
+
+Append a log entry to the local ticket's `## Upstream Lifecycle Updates` section (create the section if absent — never inserted mid-document; appended after all existing sections per the same discipline as `## Reported Upstream` in `/wr-itil:report-upstream` Step 7):
+
+```markdown
+## Upstream Lifecycle Updates
+
+- **<YYYY-MM-DD>** — Open → Known Error
+  - **Target URL**: <upstream-issue-url>
+  - **Comment URL**: <posted-comment-url> (or "queued — see ## Queued Upstream Update" when above-appetite)
+  - **Disclosure path**: posted-comment | posted-pr-comment (pull-request target, the "Prefer an upstream pull request over an issue when the upstream accepts pull requests" architecture rule — never closed) | posted-comment-and-closed (Verifying → Closed, issue targets only) | queued-above-appetite | closed-already-upstream | skipped-out-of-band
+  - **Gate verdict**: external-comms <band/score> + voice-tone <pass|fail>
+
+- **<YYYY-MM-DD>** — Known Error → Verification Pending
+  - ... (next entry appends; never replaces earlier entries)
+```
+
+The log is append-only — each transition adds an entry; earlier entries are never overwritten. The log is the audit trail per the "Restore Service Fast with an Audit Trail" user outcome's symmetric-audit-trail outcome and per the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule Confirmation criterion 3a's `## Reported Upstream` back-write pattern (extended for the bidirectional case).
+
+### Inbound-origin verdict dispatch (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem)
+
+<!-- @jtbd the "Report a Problem Without Pre-Classifying It" user outcome (Report a Problem Without Pre-Classifying It — inbound reporter feedback loop: the fix-released verdict leg for tickets someone else filed against us) -->
+
+This leg runs **in addition to** Steps 2–6 (the outbound `## Reported Upstream` path), keyed off the `**Origin**: inbound-reported (#NN)` field Step 1 extracted. It closes the "Report a Problem Without Pre-Classifying It" user outcome fix-released-verdict promise for the **inbound** direction — a plugin-user filed a `problem-report` issue *against us* (recorded at intake by the "Inbound upstream-report discovery + assessment pipeline (peer of )" architecture rule's safe-and-valid branch, which stamps the on-ticket `**Origin**` field per [the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule](../../../docs/decisions/076-inbound-reported-problems-rank-ahead-via-sort-tier.proposed.md)) and never heard the fix shipped because the outbound machinery only reads `## Reported Upstream`. Authority: [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem, inbound-verdict dispatch leg).
+
+**Why the Origin field, not `## Reported Upstream` (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem design):** the inbound issue lives on OUR OWN repo (it was filed against us). Writing it into `## Reported Upstream` would contaminate `/wr-itil:check-upstream-responses` (the "No process for issue reporters to check for responses — symmetric gap to inbound discovery" problem), which polls that section as OUTBOUND issues we filed *elsewhere*. Consuming the `**Origin**` field — distinct by construction — keeps the inbound and outbound data shapes separate and the "No process for issue reporters to check for responses — symmetric gap to inbound discovery" problem uncontaminated.
+
+#### I1. Parse the inbound origin
+
+From the `**Origin**: inbound-reported (#NN)` field, extract the originating issue number `NN`. Resolve the repo it lives on as **our own repo** — the `gh` default for the current working tree (`gh repo view --json nameWithOwner -q .nameWithOwner`), NOT an external upstream owner/repo. If the `**Origin**` field is `internal` or absent, this leg does not run (the no-op is already handled at Step 1 when both surfaces are absent).
+
+#### I2. Determine the transition (same suffix logic as Step 3)
+
+Reuse Step 3's transition table (filename-suffix vs last-logged Status) — it is direction-agnostic. The inbound leg fires verdict comments for the **fix-released** and **closed** transitions (the verdicts a reporter most wants); Open → Known Error fires an optional progress comment only when the reporter explicitly asked for status. If the suffix matches the last logged inbound entry, exit no-op (`No inbound transition since last update; nothing to post.`).
+
+#### I3. Generate the inbound verdict comment (reporter-facing, LLM-generated — no templates)
+
+These comments are **generated from the local ticket's context, not filled from canned templates** (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem rework, Directive 1). Templates produce cold, patterned prose that reporters recognise as form-letters; instead the agent reads the source-of-truth sections below and GENERATES each comment per the per-transition prompt, then rides the gate chain in [I5](#i5-compose-through-gates--post-same-composition-as-step-5) (cog-a11y → risk → voice-tone).
+
+**Source-of-truth sections** (read from the local ticket before generating): `## Description` (the reporter's original symptom report), `## Workaround`, `## Root Cause Analysis`, `## Fix Released` (the release marker, version, commit SHA — the released `@windyroad/<pkg>@<version>` upgrade target comes from here).
+
+**No-invention rule (load-bearing, carried from Step 4):** if a cited section is absent or empty, say so honestly ("we don't have a workaround to share yet") — NEVER synthesise technical claims. The gates cannot catch invented facts; the no-invention rule does. This mirrors the "Inbound upstream-report discovery + assessment pipeline (peer of )" architecture rule's safe-and-valid acknowledgement shape (Decision Outcome step 6).
+
+**Anti-leakage discipline (the "Inbound-discovery ack comments are bureaucratic, not verdict-shaped ( violation)" problem/the "agent surfaces decisions to user using opaque IDs (P-numbers, ADR-numbers, JTBD-numbers) without explaining what they mean — empathy gap" problem — REVISED per repo visibility, Directive 3):** these bodies are reporter-facing on our own repo. Determine repo visibility once: `gh repo view --json visibility -q .visibility` → `PUBLIC` / `PRIVATE` / `INTERNAL`.
+
+- **PUBLIC** — you MAY refer to a problem / ADR / RFC / JTBD / Story, but ALWAYS by its **title AND as a link**, never a bare ID:
+  - Bad (bare ID, opaque): `Tracked locally as the "Latent octal-eval bug in next-ID formula across all 4 ticket-creator skills — `$(( $local_max + 1 ))` fails with "value too great for base" when local_max reaches 099" problem.`
+  - Bad (title only, no link): `Tracked as the octal-eval bug.`
+  - Good (title + linked ID): `Tracked as [Latent octal-eval bug in next-ID formula](https://github.com/windyroad/agent-plugins/blob/main/docs/problems/known-error/164-octal-eval-bug-in-next-id-formula-across-ticket-creator-skills-fires-when-ids-cross-099.md) (the "Latent octal-eval bug in next-ID formula across all 4 ticket-creator skills — `$(( $local_max + 1 ))` fails with "value too great for base" when local_max reaches 099" problem).`
+  - Resolve the link: ADR / RFC / JTBD / Story canonical paths live on `main`; for a problem ticket the filename carries the state suffix + slug — resolve the actual filename via `ls docs/<class>/<NNN>-*` (or `gh search code`) before linking. Grounded in [the "Plugin-published artefacts use namespace-prefixed permalinks for internal IDs" architecture rule](../../../docs/decisions/055-plugin-published-namespace-prefixed-internal-ids.proposed.md)'s permalink-progressive-enhancement shape and the "Inbound-discovery ack comments are bureaucratic, not verdict-shaped ( violation)" problem's jargon-vs-link distinction.
+- **PRIVATE / INTERNAL / indeterminate** — strict ban (the prior the "Inbound-discovery ack comments are bureaucratic, not verdict-shaped ( violation)" problem rule): omit problem / ADR / RFC / JTBD / Story references entirely. External readers can't reach the URLs, so a link is worse than no reference.
+
+**Always banned (regardless of visibility):** classification tokens (`safe-and-valid`, `inbound-reported`, `clear-malicious`, `above-threshold-pushback`), internal step IDs (`Step 4.5e`, `step 6`), agent-internal vocabulary (`framework-resolution boundary`, `mechanical-stage carve-out`), runtime-detail prose (`marker-vs-file deadlock`, `subprocess-boundary contract`), and absolute `docs/problems/...` path strings (always prefer the rendered link). The released `@windyroad/<pkg>@<version>` upgrade target is always permitted.
+
+**Open → Known Error generation prompt** (only when the reporter explicitly asked for interim status — otherwise skip O→KE and wait for the fix-released verdict):
+
+```text
+GOAL: convey the root cause in plain, reporter-readable terms, AND share the
+WORKAROUND so the reporter is unblocked while the fix is in flight (Directive 2).
+
+READ: ## Description (their symptom report), ## Root Cause Analysis, ## Workaround.
+
+ROOT CAUSE: explain what's actually going wrong in terms the reporter can act
+on — no internal mechanism jargon.
+
+WORKAROUND — share it with correct PROVENANCE (Directive 4):
+  1. ## Workaround empty / "(deferred to investigation)": be honest — "we don't
+     have a workaround to share yet" — do NOT fabricate one.
+  2. Otherwise determine WHO first provided it. Read the originating issue's
+     body + comments:
+       gh issue view <NN> --repo <OWN_OWNER_REPO> --json comments,body \
+         --jq '.body, .comments[].body'
+     and semantically match (your judgement, not strict-string) the local
+     ## Workaround against the issue body and each commenter's prose:
+       - MAINTAINER-AUTHORED (no match in issue body or any comment): share the
+         workaround in our own voice.
+       - REPORTER-PROVIDED (matches the issue body / the reporter's own comment):
+         credit the reporter — e.g. "Thanks again — your workaround in the
+         original report turned out to be exactly right. To confirm the details:"
+         then the exact ## Workaround prose (we've validated it).
+       - COMMENTER-PROVIDED (matches a comment by someone other than the
+         reporter): credit them by @handle — e.g. "@<handle> — your workaround
+         upthread turned out to be the right path. Confirmed the details:" then
+         the exact ## Workaround prose.
+       - BOTH-SOURCE (reporter proposed X, a commenter refined to X'): credit
+         both per their contribution.
+     Honour @handles via standard GitHub-flavoured markdown so the credited
+     person is notified.
+  3. Always CONFIRM THE EXACT workaround details (the validated ## Workaround
+     prose) — never paraphrase a confirmed workaround into vagueness.
+
+LENGTH: concise — usually 3–6 sentences. Bullet list ONLY for a genuine
+multi-step workaround. Apply the anti-leakage discipline above. Voice/tone per
+docs/VOICE-AND-TONE.md (the voice-tone gate runs anyway).
+```
+
+**Known Error → Verification Pending (fix released) generation prompt:**
+
+```text
+GOAL: tell the reporter the fix shipped, name the upgrade target, invite verify.
+
+READ: ## Fix Released (release marker, version, commit SHA), ## Workaround.
+
+INCLUDE:
+  - What changed, in one reporter-readable sentence (from ## Fix Released) — no
+    invented detail.
+  - The upgrade target: `@windyroad/<pkg>@<version>` (or later).
+  - If ## Workaround had a workaround: note it's no longer needed after upgrade.
+  - An invitation to upgrade and confirm, and "reply here if it persists".
+
+LENGTH: concise — usually 3–5 sentences. Apply the anti-leakage discipline
+above. Voice/tone per docs/VOICE-AND-TONE.md.
+```
+
+**Verification Pending → Closed generation prompt:**
+
+```text
+GOAL: close the loop warmly, thank the reporter, give the reopen path.
+
+READ: ## Fix Released (the released version).
+
+INCLUDE:
+  - The fix is confirmed on our side and shipped in `@windyroad/<pkg>@<version>`.
+  - A genuine thank-you — their report is what got it fixed.
+  - The reopen path: reply or reopen if it resurfaces.
+
+LENGTH: concise — usually 2–4 sentences. Apply the anti-leakage discipline
+above. Voice/tone per docs/VOICE-AND-TONE.md.
+```
+
+#### I4. Idempotency guard (before posting)
+
+Inbound dispatch may re-fire (re-run on a later transition, or a stale-grep re-dispatch). Before posting, scan the originating issue's existing comments:
+
+```bash
+gh issue view "${NN}" --repo "${OWN_OWNER_REPO}" --json comments \
+  -q '.comments[].body' | grep -F "@windyroad/${PKG}@${VERSION}"
+```
+
+The verdict marker is the released `@windyroad/<pkg>@<version>` string (plus the commit SHA carried in `## Fix Released` when present) — unique enough that a prior matching comment means the verdict already posted. If a matching comment is found, **skip the post**, back-write an `already-posted-inbound` reconciliation entry to the lifecycle log (I6), and continue. This makes the inbound leg idempotent on re-runs.
+
+#### I5. Compose through gates + post (same composition as Step 5)
+
+Route the GENERATED comment through the reporter-facing gate chain — **cognitive-accessibility → external-comms (risk) → voice-tone** (Directive 1's "run cog-a11y, risk, voice and tone"). The risk + voice-tone legs are the SAME `wr-risk-scorer:external-comms` + `wr-voice-tone:external-comms` dual gate (AND composition) as Step 5 — no weaker path for inbound.
+
+**Cog-a11y gate (when-available, the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem-gated — do NOT block):** the cognitive-accessibility evaluator rides FIRST so reporter-facing prose is checked for plain-language / reading-level before the risk + voice-tone legs. `@windyroad/cognitive-a11y` does not exist yet ([the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem](../../../docs/problems/open/338-p082-phase-2-cognitive-a11y-evaluator-on-external-comms-surfaces-new-windyroad-cognitive-a11y-plugin.md) Open) — until it lands the chain degrades to the existing external-comms + voice-tone dual gate, exactly as the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule's per-evaluator marker scheme handles an uninstalled evaluator (an absent evaluator's gate is simply not registered → the remaining legs' PASS unblocks the retry). The cog-a11y-as-third-external-comms-evaluator declaration is recorded in [the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule](../../../docs/decisions/028-voice-tone-gate-external-comms.proposed.md)'s `## Amendments` (the locus the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule's own Reassessment Criteria designate for a third evaluator); this leg is the consumer-side wiring note only. **Do NOT block this iteration's inbound dispatch on the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem** — ship the wiring, ride the dual gate today.
+
+Above-appetite handling is identical to Step 5c (silent risk-reduce + re-score; if still above, save to `## Queued Upstream Update` + queue an `outstanding_questions` entry; the orchestrator continues per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem — do NOT halt). Within appetite, post on our own repo:
+
+```bash
+gh issue comment "${NN}" --repo "${OWN_OWNER_REPO}" --body "${INBOUND_BODY}"
+```
+
+On the **Verification Pending → Closed** transition, after the comment, also close the originating issue so our own tracker matches the local `.closed.md` state (this addresses the "work-problems orchestrator carries prior-ticket Fix Strategy text into iter dispatch without re-grounding in design intent" problem #97 *silent-and-unclosed* witness):
+
+```bash
+gh issue close "${NN}" --repo "${OWN_OWNER_REPO}" --comment "" --reason completed
+```
+
+If the issue is already closed (someone closed it manually), `gh issue close` returns a benign error — record `closed-already` in the disclosure path and continue.
+
+#### I6. Back-write to the lifecycle log
+
+Append to the same `## Upstream Lifecycle Updates` log (Step 6 shape), tagged for the inbound direction so the audit trail stays unified:
+
+```markdown
+- **<YYYY-MM-DD>** — Known Error → Verification Pending (inbound)
+  - **Target**: inbound #<NN> (own repo <OWN_OWNER_REPO>)
+  - **Comment URL**: <posted-comment-url> (or "skipped — already-posted-inbound" when the idempotency guard matched, or "queued — see ## Queued Upstream Update" when above-appetite)
+  - **Disclosure path**: posted-inbound-comment | posted-inbound-comment-and-closed (Verifying → Closed) | already-posted-inbound | queued-above-appetite | closed-already
+  - **Gate verdict**: external-comms <band/score> + voice-tone <pass|fail>
+```
+
+The log stays append-only and direction-tagged; `/wr-itil:check-upstream-responses` (the "No process for issue reporters to check for responses — symmetric gap to inbound discovery" problem) does NOT read this section, so logging inbound entries here cannot contaminate the outbound poller.
+
+#### I7. Both-direction tickets
+
+A ticket may carry BOTH a `## Reported Upstream` section AND an inbound `**Origin**` field (we reported it upstream *and* someone reported it against us). The two legs are **independent**: the outbound entries run Steps 2–6 against their external URLs; the inbound leg runs I1–I6 against the own-repo issue. Each gate-composes, posts, and logs separately — one above-appetite leg queues only itself; the other proceeds.
+
+### 7. Commit per the "Governance Skills Commit Their Own Completed Work" architecture rule
+
+When invoked from `transition-problem` Step 7's advisory subsection, the upstream comment + back-write + the ticket rename + the README refresh all join the **same single commit** per the "Governance Skills Commit Their Own Completed Work" architecture rule's single-commit grain — never split across commits. The transition-problem skill owns the commit; this skill's edits ride that commit as additional staged changes.
+
+When invoked user-initiatedly (no transition in this session, e.g. retroactive catch-up), the skill commits its own work:
+
+1. `git add docs/problems/<state>/<NNN>-<title>.md` (the back-write + any `## Queued Upstream Update` appendage).
+2. Score commit/push/release risk via `wr-risk-scorer:pipeline` subagent (or fall back to `/wr-risk-scorer:assess-release` skill per the "On-Demand Assessment Skills for Governance Plugins" architecture rule).
+3. `git commit -m "docs(problems): P<NNN> upstream lifecycle update — <transition>"`.
+
+If the cumulative pipeline risk lands above appetite and `request_user_input` is unavailable, apply the [the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6](../../../docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md) non-interactive fail-safe: skip the commit and report the uncommitted state. Do NOT auto-commit above appetite without the user's call.
+
+## Catchup migration mode (Phase 2)
+
+`/wr-itil:update-upstream --catchup` runs a one-shot batch-retroactive migration. It exists because the per-ticket auto-update path (Phase 1) only fires on transitions that happen *after* it shipped — every ticket reported upstream and transitioned *before* Phase 1 silently missed its lifecycle update, leaving upstream issues looking abandoned. Catchup back-fills that history. Authority: [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2).
+
+This mode is **user-initiated only** — it is never auto-fired from a transition. It is a deliberate corpus-wide migration the maintainer runs once (or re-runs safely, thanks to idempotency).
+
+### C1. Build the worklist (read-only scan)
+
+Invoke the worklist scanner via its [the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule](../../../docs/decisions/049-plugin-script-resolution-via-bin-on-path.proposed.md) `$PATH` shim — **never** via a repo-relative `packages/...` path (that path does not resolve in adopter trees):
+
+```bash
+<itil-plugin-root>/bin/wr-itil-catchup-scan
+```
+
+The scanner (`<itil-plugin-root>/scripts/catchup-scan.sh`, dispatched by the `<itil-plugin-root>/bin/wr-itil-catchup-scan` bin shim) is **read-only and local** — it makes no `gh` calls and writes nothing. It walks the `.verifying.md` + `.closed.md` corpus (dual-tolerant flat + per-state subdir per the ": docs/problems/ flat layout migration — per-state subdirs + adopter auto-migration" release design), filters to tickets carrying a `## Reported Upstream` section, applies marker-based idempotency, and prints a worklist:
+
+```
+CATCHUP P<NNN> <url> state=<verifying|closed> transition=<KE->Verifying|Verifying->Closed>
+SKIP    P<NNN> <url> reason=already-logged
+SKIP    P<NNN> <url> reason=out-of-band
+```
+
+plus a `SUMMARY scanned=… catchup=… skip-logged=… skip-out-of-band=…` line on stderr. Tickets with no `## Reported Upstream` section produce no line (the common case). Open / Known-Error / Parked tickets are out of the catchup corpus — only post-fix states (Verifying, Closed) carry the lifecycle updates a reporter most wants retroactively.
+
+### C2. Idempotency contract
+
+Catchup is **idempotent** (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2 acceptance criterion 3). The scanner skips a ticket whose `## Upstream Lifecycle Updates` log already records an entry for the current target state:
+
+- `.verifying.md` → already-logged iff the log contains a `→ Verification Pending` entry.
+- `.closed.md` → already-logged iff the log contains a `→ Closed` entry.
+
+The append-only log (written by Step 6 on every post) is the source of truth — the same marker the per-ticket path writes. Re-running `--catchup` therefore never double-posts. As defence-in-depth, before posting each `CATCHUP` entry the SKILL MAY also scan the upstream issue for a prior `Update from …` comment authored by the posting account (`gh issue view <n> --json comments`); if one already matches the target transition, treat it as already-logged, back-write the log entry to reconcile, and skip the post. The body-marker check is primary (cheap, no `gh` round-trip); the comment scan is the belt-and-braces fallback for tickets whose log predates Phase 1's back-write.
+
+### C3. Process each CATCHUP entry
+
+For each `CATCHUP` line, parse its `disclosure=` token and run the **existing per-ticket flow** (Steps 4–6) against that ticket ID. `disclosure=pull-request` selects `gh pr comment` and forbids any close command; `disclosure=issue` selects `gh issue comment` and permits `gh issue close` for Verifying → Closed:
+
+1. Draft the transition template (Step 4) for the entry's transition (`KE->Verifying` → Known Error → Verification Pending template; `Verifying->Closed` → Verification Pending → Closed template). Only an issue disclosure also runs `gh issue close`; a pull-request disclosure never runs `gh pr close`.
+2. Compose through the external-comms + voice-tone gates (Step 5) — **identical** dual-gate composition as the per-ticket path. Above-appetite handling (Step 5c) is unchanged: silent risk-reduce + re-score, then queue to `## Queued Upstream Update` + `outstanding_questions` (category `deviation-approval`) per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem if still above. Catchup does NOT bypass the gates.
+3. Post within appetite (Step 5b final) and back-write the `## Upstream Lifecycle Updates` log (Step 6).
+
+Process entries one at a time so a single above-appetite entry queues only itself; the rest proceed. There is no batch-cap on the number of catchup posts — the gate composition is the rate-limit, and the corpus is bounded (one pass over local tickets).
+
+### C4. Commit per the "Governance Skills Commit Their Own Completed Work" architecture rule
+
+The catchup migration is user-initiated, so it owns its commit per the Step 7 user-initiated path: stage every touched ticket's back-write (and any `## Queued Upstream Update` appendage), score commit/push/release risk via `wr-risk-scorer:pipeline`, and commit once covering the whole pass — `docs(problems): upstream lifecycle catchup migration — <N> tickets (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2)`. Above-appetite-and-no-request_user_input → the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 fail-safe (report the uncommitted state, do not auto-commit).
+
+### C5. Verification
+
+The live-upstream end-to-end confirmation (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem acceptance criterion 7 — a catchup comment actually lands on a real upstream issue) is the overall the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem verification step. Running `--catchup` against the real corpus (e.g. the "`/wr-itil:report-upstream` is installed and enabled but does not appear in Codex slash-command autocomplete" problem's `https://github.com/anthropics/claude-code/issues/52831`) and confirming the comment posts is what closes the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem to Verifying once a fresh release ships the mode.
+
+## AFK behaviour summary
+
+Four distinct AFK branches. Per the [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem) — same composition shape as the post-the "Agent waits for human to initiate upstream report instead of filing on detect — feedback delay class" problem initial-filing path — ALL pre-post branches route through the `wr-risk-scorer:external-comms` + `wr-voice-tone:external-comms` gates. Below-appetite proceeds; above-appetite silent risk-reduces + re-scores; if still above, queues per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem queue-and-continue without halting the loop.
+
+| Branch | AFK behaviour | Authority |
+|---|---|---|
+| Below-appetite post (Step 5b final) | Post via `gh issue comment`; on Verifying→Closed also `gh issue close`. Back-write to `## Upstream Lifecycle Updates`. Voice-tone gate per the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule may delegate-and-retry on the post; treat as expected. | the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem); the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule |
+| Above-appetite — silent risk-reduce + re-score within appetite | Re-draft with tighter source-citation + shorter prose; re-invoke `wr-risk-scorer:external-comms`. If within → post per the below-appetite branch. | the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem); the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule framework-resolution boundary; the "Auto-apply scorer remediations to reach within appetite — open action-class vocabulary" architecture rule within-axis precedent (open-vocabulary risk-reducing measures) |
+| Above-appetite — silent risk-reduce did not bring within appetite | Save drafted comment to `## Queued Upstream Update` + queue `outstanding_questions` entry (category: `deviation-approval`). Orchestrator continues per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem. | the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem); the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6; the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem |
+| Above-appetite commit (Step 7) | Skip the commit, report uncommitted state. | the "Structured User Interaction for Governance-Skill Decisions" architecture rule Rule 6 |
+| **Inbound-origin verdict (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem)** | When the ticket carries `**Origin**: inbound-reported (#NN)`, run the [§ Inbound-origin verdict dispatch](#inbound-origin-verdict-dispatch-p363) leg (I1–I7): idempotency-guard, then **GENERATE** the verdict comment from ticket context (no templates; O→KE shares the workaround with provenance-credit), route through the cog-a11y → external-comms → voice-tone gate chain (cog-a11y when-available per the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem; dual gate today), post `gh issue comment` on our own repo (and `gh issue close` on Verifying → Closed), back-write a direction-tagged lifecycle log entry. Above-appetite queues per the rows above (does NOT halt). Reporter-facing prose; anti-leakage visibility-gated (PUBLIC → titled+linked refs; PRIVATE/indeterminate → strict ban; classification tokens / step IDs / internal vocab always banned — the "Inbound-discovery ack comments are bureaucratic, not verdict-shaped ( violation)" problem/the "agent surfaces decisions to user using opaque IDs (P-numbers, ADR-numbers, JTBD-numbers) without explaining what they mean — empathy gap" problem). | the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule amendment (the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem); the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule (cog-a11y third evaluator, the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem); the "Plugin-published artefacts use namespace-prefixed permalinks for internal IDs" architecture rule (linked-title); the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule (Origin field); 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 |
+
+The pre-amendment "halt-the-orchestrator on above-appetite" semantics are **superseded** by queue-and-continue per the "AFK iter default when a skill needs to ask a question and request_user_input is unavailable — should queue the question and move to the next iteration (not halt, not silently skip)" problem — same shape as the post-the "Agent waits for human to initiate upstream report instead of filing on detect — feedback delay class" problem initial-filing path.
+
+## Triggered from transition-problem Step 7
+
+[`/wr-itil:transition-problem`](../transition-problem/SKILL.md) Step 7 hosts an advisory subsection that fires this skill when the transitioning ticket carries a `## Reported Upstream` section. The advisory wires the trigger; this skill owns the execution. The same "copy, not move" pattern (per [the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule](../../../docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md) amended Split-skill execution ownership rule, the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem) replicates the advisory in `/wr-itil:manage-problem`'s in-skill Step 7 block so in-skill callers (Step 9b auto-transition, Step 9d closure, the Parked path) also fire the lifecycle update.
+
+Both call sites delegate via the installed skill invocation:
+
+```
+/wr-itil:update-upstream <NNN>
+```
+
+The skill's no-op exit (Step 1) means firing the trigger unconditionally on every transition is cheap — most tickets have no `## Reported Upstream` section and exit immediately.
+
+## References
+
+- [the "Cross-project problem-reporting contract — `report-upstream` skill in `@windyroad/itil`" architecture rule](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) — primary contract this skill extends. The "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem amendment in `## Amendments` authorises the bidirectional lifecycle-update sibling skill, the transition-template shape, and the external-comms + voice-tone gate composition; the **the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem Phase 2 amendment** authorises the `--catchup` migration mode, the read-only worklist scanner, and the marker-based idempotency contract.
+- [the "Plugin-bundled scripts invoked from SKILL.md resolve via `bin/` on `$PATH`" architecture rule](../../../docs/decisions/049-plugin-script-resolution-via-bin-on-path.proposed.md) — the catchup worklist scanner is invoked as `<itil-plugin-root>/bin/wr-itil-catchup-scan` ($PATH shim), never via a repo-relative `packages/...` path.
+- [`<itil-plugin-root>/scripts/catchup-scan.sh`](../../scripts/catchup-scan.sh) — read-only local worklist scanner for `--catchup`; behavioural bats at `<itil-plugin-root>/scripts/test/catchup-scan.bats`.
+- [the "External-comms gate — voice-tone + risk/leak evaluators on shared PreToolUse surface" architecture rule](../../../docs/decisions/028-voice-tone-gate-external-comms.proposed.md) — voice-tone gate on `gh issue comment` and `gh issue close`.
+- [the "Structured User Interaction for Governance-Skill Decisions" architecture rule](../../../docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md) — interaction policy; Rule 1 governs the interactive above-appetite path; Rule 6 governs the AFK fail-safe.
+- [the "Governance Skills Commit Their Own Completed Work" architecture rule](../../../docs/decisions/014-governance-skills-commit-their-own-work.proposed.md) — single-commit grain for transition + back-write + upstream post.
+- [the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule](../../../docs/decisions/010-rename-wr-problem-to-wr-itil.proposed.md) amended — sibling-skill naming + split execution ownership (the "Problem 093: `/wr-itil:transition-problem` ↔ `/wr-itil:manage-problem` circular delegation for `<NNN> <status>` args" problem "copy, not move").
+- [the "— Decision-Delegation Contract: when agents act on the framework vs ask the user" architecture rule](../../../docs/decisions/044-decision-delegation-contract.proposed.md) — framework-resolution boundary; the gate verdict IS the framework, no per-transition request_user_input for the gate firing itself.
+- [the "Auto-apply scorer remediations to reach within appetite — open action-class vocabulary" architecture rule](../../../docs/decisions/042-auto-apply-scorer-remediations-open-vocabulary.proposed.md) — within-axis precedent for open-vocabulary risk-reducing measures.
+- [the ": promptfoo as the behavioural test harness for agent-prose verdicts" architecture rule](../../../docs/decisions/075-promptfoo-agent-prose-verdict-eval-harness.proposed.md) Amendment 2026-06-02 — paired promptfoo Tier-A/B eval discharges the ": Functional defects in shipped plugin behaviour" standing risk prose-floor for SKILL surfaces.
+- [the ": promptfoo as the behavioural test harness for agent-prose verdicts" architecture rule](../../../docs/decisions/075-agent-prose-behavioural-test-harness.proposed.md) — evidence-floor; the paired eval ships in the same commit as this SKILL prose for atomic the ": Functional defects in shipped plugin behaviour" standing risk discharge.
+- **the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem** — driving problem ticket (No bidirectional update of upstream-reported problems).
+- **the "Inbound-reported tickets never receive fix-released verdict on originating issue" problem** — driving problem ticket for the [§ Inbound-origin verdict dispatch](#inbound-origin-verdict-dispatch-p363) leg (inbound-reported tickets never received a fix-released verdict on the originating issue). Fix option (b) — consume the `**Origin**` field — user-ratified 2026-06-22. **Rework 2026-06-23** (four user directives): the inbound verdict is LLM-generated per-context (not templated); O→KE shares the workaround with reporter/commenter provenance-credit; anti-leakage is visibility-gated (PUBLIC → titled+linked refs); the gate chain gains a cog-a11y leg first (the "Phase 2 — cognitive-accessibility evaluator on the 4 external-comms surfaces (gh / npm / changeset / git commit), shipped as a NEW `@windyroad/cognitive-a11y` plugin" problem-gated).
+- [the "Plugin-published artefacts use namespace-prefixed permalinks for internal IDs" architecture rule](../../../docs/decisions/055-plugin-published-namespace-prefixed-internal-ids.proposed.md) — grounds the PUBLIC-repo titled+linked reference discipline (permalink-progressive-enhancement; cures the bare-ID collision failure mode).
+- [the "Inbound-reported problems rank ahead of internally-discovered problems via a sort tier" architecture rule](../../../docs/decisions/076-inbound-reported-problems-rank-ahead-via-sort-tier.proposed.md) — owns the `**Origin**: inbound-reported (#NN)` on-ticket field this leg consumes.
+- [the "Inbound upstream-report discovery + assessment pipeline (peer of )" architecture rule](../../../docs/decisions/062-inbound-upstream-report-discovery-assessment-pipeline.proposed.md) — inbound intake-time pipeline; its safe-and-valid branch is the Origin-field writer this leg reads at fix-released time.
+- **the "Problem 079: No inbound sync of upstream-reported problems — reports filed via the intake templates never surface in the local backlog" problem** — sibling problem (inbound-discovery leg); together the "Problem 079: No inbound sync of upstream-reported problems — reports filed via the intake templates never surface in the local backlog" problem + the "Problem 080: No bidirectional update of upstream-reported problems — local lifecycle transitions never propagate back to the reporter" problem close the reporter-loop end-to-end.
+- **the "Problem 078: Assistant does not offer to capture a problem ticket when the user delivers strong-signal correction" problem** — capture-on-correction; the manage-problem trap this skill closes (manual upstream-update step gets forgotten under load).
+- [`<itil-plugin-root>/skills/report-upstream/SKILL.md`](../report-upstream/SKILL.md) — reciprocal sibling (initial-filing path); shares the `## Reported Upstream` contract this skill consumes.
+- [`<itil-plugin-root>/skills/transition-problem/SKILL.md`](../transition-problem/SKILL.md) — Step 7 advisory subsection fires this skill.
+- [`<itil-plugin-root>/skills/manage-problem/SKILL.md`](../manage-problem/SKILL.md) — in-skill Step 7 copy fires this skill (per the "Rename `wr-problem` Plugin to `wr-itil`" architecture rule amended "copy, not move").
+
+$ARGUMENTS