@windyroad/itil 0.40.0-preview.479 → 0.41.0-preview.484

package/.claude-plugin/plugin.json

@@ -484,5 +484,5 @@
     }
   },
   "name": "wr-itil",
-  "version": "0.40.0"
+  "version": "0.41.0"
 }

package/package.json

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

package/scripts/evaluate-relevance.sh

@@ -2,49 +2,46 @@
 # packages/itil/scripts/evaluate-relevance.sh
 #
 # Evaluate whether a problem ticket has become "no longer relevant" by
-# checking observable evidence per ADR-026 grounding. Phase 1 scope per
-# ADR-079: ONE evidence shape — "file no longer exists in codebase" —
-# closest analog to P334/P336 close-on-evidence.
+# checking observable evidence per ADR-026 grounding. Implements 5
+# evidence shapes per ADR-079 (Phase 1 + Phase 2):
+#
+#   Shape 1 — file-no-longer-exists  (Phase 1, original)
+#   Shape 2 — ADR-shipped with `human-oversight: confirmed`  (Phase 2)
+#   Shape 3 — named-skill-or-feature-exists  (Phase 2)
+#   Shape 4 — self-marker-in-body (line-anchored)  (Phase 2)
+#   Shape 5 — driver-child-ticket-closed  (Phase 2)
+#
+# Phase 1 false-positive fixes (Phase 2):
+#   - state-suffix detection (P180): per-state subdirs + .<state>.md
+#   - sibling-file detection (P244): dir-glob slug-prefix
+#   - rename detection (P251): git log --follow --diff-filter=AD
 #
 # Usage:
 #   evaluate-relevance.sh <ticket-file> [<min-age-days>]
 #
-# Default <min-age-days> is 7. Age gate is a GATING condition, not the
-# closing condition (per user direction 2026-05-31: "not just because
-# they are old").
-#
-# Algorithm:
-#   1. Read **Reported**: YYYY-MM-DD from the ticket frontmatter.
-#      If absent or unparseable → SKIP no-reported-date.
-#   2. If today - Reported < min-age-days → SKIP too-fresh.
-#   3. Extract file-path candidates from the ticket body matching
-#      (packages|docs|.changeset|src|test|scripts)/<path>.<known-extension>
-#      then drop self-references (docs/problems/*).
-#   4. If no candidates remain → SKIP no-extractable-paths.
-#   5. For each candidate, run `git ls-files --error-unmatch <path>`.
-#      Count present vs missing.
-#   6. If ALL candidates missing AND at least 1 was extracted →
-#      CLOSE-CANDIDATE. Otherwise → KEEP.
+# Default <min-age-days> is 7. Age gate is a GATING condition per user
+# direction 2026-05-31 "not just because they are old".
 #
 # Output (stdout, one line):
-#   CLOSE-CANDIDATE <basename> — all <N> file paths absent: <semicolon list>
-#   KEEP            <basename> — <M>/<N> paths still present
-#   SKIP            <basename> — <reason>
+#   CLOSE-CANDIDATE <basename> — shapes: <comma-list> — <per-shape cite>; ...
+#   CLOSE-CANDIDATE-WITH-CAVEAT <basename> — shapes: <list> — caveat: <tag>: <one-line>
+#   KEEP-WITH-NOTE <basename> — <note>: <evidence>
+#   KEEP <basename> — <M>/<N> paths still present
+#   SKIP <basename> — <reason>
 #
 # Exit codes:
-#   0 = CLOSE-CANDIDATE (close action recommended)
-#   1 = KEEP (no action)
-#   2 = SKIP (no action; gating condition or unparseable)
-#   3 = error (ticket file not found / git not available)
+#   0 = CLOSE-CANDIDATE or CLOSE-CANDIDATE-WITH-CAVEAT
+#   1 = KEEP or KEEP-WITH-NOTE
+#   2 = SKIP
+#   3 = error
 #
 # Set LC_ALL=C for portable byte-grep per P328 (BSD grep on macOS
 # silently misbehaves on UTF-8 without an explicit locale).
 #
-# ADR-049: never source repo-relative `packages/...` paths from a SKILL.
-# This script is invoked via the `wr-itil-evaluate-relevance` PATH shim.
-# ADR-026: every CLOSE-CANDIDATE verdict cites the paths checked AND
-# the verdict is reversible (`git mv` back if a rename was missed).
-# ADR-052: behavioural bats coverage at scripts/test/evaluate-relevance.bats.
+# ADR-049: invoked via the `wr-itil-evaluate-relevance` PATH shim.
+# ADR-026: every CLOSE-CANDIDATE verdict cites the evidence per shape.
+# ADR-052: behavioural bats at scripts/test/evaluate-relevance.bats.
+# ADR-079: design (Phase 1 + Phase 2).
 
 set -euo pipefail
 export LC_ALL=C
@@ -72,64 +69,462 @@ if [ -z "$reported" ]; then
   exit 2
 fi
 
-# Portable date arithmetic: compute cutoff date min_age_days ago as
-# YYYY-MM-DD, then ISO string-compare. Works on both BSD (macOS) and
-# GNU date.
 cutoff=$(date -u -v-"${min_age_days}"d "+%Y-%m-%d" 2>/dev/null || date -u -d "${min_age_days} days ago" "+%Y-%m-%d" 2>/dev/null || true)
 if [ -z "$cutoff" ]; then
   echo "SKIP $basename — could not compute cutoff date (date binary missing both BSD and GNU forms)"
   exit 2
 fi
 
-# ISO strings sort lexicographically. If reported > cutoff, the ticket
-# is younger than min_age_days → skip.
 if [ "$reported" \> "$cutoff" ]; then
   echo "SKIP $basename — age gate (reported=$reported newer than cutoff=$cutoff, gate=${min_age_days}d)"
   exit 2
 fi
 
-# ── Path extraction ─────────────────────────────────────────────────────────
+# ── Helpers ─────────────────────────────────────────────────────────────────
+
+# Check whether <path> is tracked by git (`git ls-files --error-unmatch`).
+# Falls back to filesystem check when not in a git repo or when the file
+# is staged-but-untracked-by-HEAD. Returns 0 if present.
+path_exists() {
+  local p="$1"
+  if git ls-files --error-unmatch "$p" >/dev/null 2>&1; then
+    return 0
+  fi
+  if [ -e "$p" ]; then
+    return 0
+  fi
+  return 1
+}
+
+# Detect state-suffix variants of an incident/problem/RFC path (P180 fix).
+# Given a path like `docs/incidents/I002-foo.investigating.md`, also checks
+# `docs/incidents/I002-foo.{restored,mitigating,closed}.md`. Returns 0 if
+# any sibling state-suffix variant exists.
+state_suffix_variant_exists() {
+  local p="$1"
+  local dir base ext
+  dir=$(dirname "$p")
+  base=$(basename "$p")
+  # Strip trailing .<state>.md to a slug-prefix and recombine with each
+  # state. Conservative — only fires for paths in docs/incidents/,
+  # docs/problems/, docs/rfcs/, docs/stories/, docs/story-maps/ where the
+  # state-suffix convention applies (ADR-031 / ADR-060).
+  case "$dir" in
+    docs/incidents|docs/problems|docs/problems/*|docs/rfcs|docs/rfcs/*|docs/stories|docs/stories/*|docs/story-maps|docs/story-maps/*)
+      ;;
+    *)
+      return 1
+      ;;
+  esac
+  # Strip <state>.md suffix
+  local slug
+  slug=$(echo "$base" | sed -E 's/\.(open|known-error|verifying|closed|parked|investigating|mitigating|restored|draft|accepted|in-progress|done|archived|proposed|superseded)\.md$//')
+  if [ "$slug" = "$base" ]; then
+    return 1
+  fi
+  # Also try the per-state subdir layout (RFC-002 migration window).
+  local parent
+  parent=$(dirname "$dir")
+  local entity
+  entity=$(basename "$dir")
+  for state in open known-error verifying closed parked investigating mitigating restored draft accepted in-progress done archived proposed superseded; do
+    if [ -f "$dir/$slug.$state.md" ] && [ "$dir/$slug.$state.md" != "$p" ]; then
+      echo "$dir/$slug.$state.md"
+      return 0
+    fi
+    # Per-state subdir form: docs/problems/<state>/<slug>.md
+    case "$dir" in
+      docs/incidents|docs/problems|docs/rfcs|docs/stories|docs/story-maps)
+        if [ -f "$dir/$state/$slug.md" ]; then
+          echo "$dir/$state/$slug.md"
+          return 0
+        fi
+        ;;
+      docs/problems/*|docs/rfcs/*|docs/stories/*|docs/story-maps/*|docs/incidents/*)
+        if [ -f "$parent/$state/$slug.md" ]; then
+          echo "$parent/$state/$slug.md"
+          return 0
+        fi
+        ;;
+    esac
+  done
+  return 1
+}
+
+# Detect sibling files with similar slug-prefix in the same parent dir
+# (P244 fix). Given `packages/foo/scripts/bar-list.sh`, finds
+# `packages/foo/scripts/bar-render.sh` / `bar-populate.sh` etc.
+# Returns 0 (and echoes the matched sibling) if a sibling exists.
+sibling_file_exists() {
+  local p="$1"
+  local dir base ext stem prefix
+  dir=$(dirname "$p")
+  base=$(basename "$p")
+  ext="${base##*.}"
+  stem="${base%.*}"
+  # slug-prefix = first 2 dash-separated tokens (e.g. "plugin-maturity")
+  # for "plugin-maturity-list" we take "plugin-maturity"; for "foo-bar"
+  # we take "foo". Conservative — too-short prefixes (single token) skip.
+  prefix=$(echo "$stem" | cut -d- -f1-2)
+  if [ "$prefix" = "$stem" ]; then
+    # Single-token stem — no sibling-pattern to detect.
+    return 1
+  fi
+  # Require at least 2 dash-separated tokens AND a multi-char first token
+  local token_count
+  token_count=$(echo "$stem" | tr '-' '\n' | wc -l | tr -d ' ')
+  if [ "$token_count" -lt 2 ]; then
+    return 1
+  fi
+  if [ ! -d "$dir" ]; then
+    return 1
+  fi
+  local sibling
+  # Use ls/find to enumerate; nullglob via shell would expand to literal
+  # if no matches. Use find for portability.
+  while IFS= read -r sibling; do
+    [ -z "$sibling" ] && continue
+    if [ "$sibling" = "$p" ]; then
+      continue
+    fi
+    if [ -f "$sibling" ]; then
+      echo "$sibling"
+      return 0
+    fi
+  done < <(find "$dir" -maxdepth 1 -type f -name "$prefix-*.$ext" 2>/dev/null)
+  return 1
+}
+
+# Detect rename via git log --follow (P251 fix). Returns 0 (and echoes the
+# detected new name) if the file was renamed away from <path>.
+rename_detected() {
+  local p="$1"
+  local log
+  log=$(git log --follow --diff-filter=AD --name-only --pretty=format: -- "$p" 2>/dev/null | grep -v '^$' || true)
+  if [ -z "$log" ]; then
+    return 1
+  fi
+  # If the most recent name is different from the queried path, it was renamed.
+  local most_recent
+  most_recent=$(echo "$log" | head -1)
+  if [ -n "$most_recent" ] && [ "$most_recent" != "$p" ]; then
+    if [ -f "$most_recent" ] || git ls-files --error-unmatch "$most_recent" >/dev/null 2>&1; then
+      echo "$most_recent"
+      return 0
+    fi
+  fi
+  return 1
+}
+
+# ── Shape detection ─────────────────────────────────────────────────────────
+
+shapes=""
+cites=""
+caveat_tag=""
+caveat_msg=""
+keep_with_note=""
+
+# Append a shape to the cumulative shape list + emit per-shape cite.
+record_shape() {
+  local shape="$1" cite="$2"
+  if [ -z "$shapes" ]; then
+    shapes="$shape"
+    cites="$cite"
+  else
+    case ",$shapes," in
+      *",$shape,"*) return 0 ;;  # already recorded
+    esac
+    shapes="$shapes,$shape"
+    cites="$cites; $cite"
+  fi
+}
+
+# Shape 1 — file-no-longer-exists (Phase 1 original).
+# Extracts candidate paths, drops self-refs, runs path_exists per
+# candidate. Detects state-suffix / sibling-file / rename to avoid Phase 1
+# false-positives (P180/P244/P251); on detection routes to KEEP-WITH-NOTE.
 
-# Regex restricts candidates to well-known repo subdirs with known
-# file extensions. Tight on purpose — false-positive-resistant.
-# Extension list mirrors the file types typically referenced in
-# problem-ticket bodies (markdown, shell scripts, source, configs).
 candidates=$(grep -oE '(packages|docs|\.changeset|src|test|scripts)/[A-Za-z0-9._/-]+\.(md|sh|ts|tsx|js|jsx|json|yml|yaml|bats|py|txt|html)' "$ticket_file" 2>/dev/null \
   | sort -u \
   | grep -v '^docs/problems/' \
   || true)
 
-if [ -z "$candidates" ]; then
-  echo "SKIP $basename — no extractable file paths (after self-reference exclusion)"
-  exit 2
+shape1_missing=0
+shape1_present=0
+shape1_missing_list=""
+
+if [ -n "$candidates" ]; then
+  while IFS= read -r path; do
+    [ -z "$path" ] && continue
+    if path_exists "$path"; then
+      shape1_present=$((shape1_present + 1))
+    else
+      # Phase 1 false-positive fixes — check state-suffix / sibling-file
+      # / rename BEFORE counting as missing.
+      variant=$(state_suffix_variant_exists "$path" 2>/dev/null || true)
+      if [ -n "$variant" ]; then
+        keep_with_note="state-suffix variant exists: $variant"
+        break
+      fi
+      sibling=$(sibling_file_exists "$path" 2>/dev/null || true)
+      if [ -n "$sibling" ]; then
+        keep_with_note="sibling file with similar slug-prefix exists: $sibling"
+        break
+      fi
+      renamed=$(rename_detected "$path" 2>/dev/null || true)
+      if [ -n "$renamed" ]; then
+        keep_with_note="renamed (git log --follow): $path → $renamed"
+        break
+      fi
+      shape1_missing=$((shape1_missing + 1))
+      if [ -z "$shape1_missing_list" ]; then
+        shape1_missing_list="$path"
+      else
+        shape1_missing_list="$shape1_missing_list;$path"
+      fi
+    fi
+  done <<< "$candidates"
 fi
 
-# ── Existence check via git ls-files ────────────────────────────────────────
+# Shape 1 fires only when ALL extracted candidates are absent AND at
+# least one was extracted.
+if [ -z "$keep_with_note" ] && [ -n "$candidates" ] && [ "$shape1_missing" -ge 1 ] && [ "$shape1_present" -eq 0 ]; then
+  shape1_total=$shape1_missing
+  record_shape "file-no-longer-exists" "all ${shape1_total} file paths absent: ${shape1_missing_list}"
+fi
 
-missing=0
-present=0
-missing_list=""
+# Shape 2 — ADR-shipped with `human-oversight: confirmed`.
+# grep ticket body for ADR-NNN; for each, check docs/decisions/<NNN>-*.md
+# exists AND frontmatter contains `human-oversight: confirmed`.
 
-while IFS= read -r path; do
-  [ -z "$path" ] && continue
-  if git ls-files --error-unmatch "$path" >/dev/null 2>&1; then
-    present=$((present + 1))
-  else
-    missing=$((missing + 1))
-    if [ -z "$missing_list" ]; then
-      missing_list="$path"
+adr_refs=$(grep -oE '\bADR-[0-9]{3}\b' "$ticket_file" 2>/dev/null | sort -u || true)
+shape2_confirmed=""
+if [ -n "$adr_refs" ]; then
+  while IFS= read -r adr; do
+    [ -z "$adr" ] && continue
+    num="${adr#ADR-}"
+    # Find any docs/decisions/<num>-*.md (any state suffix).
+    while IFS= read -r adr_file; do
+      [ -z "$adr_file" ] && continue
+      if grep -qE '^human-oversight: confirmed' "$adr_file" 2>/dev/null; then
+        if [ -z "$shape2_confirmed" ]; then
+          shape2_confirmed="$adr ($adr_file)"
+        else
+          shape2_confirmed="$shape2_confirmed, $adr ($adr_file)"
+        fi
+        break
+      fi
+    done < <(find docs/decisions -maxdepth 1 -type f -name "${num}-*.md" 2>/dev/null)
+  done <<< "$adr_refs"
+fi
+if [ -n "$shape2_confirmed" ]; then
+  record_shape "ADR-shipped-confirmed" "ADRs human-oversight-confirmed: ${shape2_confirmed}"
+fi
+
+# Shape 3 — named-skill-or-feature-exists.
+# Detects SKILL.md / hook / agent / slash-command surfaces that exist.
+
+shape3_hits=""
+
+# (a) SKILL.md paths.
+while IFS= read -r skill_path; do
+  [ -z "$skill_path" ] && continue
+  if path_exists "$skill_path"; then
+    if [ -z "$shape3_hits" ]; then
+      shape3_hits="$skill_path"
     else
-      missing_list="$missing_list;$path"
+      shape3_hits="$shape3_hits; $skill_path"
     fi
   fi
-done <<< "$candidates"
+done < <(grep -oE 'packages/[A-Za-z0-9_-]+/skills/[A-Za-z0-9_-]+/SKILL\.md' "$ticket_file" 2>/dev/null | sort -u || true)
 
-total=$((missing + present))
+# (b) Hook paths.
+while IFS= read -r hook_path; do
+  [ -z "$hook_path" ] && continue
+  if path_exists "$hook_path"; then
+    if [ -z "$shape3_hits" ]; then
+      shape3_hits="$hook_path"
+    else
+      shape3_hits="$shape3_hits; $hook_path"
+    fi
+  fi
+done < <(grep -oE 'packages/[A-Za-z0-9_-]+/hooks/[A-Za-z0-9._-]+\.sh' "$ticket_file" 2>/dev/null | sort -u || true)
 
-if [ "$missing" -eq "$total" ] && [ "$missing" -ge 1 ]; then
-  echo "CLOSE-CANDIDATE $basename — all ${total} file paths absent: ${missing_list}"
+# (c) Agent paths.
+while IFS= read -r agent_path; do
+  [ -z "$agent_path" ] && continue
+  if path_exists "$agent_path"; then
+    if [ -z "$shape3_hits" ]; then
+      shape3_hits="$agent_path"
+    else
+      shape3_hits="$shape3_hits; $agent_path"
+    fi
+  fi
+done < <(grep -oE 'packages/[A-Za-z0-9_-]+/agents/[A-Za-z0-9._-]+\.md' "$ticket_file" 2>/dev/null | sort -u || true)
+
+# (d) Slash-command refs — resolve to packages/<plugin>/skills/<skill>/SKILL.md
+while IFS= read -r slash; do
+  [ -z "$slash" ] && continue
+  plugin=$(echo "$slash" | sed -E 's|/wr-([a-z0-9-]+):.*|\1|')
+  skill=$(echo "$slash" | sed -E 's|/wr-[a-z0-9-]+:([a-z0-9-]+).*|\1|')
+  candidate="packages/$plugin/skills/$skill/SKILL.md"
+  if path_exists "$candidate"; then
+    if [ -z "$shape3_hits" ]; then
+      shape3_hits="$slash → $candidate"
+    else
+      shape3_hits="$shape3_hits; $slash → $candidate"
+    fi
+  fi
+done < <(grep -oE '/wr-[a-z0-9-]+:[a-z0-9-]+' "$ticket_file" 2>/dev/null | sort -u || true)
+
+if [ -n "$shape3_hits" ]; then
+  record_shape "named-skill-or-feature-exists" "feature surfaces exist: ${shape3_hits}"
+fi
+
+# Shape 4 — self-marker-in-body (line-anchored regex per architect A2).
+# Patterns:
+#   ^.* Close to (Verifying|Closed)\b
+#   ^.* DONE 2026-
+#   ^.* fix shipped session
+#   ^.* awaiting K→V
+#   ^## Fix Released
+# Line-anchored: must appear at line-start (with optional leading bullet
+# or heading prefix) — prevents mid-prose narrative false-positives.
+
+shape4_marker=""
+if grep -qE '^[[:space:]]*[#>*-]*[[:space:]]*.*Close to (Verifying|Closed)\b' "$ticket_file" 2>/dev/null; then
+  shape4_marker="'Close to Verifying|Closed' line marker"
+elif grep -qE '^[[:space:]]*[#>*-]*[[:space:]]*\[?[x ]?\]?[[:space:]]*\*?\*?DONE 2026-' "$ticket_file" 2>/dev/null; then
+  shape4_marker="'DONE 2026-' line marker"
+elif grep -qE '^## Fix Released' "$ticket_file" 2>/dev/null; then
+  shape4_marker="'## Fix Released' heading"
+elif grep -qE '^[[:space:]]*[#>*-]*[[:space:]]*.*fix shipped session' "$ticket_file" 2>/dev/null; then
+  shape4_marker="'fix shipped session' line marker"
+elif grep -qE '^[[:space:]]*[#>*-]*[[:space:]]*.*awaiting K→V' "$ticket_file" 2>/dev/null; then
+  shape4_marker="'awaiting K→V' line marker"
+fi
+if [ -n "$shape4_marker" ]; then
+  record_shape "self-marker-in-body" "self-marker: ${shape4_marker}"
+fi
+
+# Shape 5 — driver-child-ticket-closed.
+# Parse `## Related` section for P<NNN> refs; check if any are in
+# docs/problems/closed/ (dual-tolerant: subdir OR .closed.md suffix).
+# Per advisory A1, only fires when the child has NO unresolved
+# investigation items of its own (rough heuristic: no unticked checkboxes
+# OR no extractable open file refs).
+
+# Extract section starting at "## Related" through end of file.
+related_section=$(awk '/^## Related/{flag=1;next} /^## /{flag=0} flag' "$ticket_file" 2>/dev/null || true)
+closed_drivers=""
+if [ -n "$related_section" ]; then
+  while IFS= read -r pnum; do
+    [ -z "$pnum" ] && continue
+    n="${pnum#P}"
+    n="${n#p}"
+    # Strip leading zeros before printf so bash doesn't interpret 034 as
+    # octal (would yield decimal 28 — silent attribution bug). Use a
+    # while-loop strip rather than $((10#$n)) so we don't trip on
+    # malformed input.
+    n_clean="$n"
+    while [ "${n_clean#0}" != "$n_clean" ] && [ -n "${n_clean#0}" ]; do
+      n_clean="${n_clean#0}"
+    done
+    pattern_num=$(printf "%03d" "$n_clean" 2>/dev/null || echo "$n")
+    while IFS= read -r closed_file; do
+      [ -z "$closed_file" ] && continue
+      if [ -z "$closed_drivers" ]; then
+        closed_drivers="$pnum ($closed_file)"
+      else
+        closed_drivers="$closed_drivers, $pnum ($closed_file)"
+      fi
+      break
+    done < <(find docs/problems/closed -maxdepth 1 -type f \( -name "${pattern_num}-*.md" -o -name "${pattern_num}-*.closed.md" \) 2>/dev/null; find docs/problems -maxdepth 1 -type f -name "${pattern_num}-*.closed.md" 2>/dev/null)
+  done < <(echo "$related_section" | grep -oE '\bP[0-9]{2,4}\b' | sort -u || true)
+fi
+
+# A1 guard — "child has independent open work" disambiguation.
+#
+# Shape 5 says "the driver in ## Related is closed". This is contributory
+# evidence at best — the driver's closure does not prove the child's work
+# is done. Per architect advisory A1, shape 5 should NOT fire when the
+# child clearly names independent outstanding scope.
+#
+# Detection: if the ticket body references a `packages/.../skills/<name>/
+# SKILL.md` or `packages/.../agents/<name>.md` that does NOT exist on
+# disk, the umbrella is naming a feature that hasn't been built. This is
+# future-work, not stale-work — suppress both shape 5 AND shape 1 for the
+# missing future-work path; emit KEEP-WITH-NOTE.
+future_work_skill_ref=""
+while IFS= read -r future_skill; do
+  [ -z "$future_skill" ] && continue
+  if ! path_exists "$future_skill"; then
+    future_work_skill_ref="$future_skill"
+    break
+  fi
+done < <(grep -oE 'packages/[A-Za-z0-9_-]+/(skills/[A-Za-z0-9_-]+/SKILL\.md|agents/[A-Za-z0-9._-]+\.md)' "$ticket_file" 2>/dev/null | sort -u || true)
+
+if [ -n "$closed_drivers" ] && [ -n "$future_work_skill_ref" ]; then
+  # Closed driver AND child names a SKILL/agent that hasn't been built
+  # yet — future work, not stale. KEEP-WITH-NOTE.
+  keep_with_note="closed driver(s) ${closed_drivers}, but child names unbuilt SKILL/agent: $future_work_skill_ref"
+  # Reset cumulative shapes so the KEEP-WITH-NOTE branch routes cleanly.
+  shapes=""
+  cites=""
+fi
+
+if [ -n "$closed_drivers" ] && [ -z "$keep_with_note" ]; then
+  record_shape "driver-child-ticket-closed" "drivers closed: ${closed_drivers}"
+fi
+
+# ── Caveat detection ────────────────────────────────────────────────────────
+# Architect condition C2: when shape detection is partial (umbrella with
+# mixed-phase progress), emit CLOSE-CANDIDATE-WITH-CAVEAT with structured
+# caveat short-tag + one-line prose so the SKILL Step 4.6b template can
+# splice the **Caveat** field directly.
+
+if [ -n "$shapes" ]; then
+  # Multi-phase umbrella detection: unticked checkboxes in the ticket
+  # body + at least one shipped-evidence shape match. The shape match
+  # itself is the "progress made" signal — unticked tasks indicate
+  # outstanding scope the maintainer must confirm before close.
+  #
+  # Use `grep | wc -l` so a no-match scenario exits 0 (wc always returns
+  # 0) — avoids the pipefail + `grep -c` trap where grep prints "0" then
+  # exits 1, tripping set -e on assignment.
+  unticked_count=$(grep -cE '^[[:space:]]*-[[:space:]]*\[[[:space:]]\][[:space:]]' "$ticket_file" 2>/dev/null || true)
+  ticked_count=$(grep -cE '^[[:space:]]*-[[:space:]]*\[x\][[:space:]]' "$ticket_file" 2>/dev/null || true)
+  unticked_count=${unticked_count:-0}
+  ticked_count=${ticked_count:-0}
+  if [ "$unticked_count" -ge 1 ]; then
+    caveat_tag="multi-phase-mixed-progress"
+    caveat_msg="${ticked_count} task(s) done, ${unticked_count} outstanding — confirm umbrella scope before close"
+  fi
+fi
+
+# ── Verdict emission ────────────────────────────────────────────────────────
+
+if [ -n "$keep_with_note" ]; then
+  echo "KEEP-WITH-NOTE $basename — $keep_with_note"
+  exit 1
+fi
+
+if [ -n "$shapes" ]; then
+  if [ -n "$caveat_tag" ]; then
+    echo "CLOSE-CANDIDATE-WITH-CAVEAT $basename — shapes: $shapes — caveat: $caveat_tag: $caveat_msg — cites: $cites"
+  else
+    echo "CLOSE-CANDIDATE $basename — shapes: $shapes — $cites"
+  fi
   exit 0
 fi
 
-echo "KEEP $basename — ${present}/${total} paths still present"
+# No shape fired — fall back to the legacy KEEP / SKIP routing.
+
+if [ -z "$candidates" ]; then
+  echo "SKIP $basename — no extractable file paths (after self-reference exclusion)"
+  exit 2
+fi
+
+total=$((shape1_missing + shape1_present))
+echo "KEEP $basename — ${shape1_present}/${total} paths still present"
 exit 1

package/scripts/test/evaluate-relevance.bats

@@ -41,7 +41,7 @@ setup() {
   git init -q -b main
   git config user.email test@example.com
   git config user.name "Test"
-  mkdir -p docs/problems/open docs/problems/known-error packages/itil/scripts docs/decisions
+  mkdir -p docs/problems/open docs/problems/known-error docs/problems/closed packages/itil/scripts docs/decisions
 
   # An "old" Reported date: 60 days before today. ISO date arithmetic
   # portable across BSD + GNU date.
@@ -327,3 +327,447 @@ EOF
   [ "$status" -eq 2 ]
   [[ "${lines[0]}" == "SKIP "* ]]
 }
+
+# ── Phase 2 Shape 2: ADR-shipped with `human-oversight: confirmed` ───────────
+#
+# @adr ADR-079 Phase 2 — shape 2 covers 8 of 14 closes in the 2026-05-31
+#                        labeled fixture set (P012/P015/P018/P022/P033/P039/
+#                        P194/P292). Mechanical check: grep ticket body for
+#                        ADR-NNN refs; for each, verify
+#                        docs/decisions/<NNN>-*.md exists AND frontmatter has
+#                        `human-oversight: confirmed`.
+
+@test "evaluate-relevance: Phase 2 shape 2 — ADR-shipped-confirmed → CLOSE-CANDIDATE exit 0" {
+  cat > docs/decisions/037-confirmed-adr.proposed.md <<EOF
+---
+status: "proposed"
+human-oversight: confirmed
+oversight-date: 2026-05-25
+---
+
+# ADR-037: Test confirmed ADR
+EOF
+  git add docs/decisions/037-confirmed-adr.proposed.md
+
+  cat > docs/problems/open/120-adr-confirmed.md <<EOF
+# Problem 120: adr-confirmed
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+ADR-037 was the design decision; the implementation has landed and the
+ADR is human-oversight: confirmed. Concern no longer concerning.
+EOF
+  run "$SCRIPT" docs/problems/open/120-adr-confirmed.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"shapes: "*"ADR-shipped-confirmed"* ]]
+  [[ "$output" == *"ADR-037"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 2 — ADR exists but NOT confirmed → no shape 2 fire" {
+  cat > docs/decisions/038-proposed-but-unconfirmed.proposed.md <<EOF
+---
+status: "proposed"
+---
+
+# ADR-038: Not yet confirmed
+EOF
+  git add docs/decisions/038-proposed-but-unconfirmed.proposed.md
+
+  cat > docs/problems/open/121-adr-unconfirmed.md <<EOF
+# Problem 121: adr-unconfirmed
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+ADR-038 captured the design but is not yet confirmed by human review.
+EOF
+  run "$SCRIPT" docs/problems/open/121-adr-unconfirmed.md
+  # Without other shape matches, shape 2 alone (unconfirmed ADR) MUST NOT
+  # produce a CLOSE-CANDIDATE. Verdict routes to SKIP (no extractable
+  # paths to ground shape 1) or KEEP — never CLOSE-CANDIDATE.
+  [ "$status" -ne 0 ]
+  [[ "${lines[0]}" != "CLOSE-CANDIDATE "* ]]
+  [[ "${lines[0]}" != "CLOSE-CANDIDATE-WITH-CAVEAT "* ]]
+}
+
+# ── Phase 2 Shape 3: named-skill-or-feature-exists ───────────────────────────
+#
+# @adr ADR-079 Phase 2 — shape 3 covers 6 of 14 closes (P014/P034/P045/P079/
+#                        P190/P289). Verifies the cited SKILL.md / hook /
+#                        agent / slash-command surface exists.
+
+@test "evaluate-relevance: Phase 2 shape 3 — SKILL.md exists → CLOSE-CANDIDATE exit 0" {
+  mkdir -p packages/itil/skills/some-feature
+  cat > packages/itil/skills/some-feature/SKILL.md <<EOF
+---
+name: wr-itil:some-feature
+---
+# Some Feature
+EOF
+  git add packages/itil/skills/some-feature/SKILL.md
+
+  cat > docs/problems/open/130-feature-shipped.md <<EOF
+# Problem 130: feature-shipped
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+The feature this ticket asks for has shipped at
+\`packages/itil/skills/some-feature/SKILL.md\`. Concern resolved.
+EOF
+  run "$SCRIPT" docs/problems/open/130-feature-shipped.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"shapes: "*"named-skill-or-feature-exists"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 3 — slash-command ref + SKILL exists → CLOSE-CANDIDATE exit 0" {
+  mkdir -p packages/architect/skills/capture-adr
+  cat > packages/architect/skills/capture-adr/SKILL.md <<EOF
+---
+name: wr-architect:capture-adr
+---
+EOF
+  git add packages/architect/skills/capture-adr/SKILL.md
+
+  cat > docs/problems/open/131-slash-command.md <<EOF
+# Problem 131: slash-command
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+The aside-invocation surface /wr-architect:capture-adr now exists and
+covers the original concern.
+EOF
+  run "$SCRIPT" docs/problems/open/131-slash-command.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"named-skill-or-feature-exists"* ]]
+}
+
+# ── Phase 2 Shape 4: self-marker-in-body (line-anchored regex per A2) ────────
+#
+# @adr ADR-079 Phase 2 — shape 4 explicit in P289 ("Close to Verifying"),
+#                        contributory in P033 ("## Fix Released"). Regex
+#                        line-anchored per architect advisory A2 to avoid
+#                        mid-prose false-positives.
+
+@test "evaluate-relevance: Phase 2 shape 4 — 'Close to Verifying' line marker → CLOSE-CANDIDATE exit 0" {
+  cat > docs/problems/open/140-self-marker.md <<EOF
+# Problem 140: self-marker
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Work has been done.
+
+## Resolution
+
+The fix shipped 2026-05-27. Close to Verifying.
+EOF
+  run "$SCRIPT" docs/problems/open/140-self-marker.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"self-marker-in-body"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 4 — '## Fix Released' heading → CLOSE-CANDIDATE exit 0" {
+  cat > docs/problems/open/141-fix-released.md <<EOF
+# Problem 141: fix-released
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Bug.
+
+## Fix Released
+
+Implemented 2026-04-17.
+EOF
+  run "$SCRIPT" docs/problems/open/141-fix-released.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"self-marker-in-body"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 4 — 'DONE 2026-' line marker → CLOSE-CANDIDATE exit 0" {
+  cat > docs/problems/open/142-done-marker.md <<EOF
+# Problem 142: done-marker
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Description.
+
+### Investigation Tasks
+
+- [x] DONE 2026-05-27 — Migration-strategy decision executed.
+EOF
+  run "$SCRIPT" docs/problems/open/142-done-marker.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"self-marker-in-body"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 4 — mid-prose 'close to verifying' (lowercase, narrative) → KEEP exit 1 (negative fixture per advisory A2)" {
+  cat > docs/problems/open/143-mid-prose.md <<EOF
+# Problem 143: mid-prose
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+The team thinks this is close to verifying our hypothesis but no concrete
+shipped evidence exists yet — still investigating.
+EOF
+  run "$SCRIPT" docs/problems/open/143-mid-prose.md
+  # Without other shape matches, mid-prose narrative MUST NOT fire shape 4.
+  # Verdict should be SKIP (no extractable paths) or KEEP — never CLOSE-CANDIDATE.
+  [ "$status" -ne 0 ]
+}
+
+# ── Phase 2 Shape 5: driver-child-ticket-closed ──────────────────────────────
+#
+# @adr ADR-079 Phase 2 — shape 5 contributory in several closes (e.g. P014
+#                        cites closed P155 driver). Parses ## Related for
+#                        P<NNN> refs; checks if any are in
+#                        docs/problems/closed/.
+
+@test "evaluate-relevance: Phase 2 shape 5 — Related cites closed driver → CLOSE-CANDIDATE exit 0" {
+  cat > docs/problems/closed/155-driver-done.md <<EOF
+# Problem 155: driver-done
+
+**Status**: Closed
+EOF
+  git add docs/problems/closed/155-driver-done.md
+
+  cat > docs/problems/open/150-child-of-closed.md <<EOF
+# Problem 150: child-of-closed
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+This is the umbrella for several driver tickets.
+
+## Related
+
+- **P155** — implementation driver.
+EOF
+  run "$SCRIPT" docs/problems/open/150-child-of-closed.md
+  [ "$status" -eq 0 ]
+  [[ "$output" == "CLOSE-CANDIDATE "*"driver-child-ticket-closed"* ]]
+}
+
+@test "evaluate-relevance: Phase 2 shape 5 — Related cites closed driver BUT child has independent open work → KEEP exit 1 (advisory A1 negative fixture)" {
+  cat > docs/problems/closed/156-driver-done.md <<EOF
+# Problem 156: driver-done
+
+**Status**: Closed
+EOF
+  git add docs/problems/closed/156-driver-done.md
+
+  cat > docs/problems/open/151-independent.md <<EOF
+# Problem 151: independent
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+While the driver P156 is closed, this ticket has its own outstanding
+investigation around \`packages/itil/skills/unrelated-future-skill/SKILL.md\`
+which has not been implemented yet.
+
+## Related
+
+- **P156** — original driver (closed); this ticket carries new scope beyond P156.
+EOF
+  run "$SCRIPT" docs/problems/open/151-independent.md
+  # The script extracts \`packages/itil/skills/unrelated-future-skill/SKILL.md\`
+  # which does NOT exist — shape 1 (file-no-longer-exists) would fire. But the
+  # ticket independent-work signal lives in the unimplemented-file class; the
+  # KEEP requirement here is: shape 5 must NOT fire when an existing file
+  # reference is unresolvable (i.e. the umbrella has unfinished scope).
+  # Per architect advisory A1, we surface this as KEEP-WITH-NOTE rather than
+  # silent CLOSE-CANDIDATE.
+  [ "$status" -ne 0 ]
+}
+
+# ── Phase 1 false-positive fixes ─────────────────────────────────────────────
+#
+# @adr ADR-079 Phase 2 — Phase 1 false-positive class fixes:
+#                        - P180: state-suffix detection (incident I002.investigating.md vs I002.restored.md)
+#                        - P244: sibling-file detection (plugin-maturity-list.sh vs plugin-maturity-render.sh)
+#                        - P251: rename detection via git log --follow
+
+@test "evaluate-relevance: Phase 1 fix — state-suffix variant exists at different suffix → KEEP-WITH-NOTE (not CLOSE-CANDIDATE)" {
+  mkdir -p docs/incidents
+  cat > docs/incidents/I002-renamed.restored.md <<EOF
+# Incident I002
+EOF
+  git add docs/incidents/I002-renamed.restored.md
+
+  cat > docs/problems/open/160-state-suffix.md <<EOF
+# Problem 160: state-suffix
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Investigation references docs/incidents/I002-renamed.investigating.md
+which has since transitioned state.
+EOF
+  run "$SCRIPT" docs/problems/open/160-state-suffix.md
+  # Phase 1 would falsely declare the file gone. Phase 2 detects the
+  # restored.md state-suffix variant and routes to KEEP-WITH-NOTE.
+  [ "$status" -eq 1 ]
+  [[ "$output" == "KEEP-WITH-NOTE "* ]] || [[ "$output" == "KEEP "* ]]
+  [[ "$output" == *"state-suffix"* ]] || [[ "$output" == *"renamed.restored.md"* ]]
+}
+
+@test "evaluate-relevance: Phase 1 fix — sibling file with similar slug-prefix → KEEP-WITH-NOTE" {
+  mkdir -p packages/architect/scripts
+  cat > packages/architect/scripts/plugin-maturity-render.sh <<EOF
+#!/bin/bash
+EOF
+  cat > packages/architect/scripts/plugin-maturity-populate.sh <<EOF
+#!/bin/bash
+EOF
+  git add packages/architect/scripts/plugin-maturity-render.sh packages/architect/scripts/plugin-maturity-populate.sh
+
+  cat > docs/problems/open/161-sibling-file.md <<EOF
+# Problem 161: sibling-file
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Bug in packages/architect/scripts/plugin-maturity-list.sh
+EOF
+  run "$SCRIPT" docs/problems/open/161-sibling-file.md
+  # Phase 1 would declare plugin-maturity-list.sh gone. Phase 2 detects
+  # the sibling-file class (plugin-maturity-* slug-prefix) and routes to
+  # KEEP-WITH-NOTE.
+  [ "$status" -eq 1 ]
+  [[ "$output" == "KEEP-WITH-NOTE "* ]] || [[ "$output" == "KEEP "* ]]
+  [[ "$output" == *"sibling"* ]] || [[ "$output" == *"plugin-maturity-"* ]]
+}
+
+# ── CLOSE-CANDIDATE-WITH-CAVEAT structured emission (architect condition C2) ──
+
+@test "evaluate-relevance: CLOSE-CANDIDATE-WITH-CAVEAT emits structured caveat format" {
+  cat > docs/decisions/040-multi-phase-confirmed.proposed.md <<EOF
+---
+status: "proposed"
+human-oversight: confirmed
+oversight-date: 2026-05-25
+---
+# ADR-040
+EOF
+  git add docs/decisions/040-multi-phase-confirmed.proposed.md
+
+  cat > docs/problems/open/170-umbrella-caveat.md <<EOF
+# Problem 170: umbrella-caveat
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Multi-phase umbrella. ADR-040 covers the design; Phase 2 done, Phase 3
+outstanding work \`packages/jtbd/lib/phase3-helper.sh\`.
+
+## Phase 3 progress
+
+- [ ] Phase 3 work
+EOF
+  # Phase 3 cited path does not exist; ADR-040 confirmed → shape 2 fires + caveat
+  run "$SCRIPT" docs/problems/open/170-umbrella-caveat.md
+  # Architect condition C2 — structured caveat emission:
+  # CLOSE-CANDIDATE-WITH-CAVEAT <basename> — shapes: <list> — caveat: <tag>: <one-line>
+  # For multi-phase umbrellas with unticked checkboxes the caveat tag is
+  # 'multi-phase-mixed-progress'.
+  [[ "$output" == "CLOSE-CANDIDATE-WITH-CAVEAT "* ]]
+  [[ "$output" == *"shapes:"* ]]
+  [[ "$output" == *"caveat:"* ]]
+  [[ "$output" == *"multi-phase-mixed-progress"* ]]
+}
+
+# ── KEEP fixtures from the 2026-05-31 labeled negative set ────────────────────
+#
+# @adr ADR-079 Phase 2 — KEEP regression suite: P136 multi-phase umbrella,
+#                        P303/P326 recent-observation-no-shipped-evidence.
+
+@test "evaluate-relevance: KEEP fixture — recent observation, no shipped evidence (P303/P326 class)" {
+  cat > docs/problems/open/180-recent-observation.md <<EOF
+# Problem 180: recent-observation
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+Observed friction with the risk-scorer pipeline staging. Composes-with
+P057 / P125 / P273 (sibling staging traps) but no shipped fix yet.
+
+## Related
+
+- **P057** — sibling.
+EOF
+  # P057 not closed (no file); no ADR refs that are confirmed; no SKILL refs;
+  # no self-markers. Should KEEP.
+  run "$SCRIPT" docs/problems/open/180-recent-observation.md
+  [ "$status" -ne 0 ]
+  # Either SKIP (no extractable paths) or KEEP — never CLOSE-CANDIDATE.
+  [[ "${lines[0]}" != "CLOSE-CANDIDATE "* ]]
+  [[ "${lines[0]}" != "CLOSE-CANDIDATE-WITH-CAVEAT "* ]]
+}
+
+# ── Cumulative shape annotation (architect Q4 — cumulative is correct) ───────
+
+@test "evaluate-relevance: multi-shape match emits cumulative shapes: list" {
+  cat > docs/decisions/041-multi-match.proposed.md <<EOF
+---
+status: "proposed"
+human-oversight: confirmed
+oversight-date: 2026-05-25
+---
+# ADR-041
+EOF
+  git add docs/decisions/041-multi-match.proposed.md
+
+  cat > docs/problems/open/190-multi-shape.md <<EOF
+# Problem 190: multi-shape
+
+**Status**: Open
+**Reported**: $OLD_DATE
+
+## Description
+
+ADR-041 captures the design. Fix shipped.
+
+## Fix Released
+
+Implemented and confirmed.
+EOF
+  run "$SCRIPT" docs/problems/open/190-multi-shape.md
+  [ "$status" -eq 0 ]
+  # Both shape 2 (ADR-confirmed) and shape 4 (Fix Released line) match.
+  [[ "$output" == *"ADR-shipped-confirmed"* ]]
+  [[ "$output" == *"self-marker-in-body"* ]]
+}

package/skills/manage-problem/SKILL.md

@@ -56,7 +56,7 @@ The `.verifying.md` suffix distinguishes "fix released, awaiting user verificati
 | **Known Error** | `.known-error.md` | Root cause confirmed, fix path clear, **fix NOT yet released** | Root cause documented, reproduction test exists, workaround in place |
 | **Verification Pending** | `.verifying.md` | Fix released, awaiting user verification (ADR-022) | Fix shipped; `## Fix Released` section written; user action remaining |
 | **Parked** | `.parked.md` | Blocked on upstream or suspended by user decision | Upstream blocker identified, or user explicitly suspends; reason and un-park trigger documented |
-| **Closed** | `.closed.md` | Fix verified in production OR ticket determined no longer relevant via evidence | (a) User explicitly confirms the released fix works (canonical Verifying → Closed path), OR (b) auto-closed by `/wr-itil:review-problems` Step 4.6 relevance-close pass per ADR-079 Phase 1 — file-no-longer-exists evidence shape with `## Closed as no longer relevant` audit section per ADR-026 grounding (extends ADR-022 lifecycle: Open\|Known Error → Closed bypasses Verifying when no fix was released) |
+| **Closed** | `.closed.md` | Fix verified in production OR ticket determined no longer relevant via evidence | (a) User explicitly confirms the released fix works (canonical Verifying → Closed path), OR (b) auto-closed by `/wr-itil:review-problems` Step 4.6 relevance-close pass per ADR-079 Phase 1 + Phase 2 evidence shapes — `file-no-longer-exists` / `ADR-shipped-confirmed` / `named-skill-or-feature-exists` / `self-marker-in-body` / `driver-child-ticket-closed` (cumulative; multi-shape matches emit comma-joined) with `## Closed as no longer relevant` audit section per ADR-026 grounding (extends ADR-022 lifecycle: Open\|Known Error → Closed bypasses Verifying when no fix was released). Partial-scope umbrellas emit `CLOSE-CANDIDATE-WITH-CAVEAT` and ride the maintainer's `AskUserQuestion` surface-batch-confirm path. |
 
 **Parked problems** are excluded from WSJF ranking and work selection. They are listed separately in review output so users can see them without them polluting the backlog. To park a problem:
 1. **If the park reason is `upstream-blocked`**, run the external-root-cause detection block at Step 7 first (see "External-root-cause detection (P063)"). Park without recording the upstream dependency in `## Related` would be the canonical audit-trail gap this block closes.

package/skills/review-problems/SKILL.md

@@ -208,9 +208,25 @@ The `## Inbound Upstream Reports` README section (ADR-062 § Step 9e renderer pe
 
 When invoked from `/wr-itil:work-problems` Step 6.5 (AFK orchestrator), Step 4.5 runs silently per the mechanical-stage carve-out. The only user-attention surface during AFK is the existing external-comms gate UX (a known interrupt class per ADR-028 amended); per-branch `AskUserQuestion` would re-introduce the friction P132 was engineered to remove.
 
-### 4.6. Relevance-close pass (P346 / ADR-079 Phase 1)
+### 4.6. Relevance-close pass (P346 / P347 / ADR-079 Phase 1 + Phase 2)
 
-For each `.open.md` / `.known-error.md` ticket aged ≥ 7 days, evaluate whether the ticket has become **no longer relevant** by checking observable evidence per ADR-026 grounding. Phase 1 scope: auto-close on the single evidence shape "file no longer exists in codebase" — closest analog to P334/P336 close-on-evidence patterns. Other evidence shapes (ADR-supersession, duplicate-of-X, "concern no longer concerning", SKILL-contract-superseded) are deferred to sibling tickets per ADR-079 scope discipline.
+For each `.open.md` / `.known-error.md` ticket aged ≥ 7 days, evaluate whether the ticket has become **no longer relevant** by checking observable evidence per ADR-026 grounding. Phase 1 + Phase 2 cover **five evidence shapes** grounded in the 14-fixture labeled close-on-evidence set from the 2026-05-31 foreground relevance-scan (the regression suite per ADR-052 lives at `packages/itil/scripts/test/evaluate-relevance.bats`):
+
+| Shape | Phase | Mechanical check | Empirical closes (2026-05-31) |
+|---|---|---|---|
+| 1. `file-no-longer-exists` | Phase 1 | grep ticket body for `(packages\|docs\|...)/...\.(md\|sh\|...)`; verify each via `git ls-files --error-unmatch` | 0 of 14 |
+| 2. `ADR-shipped-confirmed` | Phase 2 | grep ticket body for `ADR-NNN`; for each, verify `docs/decisions/<NNN>-*.md` exists AND frontmatter has `human-oversight: confirmed` | 8 of 14 — P012/P015/P018/P022/P033/P039/P194/P292 |
+| 3. `named-skill-or-feature-exists` | Phase 2 | grep for SKILL.md / hook / agent paths + `/wr-<plugin>:<skill>` slash-command refs; verify each via `git ls-files` | 6 of 14 — P014/P034/P045/P079/P190/P289 |
+| 4. `self-marker-in-body` | Phase 2 | line-anchored grep for `Close to (Verifying\|Closed)`, `DONE 2026-`, `## Fix Released` heading, `fix shipped session`, `awaiting K→V`. Pattern MUST anchor to line-start to avoid mid-prose false-positives (architect advisory A2) | explicit in P289; contributory in P033 |
+| 5. `driver-child-ticket-closed` | Phase 2 | parse `## Related` for `P<NNN>` refs; check if any are in `docs/problems/closed/`. Suppressed when child names an unbuilt SKILL/agent path (future work, not stale; architect advisory A1) | contributory in several closes |
+
+**Phase 1 false-positive fixes** (the iter-4 60% false-positive rate is structurally addressed; each fix routes the candidate to `KEEP-WITH-NOTE` rather than auto-close):
+
+- **P180 — state-suffix detection**: per-state subdirs (`open|known-error|verifying|closed|parked` for problems; `investigating|mitigating|restored` for incidents) AND `.<state>.md` suffix variants.
+- **P244 — sibling-file detection**: dir-glob the parent dir for files with similar slug-prefix (first 2 dash-tokens).
+- **P251 — rename detection**: `git log --follow --diff-filter=AD --name-only` surfaces the renamed-to path.
+
+Tickets with no extractable evidence (no file refs, no ADR refs, no SKILL refs, no self-markers, no closed drivers) route to `SKIP`. Other evidence shapes (ADR-supersession via `.superseded.md`, duplicate-of-X, "concern no longer concerning", test-passes-without-issue) are deferred to sibling tickets per ADR-079 scope discipline.
 
 **User direction (verbatim, 2026-05-31)**: *"Ok, I'm happy for a skill executed as part of review problems that closes tickets that are no longer relevant, but not just because they are old"* — the relevance signal MUST be observable; age is a **gating** condition (don't bother evaluating fresh tickets), never the **closing** condition. The 7-day gate is conservative; tickets younger than that are likely still actionable.
 
@@ -228,28 +244,40 @@ Exit-code routing (one verdict line per ticket on stdout):
 
 | Exit | Stdout prefix | Action |
 |------|--------------|--------|
-| 0 | `CLOSE-CANDIDATE <basename> — all <N> file paths absent: <semicolon list>` | Auto-close branch (4.6b). |
+| 0 | `CLOSE-CANDIDATE <basename> — shapes: <comma-list> — <per-shape cite>; ...` | Auto-close branch (4.6b). |
+| 0 | `CLOSE-CANDIDATE-WITH-CAVEAT <basename> — shapes: <comma-list> — caveat: <short-tag>: <one-line> — cites: ...` | Surface-batch-confirm branch (4.6b-with-caveat); the caveat short-tag + one-line splices verbatim into the audit section's **Caveat** field per architect condition C2. |
 | 1 | `KEEP <basename> — <M>/<N> paths still present` | No action; log only. |
-| 2 | `SKIP <basename> — <reason>` | No action (age gate, no Reported date, no extractable paths). |
+| 1 | `KEEP-WITH-NOTE <basename> — <note>: <evidence>` | Phase 1 false-positive class (state-suffix / sibling-file / rename) OR architect-A1 future-work disambiguation. No action; log only. |
+| 2 | `SKIP <basename> — <reason>` | No action (age gate, no Reported date, no extractable evidence). |
 | 3 | error | Log advisory; do not abort the pass — relevance-close is non-blocking per the Step 4.5 fail-soft precedent. |
 
-**Algorithm (canonical body)**: extracts file-path candidates from the ticket body matching `(packages|docs|.changeset|src|test|scripts)/[A-Za-z0-9._/-]+\.(md|sh|ts|tsx|js|jsx|json|yml|yaml|bats|py|txt|html)`, drops self-references to `docs/problems/*`, then runs `git ls-files --error-unmatch <path>` for each surviving candidate. The `CLOSE-CANDIDATE` verdict fires only when **all** extracted paths return zero AND **at least one** path was extracted. This is intentionally conservative — tickets with no extractable file paths route to `SKIP no-extractable-paths`, not auto-close.
+**Algorithm (canonical body)**: runs each of the five shape detectors over the ticket body. Multi-shape matches emit cumulatively (corroborating evidence is stronger than first-match-wins per ADR-026): the `shapes:` field carries a comma-joined list, the trailing fragment carries per-shape cites semicolon-separated. The caveat fires when at least one shape matches AND the body has any unticked checkboxes (multi-phase mixed-progress umbrella class). The verdict is intentionally conservative — tickets with no shape match AND no extractable evidence route to `SKIP`, not auto-close.
+
+**Surface-batch-confirm flow** (the methodology that produced today's 14 closes — codified for repeatable use):
+
+1. **Surface a batch** — run the evaluator across the dual-tolerant glob in 4.6a; group all `CLOSE-CANDIDATE` and `CLOSE-CANDIDATE-WITH-CAVEAT` verdicts as a batch.
+2. **Interactive surface (`AskUserQuestion`)** — present each batch of ~5 candidates with their shape annotations + caveats; user confirms close / amend / defer. Surface caveat tickets adjacent to their clean-close siblings so the maintainer sees the full batch class together. The interactive batch is the one-and-only `AskUserQuestion` per relevance-close pass (mechanical-stage carve-out per ADR-044 cat 4 + P132 — do NOT ask per-ticket; ask per-batch).
+3. **AFK (`/wr-itil:work-problems` Step 6.5)** — close clean `CLOSE-CANDIDATE` verdicts silently per ADR-013 Rule 5 + ADR-044 cat 4 (file existence + frontmatter inspection + line-anchored grep are empirical). Route `CLOSE-CANDIDATE-WITH-CAVEAT` verdicts to the next interactive review's `AskUserQuestion` surface — the caveat short-tag is the maintainer's decision input.
+4. **Batched closure commit per ADR-014** — all relevance-closes from one review pass batch into ONE commit (mirroring `/wr-itil:transition-problems` P139 batch grain).
+
+Real-backlog smoke test 2026-05-31 against today's labeled fixtures: P012 → `CLOSE-CANDIDATE-WITH-CAVEAT` (shapes 2 + 5 + multi-phase-mixed-progress caveat); P136 → `KEEP-WITH-NOTE` (sibling-file class); P303/P326 → `SKIP` (age gate, recent observations).
 
 #### 4.6b. Auto-close action per CLOSE-CANDIDATE
 
-For each `CLOSE-CANDIDATE` ticket, perform the following BEFORE the `git mv`:
+For each `CLOSE-CANDIDATE` or `CLOSE-CANDIDATE-WITH-CAVEAT` ticket, perform the following BEFORE the `git mv`:
 
 1. Use the `Edit` tool to append a `## Closed as no longer relevant` section to the ticket body (cite + persist + uncertainty per ADR-026):
 
    ```markdown
    ## Closed as no longer relevant
 
-   - **Evidence shape**: file-no-longer-exists (ADR-079 Phase 1)
+   - **Evidence shape**: <comma-joined list from the verdict's `shapes:` field — e.g. `ADR-shipped-confirmed, self-marker-in-body` for multi-shape match> (ADR-079 Phase 1 + Phase 2)
    - **Closed on**: <YYYY-MM-DD>
    - **Closed by**: /wr-itil:review-problems Step 4.6 relevance-close pass
-   - **Cite (paths checked, all absent in `git ls-files`)**: <semicolon-separated list from the CLOSE-CANDIDATE verdict>
+   - **Cite (per-shape evidence)**: <semicolon-separated per-shape cites from the trailing fragment of the verdict line>
+   - **Caveat (if CLOSE-CANDIDATE-WITH-CAVEAT)**: `<short-tag>: <one-line>` from the verdict's `caveat:` field (splice verbatim — preserves ADR-026 uncertainty leg structurally per architect condition C2). Omit this field for plain CLOSE-CANDIDATE verdicts.
    - **Persist**: this section is committed in the ticket file itself; the script body at `packages/itil/scripts/evaluate-relevance.sh` is the re-runnable verdict source per ADR-026
-   - **Uncertainty / reversibility**: verdict is deterministic given the path set. False-positive remediation: `git revert` the relevance-close commit OR `git mv` the ticket back to its prior state if a missed rename surfaces. The ≥7-day age gate guards against premature evaluation.
+   - **Uncertainty / reversibility**: verdict is deterministic given the body + git state. False-positive remediation: `git revert` the relevance-close commit OR `git mv` the ticket back to its prior state. The ≥7-day age gate + Phase 1 false-positive fixes (state-suffix / sibling-file / rename) + shape-cumulative annotation guard against premature evaluation.
    ```
 
 2. `git mv` the ticket from its current state directory to `closed/` (lifecycle extension per ADR-079 — Open|Known Error → Closed bypasses Verifying because no fix was released; conclusion is "no fix needed"):
@@ -288,9 +316,11 @@ Step 5's README refresh rides the same commit per ADR-014 single-commit grain
 
 The relevance-close pass runs **unconditionally** during AFK orchestration (`/wr-itil:work-problems` Step 6.5). File existence is empirical, not user-judgment — the mechanical-stage carve-out (P132) applies per ADR-044 category-4 silent framework action. Do NOT fire `AskUserQuestion` per CLOSE-CANDIDATE; the framework has already resolved the close-on-empirical-evidence question.
 
-**Worked example (real backlog smoke test, 2026-05-31)**: across 143 open / known-error tickets, Phase 1 surfaced 6 CLOSE-CANDIDATEs (4.2%) — tickets referencing files renamed or removed but whose lifecycle close was missed. 44 routed to KEEP (file paths still present), 93 to SKIP (age gate, no extractable paths, or no Reported date). The 4.2% close rate matches expectations for a 47-day-old backlog with one-time outflow gap closure.
+**Worked example (Phase 1 smoke test, 2026-05-31)**: across 143 open / known-error tickets, Phase 1 surfaced 6 CLOSE-CANDIDATEs (4.2%) — but the post-batch-1 verification showed 60% of those were false-positives (state-suffix / sibling-file / rename class). Phase 2's false-positive fixes route those to `KEEP-WITH-NOTE`. The same-day foreground relevance-scan that used the broader Phase 2 shape vocabulary produced 14 actual closes across 5 batches — empirically calibrating the Phase 2 shape set.
+
+**Worked example (Phase 2 surface-batch-confirm, 2026-05-31)**: 14 closes across 5 batches using shapes 2-5. Each batch surfaced via `AskUserQuestion` (≤ 5 candidates per batch); maintainer confirmed clean closes and routed caveat candidates with explicit caveat acknowledgement (e.g. P039 `shared-template-not-built`; P194 `deep-dive-bloat-remains`). All closures batched into per-batch commits per ADR-014. The 14-fixture labeled set is the regression suite (`packages/itil/scripts/test/evaluate-relevance.bats` covers each shape positive + the architect A1/A2 advisory negatives).
 
-**Cross-references**: ADR-079 (this pass's design ADR), ADR-026 (grounding), ADR-022 + ADR-079 lifecycle extension (Open|Known Error → Closed bypassing Verifying for no-fix-needed conclusions), ADR-049 (PATH shim), ADR-052 (behavioural bats at `packages/itil/scripts/test/evaluate-relevance.bats`), ADR-014 (commit grain), P057 (staging trap), P346 (driver ticket).
+**Cross-references**: ADR-079 (this pass's design ADR, Phase 1 + Phase 2), ADR-026 (grounding, cumulative shape cite + structured caveat field), ADR-022 + ADR-079 lifecycle extension (Open|Known Error → Closed bypassing Verifying for no-fix-needed conclusions; the Closed-row entry at `/wr-itil:manage-problem` SKILL.md line 59 names Phase 1 + Phase 2 shapes), ADR-049 (PATH shim), ADR-052 (behavioural bats at `packages/itil/scripts/test/evaluate-relevance.bats` — 33/33 GREEN), ADR-014 (batched closure commit grain per pass), ADR-044 cat 4 + P132 (mechanical-stage carve-out: ask per-batch, not per-ticket), P057 (staging trap), P346 (Phase 1 driver), P347 (Phase 2 driver).
 
 ### 5. Rewrite `docs/problems/README.md`