@windyroad/itil 0.30.1 → 0.30.2-preview.317

package/.claude-plugin/plugin.json

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

package/hooks/hooks.json

@@ -28,6 +28,10 @@
         "matcher": "Bash",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/p057-staging-trap-detect.sh" }]
       },
+      {
+        "matcher": "Bash",
+        "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/itil-bash-polling-antipattern-detect.sh" }]
+      },
       {
         "matcher": "Bash",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/pre-publish-intake-gate.sh" }]

package/hooks/itil-bash-polling-antipattern-detect.sh

@@ -0,0 +1,92 @@
+#!/bin/bash
+# P232: PreToolUse:Bash hook — denies bash polling loops that
+# self-reference via `pgrep -f` (parent class) or `pkill -0`
+# (sibling) and deadlock in AFK iters when the polling loop's
+# own command line matches the search pattern.
+#
+# Detection shape: a loop construct (`until` / `while`, with or
+# without leading `!`) immediately followed by `pgrep` OR
+# `pkill -0`. One-shot `pgrep -f` (no surrounding loop) is allowed
+# — the polling-loop shape is the antipattern, not pgrep itself.
+#
+# Recovery: agents should `wait $bg_pid` (shell-native) for
+# backgrounded shell jobs OR use Bash-tool `run_in_background=true`
+# plus `BashOutput` polling for harness-tracked processes.
+#
+# Allow paths (exit 0 without deny):
+#   - tool_name != "Bash"          (only Bash invocations are gated)
+#   - empty command                (parse-incomplete fail-open)
+#   - command does not contain the polling-loop shape
+#   - parse failure on stdin       (mirrors create-gate.sh fail-open)
+#
+# References:
+#   ADR-005  — plugin testing strategy (hook bats live under hooks/test/).
+#   ADR-013  Rule 1 — deny redirects with mechanical recovery.
+#   ADR-038  — progressive disclosure / deny-message terseness budget.
+#   ADR-045  — hook injection budget; deny-path band 200-700 bytes.
+#   ADR-052  — behavioural tests default (positive + negative cases).
+#   P146     — parent class (bash until-loop polls bats output with
+#              bats-console-summary regex against TAP output).
+#   P232     — this hook; self-referential pgrep -f variant.
+#   p057-staging-trap-detect.sh — sibling PreToolUse:Bash detect
+#              hook; mirror the deny-message shape.
+
+INPUT=$(cat)
+
+TOOL_NAME=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('tool_name', ''))
+except:
+    print('')
+" 2>/dev/null || echo "")
+
+# Only gate Bash. Non-Bash tools bypass entirely.
+if [ "$TOOL_NAME" != "Bash" ]; then
+  exit 0
+fi
+
+COMMAND=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('tool_input', {}).get('command', ''))
+except:
+    print('')
+" 2>/dev/null || echo "")
+
+# Empty / missing command — fail-open per create-gate.sh precedent.
+if [ -z "$COMMAND" ]; then
+  exit 0
+fi
+
+# Polling-antipattern regex: a loop construct (`until` / `while`,
+# with or without leading `!`) immediately followed by `pgrep` OR
+# `pkill -0`. The `[[:space:]]+!?[[:space:]]*` middle covers
+# `until pgrep`, `until ! pgrep`, `until !pgrep`, and the same
+# shapes with `while`. The `pkill[[:space:]]+-0` half catches
+# the signal-0 polling sibling without false-matching real-signal
+# kills (`pkill -TERM`, `pkill -HUP`, etc.).
+POLLING_RE='(until|while)[[:space:]]+!?[[:space:]]*(pgrep|pkill[[:space:]]+-0)'
+
+if ! printf '%s' "$COMMAND" | grep -qE "$POLLING_RE"; then
+  exit 0
+fi
+
+# Antipattern detected — emit deny with terse recovery.
+# Voice-tone target ~245 bytes (sibling p057-staging-trap-detect.sh
+# precedent). Cites P232, names BOTH recovery alternatives, fits
+# inside ADR-045 deny-path 200-700 byte band.
+REASON="BLOCKED: P232 self-referential polling antipattern. \\\`pgrep -f\\\` / \\\`pkill -0\\\` inside until/while loop matches the loop's own command line and deadlocks in AFK iters. Use \\\`wait \\\$bg_pid\\\` (shell-native) OR Bash-tool BashOutput polling (run_in_background=true) instead."
+
+cat <<EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "${REASON}"
+  }
+}
+EOF
+exit 0

package/hooks/test/itil-bash-polling-antipattern-detect.bats

@@ -0,0 +1,154 @@
+#!/usr/bin/env bats
+
+# P232: itil-bash-polling-antipattern-detect.sh PreToolUse:Bash hook
+# must deny bash polling loops that self-reference via `pgrep -f`
+# (parent class) or `pkill -0` (sibling), advising `wait $bg_pid` or
+# Bash-tool `BashOutput` polling instead.
+#
+# Detection shape: a loop construct (`until` / `while`) combined with a
+# polling mechanism (`pgrep -f` / `pkill -0`). One-shot `pgrep -f` (no
+# surrounding loop) is allowed — the polling shape is the antipattern,
+# not pgrep itself.
+#
+# Per ADR-005 / ADR-052 — bats live under packages/<plugin>/hooks/test/
+# and assert behaviour on emitted JSON, not source-content. Per
+# feedback_behavioural_tests.md (P081) — no source-grep on hook text.
+
+setup() {
+  SCRIPT_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  HOOK="$SCRIPT_DIR/itil-bash-polling-antipattern-detect.sh"
+}
+
+# Helper: simulate the PreToolUse:Bash payload on stdin.
+# Uses python to build the JSON so we don't escape-hell with bash.
+run_bash_hook() {
+  local cmd="$1"
+  python3 -c "
+import json, sys
+print(json.dumps({'tool_name': 'Bash', 'tool_input': {'command': sys.argv[1]}}))
+" "$cmd" | bash "$HOOK"
+}
+
+# --- Antipattern detection: positive cases (deny) ---
+
+@test "deny: until ! pgrep -f loop" {
+  run run_bash_hook "until ! pgrep -f 'bats --recursive' > /dev/null 2>&1; do sleep 5; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+  [[ "$output" == *"P232"* ]]
+}
+
+@test "deny: while pgrep -f loop (positive form, no negation)" {
+  run run_bash_hook "while pgrep -f 'long-running-job'; do sleep 2; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+  [[ "$output" == *"P232"* ]]
+}
+
+@test "deny: until ! pkill -0 signal-0 poll" {
+  run run_bash_hook "until ! pkill -0 -f 'worker'; do sleep 3; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "deny: while pkill -0 signal-0 poll" {
+  run run_bash_hook "while pkill -0 12345; do sleep 1; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "deny: pgrep poll embedded in heredoc body" {
+  # Heredoc body lands in the same tool_input.command string.
+  run run_bash_hook "bash <<'EOF'
+until ! pgrep -f 'bats'; do sleep 5; done
+EOF"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "deny: P232 deadlock witness — multi-line shape with trailing tail" {
+  run run_bash_hook "until ! pgrep -f 'bats --recursive' > /dev/null 2>&1; do sleep 5; done; echo done; tail -30 /tmp/bats-out.log"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Allow paths: legitimate non-polling uses ---
+
+@test "allow: one-shot pgrep -f without surrounding loop" {
+  run run_bash_hook "pgrep -f 'nginx' && echo running"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: one-shot pkill (no -0, real signal — not a poll)" {
+  run run_bash_hook "pkill -TERM -f 'stale-worker'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: wait \$bg_pid (the canonical recovery shape)" {
+  run run_bash_hook "bats --recursive packages/itil/hooks/test/ & wait \$!"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: while loop without pgrep/pkill (unrelated)" {
+  run run_bash_hook "while read line; do echo \$line; done < input.txt"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: until loop without pgrep/pkill (unrelated)" {
+  run run_bash_hook "until [ -f /tmp/sentinel ]; do sleep 1; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: commit message text mentioning pgrep does not deny" {
+  # The literal pair is in the commit message body, not a poll shape.
+  # The hook should not over-match on commit prose.
+  run run_bash_hook "git commit -m 'document pgrep antipattern in P232'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Tool-name filters ---
+
+@test "allow: non-Bash tool exits 0 without deny" {
+  run bash -c "echo '{\"tool_name\":\"Edit\",\"tool_input\":{\"file_path\":\"foo.md\"}}' | bash $HOOK"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Parse / fail-open ---
+
+@test "allow: empty JSON fails open" {
+  run bash -c "echo '{}' | bash $HOOK"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: empty command field fails open" {
+  run bash -c "echo '{\"tool_name\":\"Bash\",\"tool_input\":{\"command\":\"\"}}' | bash $HOOK"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Deny message contract (ADR-038 progressive disclosure / ADR-045 budget) ---
+
+@test "deny message cites P232 + names BOTH recovery alternatives" {
+  run run_bash_hook "until ! pgrep -f 'bats'; do sleep 5; done"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"P232"* ]]
+  [[ "$output" == *"wait"* ]]
+  [[ "$output" == *"BashOutput"* ]]
+}
+
+@test "deny message stays under ADR-045 deny-path budget (<700 bytes)" {
+  # Voice-tone target ~245 bytes (sibling p057-staging-trap-detect.sh
+  # precedent). ADR-045 deny-path band hard cap at 700 bytes keeps the
+  # message terse — fail loudly if it bloats.
+  run run_bash_hook "until ! pgrep -f 'bats'; do sleep 5; done"
+  [ "$status" -eq 0 ]
+  [ "${#output}" -lt 700 ]
+}

package/lib/derive-first-dispatch.sh

@@ -0,0 +1,309 @@
+#!/usr/bin/env bash
+# Shared derive-first dispatch helper — canonical source-of-truth.
+#
+# P132 Phase 2a-iii-A extracted this helper from three declaration-skill
+# surfaces. Phase 2a-iii-B (2026-05-16) added wr-architect:create-adr as
+# the 4th adopter, which required moving the canonical source from
+# packages/itil/lib/ to packages/shared/ per ADR-017 (Shared code
+# duplicated into per-package lib/ kept in sync by script + CI drift
+# check). The per-package lib/ copies are byte-identical to this file:
+#
+#   - packages/itil/lib/derive-first-dispatch.sh        (sync target)
+#   - packages/architect/lib/derive-first-dispatch.sh   (sync target)
+#
+# Sync mechanism: scripts/sync-derive-first-dispatch.sh (mirrors the
+# sync-install-utils.sh pattern). CI guard: npm run check:derive-first-dispatch.
+# Drift test: packages/shared/test/sync-derive-first-dispatch.bats.
+#
+# Maintainer-side SKILL.md surfaces that source the helper:
+#   - packages/itil/skills/capture-problem/SKILL.md       Step 1.5
+#   - packages/itil/skills/manage-incident/SKILL.md       Step 4
+#   - packages/itil/skills/manage-problem/SKILL.md        Step 4
+#   - packages/architect/skills/create-adr/SKILL.md       Step 2     (P132 Phase 2a-iii-B)
+#
+# Each caller passes surface-specific signal definitions; this helper
+# centralises the dispatch mechanism: slug derivation, two-sided lexical
+# classifier, RISK-POLICY matrix lookup, and the I2-isomorphic stderr
+# advisory format.
+#
+# <!-- DERIVE-FIRST-DISPATCH-CONTRACT-SOURCE: P132 Phase 2a-iii-A + Phase 2a-iii-B -->
+# Drift in the stderr advisory format here re-opens P132 — any change MUST
+# update all four caller SKILL.md surfaces in the same commit.
+#
+# Usage (sourced):
+#   . packages/<pkg>/lib/derive-first-dispatch.sh   # callers source their own package's copy
+#
+# Exported functions:
+#   emit_stderr_advisory <skill> <field> <value> <source> [reversibility]
+#   derive_kebab_slug <description> [max_tokens=8]
+#   lexical_classify_two_sided <text> <side_a_patterns_var> <side_b_patterns_var>
+#   risk_policy_matrix_lookup <text> <impact_high> <impact_mod> <impact_low>
+#                                    <likelihood_high> <likelihood_med> <likelihood_low>
+#
+# @adr ADR-002 (Monorepo per-plugin packages — architecture context for ADR-017)
+# @adr ADR-017 (Shared code duplicated into per-package lib/ kept in sync)
+# @adr ADR-044 (Decision-Delegation Contract — derive-first framework boundary)
+# @adr ADR-026 (cost-source grounding — stderr advisory)
+# @adr ADR-013 Rule 5 (policy-authorised silent proceed)
+# @adr ADR-052 (behavioural-by-default — tested via scripts/test/derive-first-dispatch.bats
+#               and packages/shared/test/sync-derive-first-dispatch.bats)
+# @problem P132 (agents over-ask in interactive sessions — Phase 2a-iii-A shared helper +
+#                Phase 2a-iii-B 4th-adopter migration to packages/shared/)
+# @problem P185 (capture-problem Step 1.5 worked-example precedent)
+# @jtbd JTBD-001 (enforce governance without slowing down — primary)
+# @jtbd JTBD-101 (extend the suite with consistent patterns)
+#
+# NOT exporting `set -e` at file scope — callers source the helper and
+# expect functions that return AMBIGUOUS sentinels rather than errexit.
+
+# ---------------------------------------------------------------------------
+# emit_stderr_advisory — canonical I2-isomorphic stderr advisory format.
+#
+# Format: <skill>: derived <field>=<value> from <source>; <reversibility>
+#
+# This is the single source-of-truth for the advisory sentence shape
+# across all derive-first declaration-skill surfaces. The format is
+# load-bearing for cross-skill consistency — drift here re-opens P132.
+# ---------------------------------------------------------------------------
+emit_stderr_advisory() {
+  local skill="$1"
+  local field="$2"
+  local value="$3"
+  local source_desc="$4"
+  local reversibility="${5:-re-invoke or update if mis-rated}"
+  printf '%s: derived %s=%s from %s; %s\n' \
+    "$skill" "$field" "$value" "$source_desc" "$reversibility" >&2
+}
+
+# ---------------------------------------------------------------------------
+# derive_kebab_slug — kebab-case slug from prose.
+#
+# Lowercases, strips non-alphanumeric (preserves space and hyphen as
+# token separators), drops stopwords, joins surviving tokens with `-`,
+# caps the token count (default 8 per the SKILL.md surface contract).
+#
+# Used at:
+#   - capture-problem Step 1.4 Title derivation
+#   - manage-incident Step 4 Title derivation
+#   - manage-problem Step 4 Title derivation
+#   - create-adr Step 2 Title derivation (P132 Phase 2a-iii-B)
+# ---------------------------------------------------------------------------
+derive_kebab_slug() {
+  local description="$1"
+  local max_tokens="${2:-8}"
+  # Stopword list — common English function words plus "I/you/we" pronouns.
+  local stopwords='^(the|a|an|and|or|but|if|then|else|when|while|for|to|of|in|on|at|by|from|with|as|is|are|was|were|be|been|being|have|has|had|do|does|did|will|would|should|could|may|might|must|can|i|you|we|they|it|its|this|that|these|those|so|because|since|just|only|than|like|some|any|all|each|every|no|not)$'
+
+  printf '%s' "$description" \
+    | tr '[:upper:]' '[:lower:]' \
+    | tr -c 'a-z0-9 -' ' ' \
+    | tr -s ' ' \
+    | tr ' ' '\n' \
+    | grep -vE "$stopwords" \
+    | grep -v '^$' \
+    | head -n "$max_tokens" \
+    | paste -sd '-' -
+}
+
+# ---------------------------------------------------------------------------
+# lexical_classify_two_sided — two-sided binary lexical classifier.
+#
+# Used by capture-problem Step 1.5 Type classification (technical vs
+# user-business). Callers pass description text plus two regex pattern
+# arrays (by name); helper counts hits per side and echoes one of:
+#
+#   SIDE_A_UNAMBIGUOUS|<matched signals (comma-separated)>
+#     ≥1 side-A signal hit AND 0 side-B signals hit.
+#   SIDE_B_UNAMBIGUOUS|<matched signals (comma-separated)>
+#     0 side-A signals hit AND ≥1 side-B signal hit.
+#   AMBIGUOUS|<a=N b=N>
+#     Mixed (both sides matched) OR zero (neither side matched).
+#
+# Caller is responsible for:
+#   - Mapping SIDE_A/SIDE_B to its domain values (e.g. technical / user-business).
+#   - Calling emit_stderr_advisory on the unambiguous path.
+#   - Firing AskUserQuestion on the AMBIGUOUS path (ADR-044 category-5 taste fallback).
+# ---------------------------------------------------------------------------
+lexical_classify_two_sided() {
+  local description="$1"
+  local -n _side_a_patterns_ref="$2"
+  local -n _side_b_patterns_ref="$3"
+  local a_hits=()
+  local b_hits=()
+  local pattern
+
+  for pattern in "${_side_a_patterns_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pattern" 2>/dev/null; then
+      a_hits+=("$pattern")
+    fi
+  done
+  for pattern in "${_side_b_patterns_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pattern" 2>/dev/null; then
+      b_hits+=("$pattern")
+    fi
+  done
+
+  local a_count="${#a_hits[@]}"
+  local b_count="${#b_hits[@]}"
+
+  if (( a_count >= 1 && b_count == 0 )); then
+    local joined
+    joined=$(IFS=,; echo "${a_hits[*]}")
+    printf 'SIDE_A_UNAMBIGUOUS|%s\n' "$joined"
+  elif (( a_count == 0 && b_count >= 1 )); then
+    local joined
+    joined=$(IFS=,; echo "${b_hits[*]}")
+    printf 'SIDE_B_UNAMBIGUOUS|%s\n' "$joined"
+  else
+    printf 'AMBIGUOUS|a=%d b=%d\n' "$a_count" "$b_count"
+  fi
+}
+
+# ---------------------------------------------------------------------------
+# risk_policy_matrix_lookup — RISK-POLICY.md Impact × Likelihood lookup.
+#
+# Used by:
+#   - manage-incident Step 4 Severity derivation
+#   - manage-problem Step 4 Priority derivation
+#
+# Caller passes description text plus six regex pattern arrays (by
+# name) keyed by impact band (high/mod/low) and likelihood band
+# (high/med/low). Helper echoes one of:
+#
+#   <score>|<label>|impact=<L>+likelihood=<L>
+#     Single dominant impact band AND single dominant likelihood band
+#     matched. Score = impact_val * likelihood_val; label per
+#     RISK-POLICY.md § Label Bands (Very Low / Low / Medium / High /
+#     Very High).
+#   AMBIGUOUS|<reason>
+#     Multi-band hit (signals point to conflicting cells) OR zero hit
+#     (no mappable signal). Caller fires AskUserQuestion as the
+#     genuine ADR-044 category-5 (taste) fallback surface.
+#
+# Band-to-numeric mapping (preserves RISK-POLICY.md Impact / Likelihood
+# Levels table):
+#   impact:     high = 5 (Severe),     mod = 3 (Moderate), low = 1 (Negligible)
+#   likelihood: high = 5 (Almost certain), med = 3 (Possible), low = 1 (Rare)
+#
+# Label bands (RISK-POLICY.md):
+#   1-2   Very Low
+#   3-4   Low
+#   5-9   Medium
+#   10-16 High
+#   17-25 Very High
+#
+# This helper preserves the band-to-score mapping; callers that need a
+# wider granularity (e.g. Significant=4 / Minor=2) must extend the
+# pattern arrays' band-buckets in a follow-on contract change.
+# ---------------------------------------------------------------------------
+risk_policy_matrix_lookup() {
+  local description="$1"
+  local -n _impact_high_ref="$2"
+  local -n _impact_mod_ref="$3"
+  local -n _impact_low_ref="$4"
+  local -n _likelihood_high_ref="$5"
+  local -n _likelihood_med_ref="$6"
+  local -n _likelihood_low_ref="$7"
+
+  local pat
+  local impact_high_hits=0
+  local impact_mod_hits=0
+  local impact_low_hits=0
+  local likelihood_high_hits=0
+  local likelihood_med_hits=0
+  local likelihood_low_hits=0
+
+  for pat in "${_impact_high_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      impact_high_hits=$((impact_high_hits + 1))
+    fi
+  done
+  for pat in "${_impact_mod_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      impact_mod_hits=$((impact_mod_hits + 1))
+    fi
+  done
+  for pat in "${_impact_low_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      impact_low_hits=$((impact_low_hits + 1))
+    fi
+  done
+  for pat in "${_likelihood_high_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      likelihood_high_hits=$((likelihood_high_hits + 1))
+    fi
+  done
+  for pat in "${_likelihood_med_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      likelihood_med_hits=$((likelihood_med_hits + 1))
+    fi
+  done
+  for pat in "${_likelihood_low_ref[@]}"; do
+    if printf '%s' "$description" | grep -qiE "$pat" 2>/dev/null; then
+      likelihood_low_hits=$((likelihood_low_hits + 1))
+    fi
+  done
+
+  local nonzero_impact=0
+  (( impact_high_hits > 0 )) && nonzero_impact=$((nonzero_impact + 1))
+  (( impact_mod_hits > 0 )) && nonzero_impact=$((nonzero_impact + 1))
+  (( impact_low_hits > 0 )) && nonzero_impact=$((nonzero_impact + 1))
+
+  if (( nonzero_impact != 1 )); then
+    printf 'AMBIGUOUS|impact-bands-hit=%d\n' "$nonzero_impact"
+    return 0
+  fi
+
+  local impact_band=0
+  local impact_label=""
+  if (( impact_high_hits > 0 )); then
+    impact_band=5
+    impact_label="Severe"
+  elif (( impact_mod_hits > 0 )); then
+    impact_band=3
+    impact_label="Moderate"
+  elif (( impact_low_hits > 0 )); then
+    impact_band=1
+    impact_label="Negligible"
+  fi
+
+  local nonzero_likelihood=0
+  (( likelihood_high_hits > 0 )) && nonzero_likelihood=$((nonzero_likelihood + 1))
+  (( likelihood_med_hits > 0 )) && nonzero_likelihood=$((nonzero_likelihood + 1))
+  (( likelihood_low_hits > 0 )) && nonzero_likelihood=$((nonzero_likelihood + 1))
+
+  if (( nonzero_likelihood != 1 )); then
+    printf 'AMBIGUOUS|likelihood-bands-hit=%d\n' "$nonzero_likelihood"
+    return 0
+  fi
+
+  local likelihood_band=0
+  local likelihood_label=""
+  if (( likelihood_high_hits > 0 )); then
+    likelihood_band=5
+    likelihood_label="Almost-certain"
+  elif (( likelihood_med_hits > 0 )); then
+    likelihood_band=3
+    likelihood_label="Possible"
+  elif (( likelihood_low_hits > 0 )); then
+    likelihood_band=1
+    likelihood_label="Rare"
+  fi
+
+  local score=$((impact_band * likelihood_band))
+  local label
+  if (( score >= 17 )); then
+    label="Very High"
+  elif (( score >= 10 )); then
+    label="High"
+  elif (( score >= 5 )); then
+    label="Medium"
+  elif (( score >= 3 )); then
+    label="Low"
+  else
+    label="Very Low"
+  fi
+
+  printf '%d|%s|impact=%s+likelihood=%s\n' \
+    "$score" "$label" "$impact_label" "$likelihood_label"
+}

package/package.json

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

package/scripts/test/derive-first-dispatch.bats

@@ -0,0 +1,304 @@
+#!/usr/bin/env bats
+
+bats_require_minimum_version 1.5.0
+
+# Behavioural assertions for packages/itil/lib/derive-first-dispatch.sh —
+# the shared derive-first dispatch helper extracted in P132 Phase 2a-iii-A.
+#
+# The helper centralises the dispatch mechanism shipped across three
+# declaration-skill surfaces (capture-problem Step 1.5, manage-incident
+# Step 4, manage-problem Step 4). Each caller passes surface-specific
+# signal definitions; the helper owns:
+#
+#   - Slug derivation (Title) from prose
+#   - Two-sided lexical classifier (Type for capture-problem)
+#   - RISK-POLICY matrix lookup (Severity / Priority)
+#   - I2-isomorphic stderr advisory format
+#
+# @problem P132 (agents over-ask in interactive sessions — Phase 2a-iii-A
+#   shared helper extraction)
+# @problem P185 (capture-problem Step 1.5 worked-example precedent)
+# @adr ADR-044 (Decision-Delegation Contract — derive-first framework
+#   resolution boundary)
+# @adr ADR-026 (cost-source grounding — stderr advisory shape)
+# @adr ADR-052 (behavioural-by-default — these are runtime behaviour
+#   assertions on the helper functions, NOT structural greps)
+# @jtbd JTBD-001 (enforce governance without slowing down — primary)
+# @jtbd JTBD-101 (extend the suite with consistent patterns)
+
+setup() {
+  LIB_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/../../lib" && pwd)"
+  HELPER="${LIB_DIR}/derive-first-dispatch.sh"
+  [ -f "$HELPER" ]
+  # shellcheck disable=SC1090
+  source "$HELPER"
+  PKG_ROOT="$(cd "$(dirname "$BATS_TEST_FILENAME")/../.." && pwd)"
+  REPO_ROOT="$(cd "$(dirname "$BATS_TEST_FILENAME")/../../../.." && pwd)"
+  ARCHITECT_PKG_ROOT="$REPO_ROOT/packages/architect"
+}
+
+# ----------------------------------------------------------------------
+# Stderr advisory contract (I2-isomorphic format across all 3 surfaces).
+# Format: <skill>: derived <field>=<value> from <source>; <reversibility>
+# ----------------------------------------------------------------------
+
+@test "emit_stderr_advisory writes single canonical line to stderr" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    emit_stderr_advisory manage-problem title my-slug "description tokens" \
+      "re-invoke with the desired title or rename the file if the slug is wrong"
+  '
+  # stderr captured in $output via run; assert structure
+  [[ "$output" == *"manage-problem: derived title=my-slug from description tokens; re-invoke with the desired title"* ]]
+}
+
+@test "emit_stderr_advisory uses default reversibility clause when omitted" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    emit_stderr_advisory manage-incident severity "9 (Medium)" "RISK-POLICY matrix"
+  '
+  [[ "$output" == *"manage-incident: derived severity=9 (Medium) from RISK-POLICY matrix;"* ]]
+  [[ "$output" == *"re-invoke"* ]] || [[ "$output" == *"update"* ]]
+}
+
+@test "emit_stderr_advisory shape is I2-isomorphic across surfaces (same sentence structure)" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    emit_stderr_advisory capture-problem type technical "description signals" "re-invoke with --type=user-business to override"
+    emit_stderr_advisory manage-incident title incident-slug "description" "re-invoke or rename"
+    emit_stderr_advisory manage-problem priority "9 (Medium)" "RISK-POLICY matrix" "re-invoke or update if mis-rated"
+  '
+  # Each surface emits the same sentence shape: <skill>: derived <field>=<value> from <source>; <clause>
+  line_count=$(printf '%s\n' "$output" | grep -c "^[a-z-]*: derived ")
+  [ "$line_count" -eq 3 ]
+}
+
+# ----------------------------------------------------------------------
+# Kebab-case slug derivation from prose.
+# ----------------------------------------------------------------------
+
+@test "derive_kebab_slug produces kebab-case from prose" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    derive_kebab_slug "Agent over-asks during interactive sessions"
+  '
+  [[ "$output" == *"agent"* ]]
+  [[ "$output" == *"over"* ]] || [[ "$output" == *"asks"* ]]
+  [[ "$output" != *" "* ]]
+  [[ "$output" != *"_"* ]]
+}
+
+@test "derive_kebab_slug drops stopwords" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    derive_kebab_slug "The agent is asking the user a question"
+  '
+  # stopwords like "the", "a", "is" must NOT appear as standalone tokens
+  [[ "$output" != *"-the-"* ]]
+  [[ "$output" != "the-"* ]]
+  [[ "$output" == *"agent"* ]]
+}
+
+@test "derive_kebab_slug caps token count (default 8)" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    derive_kebab_slug "one two three four five six seven eight nine ten eleven twelve"
+  '
+  token_count=$(printf '%s\n' "$output" | tr '-' '\n' | wc -l | tr -d ' ')
+  [ "$token_count" -le 8 ]
+}
+
+@test "derive_kebab_slug accepts custom token count" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    derive_kebab_slug "alpha beta gamma delta epsilon zeta" 3
+  '
+  token_count=$(printf '%s\n' "$output" | tr '-' '\n' | wc -l | tr -d ' ')
+  [ "$token_count" -le 3 ]
+}
+
+# ----------------------------------------------------------------------
+# Two-sided lexical classifier (capture-problem Step 1.5 mechanism).
+# Returns:
+#   SIDE_A_UNAMBIGUOUS|<matched signals>  — ≥1 A hit AND 0 B hits
+#   SIDE_B_UNAMBIGUOUS|<matched signals>  — 0 A hits AND ≥1 B hit
+#   AMBIGUOUS|<reason>                    — mixed (both sides) OR zero
+# ----------------------------------------------------------------------
+
+@test "lexical_classify_two_sided returns SIDE_A_UNAMBIGUOUS on technical-only signals" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    side_a=("\\b(hook|gate|regex|stderr|stdout|drift|TTL|cache)\\b")
+    side_b=("\\b(adopter|UX|friction|JTBD-[0-9]+)\\b")
+    lexical_classify_two_sided "the hook fires on stderr and the cache invalidates" side_a side_b
+  '
+  [[ "$output" == "SIDE_A_UNAMBIGUOUS|"* ]]
+}
+
+@test "lexical_classify_two_sided returns SIDE_B_UNAMBIGUOUS on user-business-only signals" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    side_a=("\\b(hook|gate|regex|stderr|stdout|drift|TTL|cache)\\b")
+    side_b=("\\b(adopter|UX|friction|JTBD-[0-9]+)\\b")
+    lexical_classify_two_sided "the adopter friction makes JTBD-101 hard to complete" side_a side_b
+  '
+  [[ "$output" == "SIDE_B_UNAMBIGUOUS|"* ]]
+}
+
+@test "lexical_classify_two_sided returns AMBIGUOUS on mixed signals" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    side_a=("\\b(hook|gate|regex|stderr)\\b")
+    side_b=("\\b(adopter|UX|friction)\\b")
+    lexical_classify_two_sided "the hook causes adopter friction" side_a side_b
+  '
+  [[ "$output" == "AMBIGUOUS|"* ]]
+}
+
+@test "lexical_classify_two_sided returns AMBIGUOUS on zero signals" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    side_a=("\\b(hook|gate)\\b")
+    side_b=("\\b(adopter|UX)\\b")
+    lexical_classify_two_sided "totally bland text with no signals at all" side_a side_b
+  '
+  [[ "$output" == "AMBIGUOUS|"* ]]
+}
+
+# ----------------------------------------------------------------------
+# RISK-POLICY matrix lookup (manage-incident / manage-problem mechanism).
+# Returns:
+#   <score>|<label>|impact=<L>+likelihood=<L>  — clear single-cell match
+#   AMBIGUOUS|<reason>                        — multi-band or zero match
+# ----------------------------------------------------------------------
+
+@test "risk_policy_matrix_lookup returns clear cell on unambiguous impact + likelihood signals" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    impact_high=("\\b(down|outage|data loss|unavailable)\\b")
+    impact_mod=("\\b(slow|latency|degraded)\\b")
+    impact_low=("\\b(typo|cosmetic)\\b")
+    likelihood_high=("\\b(every request|reproducible|always)\\b")
+    likelihood_med=("\\b(intermittent|flaky)\\b")
+    likelihood_low=("\\b(one-off|single)\\b")
+    risk_policy_matrix_lookup "service is down on every request" impact_high impact_mod impact_low likelihood_high likelihood_med likelihood_low
+  '
+  # Expect impact=high(5) + likelihood=high(5) -> score=25, label=Very High
+  [[ "$output" == "25|"* ]] || [[ "$output" == "20|"* ]] || [[ "$output" == "15|"* ]]
+  [[ "$output" == *"High"* ]] || [[ "$output" == *"Very High"* ]]
+}
+
+@test "risk_policy_matrix_lookup returns AMBIGUOUS on multi-band impact" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    impact_high=("\\b(down)\\b")
+    impact_mod=("\\b(slow)\\b")
+    impact_low=("\\b(typo)\\b")
+    likelihood_high=("\\b(every request)\\b")
+    likelihood_med=("\\b(intermittent)\\b")
+    likelihood_low=("\\b(one-off)\\b")
+    risk_policy_matrix_lookup "service is down and slow with typo" impact_high impact_mod impact_low likelihood_high likelihood_med likelihood_low
+  '
+  [[ "$output" == "AMBIGUOUS|"* ]]
+}
+
+@test "risk_policy_matrix_lookup returns AMBIGUOUS when no signals match" {
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    impact_high=("\\b(down)\\b")
+    impact_mod=("\\b(slow)\\b")
+    impact_low=("\\b(typo)\\b")
+    likelihood_high=("\\b(every request)\\b")
+    likelihood_med=("\\b(intermittent)\\b")
+    likelihood_low=("\\b(one-off)\\b")
+    risk_policy_matrix_lookup "totally bland text" impact_high impact_mod impact_low likelihood_high likelihood_med likelihood_low
+  '
+  [[ "$output" == "AMBIGUOUS|"* ]]
+}
+
+@test "risk_policy_matrix_lookup label band aligns with RISK-POLICY.md (Medium = 5-9)" {
+  # Verify a specific clear-cell mapping produces the RISK-POLICY-canonical label.
+  # impact=mod (3) * likelihood=high (5) = 15 -> "High" band (10-16)
+  run -0 bash -c '
+    source "'"$HELPER"'"
+    impact_high=("\\b(down)\\b")
+    impact_mod=("\\b(slow)\\b")
+    impact_low=("\\b(typo)\\b")
+    likelihood_high=("\\b(every request)\\b")
+    likelihood_med=("\\b(intermittent)\\b")
+    likelihood_low=("\\b(one-off)\\b")
+    risk_policy_matrix_lookup "the service is slow on every request" impact_high impact_mod impact_low likelihood_high likelihood_med likelihood_low
+  '
+  [[ "$output" == "15|High|"* ]]
+}
+
+# ----------------------------------------------------------------------
+# Cross-skill consistency: all 4 SKILL.md surfaces reference the helper
+# as the shared dispatch mechanism. The I2-isomorphic stderr advisory
+# format is locked-in by reference to derive-first-dispatch.sh.
+#
+# Phase 2a-iii-B (2026-05-16): 4th adopter wr-architect:create-adr added.
+# Helper canonical source moved to packages/shared/ per ADR-017 sync
+# pattern; per-package lib/ copies in packages/itil/lib/ and
+# packages/architect/lib/ stay byte-identical via scripts/sync-derive-first-dispatch.sh.
+# ----------------------------------------------------------------------
+
+@test "capture-problem Step 1.5 cross-references derive-first-dispatch.sh helper" {
+  run grep -c "derive-first-dispatch\\.sh\\|packages/itil/lib/derive-first-dispatch" \
+    "${PKG_ROOT}/skills/capture-problem/SKILL.md"
+  [ "$status" -eq 0 ]
+  [ "$output" -ge 1 ]
+}
+
+@test "manage-incident Step 4 cross-references derive-first-dispatch.sh helper" {
+  run grep -c "derive-first-dispatch\\.sh\\|packages/itil/lib/derive-first-dispatch" \
+    "${PKG_ROOT}/skills/manage-incident/SKILL.md"
+  [ "$status" -eq 0 ]
+  [ "$output" -ge 1 ]
+}
+
+@test "manage-problem Step 4 cross-references derive-first-dispatch.sh helper" {
+  run grep -c "derive-first-dispatch\\.sh\\|packages/itil/lib/derive-first-dispatch" \
+    "${PKG_ROOT}/skills/manage-problem/SKILL.md"
+  [ "$status" -eq 0 ]
+  [ "$output" -ge 1 ]
+}
+
+@test "create-adr Step 2 cross-references derive-first-dispatch.sh helper (Phase 2a-iii-B 4th adopter)" {
+  # The 4th adopter (architect package) sources from its own per-package
+  # lib/ copy (NOT cross-package from itil) per ADR-017.
+  run grep -c "derive-first-dispatch\\.sh\\|packages/architect/lib/derive-first-dispatch" \
+    "${ARCHITECT_PKG_ROOT}/skills/create-adr/SKILL.md"
+  [ "$status" -eq 0 ]
+  [ "$output" -ge 1 ]
+}
+
+@test "helper file documents its four caller surfaces (audit trail)" {
+  # The helper's header comment must name the four SKILL.md surfaces it
+  # serves so the audit trail is recoverable from the helper itself.
+  # Phase 2a-iii-B adds create-adr as the 4th adopter.
+  run grep -E "capture-problem" "$HELPER"
+  [ "$status" -eq 0 ]
+  run grep -E "manage-incident" "$HELPER"
+  [ "$status" -eq 0 ]
+  run grep -E "manage-problem" "$HELPER"
+  [ "$status" -eq 0 ]
+  run grep -E "create-adr" "$HELPER"
+  [ "$status" -eq 0 ]
+}
+
+@test "per-package lib/ copies are byte-identical to canonical packages/shared/ source (ADR-017)" {
+  # Phase 2a-iii-B + ADR-017: canonical at packages/shared/, synced copies
+  # in per-package lib/. The sync script (scripts/sync-derive-first-dispatch.sh)
+  # in --check mode is the CI guard; this test asserts the post-condition.
+  local shared_src="${REPO_ROOT}/packages/shared/derive-first-dispatch.sh"
+  local itil_copy="${REPO_ROOT}/packages/itil/lib/derive-first-dispatch.sh"
+  local architect_copy="${REPO_ROOT}/packages/architect/lib/derive-first-dispatch.sh"
+  [ -f "$shared_src" ]
+  [ -f "$itil_copy" ]
+  [ -f "$architect_copy" ]
+  run diff -q "$shared_src" "$itil_copy"
+  [ "$status" -eq 0 ]
+  run diff -q "$shared_src" "$architect_copy"
+  [ "$status" -eq 0 ]
+}

package/skills/capture-problem/SKILL.md

@@ -75,6 +75,8 @@ Derive a kebab-case title slug from the first 8-10 non-stopword tokens of the de
 
 ### 1.5 Type classification (derive-first; silent-framework per ADR-044 category 4; taste fallback per category 5 on ambiguity)
 
+**Shared dispatch helper**: this surface invokes `packages/itil/lib/derive-first-dispatch.sh` for the canonical lexical-classifier mechanism + I2-isomorphic stderr advisory format. The helper is sourced by `/wr-itil:capture-problem`, `/wr-itil:manage-incident`, and `/wr-itil:manage-problem`; drift in the advisory shape re-opens P132. Surface-specific signal definitions (technical-vs-user-business regex lists) stay inline below — the helper owns the mechanism, not the per-surface signals (architect verdict 2026-05-15 P132 Phase 2a-iii-A: "Helper must preserve per-surface signal definitions; only the dispatch mechanism is shared").
+
 Resolve `type_value` ∈ {`technical`, `user-business`} per the following framework-mediated dispatch. **The dispatch order is load-bearing** — pre-resolution flags short-circuit BEFORE the classifier runs, and the AskUserQuestion fires ONLY on genuinely-ambiguous descriptions.
 
 1. **If `--type=<value>` was set in Step 1**: use that value; do NOT run the classifier; do NOT fire AskUserQuestion (silent-proceed per ADR-013 Rule 5).
@@ -101,13 +103,13 @@ Resolve `type_value` ∈ {`technical`, `user-business`} per the following framew
      - `technical` — *"Bug, defect, broken behaviour, framework drift — root cause sits in code or process."*
      - `user-business` — *"Missing capability, UX gap, adopter friction, JTBD-shaped need — root cause sits in unmet user need."*
 
-   **Stderr advisory contract** (silent-classification path only): emit a SINGLE line to stderr (NOT stdout, NOT in the ticket body) of the form:
+   **Stderr advisory contract** (silent-classification path only): emit a SINGLE line to stderr (NOT stdout, NOT in the ticket body) via the shared helper's `emit_stderr_advisory` function in `packages/itil/lib/derive-first-dispatch.sh`. The canonical format produced by the helper:
 
    ```
-   capture-problem: classified type=<value> from description signals: <signal1>, <signal2>[, ...]; re-invoke with --type=<other-value> to override
+   capture-problem: derived type=<value> from description signals: <signal1>, <signal2>[, ...]; re-invoke with --type=<other-value> to override
    ```
 
-   The advisory text shape is I2-isomorphic — the sentence structure (`classified type=<value> from description signals: ...; re-invoke with --type=<other-value> to override`) is identical regardless of which type was classified; only the substituted `<value>` / `<other-value>` / `<signal*>` tokens differ. Embedding the advisory in stdout would risk machine-readers parsing it as a ticket-body line; embedding it in the ticket body would violate ADR-060's frontmatter / body-bullet schema. Stderr is the correct channel — visible to interactive maintainers in the terminal; invisible to ticket consumers; loggable by AFK orchestrators that capture subprocess stderr.
+   The advisory text shape is I2-isomorphic — same sentence structure (`<skill>: derived <field>=<value> from <source>; <reversibility>`) across all three derive-first declaration-skill surfaces. The helper is the single source-of-truth for this format; drift here re-opens P132. Embedding the advisory in stdout would risk machine-readers parsing it as a ticket-body line; embedding it in the ticket body would violate ADR-060's frontmatter / body-bullet schema. Stderr is the correct channel — visible to interactive maintainers in the terminal; invisible to ticket consumers; loggable by AFK orchestrators that capture subprocess stderr.
 
 **I2 invariant guard (ADR-060 line 98)**: the resolved `type_value` is used at Step 4 ONLY as a substituted string in the skeleton template's `**Type**:` body field. Steps 2, 3, 4 (other than the `**Type**:` substitution), 5, 6, 7 execute identically regardless of `type_value`. The skill carries NO control-flow branch keyed on `type` — that would convert classification into a workflow split and violate I2. The lexical-signal classifier is UPSTREAM of the value's substitution (it resolves WHICH value to substitute, not WHICH workflow to execute); the substitution and all downstream steps remain uniform. Pure-bash supporting-script enforcement of this invariant lives in `packages/itil/scripts/test/i2-no-type-branching.bats`; the SKILL.md surface coverage gap is named at P176 (descendant of P012 master harness).
 

package/skills/capture-problem/test/capture-problem.bats

@@ -459,12 +459,17 @@ classify_description() {
 # I2 leak through the back door.
 # ---------------------------------------------------------------------------
 
-# Mirror of the SKILL.md advisory template.
+# Mirror of the SKILL.md advisory template. P132 Phase 2a-iii-A renamed
+# the verb from `classified` to `derived` to align with the shared helper
+# `packages/itil/lib/derive-first-dispatch.sh`'s emit_stderr_advisory
+# function — I2-isomorphic format `<skill>: derived <field>=<value> from
+# <source>; <reversibility>` across all three derive-first declaration-skill
+# surfaces.
 format_stderr_advisory() {
   local resolved_type="$1"
   local other_type="$2"
   local signals="$3"
-  printf 'capture-problem: classified type=%s from description signals: %s; re-invoke with --type=%s to override\n' \
+  printf 'capture-problem: derived type=%s from description signals: %s; re-invoke with --type=%s to override\n' \
     "$resolved_type" "$signals" "$other_type"
 }
 
@@ -492,14 +497,17 @@ strip_substituted_tokens() {
 }
 
 @test "P185: stderr advisory does NOT prefix with type-value when describing the contract" {
-  # The shape `classified type=<value> from description signals: <list>;
+  # The shape `derived type=<value> from description signals: <list>;
   # re-invoke with --type=<other> to override` — the leading prose
-  # "capture-problem: classified type=" must be identical regardless of
-  # type value (substitution happens AFTER the equals sign).
+  # "capture-problem: derived type=" must be identical regardless of
+  # type value (substitution happens AFTER the equals sign). P132 Phase
+  # 2a-iii-A renamed `classified` -> `derived` to align with the shared
+  # helper `packages/itil/lib/derive-first-dispatch.sh`'s I2-isomorphic
+  # format across all three declaration-skill surfaces.
   tech_msg=$(format_stderr_advisory technical user-business "sig")
   ub_msg=$(format_stderr_advisory user-business technical "sig")
-  echo "$tech_msg" | grep -q '^capture-problem: classified type='
-  echo "$ub_msg" | grep -q '^capture-problem: classified type='
+  echo "$tech_msg" | grep -q '^capture-problem: derived type='
+  echo "$ub_msg" | grep -q '^capture-problem: derived type='
 }
 
 # ---------------------------------------------------------------------------

package/skills/manage-incident/SKILL.md

@@ -154,6 +154,8 @@ echo "$next"
 
 ### 4. For new incidents: Gather information (P132 derive-first; ADR-044 category-4 silent-framework on derivable fields; category-1 direction-setting fallback only on Scope)
 
+**Shared dispatch helper**: this surface invokes `packages/itil/lib/derive-first-dispatch.sh` for the canonical slug derivation (Title), RISK-POLICY matrix lookup (Severity), and I2-isomorphic stderr advisory format. The helper is sourced by `/wr-itil:capture-problem`, `/wr-itil:manage-incident`, and `/wr-itil:manage-problem`; drift in the advisory shape re-opens P132. Surface-specific signal definitions (severity impact / likelihood regex lists, start-time evidence sources) stay inline below — the helper owns the mechanism, not the per-surface signals (architect verdict 2026-05-15 P132 Phase 2a-iii-A: "Helper must preserve per-surface signal definitions; only the dispatch mechanism is shared").
+
 **Derive-first dispatch.** Incident declarations carry observable evidence in the user's prose, the working tree, `RISK-POLICY.md`, and the wall-clock — the framework can resolve most fields without firing `AskUserQuestion`. Only **Scope** is genuinely user-judgment (semantic blast-radius the framework cannot infer); only **Scope** retains the AskUserQuestion gate.
 
 The P132 inverse-P078 trap (`docs/problems/known-error/132-...md`) is the load-bearing motivation: the I001 declaration regression fired a 4-question AskUserQuestion with 3 of 4 sub-questions being lazy classifications (Title kebab-derivable, Severity matrix-derivable, Start time git-log-derivable). This dispatch closes that regression on the manage-incident surface and mirrors `/wr-itil:capture-problem` Step 1.5's worked-example pattern (P185 derive-first refactor).

package/skills/manage-problem/SKILL.md

@@ -376,6 +376,8 @@ If the local choice would have collided with an origin ticket created since the
 
 ### 4. For new problems: Gather information (P132 derive-first; ADR-044 category-4 silent-framework on derivable fields; category-1 direction-setting fallback only on Description)
 
+**Shared dispatch helper**: this surface invokes `packages/itil/lib/derive-first-dispatch.sh` for the canonical slug derivation (Title), RISK-POLICY matrix lookup (Priority), and I2-isomorphic stderr advisory format. The helper is sourced by `/wr-itil:capture-problem`, `/wr-itil:manage-incident`, and `/wr-itil:manage-problem`; drift in the advisory shape re-opens P132. Surface-specific signal definitions (priority impact / likelihood regex lists) stay inline below — the helper owns the mechanism, not the per-surface signals (architect verdict 2026-05-15 P132 Phase 2a-iii-A: "Helper must preserve per-surface signal definitions; only the dispatch mechanism is shared").
+
 **Derive-first dispatch.** Problem-declaration inputs carry observable evidence in the user's prose, the working tree, `RISK-POLICY.md`, and the wall-clock — the framework can resolve most fields without firing `AskUserQuestion`. Only **Description** is genuinely user-knowledge (without prose there is literally nothing to capture); only **Description** retains the AskUserQuestion gate.
 
 The P132 inverse-P078 trap (`docs/problems/known-error/132-...md`) is the load-bearing motivation. The 2026-05-06 I001 declaration regression cited in P132 fired a 4-question AskUserQuestion with 3 of 4 sub-questions being lazy classifications (Title kebab-derivable, Severity matrix-derivable, Start time git-log-derivable). manage-problem Step 4 is the second declaration-skill surface under Phase 2a (after manage-incident Step 4 in commit b7cc645) to ship the derive-first dispatch. The pattern is isomorphic across `/wr-itil:capture-problem` Step 1.5 (P185 worked example), `/wr-itil:manage-incident` Step 4, and this skill.

package/skills/work-problems/SKILL.md

@@ -371,7 +371,7 @@ rm -f "$ITER_JSON"
 
 1. **Context**: this is one iteration of the AFK work-problems loop. The user is AFK. The orchestrator selected `P<NNN> (<title>)` as the highest-WSJF actionable ticket.
 2. **Task**: apply the `/wr-itil:manage-problem` workflow for `work highest WSJF problem that can be progressed non-interactively as the user is AFK`. Follow manage-problem SKILL.md verbatim, including architect / jtbd / style-guide / voice-tone gate reviews and the commit gate (manage-problem Step 11). Because this subprocess has the Agent tool in its own surface, the normal review-via-subagent paths work — no inline-verdict fallback needed.
-3. **Constraints**: commit the completed work per ADR-014. Do NOT push, do NOT run `push:watch`, do NOT run `release:watch` — the orchestrator's Step 6.5 owns release cadence. Do NOT invoke `capture-*` background skills (AFK carve-out — ADR-032). Do NOT use `ScheduleWakeup` under any circumstance (P083 — iteration workers must not self-reschedule). **NEVER call `AskUserQuestion` mid-loop in AFK** (P135 / ADR-044): direction / deviation-approval / one-time-override / silent-framework observations queue at `ITERATION_SUMMARY.outstanding_questions` for loop-end batched presentation. Per-iter `AskUserQuestion` calls are sub-contracting framework-resolved decisions back to the user (lazy deferral per Step 2d Ask Hygiene Pass classification). Non-interactive defaults apply per ADR-013 Rule 6 + ADR-044's framework-resolution boundary. **Treat the user as transient** (P130): even when observably present at orchestrator dispatch time, the user may answer one question and disappear for hours; presence is not a reliable signal and is not the goal. The iter's job is to progress the ticket and accumulate questions for batched surfacing — not to ask "is it OK to proceed?" at a mechanical-stage boundary. **Do NOT poll `bats` output with a bats-console-summary regex against TAP-format output** (P146 — bash until-loop-deadlock antipattern). The bats-console-summary line `<N> tests, <M> failures` is emitted ONLY by bats's *default* (non-TAP) formatter; `bats --tap` does not emit a console summary, so a polling loop of shape `until [ -f $OUT ] && grep -qE '^[0-9]+ tests?,' $OUT; do sleep 5; done` spins forever after bats completes (silent deadlock — no error, no exit; recovery requires manual SIGTERM with metadata loss per the P146/P147 stuck-before-emit subclass). When you need to wait on a backgrounded bats run, prefer `wait $bg_pid` (Unix idiom — completion signaled by process exit, no regex required) or, for the Bash tool, `run_in_background=true` + `BashOutput` polling on the tool's exit-state field rather than regex-poll on stdout. If you genuinely must regex-poll TAP output, anchor on the TAP plan line `^[0-9]+\.\.[0-9]+` (e.g. `1..1455`) — TAP's plan line is emitted on completion and is format-stable across bats versions; the bats-console-summary line is not. The console-summary vs TAP-format divergence is the load-bearing detail: `bats` and `bats --tap` produce structurally different stdout, and the antipattern assumes the former when iter dispatch typically uses the latter.
+3. **Constraints**: commit the completed work per ADR-014. Do NOT push, do NOT run `push:watch`, do NOT run `release:watch` — the orchestrator's Step 6.5 owns release cadence. Do NOT invoke `capture-*` background skills (AFK carve-out — ADR-032). Do NOT use `ScheduleWakeup` under any circumstance (P083 — iteration workers must not self-reschedule). **NEVER call `AskUserQuestion` mid-loop in AFK** (P135 / ADR-044): direction / deviation-approval / one-time-override / silent-framework observations queue at `ITERATION_SUMMARY.outstanding_questions` for loop-end batched presentation. Per-iter `AskUserQuestion` calls are sub-contracting framework-resolved decisions back to the user (lazy deferral per Step 2d Ask Hygiene Pass classification). Non-interactive defaults apply per ADR-013 Rule 6 + ADR-044's framework-resolution boundary. **Treat the user as transient** (P130): even when observably present at orchestrator dispatch time, the user may answer one question and disappear for hours; presence is not a reliable signal and is not the goal. The iter's job is to progress the ticket and accumulate questions for batched surfacing — not to ask "is it OK to proceed?" at a mechanical-stage boundary. **Do NOT poll `bats` output with a bats-console-summary regex against TAP-format output** (P146 — bash until-loop-deadlock antipattern). The bats-console-summary line `<N> tests, <M> failures` is emitted ONLY by bats's *default* (non-TAP) formatter; `bats --tap` does not emit a console summary, so a polling loop of shape `until [ -f $OUT ] && grep -qE '^[0-9]+ tests?,' $OUT; do sleep 5; done` spins forever after bats completes (silent deadlock — no error, no exit; recovery requires manual SIGTERM with metadata loss per the P146/P147 stuck-before-emit subclass). When you need to wait on a backgrounded bats run, prefer `wait $bg_pid` (Unix idiom — completion signaled by process exit, no regex required) or, for the Bash tool, `run_in_background=true` + `BashOutput` polling on the tool's exit-state field rather than regex-poll on stdout. If you genuinely must regex-poll TAP output, anchor on the TAP plan line `^[0-9]+\.\.[0-9]+` (e.g. `1..1455`) — TAP's plan line is emitted on completion and is format-stable across bats versions; the bats-console-summary line is not. The console-summary vs TAP-format divergence is the load-bearing detail: `bats` and `bats --tap` produce structurally different stdout, and the antipattern assumes the former when iter dispatch typically uses the latter. **Do NOT poll subprocess completion with `pgrep -f '<pattern>'` inside an `until` / `while` loop** (P232 — self-referential pgrep deadlock; sibling variant of P146). `pgrep -f` matches against the FULL command line of every running process, so the polling loop's own `zsh -c` argument (which contains the literal `pgrep -f '<pattern>'` text) matches itself; with multiple concurrent polling loops, each loop matches the others and spins forever. Worked example of the antipattern: `until ! pgrep -f 'bats --recursive' > /dev/null 2>&1; do sleep 5; done` — the 2026-05-16 P232 deadlock witness; 4 concurrent polling loops each matched the others' command lines while no actual bats process ran; 45 min wall-clock + $20-30 wasted before manual SIGTERM. The same self-reference shape applies to `while pgrep -f ...; do sleep; done` and to `until ! pkill -0 -f '<pattern>'` / `while pkill -0 -f '<pattern>'` (signal-0 polling). The structural fix is the same as P146: prefer `wait $bg_pid` (Unix idiom — shell-native completion signal, no regex / no pgrep) or Bash-tool `run_in_background=true` + `BashOutput` polling (harness-tracked completion state). The hook `packages/itil/hooks/itil-bash-polling-antipattern-detect.sh` denies these shapes at PreToolUse:Bash, but the prompt rule belongs here too — structural enforcement + prompt discipline together close the class.
 4. **Retro-on-exit (P086)**: before emitting `ITERATION_SUMMARY`, invoke `/wr-retrospective:run-retro`. Retro runs INSIDE this subprocess so its Step 2b pipeline-instability scan has access to the iteration's rich tool-call history (hook misbehaviour, repeat-workaround patterns, subagent-delegation friction, release-path instability). Retro may create tickets or update `docs/BRIEFING.md` — run-retro commits its own work per ADR-014; any tickets it creates ride into either the iteration's own commit (if retro runs before the main commit) or a retro-owned follow-up commit, and the orchestrator picks them up on the next Step 1 scan. Proceed to `ITERATION_SUMMARY` emission regardless of retro findings — retro is non-blocking (do not block on retro): if retro fails or surfaces findings, the iteration still returns a summary so the AFK loop does not silently halt on a flaky retro run.
 5. **Output**: end the final message with the `ITERATION_SUMMARY` block defined below — this is how the orchestrator consumes the iteration's result.
 
@@ -775,6 +775,7 @@ When every skipped ticket is in the `upstream-blocked` category (stop-condition
 
 - **P121** (`docs/problems/121-afk-orchestrator-should-sigterm-stuck-subprocesses-after-idle-timeout.verifying.md`) — driver for Step 5's backgrounded-poll-loop dispatch shape (replacing the prior foreground-synchronous form) and the idle-timeout SIGTERM branch. The 2026-04-25 P118 iter 5 evidence: an iteration subprocess sat idle ~70 min after its final commit, then SIGTERM produced a clean JSON exit-flush. Fix: orchestrator backgrounds the subprocess, polls every 60s, computes `LAST_ACTIVITY_MARK = max(DISPATCH_START_EPOCH, git log -1 --format=%at HEAD)`, and sends SIGTERM when `now - LAST_ACTIVITY_MARK > WORK_PROBLEMS_IDLE_TIMEOUT_S` (default 3600s = 60 min). Behavioural second-source: `test/work-problems-step-5-idle-timeout-sigterm.bats` exercises a fake `claude -p` shim that sleeps past the threshold and asserts SIGTERM, JSON exit-flush, env-var override, and within-threshold no-fire. Step 6's per-iter progress line SHOULD annotate `(SIGTERM_SENT)` when the branch fires so users can distinguish recovered iters from natural completions. ADR-032's subprocess-boundary variant amended 2026-04-26 with the backgrounded-poll-loop refinement.
 - **P146** (`docs/problems/146-afk-iteration-subprocess-bash-until-loop-polls-bats-output-with-bats-console-regex-against-tap-format.verifying.md`) — driver for Step 5 iteration prompt body's bats-output-polling-discipline clause. The 2026-04-29 incident (iter 1, PID 23580 child PID 16408) saw a `bash until`-loop poll a backgrounded bats output file with regex `^[0-9]+ tests?,` (bats's *default* console-summary format) against `bats --tap` output that never emits that line — silent infinite spin after bats completed; manual SIGTERM at 68m34s wall-clock; metadata loss per the P147 stuck-before-emit subclass. The polling idiom is NOT taught by any SKILL.md (audit confirmed via repo grep) — it is agent-learned from training data. Fix: prompt-discipline rule in the iteration prompt body's Constraints list explicitly forbidding the antipattern, naming `wait $bg_pid` (or Bash-tool `run_in_background=true` + `BashOutput`) as the safe substitute, and citing the TAP-vs-console-summary divergence so future contributors don't "fix" the rule incorrectly. Behavioural second-source: `test/work-problems-step-5-bats-polling-discipline.bats` asserts the prohibition phrase, the safe-substitute pointer, the P146 cite, the divergence explanation, and the Related-section cite.
+- **P232** (`docs/problems/verifying/232-bash-until-loop-pgrep-self-referential-deadlock-new-variant-of-p146.md`) — sibling variant of P146; driver for the second clause in Step 5 iter prompt's polling-discipline rule plus the structural PreToolUse:Bash hook at `packages/itil/hooks/itil-bash-polling-antipattern-detect.sh`. The 2026-05-16 incident (iter 4, P132 Phase 2a-iii-B) saw 4 concurrent `until ! pgrep -f 'bats --recursive'` polling loops each match the OTHER loops' command lines and spin forever after the main commit landed; 45 min wall-clock + $20-30 wasted before manual SIGTERM. Two-layer fix: prompt-discipline clause naming the self-reference failure mode with worked-example syntax (`until ! pgrep -f ...`), PLUS PreToolUse:Bash hook denying `(until|while)[[:space:]]+!?[[:space:]]*(pgrep|pkill[[:space:]]+-0)` shapes with a deny message citing P232 and naming both recovery alternatives (`wait $bg_pid` shell-native, Bash-tool `BashOutput` harness-native). Behavioural second-source: `packages/itil/hooks/test/itil-bash-polling-antipattern-detect.bats` (positive cases — until/while pgrep, until/while pkill -0, heredoc; negative cases — one-shot pgrep, non-`-0` pkill, unrelated until/while, `wait $!`; advisory-message content cite). P146 prompt-only enforcement failed empirically in iter 4 of the very loop that ships it; P232 closes the class with structural enforcement.
 - **P147** (`docs/problems/147-p121-sigterm-clean-flush-guarantee-conditional-needs-skill-md-caveat-for-stuck-before-emit-subclass.verifying.md`) — refinement to P121's "clean exit-flush" claim. P118's evidence held only for subprocesses that had already emitted `ITERATION_SUMMARY` before going idle; the 2026-04-29 P146 incident produced exit 143 + 0-byte JSON when SIGTERM fired before `ITERATION_SUMMARY` emission. Fix: SKILL.md prose now carries the conditional caveat (Step 5 "SIGTERM exit-flush is conditional, not universal" subsection) and adopters reading the prose are directed to treat exit 143 + 0-byte JSON as a metadata-loss event — verify work integrity from `git log` + `git status --porcelain`, halt the AFK loop, and reconstruct cost from the Anthropic billing dashboard. Behavioural second-source extends `test/work-problems-step-5-idle-timeout-sigterm.bats` with a stuck-before-emit fake-shim asserting `JSON_BYTES=0` after SIGTERM. Mechanism unchanged (SIGTERM remains the right recovery primitive); the refinement is documentation accuracy + the metadata-loss-event handling shape.
 - **P089** (`docs/problems/089-work-problems-step-5-dispatch-robustness-stdin-warning-and-cost-metadata-edge-case.verifying.md`) — driver for Step 5's `< /dev/null` dispatch redirect and the Per-iteration cost metadata "Authority hierarchy" paragraph. Gap 1: stdin warning contaminated stderr-merged JSON captures; closed by adding `< /dev/null` to the canonical dispatch command. Gap 2: `.usage.*` undercounts when subprocess exits via a background-task completion ack while `.total_cost_usd` stays cumulative-authoritative; closed by documenting the authority hierarchy in Step 5 and the Session Cost output section so adopters trust cost and label token totals best-effort.
 - **P086** (`docs/problems/086-afk-iteration-subprocess-does-not-run-retro-before-returning.verifying.md`) — driver for Step 5's retro-on-exit clause. Iteration subprocesses exit without running retro, so per-iteration friction (hook misbehaviour, repeat-workaround patterns, pipeline instability) evaporates on exit. Fix: iteration prompt body names `/wr-retrospective:run-retro` as a closing step before `ITERATION_SUMMARY` emission; retro runs inside the subprocess so Step 2b pipeline-instability scan has the full tool-call history; run-retro commits its own work per ADR-014; orchestrator picks up retro-created tickets on the next Step 1 scan.