@windyroad/itil 0.16.0 → 0.17.0-preview.168

package/.claude-plugin/plugin.json

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

package/package.json

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

package/skills/manage-problem/SKILL.md

@@ -92,6 +92,46 @@ WSJF = (8 × 1.0) / 8 = **1.0** — defer until severity climbs or scope shrinks
 
 When estimating effort, read the problem's root cause analysis and fix strategy. If effort is unknown, default to M (2). Effort is a **live estimate**, not a set-once label: re-rate it when root cause is confirmed, when architect review narrows or expands scope, and during each `manage-problem review`. A note capturing the reason for any bucket change makes the ranking audit-able (see steps 7 and 9b).
 
+### Transitive dependencies (P076)
+
+> **Serves**: JTBD-001 (enforce governance without slowing down — queue must not lie), JTBD-006 (progress the backlog while I'm away — AFK orchestrator iterates top-down on a trustworthy rank), JTBD-201 (restore service fast with an audit trail — ranking decisions must be defensible post-hoc).
+
+Effort is scored per-ticket as a **marginal** estimate (the work this ticket adds on top of its upstream dependencies). When a ticket has upstream dependencies — other tickets that must close first before this one can reach "done" — the ticket's effective effort for WSJF purposes is the **transitive closure** of its marginal effort plus all blocking upstreams, not the marginal alone.
+
+**Rule**:
+
+```
+Effort(T)_transitive = max(
+  Effort(T)_marginal,
+  max{ Effort(U)_transitive | U ∈ Blocked_by(T) }
+)
+
+WSJF(T) = (Severity(T) × StatusMultiplier(T)) / Effort(T)_transitive
+```
+
+A dependent ticket cannot reach its "done" state without the upstream work happening first. Scoring the dependent at its marginal-only effort lies about what it costs to deliver — the **queue** would rank it higher than its blocker even though the blocker's work is strictly contained within it.
+
+**Dependency signal**: drive the closure from the ticket's `## Dependencies` section (see the Step 5 template). Only `**Blocked by**` entries propagate effort; `**Composes with**` does NOT propagate — compositional overlap shares surface but neither side strictly blocks.
+
+**Upstream status carve-out**: an upstream ticket in `.closed.md`, `.verifying.md`, or `.parked.md` contributes **0** to the transitive closure. Closed upstream work is done; verifying upstream work is user-side (not dev effort and excluded from dev ranking per the WSJF multiplier table); parked upstream work is suspended (excluded from ranking until un-parked). Without this carve-out, a ticket blocked by a closed ticket would inherit XL forever.
+
+**Cycle handling**: when two or more tickets mutually block each other (e.g., shared gate-surface tickets that each list the other under `**Blocked by**`), treat the strongly-connected component as a **bundle**. The bundle's effective effort is `max{ marginal | members }`. All bundle members surface the same WSJF in review output — the shared WSJF is a **computed artefact** of the rendering, not written as a field into individual ticket files. Bundle members retain their individual Status suffixes and individual ticket files (ADR-022 suffix-based lifecycle).
+
+**Re-rate on upstream status change**: when a dependency transitions to `.closed.md` / `.verifying.md` / `.parked.md`, the dependent ticket's transitive closure shrinks and the effort drops accordingly. Step 9b catches this automatically — no transition-time graph re-walk is required.
+
+**Worked example**: P073 has marginal effort S (one surface-row add). P073 is blocked by P038 (XL). Then:
+
+```
+Effort(P073)_transitive = max(S=1, Effort(P038)_transitive) = max(1, 8) = 8
+WSJF(P073) = (Severity(P073) × 1.0) / 8 = 12 / 8 = 1.5
+```
+
+P073's WSJF matches P038's by construction — P073 cannot out-rank the ticket whose work is strictly contained within it. Contrast with the marginal-only (incorrect) computation: `12 / 2 = 6.0`, which would mis-rank P073 as "top of queue" despite being blocked.
+
+**Determinism**: the rule is deterministic from the graph — no `AskUserQuestion` branch is required when Step 9b re-rates a ticket. The re-rate fires silently and is logged in the review output per the Step 9b re-rate message format.
+
+**Reassessment criteria**: this rule lives inline in manage-problem's SKILL.md (following ADR-022's precedent for inline WSJF additions). If a second skill (e.g., manage-incident or a future cross-plugin `work-backlog` orchestrator) adopts the `## Dependencies` section and the transitive-effort rule, extract to a sibling ADR at that point — wider adoption justifies the ADR cost that today's single-skill scope does not.
+
 ## Working a Problem
 
 What "work" means depends on the problem's status:
@@ -286,11 +326,29 @@ Before writing the problem file, perform a concern-boundary analysis on the gath
 - [ ] Create reproduction test
 - [ ] Create INVEST story for permanent fix
 
+## Dependencies
+
+- **Blocks**: <tickets that can't close until this one does — bare IDs, comma-separated; leave empty if none>
+- **Blocked by**: <tickets that must close first — bare IDs, comma-separated; drives the transitive-effort rule; leave empty if none>
+- **Composes with**: <tickets whose work overlaps but neither blocks the other — does NOT propagate effort; leave empty if none>
+
 ## Related
 
 <links to related files, problems, ADRs>
 ```
 
+The `## Dependencies` section uses **bare ticket IDs** (`P038`, not `[P038](./038-...)` link syntax) — review output renders to links on demand. An empty row is valid and explicit: `- **Blocked by**: (none)` reads better than omitting the row. The transitive-effort rule in the WSJF Prioritisation section consumes this section at review time.
+
+**Concrete example** (for P073 referencing two upstreams):
+
+```markdown
+## Dependencies
+
+- **Blocks**: (none)
+- **Blocked by**: P038, P064
+- **Composes with**: (none)
+```
+
 ### 6. For updates: Edit the existing file
 
 Find the file matching the problem ID:
@@ -469,6 +527,27 @@ Parked problems and Verification Pending problems are excluded from WSJF ranking
     - Update the Status field to "Known Error"
     - This happens automatically — do not ask the user
 
+**Step 9b.1: Dependency-graph traversal — propagate transitive effort (P076)**
+
+After every `.open.md` / `.known-error.md` ticket has a marginal effort, run a **second pass** that walks the dependency graph and propagates effort up per the transitive-dependency rule (see the WSJF Prioritisation section's "Transitive dependencies" subsection). This is a deterministic re-rate — no `AskUserQuestion` required.
+
+1. **Build the graph**: for each `.open.md` / `.known-error.md` ticket, parse the `## Dependencies` section. Record `Blocked by` edges (bare IDs) into an adjacency map. Ignore `Composes with` (does not propagate) and `Blocks` (derivable from inverse).
+2. **Classify upstream status**: for each upstream ID referenced in any `Blocked by` edge, resolve the file suffix. Upstreams in `.closed.md`, `.verifying.md`, or `.parked.md` contribute **0** to the closure per the carve-out. Upstreams in `.open.md` or `.known-error.md` contribute their own transitive effort.
+3. **Topologically sort** the open/known-error subgraph so upstream tickets are scored before their dependents. If a cycle is detected (two or more tickets mutually `Blocked by` each other), treat the strongly-connected component as a **bundle** with effort = `max{ marginal | members }`.
+4. **Compute transitive effort** for each ticket in topological order using `Effort_transitive = max(marginal, max{ upstream transitive })`. Cycle-bundle members all receive the bundle's effort.
+5. **Update Effort and WSJF lines**: if a ticket's transitive effort differs from its marginal, edit the Effort line to the transitive bucket (S → M / L / XL as needed), recompute WSJF, and update the Priority and WSJF lines. Write a short audit trail in a `<!-- transitive: <bucket> via <UPSTREAM> -->` HTML comment on the Effort line so the next review can distinguish a manually-set marginal from a propagated transitive.
+6. **Report each re-rate** in the review summary using the concrete format:
+
+   ```
+   P<NNN>: Effort <OLD> → <NEW> (transitive via <UPSTREAM>)
+   ```
+
+   Example: `P073: Effort S → XL (transitive via P038)`. The shape is fixed so downstream audit tools can grep it deterministically.
+
+7. **Cycle-bundle output**: for cycle bundles, surface a shared WSJF line covering all members, e.g. `Bundle [P038, P064]: effort XL (cycle), WSJF 3.0 (shared)`. The shared WSJF is a computed artefact of the review rendering — do NOT write a shared-bundle field into the individual ticket files.
+
+The re-rate pass is part of Step 9b's output — a re-rate row appears in the step 9c ranked table with the transitive effort (not the marginal). Hide the marginal from the main table but preserve it in the ticket's HTML-comment audit trail so a future review knows where the propagation came from.
+
 **Step 9c: Present summary and select problem to work**
 
 After reviewing all problems, present a WSJF-ranked table for open/known-error problems (the main dev-work queue):

package/skills/manage-problem/test/manage-problem-transitive-dependencies.bats

@@ -0,0 +1,365 @@
+#!/usr/bin/env bats
+# Contract + behavioural tests: manage-problem SKILL.md must define a
+# transitive-dependency rule for WSJF effort, extend Step 9b with
+# dependency-graph traversal, and the problem-ticket template must carry
+# a `## Dependencies` section.
+#
+# Mixed shape — structural assertions (ADR-037 Permitted Exception) for
+# the contract prose Claude interprets at invocation time, AND one
+# behavioural fixture test that exercises the transitive-closure
+# algorithm directly so the rule is not merely "keyword present" (P081
+# pressure — behavioural where feasible).
+#
+# Cross-reference:
+#   @problem P076 — docs/problems/076-wsjf-does-not-model-transitive-dependencies.open.md
+#   ADR-022: verification-pending status carve-out from the closure
+#   ADR-014: governance-skills commit their own work
+#   ADR-037: contract-assertion bats pattern for SKILL.md prose contracts
+#   @jtbd JTBD-001 (solo-developer — enforce governance without slowing down)
+#   @jtbd JTBD-006 (solo-developer — progress the backlog while I'm away)
+#   @jtbd JTBD-201 (tech-lead — restore service fast with an audit trail)
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+  FIXTURE_DIR="$(mktemp -d)"
+}
+
+teardown() {
+  [ -n "${FIXTURE_DIR:-}" ] && [ -d "$FIXTURE_DIR" ] && rm -rf "$FIXTURE_DIR"
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Contract: WSJF section defines the transitive-dependency rule
+# ──────────────────────────────────────────────────────────────────────────────
+
+@test "SKILL.md WSJF section has a Transitive dependencies subsection (P076)" {
+  # The rule must live in a discoverable subsection so Claude finds it
+  # when interpreting the WSJF scoring contract.
+  run grep -nE "^### .*[Tt]ransitive [Dd]ependenc" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule defines effort as max(marginal, blocked-by closure) (P076)" {
+  # The core rule: Effort(T)_transitive = max(marginal, max{blocked-by})
+  # The prose must make the max-of relationship explicit so a dependent
+  # ticket inherits upstream effort.
+  run grep -inE "max.*marginal|marginal.*max|transitive.*effort|effort.*transitive" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule cites Blocked by as the dependency signal (P076)" {
+  # Blocked_by is the formally-scoped edge in the ticket-dependency graph.
+  # The rule must name it (not just generic "dependencies") so Claude knows
+  # which `## Dependencies` row drives the effort propagation.
+  run grep -inE "Blocked[[:space:]-]?by" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule carves Composes with OUT of the closure (P076)" {
+  # Compositional overlap does NOT strictly block — sibling work that
+  # shares surface should not inflate the dependent's effort.
+  run grep -inE "[Cc]omposes[[:space:]]with.*not|not.*[Cc]omposes|[Cc]omposes[[:space:]]with.*does NOT|[Cc]omposes[[:space:]]with.*excluded" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule carves .closed / .verifying / .parked OUT of the closure (architect note)" {
+  # Architect correction: already-done or user-blocked upstreams contribute
+  # zero marginal dev effort — otherwise a ticket blocked by a closed
+  # ticket would inherit XL forever.
+  run grep -inE "(\.closed\.md|\.verifying\.md|\.parked\.md).*(contribut|0|zero|exclud)|contribut.*0.*(\.closed|\.verifying|\.parked)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule documents cycle bundling (shared WSJF as computed artefact) (P076)" {
+  # Cycles (e.g. P038/P064 mutual composition) must be handled — bundle's
+  # effort = max of members' marginals; shared WSJF surfaced in review
+  # output, not written as a field per-ticket (ADR-022 suffix-based pattern).
+  run grep -inE "cycle|bundle" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule carries a worked example (P076)" {
+  # Worked example: P073 marginal S blocked by P038 XL → transitive XL →
+  # WSJF drops to match P038. The number-grounded example keeps the rule
+  # out of hand-wavy territory (ADR-026 grounded output).
+  run grep -inE "[Ww]orked[[:space:]]example|example.*transitive|transitive.*example" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive rule notes reassessment-criteria for future ADR extraction (architect note)" {
+  # Architect guidance: keep a pointer for when another skill adopts the
+  # `## Dependencies` convention — at that point, extract to a sibling ADR.
+  # Inline note now avoids speculative ADR authoring today.
+  run grep -inE "[Rr]eassessment|[Ee]xtract.*ADR|sibling ADR|future ADR" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Contract: Step 9b review extends to dependency-graph traversal
+# ──────────────────────────────────────────────────────────────────────────────
+
+@test "SKILL.md Step 9b describes a dependency-graph traversal pass (P076)" {
+  # After per-ticket marginal scoring, Step 9b must walk the graph and
+  # propagate effort up. The prose must name the traversal explicitly so
+  # Claude performs the second pass, not just the first.
+  run grep -inE "dependency[[:space:]-]?graph|graph traversal|topological.*sort|propagate.*effort|effort.*propagat" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md Step 9b reports transitive re-rates in the review summary (P076 + JTBD-006)" {
+  # The AFK orchestrator (JTBD-006) and the audit-trail persona (JTBD-201)
+  # depend on Step 9b emitting a visible re-rate line — not a silent
+  # update.
+  run grep -inE "transitive.*(re-?rate|rerat|re-?estimat)|report.*transitive|re-?rate.*transitive" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md Step 9b re-rate message format is concrete (architect note — bats-assertable shape)" {
+  # Architect correction 4: specify a concrete message shape so the
+  # contract can be grepped. Format: P<NNN>: Effort <OLD> → <NEW>
+  # (transitive via <UPSTREAM>).
+  run grep -inE "Effort.*→.*transitive via|transitive via.*P[0-9]" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Contract: Step 5 problem-ticket template includes `## Dependencies`
+# ──────────────────────────────────────────────────────────────────────────────
+
+@test "SKILL.md Step 5 template includes a ## Dependencies section (P076)" {
+  # New tickets must carry an explicit dependency list so the graph is
+  # legible. Empty lists are allowed (default: no deps).
+  run grep -nE "^## Dependencies" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md Dependencies template lists Blocks / Blocked by / Composes with rows (P076)" {
+  # The three row labels must all be present in the template so the
+  # author knows which semantics apply. Blocks = downstream; Blocked by =
+  # drives effort propagation; Composes with = overlap without blocking.
+  run grep -inE "\*\*Blocks\*\*|\*\*Blocked by\*\*|\*\*Composes with\*\*" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  # All three labels must be present.
+  blocks_hits=$(grep -cE "\*\*Blocks\*\*" "$SKILL_FILE" || true)
+  blocked_hits=$(grep -cE "\*\*Blocked by\*\*" "$SKILL_FILE" || true)
+  composes_hits=$(grep -cE "\*\*Composes with\*\*" "$SKILL_FILE" || true)
+  [ "$blocks_hits" -ge 1 ]
+  [ "$blocked_hits" -ge 1 ]
+  [ "$composes_hits" -ge 1 ]
+}
+
+@test "SKILL.md Dependencies rows use bare ticket IDs (architect note Q1)" {
+  # Bare IDs (P038) beat link syntax (`[P038](./038-...)`) — less
+  # maintenance; review output renders to links on demand. The template
+  # example must show bare-ID form (not `[P038](./038-...)`).
+  # Canonical shape: `- **Blocked by**: P<NNN>, P<NNN>` — match either
+  # bold-markdown label form or plain-label form, asserting the ID is
+  # bare (not bracketed).
+  run grep -inE "Blocked by\*{0,2}:[[:space:]]*P[0-9]" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  # Assert the example does NOT use link syntax `[PNNN](./...)`.
+  ! grep -E "Blocked by\*{0,2}:[[:space:]]*\[P[0-9]" "$SKILL_FILE"
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Traceability: P076 cited
+# ──────────────────────────────────────────────────────────────────────────────
+
+@test "SKILL.md cites P076 in the transitive-dependencies prose (traceability)" {
+  # Every governance-contract change must cite the problem ticket that
+  # motivated it — audit trail per ADR-014.
+  run grep -n "P076" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+# ──────────────────────────────────────────────────────────────────────────────
+# Behavioural: exercise the transitive-closure rule with fixture tickets
+# ──────────────────────────────────────────────────────────────────────────────
+# These tests build a minimal fixture backlog and run a bash transcription
+# of the transitive-closure rule against it. The rule's executable form is
+# small enough to bash-implement; we assert the output matches the rule's
+# spec so a prose drift (e.g. accidentally documenting `min` instead of
+# `max`) would be caught at test time.
+
+# Bash transcription of the transitive-closure rule — effort map is
+# keyed by ticket ID, value is the integer divisor from the SKILL.md
+# effort table (S=1, M=2, L=4, XL=8).
+transitive_effort() {
+  local ticket="$1"
+  local backlog_dir="$2"
+  local file
+  file=$(ls "$backlog_dir"/${ticket}-*.md 2>/dev/null | head -1)
+  [ -z "$file" ] && { echo 0; return; }
+
+  # Extract marginal effort from the Effort line. The line shape matches
+  # the SKILL.md Priority/Effort convention: "**Effort**: <bucket> — ..."
+  local marginal_bucket
+  marginal_bucket=$(grep -oE '\*\*Effort\*\*: [SMLXL]+' "$file" | head -1 | grep -oE '[SMLXL]+' | head -1)
+  local marginal_divisor
+  case "$marginal_bucket" in
+    S) marginal_divisor=1 ;;
+    M) marginal_divisor=2 ;;
+    L) marginal_divisor=4 ;;
+    XL) marginal_divisor=8 ;;
+    *) marginal_divisor=2 ;;  # default M
+  esac
+
+  # .closed.md / .verifying.md / .parked.md upstreams contribute 0 (architect carve-out)
+  case "$file" in
+    *.closed.md|*.verifying.md|*.parked.md)
+      echo 0
+      return
+      ;;
+  esac
+
+  # Extract `Blocked by:` dependency IDs (bare, comma-separated).
+  # The template shape is `- **Blocked by**: P<NNN>, P<NNN>` (markdown
+  # list item under `## Dependencies`) — match the label with optional
+  # leading list marker.
+  local blocked_by_line
+  blocked_by_line=$(grep -E "^[[:space:]]*-?[[:space:]]*\*\*Blocked by\*\*:" "$file" | head -1 | sed 's/.*\*\*Blocked by\*\*://')
+  local max_upstream=0
+  local dep
+  for dep in $(echo "$blocked_by_line" | grep -oE 'P[0-9]+'); do
+    local upstream_effort
+    upstream_effort=$(transitive_effort "$dep" "$backlog_dir")
+    [ "$upstream_effort" -gt "$max_upstream" ] && max_upstream="$upstream_effort"
+  done
+
+  # Transitive = max(marginal, upstream closure)
+  if [ "$max_upstream" -gt "$marginal_divisor" ]; then
+    echo "$max_upstream"
+  else
+    echo "$marginal_divisor"
+  fi
+}
+
+@test "behavioural: dependent ticket inherits upstream XL when blocked by XL ticket (P076 worked example)" {
+  # Fixture: P200 (marginal S) Blocked by: P201 (XL)
+  # Expected: transitive effort for P200 = XL divisor = 8
+  cat > "$FIXTURE_DIR/P201-upstream-xl.open.md" <<'EOF'
+# Problem 201: upstream XL ticket
+**Status**: Open
+**Effort**: XL — multi-day cross-package work
+
+## Dependencies
+- **Blocked by**: (none)
+EOF
+  cat > "$FIXTURE_DIR/P200-dependent-small.open.md" <<'EOF'
+# Problem 200: dependent with small marginal effort
+**Status**: Open
+**Effort**: S — one-line surface add
+
+## Dependencies
+- **Blocked by**: P201
+EOF
+  result=$(transitive_effort "P200" "$FIXTURE_DIR")
+  [ "$result" = "8" ]
+}
+
+@test "behavioural: self-contained ticket keeps marginal effort (P076 no-op path)" {
+  # Fixture: P210 (marginal M) with empty Blocked by.
+  # Expected: transitive = marginal M divisor = 2.
+  cat > "$FIXTURE_DIR/P210-solo-m.open.md" <<'EOF'
+# Problem 210: self-contained
+**Status**: Open
+**Effort**: M — couple of files
+
+## Dependencies
+- **Blocked by**: (none)
+EOF
+  result=$(transitive_effort "P210" "$FIXTURE_DIR")
+  [ "$result" = "2" ]
+}
+
+@test "behavioural: closed upstream contributes 0 to the closure (architect carve-out)" {
+  # Fixture: P220 (marginal S) Blocked by: P221 (was XL, now closed).
+  # Expected: transitive = marginal S = 1 (closed upstream contributes 0;
+  # otherwise P220 would inherit XL forever).
+  cat > "$FIXTURE_DIR/P221-closed-xl.closed.md" <<'EOF'
+# Problem 221: closed upstream (was XL)
+**Status**: Closed
+**Effort**: XL
+EOF
+  cat > "$FIXTURE_DIR/P220-dependent-on-closed.open.md" <<'EOF'
+# Problem 220: dependent on closed
+**Status**: Open
+**Effort**: S
+
+## Dependencies
+- **Blocked by**: P221
+EOF
+  result=$(transitive_effort "P220" "$FIXTURE_DIR")
+  [ "$result" = "1" ]
+}
+
+@test "behavioural: marginal effort wins when upstream is smaller (P076 max-of semantics)" {
+  # Fixture: P230 (marginal L = 4) Blocked by: P231 (S = 1)
+  # Expected: transitive = max(L, S) = L divisor = 4.
+  # (Contrast: a buggy implementation using min or sum would produce 1 or 5.)
+  cat > "$FIXTURE_DIR/P231-small-upstream.open.md" <<'EOF'
+# Problem 231: small upstream
+**Status**: Open
+**Effort**: S
+EOF
+  cat > "$FIXTURE_DIR/P230-big-dependent.open.md" <<'EOF'
+# Problem 230: bigger dependent
+**Status**: Open
+**Effort**: L
+
+## Dependencies
+- **Blocked by**: P231
+EOF
+  result=$(transitive_effort "P230" "$FIXTURE_DIR")
+  [ "$result" = "4" ]
+}
+
+@test "behavioural: transitive propagates across two hops (P076 closure semantics)" {
+  # Fixture: P240 (S) → blocked by P241 (S) → blocked by P242 (XL)
+  # Expected: transitive(P240) = max(S, transitive(P241)) = max(S, max(S, XL)) = XL = 8.
+  cat > "$FIXTURE_DIR/P242-deepest-xl.open.md" <<'EOF'
+# Problem 242: deepest XL
+**Status**: Open
+**Effort**: XL
+EOF
+  cat > "$FIXTURE_DIR/P241-middle-s.open.md" <<'EOF'
+# Problem 241: middle S
+**Status**: Open
+**Effort**: S
+
+## Dependencies
+- **Blocked by**: P242
+EOF
+  cat > "$FIXTURE_DIR/P240-top-s.open.md" <<'EOF'
+# Problem 240: top S
+**Status**: Open
+**Effort**: S
+
+## Dependencies
+- **Blocked by**: P241
+EOF
+  result=$(transitive_effort "P240" "$FIXTURE_DIR")
+  [ "$result" = "8" ]
+}
+
+@test "behavioural: verification-pending upstream contributes 0 (architect carve-out for .verifying.md)" {
+  # Fixture: P250 (marginal S) Blocked by: P251 (was XL, now verifying).
+  # Expected: transitive = marginal S = 1 (verifying contributes 0 — the
+  # remaining work is user-side verification, not dev effort).
+  cat > "$FIXTURE_DIR/P251-verifying-xl.verifying.md" <<'EOF'
+# Problem 251: verification pending (was XL)
+**Status**: Verification Pending
+**Effort**: XL
+EOF
+  cat > "$FIXTURE_DIR/P250-dependent-on-verifying.open.md" <<'EOF'
+# Problem 250: dependent on verifying
+**Status**: Open
+**Effort**: S
+
+## Dependencies
+- **Blocked by**: P251
+EOF
+  result=$(transitive_effort "P250" "$FIXTURE_DIR")
+  [ "$result" = "1" ]
+}

package/skills/report-upstream/SKILL.md

@@ -1,6 +1,6 @@
 ---
 name: wr-itil:report-upstream
-description: Report a local problem ticket as a structured issue against an upstream repository, with bidirectional cross-references and SECURITY.md-aware routing for security-classified tickets. Implements the contract in ADR-024.
+description: Report a local problem ticket as a structured issue against an upstream repository, with bidirectional cross-references and SECURITY.md-aware routing for security-classified tickets. Implements the contract in ADR-024, with ADR-033 governing problem-first classifier + default body shape.
 allowed-tools: Read, Write, Edit, Bash, Glob, Grep, AskUserQuestion
 ---
 
@@ -10,6 +10,8 @@ File a local `docs/problems/<NNN>` ticket as an issue (or private security advis
 
 This skill implements the contract documented in [ADR-024](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) (Cross-project problem-reporting contract). All step numbering below maps 1:1 to ADR-024 Decision Outcome.
 
+[ADR-033](../../../docs/decisions/033-report-upstream-classifier-problem-first.proposed.md) (Report-upstream classifier is problem-first) partially supersedes ADR-024 Decision Outcome **Steps 3 and 5 only** — the classifier is problem-first with best-fit backward-compat fallback (per Step 3 below), and the structured default body is problem-shaped (per Step 5 below). ADR-024 Steps 1, 2, 4, 6, 7, 8 and all Consequences / Confirmation clauses remain in force unchanged.
+
 ## Invocation
 
 ```
@@ -77,18 +79,28 @@ For each `.yml` template found, fetch the file via `gh api repos/<owner>/<repo>/
 
 ### 3. Classify the local ticket and pick the best-matching template
 
-Heuristic:
-- Local ticket title contains `bug`, `defect`, `crash`, `error`, `fails to`, `broken`, `regression` → classify as `bug`.
-- Local ticket title contains `feature`, `add`, `support for`, `would be nice`, `enhancement` → classify as `feature`.
-- Local ticket title is a question → classify as `question`.
-- The CLI `--classification` argument overrides the heuristic.
+This step is governed by [ADR-033](../../../docs/decisions/033-report-upstream-classifier-problem-first.proposed.md) (Report-upstream classifier is problem-first), which partially supersedes ADR-024 Decision Outcome Step 3. Classification is **problem-first with best-fit backward-compat fallback** — upstream repos that have adopted the problem-first intake shape (per `@windyroad/itil`) are targeted first; older repos that still ship bug/feature/question templates are served via a fallback.
+
+**Preference order** (first match wins):
+
+1. **`problem` shape (primary)** — any of the tokens `problem`, `issue`, `concern`, `defect`, `gap` appear in the local ticket title or body; or the body contains a scoped-npm package reference (`@scope/name`); or the body contains any of `root cause`, `reproduction`, `workaround`. This is the default for tickets authored via `/wr-itil:manage-problem`.
+2. **`bug` shape (backward-compat fallback)** — no primary tokens match, and the prose is defect-like (contains `broken`, `fails`, `error`, `bug`, `regression`, or a specific observed-vs-expected contrast). Produces a bug-shaped body only when the upstream has no `problem-report.yml`.
+3. **`feature` shape (backward-compat fallback)** — no primary tokens match, and the prose is proposal-like (contains `would be nice`, `enhancement`, `feature request`, `could we`, `wish`).
+4. **`question` shape (backward-compat fallback)** — trailing fallback when the prose is a genuine question (ends in `?`, contains `how do I`, `is there a way`).
+
+The CLI `--classification` argument overrides the heuristic. The security-path check in Step 4 fires **before** this classifier — security-classified tickets bypass the classifier entirely.
+
+**Template-discovery preference order** (extends ADR-024 Step 1; search the upstream `.github/ISSUE_TEMPLATE/` directory in this order, first match wins):
 
-Pick the upstream template whose `name:` (or filename) most closely matches the classification:
-- For `bug`: prefer `bug-report.yml`, `bug.yml`, `bug-report.md`, `bug.md`.
-- For `feature`: prefer `feature-request.yml`, `feature.yml`, `feature-request.md`.
-- For `question`: prefer `question.yml`, `question.md`. If absent, the upstream's `config.yml` likely routes questions elsewhere (Discussions); halt and surface the routing target.
+1. `problem-report.yml` — preferred; the Windy-Road problem-first shape.
+2. `problem.yml` — alternate naming for problem-shaped templates.
+3. `problem-report.md` / `problem.md` — legacy markdown variants of the problem-shaped template.
+4. `bug-report.yml` / `bug.yml` / `bug-report.md` / `bug.md` — if primary classifier picked `bug` shape OR no problem template exists and fallback is `bug`.
+5. `feature-request.yml` / `feature.yml` / `feature-request.md` — `feature` shape fallback.
+6. `question.yml` / `question.md` — `question` shape fallback. If absent, the upstream's `config.yml` likely routes questions elsewhere (Discussions); halt and surface the routing target.
+7. Structured default body per Step 5 below — if no template matches.
 
-Log the matched template name in the Step 7 back-write. If no template matches the classification, fall through to the structured default in Step 5.
+Log the matched template name (or `structured default`) in the Step 7 back-write. If no template matches the classification, fall through to the structured default in Step 5.
 
 ### 4. Security-path routing check
 
@@ -102,19 +114,72 @@ If security-classified, route to Step 6. Otherwise, route to Step 5 (public-issu
 
 ### 5. Public-issue path
 
-If the upstream had a matching template (Step 3), fill its required fields from the local ticket:
+This step is governed by [ADR-033](../../../docs/decisions/033-report-upstream-classifier-problem-first.proposed.md) (Report-upstream classifier is problem-first), which partially supersedes ADR-024 Decision Outcome Step 5. The primary structured default body is **problem-shaped** and mirrors the `/wr-itil:manage-problem` ticket shape; the bug-shaped / feature-shaped / question-shaped bodies are retained as fallback-only templates for the backward-compat branches of the Step 3 classifier.
+
+If the upstream had a matching template (Step 3), fill its required fields from the local ticket. Field-mapping table for the problem-first case (problem-report.yml template):
 
 | Upstream template field (typical) | Local ticket source |
 |---|---|
-| `plugin` / `package` / `module` | Inferred from upstream repo name or local ticket's "Affected plugin" section |
+| `plugin` / `package` / `module` | Inferred from upstream repo name or local ticket's "Affected plugin / component" |
 | `version` | Local ticket's environment notes; or `npm view <pkg> version` for the latest if ambiguous |
 | `claude-code-version` | `claude --version` if the report originates from a Claude Code session |
 | `os` | Local ticket's environment notes; or `uname -srm` of the reporting host |
-| `reproduction` | Local ticket's `## Symptoms` section |
-| `expected` | Local ticket's "expected behaviour" line under `## Description` |
-| `actual` | Local ticket's "actual behaviour" line under `## Description` |
+| `description` | Local ticket's `## Description` section |
+| `symptoms` | Local ticket's `## Symptoms` section |
+| `workaround` | Local ticket's `## Workaround` section (or "None identified yet.") |
+| `frequency` | Local ticket's `## Impact Assessment` Frequency line |
+| `evidence` | Commit SHAs, test output, transcript excerpts from Investigation Tasks |
+
+For upstream repos whose matched template is `bug-report.yml` / `feature-request.yml` / `question.yml` (Step 3 backward-compat fallback), the skill fills the corresponding field set: `reproduction` ← `## Symptoms`; `expected` / `actual` ← observed-vs-expected contrast lines under `## Description`; `proposal` (for features) ← `## Description`.
+
+#### Structured default body — problem-shaped (primary, per ADR-033)
+
+Use this body when the Step 3 classifier picked `problem` shape AND the upstream has no `problem-report.yml` / `problem.yml` / `problem-report.md` / `problem.md`:
+
+```markdown
+## Description
+
+<one-paragraph synthesis of the local ticket's Description>
+
+## Symptoms
+
+<bullet list from local ticket's Symptoms>
+
+## Workaround
+
+<from local ticket's Workaround section; "None identified yet." if absent>
+
+## Affected plugin / component
+
+<inferred from the local ticket's Impact Assessment or inferred from context>
+
+## Frequency
+
+<from the local ticket's Impact Assessment "Frequency" line>
+
+## Environment
+
+- Package: <inferred from upstream repo>
+- Version: <detected via npm ls or local ticket's notes>
+- Claude Code version: <claude --version>
+- OS: <uname -srm>
+
+## Evidence
+
+<commit SHAs, test output, transcript excerpts — drawn from the local ticket's Investigation Tasks>
+
+## Cross-reference
+
+Reported from <downstream-repo-url>/<local-ticket-relative-path>
+
+This issue is tracked locally as P<NNN> in the downstream project's `docs/problems/` directory.
+```
+
+The body MUST include the `## Cross-reference` section so Step 7's back-write contract works (the downstream ticket's `## Reported Upstream` section records the upstream URL; the upstream issue body records the downstream reference).
 
-If no template matches, emit the **structured default** body:
+#### Structured default body — bug-shaped (fallback-only)
+
+Use this body only when the Step 3 classifier picked `bug` shape as backward-compat fallback (no primary `problem` tokens matched) AND the upstream has no matching template:
 
 ```markdown
 ## Summary
@@ -147,6 +212,50 @@ Reported from <downstream-repo-url>/<local-ticket-relative-path>
 This issue is tracked locally as P<NNN> in the downstream project's `docs/problems/` directory.
 ```
 
+#### Structured default body — feature-shaped (fallback-only)
+
+Use this body only when the Step 3 classifier picked `feature` shape as backward-compat fallback AND the upstream has no matching template:
+
+```markdown
+## Proposal
+
+<one-paragraph synthesis of the local ticket's Description>
+
+## Motivation
+
+<why this matters, from local ticket's Impact Assessment>
+
+## Alternatives considered
+
+<from local ticket's Root Cause Analysis or Candidate fix options>
+
+## Cross-reference
+
+Reported from <downstream-repo-url>/<local-ticket-relative-path>
+
+This issue is tracked locally as P<NNN> in the downstream project's `docs/problems/` directory.
+```
+
+#### Structured default body — question-shaped (fallback-only)
+
+Use this body only when the Step 3 classifier picked `question` shape as backward-compat fallback AND the upstream has no matching template (and no `config.yml` re-routing to Discussions):
+
+```markdown
+## Question
+
+<the question itself, from the local ticket's title or Description>
+
+## Context
+
+<what prompted the question, from local ticket's Description or Symptoms>
+
+## Cross-reference
+
+Reported from <downstream-repo-url>/<local-ticket-relative-path>
+
+This issue is tracked locally as P<NNN> in the downstream project's `docs/problems/` directory.
+```
+
 Open the issue:
 
 ```bash
@@ -236,13 +345,16 @@ Three distinct AFK branches per the architect review of ADR-024 + ADR-013 Rule 6
 
 ## References
 
-- [ADR-024](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) — primary contract this skill implements.
+- [ADR-024](../../../docs/decisions/024-cross-project-problem-reporting-contract.proposed.md) — primary contract this skill implements. Steps 1, 2, 4, 6, 7, 8 and all Consequences remain authoritative.
+- [ADR-033](../../../docs/decisions/033-report-upstream-classifier-problem-first.proposed.md) — partially supersedes ADR-024 Decision Outcome Steps 3 + 5; governs the problem-first classifier and problem-shaped structured default body.
 - [ADR-027](../../../docs/decisions/027-governance-skill-auto-delegation.proposed.md) — Step-0 deferral rationale (held for reassessment).
 - [ADR-028](../../../docs/decisions/028-voice-tone-gate-external-comms.proposed.md) — voice-tone gate on `gh issue create` and `gh api .../security-advisories`.
 - [ADR-013](../../../docs/decisions/013-structured-user-interaction-for-governance-decisions.proposed.md) — interaction policy; Rule 1 governs Step 6 missing-SECURITY.md `AskUserQuestion`; Rule 6 governs the commit-gate AFK branch.
 - [ADR-014](../../../docs/decisions/014-governance-skills-commit-their-own-work.proposed.md) — work → score → commit ordering.
 - [ADR-015](../../../docs/decisions/015-on-demand-assessment-skills.proposed.md) — fallback path for `wr-risk-scorer:assess-release`.
 - [P055](../../../docs/problems/055-no-standard-problem-reporting-channel.open.md) — upstream problem ticket (Part B).
+- **P066** — intake templates in this repo adopted the problem-first shape (must ship before P067 so the skill's preference order matches the reference shape).
+- **P067** — driver ticket for the problem-first classifier reform implemented via ADR-033.
 - `packages/itil/skills/manage-problem/SKILL.md` — names the optional `## Reported Upstream` section as an allowed appendage to a problem ticket.
 
 $ARGUMENTS

package/skills/report-upstream/test/report-upstream-contract.bats

@@ -73,3 +73,88 @@ setup() {
   run grep -F 'AFK behaviour summary' "$SKILL_MD"
   [ "$status" -eq 0 ]
 }
+
+# ─── ADR-033 problem-first classifier contract (P067) ──────────────────────────
+#
+# ADR-033 partially supersedes ADR-024 Decision Outcome Steps 3 + 5 with a
+# problem-first classifier and a problem-shaped structured default body. The
+# following assertions pin the SKILL.md to ADR-033's Confirmation clauses
+# (lines 157-164 of the ADR).
+
+@test "report-upstream: SKILL.md cross-references ADR-033 (ADR-033 Confirmation)" {
+  run grep -F 'ADR-033' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "report-upstream: SKILL.md Step 3 classifier lists problem-first tokens (ADR-033 Step 3)" {
+  # Primary classifier tokens per ADR-033: problem / issue / concern / defect / gap.
+  # All five must appear in the SKILL.md classifier narrative.
+  for token in problem issue concern defect gap; do
+    run grep -iE "\`${token}\`|\"${token}\"|'${token}'|${token} shape|${token}," "$SKILL_MD"
+    [ "$status" -eq 0 ] || {
+      echo "missing classifier token: $token"
+      return 1
+    }
+  done
+}
+
+@test "report-upstream: SKILL.md template-discovery cites problem-report.yml first (ADR-033 Step 3)" {
+  # Preference order: problem-report.yml / problem.yml BEFORE bug-report.yml.
+  run grep -n 'problem-report.yml' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+  problem_line=$(grep -n 'problem-report.yml' "$SKILL_MD" | head -1 | cut -d: -f1)
+  bug_line=$(grep -n 'bug-report.yml' "$SKILL_MD" | head -1 | cut -d: -f1)
+  [ -n "$problem_line" ] && [ -n "$bug_line" ]
+  [ "$problem_line" -lt "$bug_line" ]
+}
+
+@test "report-upstream: SKILL.md retains bug/feature/question fallbacks (ADR-033 Step 3 backward compat)" {
+  # Backward-compat fallbacks must still be documented for upstreams that
+  # have not adopted problem-first templates.
+  run grep -F 'bug-report.yml' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+  run grep -F 'feature-request.yml' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+  run grep -F 'question.yml' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "report-upstream: SKILL.md structured default uses problem-shaped section order (ADR-033 Step 5)" {
+  # Problem-shaped default body per ADR-033: Description -> Symptoms ->
+  # Workaround -> Affected plugin / component -> Frequency -> Environment
+  # -> Evidence -> Cross-reference. Assert section order in the primary
+  # default block.
+  desc_line=$(grep -n '^## Description$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  symptoms_line=$(grep -n '^## Symptoms$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  workaround_line=$(grep -n '^## Workaround$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  affected_line=$(grep -nE '^## Affected plugin' "$SKILL_MD" | head -1 | cut -d: -f1)
+  freq_line=$(grep -n '^## Frequency$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  env_line=$(grep -n '^## Environment$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  evidence_line=$(grep -n '^## Evidence$' "$SKILL_MD" | head -1 | cut -d: -f1)
+  xref_line=$(grep -n '^## Cross-reference$' "$SKILL_MD" | head -1 | cut -d: -f1)
+
+  [ -n "$desc_line" ] || { echo "missing ## Description"; return 1; }
+  [ -n "$symptoms_line" ] || { echo "missing ## Symptoms"; return 1; }
+  [ -n "$workaround_line" ] || { echo "missing ## Workaround"; return 1; }
+  [ -n "$affected_line" ] || { echo "missing ## Affected plugin / component"; return 1; }
+  [ -n "$freq_line" ] || { echo "missing ## Frequency"; return 1; }
+  [ -n "$env_line" ] || { echo "missing ## Environment"; return 1; }
+  [ -n "$evidence_line" ] || { echo "missing ## Evidence"; return 1; }
+  [ -n "$xref_line" ] || { echo "missing ## Cross-reference"; return 1; }
+
+  [ "$desc_line" -lt "$symptoms_line" ]
+  [ "$symptoms_line" -lt "$workaround_line" ]
+  [ "$workaround_line" -lt "$affected_line" ]
+  [ "$affected_line" -lt "$freq_line" ]
+  [ "$freq_line" -lt "$env_line" ]
+  [ "$env_line" -lt "$evidence_line" ]
+  [ "$evidence_line" -lt "$xref_line" ]
+}
+
+@test "report-upstream: SKILL.md cites ADR-033 as authority for Steps 3 + 5 (ADR-033 Confirmation)" {
+  # ADR-033 must be cited near the Step 3 / Step 5 headings, not only in the
+  # References section, so future maintainers see the authority inline.
+  run grep -niE 'adr-033|033.*problem-first' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+  [ "${#lines[@]}" -ge 2 ]
+}

package/skills/review-problems/SKILL.md

@@ -49,6 +49,18 @@ For each `docs/problems/*.open.md` and `docs/problems/*.known-error.md` file (sk
     - Re-stage explicitly per the P057 staging trap: `git add <new-path>` after the Edit.
     - This happens automatically — do not ask the user. The transition's fix-strategy is documented; only the shipping is outstanding.
 
+### 2.5. Dependency-graph traversal — propagate transitive effort (P076)
+
+After Step 2 assigns each ticket its **marginal** effort, run a second pass that walks the `## Dependencies` graph and propagates effort up per the transitive-dependency rule defined in `/wr-itil:manage-problem`'s WSJF Prioritisation section (the canonical location). This is a deterministic re-rate — no `AskUserQuestion` required.
+
+1. **Build the graph**: for each `.open.md` / `.known-error.md` ticket, parse the `## Dependencies` section. Record `**Blocked by**` edges (bare IDs) into an adjacency map. Ignore `**Composes with**` (does not propagate) and `**Blocks**` (derivable from inverse).
+2. **Classify upstream status**: upstreams in `.closed.md`, `.verifying.md`, or `.parked.md` contribute **0** to the closure (architect carve-out per P076). Upstreams in `.open.md` or `.known-error.md` contribute their own transitive effort.
+3. **Topologically sort** and compute `Effort_transitive = max(marginal, max{ upstream transitive })`. Cycle-bundle members all receive the bundle's effort = `max{ marginal | members }`.
+4. **Update Effort and WSJF lines** when the transitive effort differs from the marginal. Add a `<!-- transitive: <bucket> via <UPSTREAM> -->` HTML comment on the Effort line so the next review can distinguish a manually-set marginal from a propagated transitive.
+5. **Report each re-rate** in the review summary using the concrete format `P<NNN>: Effort <OLD> → <NEW> (transitive via <UPSTREAM>)`, e.g. `P073: Effort S → XL (transitive via P038)`. Cycle bundles surface a shared line: `Bundle [P038, P064]: effort XL (cycle), WSJF 3.0 (shared)`.
+
+Re-read the WSJF Prioritisation → "Transitive dependencies (P076)" subsection in `packages/itil/skills/manage-problem/SKILL.md` if unsure — that is the canonical rule definition.
+
 ### 3. Present the refreshed ranking
 
 After re-scoring, present three sections matching the README.md format (same rendering used by `/wr-itil:list-problems` and by the README cache — Step 5 writes the same layout):

package/skills/review-problems/test/review-problems-contract.bats

@@ -175,3 +175,33 @@ setup() {
   run grep -inE "If arguments start with|If arguments contain" "$SKILL_FILE"
   [ "$status" -ne 0 ]
 }
+
+@test "SKILL.md has a dependency-graph-traversal pass for transitive effort (P076)" {
+  # P076: review-problems is the executor for the WSJF transitive-effort
+  # rule. Step 2 assigns marginal effort; a second pass must walk
+  # `## Dependencies` edges and propagate effort per the canonical rule
+  # in /wr-itil:manage-problem's WSJF Prioritisation section. Without
+  # this pass, the marginal-only ranking mis-ranks dependent tickets
+  # above their blockers (the exact failure P076 documents).
+  run grep -inE "transitive[[:space:]]?effort|graph traversal|propagate.*effort|dependency[[:space:]-]?graph" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive-effort pass cites P076 and the canonical rule location (traceability)" {
+  # Audit trail: the Step 2.5 block must cite P076 (motivation) and
+  # point to /wr-itil:manage-problem's WSJF section as the canonical
+  # definition — duplication would fork the contract.
+  run grep -n "P076" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+  run grep -inE "manage-problem.*WSJF|WSJF.*manage-problem|canonical" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md transitive re-rate message format matches the canonical shape (P076)" {
+  # Architect correction 4: the re-rate message must be greppable and
+  # consistent across skills. Shape: `P<NNN>: Effort <OLD> → <NEW>
+  # (transitive via <UPSTREAM>)`. review-problems emits this in step 3's
+  # summary output so downstream audit tools can grep the review log.
+  run grep -inE "Effort.*→.*transitive via|transitive via.*P[0-9]" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}