@windyroad/itil 0.23.2 → 0.23.3

package/.claude-plugin/plugin.json

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

package/hooks/hooks.json

@@ -8,6 +8,10 @@
       { "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/itil-correction-detect.sh" }] }
     ],
     "PreToolUse": [
+      {
+        "matcher": "Bash|Write|Edit|Read",
+        "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/itil-runtime-sid-marker.sh" }]
+      },
       {
         "matcher": "Write",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/manage-problem-enforce-create.sh" }]

package/hooks/itil-runtime-sid-marker.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# P142 / ADR-050: runtime-SID instrumentation PreToolUse hook.
+#
+# Captures the runtime stdin `session_id` from Claude Code's PreToolUse
+# JSON payload and writes it to a per-machine, per-user, per-project
+# marker file. The `get_current_session_id` helper (lib/session-id.sh)
+# reads this marker as the authoritative current-session UUID, replacing
+# the Phase 3 mtime-based announce-marker selection that misfired in
+# orchestrator main turns AFTER subprocess dispatch (P142 ticket).
+#
+# Why a NEW PreToolUse hook (not an extension of an existing one):
+#   - manage-problem-enforce-create.sh already runs on PreToolUse:Write,
+#     but its perf-sensitive denial-path needs the runtime SID BEFORE
+#     this hook would write it. Writing in a separate, prior hook
+#     ensures the marker is in place by the time enforce-create reads.
+#   - The architect-enforce-edit / jtbd-enforce-edit / tdd-enforce hooks
+#     are owned by sibling plugins; cross-plugin coupling is rejected
+#     per ADR-017 (shared-code-sync).
+#   - A standalone, single-purpose hook is the cleanest fit for ADR-045
+#     Pattern 1 (silent-on-pass, side-effect-only).
+#
+# Matcher: PreToolUse:Bash|Write|Edit|Read covers the tool calls that
+# may invoke `get_current_session_id` indirectly (Bash sources the
+# helper; Write/Edit fires the create-gate that consumes the marker;
+# Read is included for completeness — every tool call that fires a
+# PreToolUse hook contributes a fresh marker).
+#
+# ADR-045 Pattern 1 binding: this hook MUST emit 0 bytes on stdout.
+# Adding stdout output would burn the per-tool-call context budget.
+# All side effects are filesystem writes; observability is via the
+# marker file itself.
+#
+# Fail-open contract: any error path (missing jq, malformed JSON, empty
+# session_id, write failure) exits 0 without modifying state. The hook
+# MUST NOT block tool calls — its only role is to deposit a marker for
+# the helper. If the marker is absent, the helper falls back to the
+# announce-marker priority logic.
+#
+# References:
+#   ADR-050 — runtime-SID instrumentation surface (this hook).
+#   ADR-048 — gate-misfire recovery (superseded by ADR-050).
+#   ADR-045 — hook injection budget; Pattern 1 binding.
+#   ADR-038 — announce-marker contract (cold-path fallback consumer).
+#   P142    — the ticket this hook closes.
+#   P124    — Phase 3 helper this hook complements.
+
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+# shellcheck source=lib/runtime-sid.sh
+source "$SCRIPT_DIR/lib/runtime-sid.sh"
+
+INPUT=$(cat)
+
+# Empty stdin -> no-op. Hook harnesses, manual invocation, or a
+# malformed stdin payload all land here; fail-open per the contract.
+if [ -z "$INPUT" ]; then
+  exit 0
+fi
+
+# Parse session_id with python3 (universally present on macOS + most
+# Linux distros; also already used by manage-problem-enforce-create.sh
+# as the JSON parser of choice in this plugin). jq fallback if python3
+# is absent. Any parse failure -> empty SESSION_ID -> no-op below.
+SESSION_ID=""
+if command -v python3 >/dev/null 2>&1; then
+  SESSION_ID=$(echo "$INPUT" | python3 -c "
+import sys, json
+try:
+    data = json.load(sys.stdin)
+    print(data.get('session_id', ''))
+except Exception:
+    print('')
+" 2>/dev/null || echo "")
+elif command -v jq >/dev/null 2>&1; then
+  SESSION_ID=$(echo "$INPUT" | jq -r '.session_id // empty' 2>/dev/null || echo "")
+fi
+
+if [ -z "$SESSION_ID" ]; then
+  exit 0
+fi
+
+# Write the marker. printf (not echo) to avoid trailing newline; the
+# helper's `cat` reads contents verbatim, and a trailing newline would
+# corrupt the SID comparison the runtime hook performs.
+MARKER_PATH=$(runtime_sid_path)
+printf '%s' "$SESSION_ID" > "$MARKER_PATH" 2>/dev/null || true
+
+exit 0

package/hooks/lib/runtime-sid.sh

@@ -0,0 +1,61 @@
+#!/bin/bash
+# P142 (P124 Phase 4): runtime-SID marker path helper.
+#
+# Computes the per-machine, per-user, per-project marker path that the
+# `itil-runtime-sid-marker.sh` PreToolUse hook writes the runtime
+# `session_id` to (parsed from hook stdin JSON) and that
+# `get_current_session_id` reads as the authoritative current-session
+# identifier. Both producer (hook) and consumer (helper) source this
+# lib so they agree on the path.
+#
+# Why this exists:
+#   The Phase 3 helper relied on within-system mtime selection across
+#   ADR-038 announce markers. In orchestrator main turns AFTER subprocess
+#   dispatch, subprocess announce markers had NEWER mtimes than the
+#   orchestrator's, so newest-mtime-wins picked the wrong UUID. No pure-
+#   helper algorithm can disambiguate orchestrator vs subprocess context
+#   from filesystem state alone (P142 ticket Investigation Tasks). The
+#   structural fix is to capture the runtime stdin SID — known with
+#   certainty by the hook on every tool call — into a discoverable file
+#   the helper can read. See ADR-050.
+#
+# Path scoping:
+#   When SESSION_MARKER_DIR is set (sandboxed bats per session-id.bats
+#   convention), the marker lives at "${SESSION_MARKER_DIR}/itil-runtime-sid.current"
+#   — a single fixed filename, no per-user/per-project scoping. Tests
+#   create and tear down their own SANDBOX_TMP, so cross-test pollution
+#   is impossible without further scoping.
+#
+#   In production (no SESSION_MARKER_DIR), the path is
+#   "/tmp/itil-runtime-sid-${USER}-${proj_hash}.current" where
+#   proj_hash = cksum of $PWD. Two Claude Code sessions in DIFFERENT
+#   projects do not race (different proj_hash). Two sessions in the
+#   SAME project on the same machine still race; per ADR-050 this is
+#   accepted as a documented limitation — the failure mode is a hook-
+#   denied Write that the agent can recover from, not silent corruption.
+#
+# References:
+#   ADR-050 — runtime-SID instrumentation via PreToolUse (this surface).
+#   ADR-048 — gate-misfire recovery procedure (superseded by ADR-050 +
+#             P142 + this lib).
+#   ADR-038 — announce-marker contract (cold-path fallback consumer).
+#   ADR-009 — gate marker lifecycle.
+#   P142    — this fix's ticket.
+
+# Echoes the runtime-SID marker path on stdout. Always exits 0.
+#
+# Usage:
+#   source packages/itil/hooks/lib/runtime-sid.sh
+#   path=$(runtime_sid_path)
+runtime_sid_path() {
+  if [ -n "${SESSION_MARKER_DIR:-}" ]; then
+    echo "${SESSION_MARKER_DIR}/itil-runtime-sid.current"
+    return 0
+  fi
+  local user="${USER:-anon}"
+  local proj_hash
+  # cksum is POSIX; portable across macOS BSD and Linux GNU.
+  # Trailing whitespace stripped via awk; first field is the checksum.
+  proj_hash=$(printf '%s' "${PWD:-/}" | cksum 2>/dev/null | awk '{print $1}')
+  echo "/tmp/itil-runtime-sid-${user}-${proj_hash:-0}.current"
+}

package/hooks/lib/session-id.sh

@@ -69,6 +69,30 @@ get_current_session_id() {
     return 0
   fi
 
+  # P142 / ADR-050: runtime-SID marker. The PreToolUse hook
+  # (itil-runtime-sid-marker.sh) writes the runtime stdin session_id
+  # to a per-machine marker on EVERY tool call. The helper, running
+  # inside a Bash tool call, reads the marker that the same Bash
+  # tool call's PreToolUse hook just wrote — by construction the
+  # current session's SID. This is the authoritative path; the
+  # announce-marker fallback below is the cold-path (no PreToolUse
+  # has fired yet in this session).
+  local rt_lib_dir
+  rt_lib_dir="$(cd "$(dirname "${BASH_SOURCE[0]}")" 2>/dev/null && pwd)"
+  if [ -f "${rt_lib_dir}/runtime-sid.sh" ]; then
+    # shellcheck source=runtime-sid.sh
+    source "${rt_lib_dir}/runtime-sid.sh"
+    local rt_path rt_sid
+    rt_path=$(runtime_sid_path)
+    if [ -s "$rt_path" ]; then
+      rt_sid=$(cat "$rt_path" 2>/dev/null)
+      if [ -n "$rt_sid" ]; then
+        echo "$rt_sid"
+        return 0
+      fi
+    fi
+  fi
+
   local marker_dir="${SESSION_MARKER_DIR:-/tmp}"
 
   # Marker-system priority order. Architect first because architect-

package/hooks/manage-problem-enforce-create.sh

@@ -117,20 +117,14 @@ if check_create_gate "$SESSION_ID"; then
   exit 0
 fi
 
-# P144 / ADR-048: gate-misfire recovery hint. When SOME marker exists (for
-# any SID) but the gate denies, the agent is likely hitting the P124 Phase 3
-# helper regression — `mark_step2_complete` succeeded but the marker landed
-# under the wrong UUID. Append a recovery pointer to the deny message so
-# the agent finds the documented two-tier procedure in SKILL.md Step 2
-# substep 7 instead of reaching for the brute-force-marker anti-pattern
-# (139-marker incident, 2026-04-28 P144 driver evidence).
-#
-# Routine first-creation deny (no marker for ANY SID in this session)
-# leaves the deny message unchanged — the helper-bug signal is conditional.
-RECOVERY_HINT=""
-if compgen -G '/tmp/manage-problem-grep-*' > /dev/null 2>&1; then
-  RECOVERY_HINT=" (Helper succeeded but SID mismatch detected — see manage-problem SKILL.md Step 2 substep 7.)"
-fi
-
-create_gate_deny "BLOCKED: Cannot Write '${BASENAME}' under docs/problems/ without running /wr-itil:manage-problem Step 2 (duplicate-check) first. New problem tickets MUST be created via the skill so the duplicate-prevention grep fires before the file lands. Invoke the Skill tool with skill='wr-itil:manage-problem' and a description of the new problem; Step 2 will grep for related existing tickets and surface any matches via AskUserQuestion before creating the new ticket. (P119)${RECOVERY_HINT}"
+# P142 / ADR-050: the runtime-SID instrumentation hook
+# (itil-runtime-sid-marker.sh) writes the runtime stdin session_id to a
+# per-machine marker on every PreToolUse:Bash|Write|Edit|Read event. The
+# `get_current_session_id` helper reads that marker as the authoritative
+# SID, so the marker `mark_step2_complete` writes is bound to the same
+# session_id this hook will see on the subsequent Write. SID-mismatch
+# denial is structurally eliminated; the only remaining deny path is
+# the routine "Step 2 grep has not run yet for this session" case, for
+# which the deny message stays focused and skill-pointing.
+create_gate_deny "BLOCKED: Cannot Write '${BASENAME}' under docs/problems/ without running /wr-itil:manage-problem Step 2 (duplicate-check) first. New problem tickets MUST be created via the skill so the duplicate-prevention grep fires before the file lands. Invoke the Skill tool with skill='wr-itil:manage-problem' and a description of the new problem; Step 2 will grep for related existing tickets and surface any matches via AskUserQuestion before creating the new ticket. (P119)"
 exit 0

package/hooks/test/manage-problem-enforce-create.bats

@@ -187,16 +187,23 @@ set_marker() {
   [[ "$output" != *"BLOCKED"* ]]
 }
 
-# --- P144 / ADR-048: gate-misfire recovery hint on deny message ---
+# --- P142 / ADR-050: deny-message simplicity post-supersession ---
 #
-# When the deny fires AND any /tmp/manage-problem-grep-* marker exists for
-# SOME SID, that's the helper-bug signal (P124 Phase 3 regression — helper
-# returned wrong SID, marker exists but doesn't match runtime hook stdin).
-# The deny message appends a recovery pointer to direct the agent at the
-# documented two-tier procedure in SKILL.md Step 2 substep 7.
+# ADR-048 documented a two-tier recovery procedure for SID-mismatch denials
+# (when the helper picked a stale subprocess SID while the runtime hook saw
+# the orchestrator SID). The hook appended a "Helper succeeded but SID
+# mismatch detected — see manage-problem SKILL.md Step 2 substep 7."
+# pointer when SOME marker existed for SOME SID (the helper-bug signal).
 #
-# Routine first-creation deny (no marker exists for any SID at all) is
-# unchanged — recovery hint MUST NOT appear.
+# P142 / ADR-050 superseded ADR-048 by capturing the runtime stdin SID
+# in a per-machine marker via a new PreToolUse hook
+# (`itil-runtime-sid-marker.sh`). The helper reads the marker as
+# authoritative; SID-mismatch is structurally impossible in routine flow.
+# The conditional RECOVERY_HINT was removed; the deny message stays
+# terse and skill-pointing regardless of marker presence.
+#
+# These tests pin that the deny message is INVARIANT of the
+# /tmp/manage-problem-grep-* marker state (no recovery-hint branching).
 
 setup_other_sid_marker() {
   OTHER_SID="other-sid-$$-$RANDOM"
@@ -209,35 +216,21 @@ teardown_other_sid_marker() {
   fi
 }
 
-@test "deny without ANY /tmp/manage-problem-grep-* marker → deny message OMITS recovery hint" {
-  # Scrub any markers so the helper-bug signal cannot fire.
+@test "deny without ANY /tmp/manage-problem-grep-* marker → deny is terse, no recovery prose" {
   rm -f /tmp/manage-problem-grep-*
   run run_write_hook "$PWD/docs/problems/999-foo.open.md" "$SID"
   [ "$status" -eq 0 ]
   [[ "$output" == *"BLOCKED"* ]]
-  # No marker exists for any SID → routine first-creation deny → no recovery hint.
   [[ "$output" != *"SID mismatch"* ]]
   [[ "$output" != *"Step 2 substep 7"* ]]
 }
 
-@test "deny with /tmp/manage-problem-grep-* marker for OTHER SID → deny message INCLUDES recovery hint" {
-  # Scrub other markers first, then set a marker for a different SID.
-  rm -f /tmp/manage-problem-grep-*
-  setup_other_sid_marker
-  run run_write_hook "$PWD/docs/problems/999-foo.open.md" "$SID"
-  status=$?
-  teardown_other_sid_marker
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"BLOCKED"* ]]
-  # Marker exists for OTHER SID → helper-bug signal → recovery hint appended.
-  [[ "$output" == *"SID mismatch"* ]]
-  [[ "$output" == *"Step 2 substep 7"* ]]
-}
-
-@test "recovery hint avoids ADR-038 jargon (no internal P-number jargon in deny string)" {
-  # ADR-038 progressive disclosure — deny stays terse + actionable. Architect
-  # advisory rejected "P124-Phase-3-regression" wording in favour of plain
-  # "Helper succeeded but SID mismatch detected".
+@test "deny with /tmp/manage-problem-grep-* marker for OTHER SID → deny is terse (post-ADR-050; no recovery hint)" {
+  # Pre-ADR-050 contract: an other-SID marker triggered the helper-bug
+  # recovery pointer. Post-ADR-050: the runtime-SID marker prevents
+  # SID-mismatch in routine flow, so the recovery pointer is removed.
+  # The deny message is identical regardless of marker presence — the
+  # only signal that matters is "this session has not run Step 2".
   rm -f /tmp/manage-problem-grep-*
   setup_other_sid_marker
   run run_write_hook "$PWD/docs/problems/999-foo.open.md" "$SID"
@@ -245,5 +238,6 @@ teardown_other_sid_marker() {
   teardown_other_sid_marker
   [ "$status" -eq 0 ]
   [[ "$output" == *"BLOCKED"* ]]
-  [[ "$output" != *"P124-Phase-3-regression"* ]]
+  [[ "$output" != *"SID mismatch"* ]]
+  [[ "$output" != *"Step 2 substep 7"* ]]
 }

package/hooks/test/runtime-sid-marker.bats

@@ -0,0 +1,90 @@
+#!/usr/bin/env bats
+
+# P142 / ADR-050: itil-runtime-sid-marker.sh PreToolUse hook.
+#
+# Behavioural contract:
+#   1. Hook receives JSON on stdin with a `session_id` field.
+#   2. Hook writes the session_id to the runtime-SID marker path
+#      (computed by `runtime_sid_path()` in lib/runtime-sid.sh).
+#   3. Hook emits 0 bytes on stdout (ADR-045 Pattern 1: side-effect-only,
+#      silent-on-pass — no context budget burn per tool call).
+#   4. Hook always exits 0 (fail-open — never block a tool call on
+#      marker write).
+#   5. Empty session_id -> hook is a no-op (marker not touched).
+#   6. Subsequent invocations OVERWRITE the marker (so a subprocess
+#      tool call replaces the orchestrator's SID with the subprocess's
+#      SID for the duration of the subprocess; the orchestrator's
+#      next tool call after subprocess exit overwrites it back).
+#
+# Per feedback_behavioural_tests.md (P081): tests assert the hook's
+# observable effects (marker contents, stdout bytes, exit code) — NOT
+# the source content of the hook script.
+
+setup() {
+  SCRIPT_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  HOOK="$SCRIPT_DIR/itil-runtime-sid-marker.sh"
+  SANDBOX_TMP=$(mktemp -d)
+  export SESSION_MARKER_DIR="$SANDBOX_TMP"
+  MARKER_PATH="$SANDBOX_TMP/itil-runtime-sid.current"
+}
+
+teardown() {
+  rm -rf "$SANDBOX_TMP"
+  unset SESSION_MARKER_DIR
+}
+
+# Helper: invoke the hook with a JSON stdin payload.
+fire_hook() {
+  local json="$1"
+  echo "$json" | bash "$HOOK"
+}
+
+@test "hook writes session_id to runtime-SID marker" {
+  expected_uuid="aaaaaaaa-1111-2222-3333-444444444444"
+  fire_hook "{\"session_id\":\"$expected_uuid\",\"tool_name\":\"Bash\"}"
+  [ -f "$MARKER_PATH" ]
+  [ "$(cat "$MARKER_PATH")" = "$expected_uuid" ]
+}
+
+@test "hook is silent on stdout (ADR-045 Pattern 1)" {
+  expected_uuid="bbbbbbbb-1111-2222-3333-444444444444"
+  output=$(fire_hook "{\"session_id\":\"$expected_uuid\",\"tool_name\":\"Bash\"}")
+  [ -z "$output" ]
+}
+
+@test "hook exits 0 on success" {
+  expected_uuid="cccccccc-1111-2222-3333-444444444444"
+  echo "{\"session_id\":\"$expected_uuid\",\"tool_name\":\"Bash\"}" | bash "$HOOK"
+  [ "$?" -eq 0 ]
+}
+
+@test "hook overwrites prior marker on subsequent invocation" {
+  first_uuid="dddddddd-1111-2222-3333-444444444444"
+  second_uuid="eeeeeeee-1111-2222-3333-444444444444"
+  fire_hook "{\"session_id\":\"$first_uuid\",\"tool_name\":\"Bash\"}"
+  [ "$(cat "$MARKER_PATH")" = "$first_uuid" ]
+  fire_hook "{\"session_id\":\"$second_uuid\",\"tool_name\":\"Write\"}"
+  [ "$(cat "$MARKER_PATH")" = "$second_uuid" ]
+}
+
+@test "hook is a no-op when session_id is empty" {
+  fire_hook "{\"tool_name\":\"Bash\"}"
+  [ ! -f "$MARKER_PATH" ]
+}
+
+@test "hook is a no-op when stdin is not valid JSON" {
+  echo "not-json-at-all" | bash "$HOOK"
+  [ "$?" -eq 0 ]
+  [ ! -f "$MARKER_PATH" ]
+}
+
+@test "hook fail-open on jq absent (graceful degradation)" {
+  # Simulate jq absent by making PATH not include any jq binary.
+  expected_uuid="ffffffff-1111-2222-3333-444444444444"
+  result=$(echo "{\"session_id\":\"$expected_uuid\",\"tool_name\":\"Bash\"}" | env PATH="/usr/bin:/bin" bash "$HOOK"; echo "EXIT:$?")
+  # Either jq is in /usr/bin (fine — marker written), or it's absent
+  # (hook should still exit 0 without crashing). The exit-0 contract
+  # is the load-bearing assertion; marker presence is a bonus when
+  # jq is available.
+  [[ "$result" == *"EXIT:0"* ]]
+}

package/hooks/test/session-id.bats

@@ -176,3 +176,83 @@ mark_announced() {
   [[ "$output" != *"$middle_uuid"* ]]
   [[ "$output" == *"EXIT:0"* ]]
 }
+
+# --- Behavioural contract: runtime-SID marker (P142 Phase 4) ---
+#
+# Phase 3 mtime-based within-system selection introduced a regression
+# in orchestrator main turns AFTER subprocess dispatch: subprocess
+# announce markers have NEWER mtime than the orchestrator's, so the
+# helper picked the subprocess SID while the runtime hook stdin still
+# contained the orchestrator SID — marker landed under the wrong UUID,
+# create-gate (P119) denied. Mirror failure mode would fire in
+# subprocess context if the priority list were re-ordered to favour
+# orchestrator-only announce systems (no pure-helper algorithm can
+# distinguish "running in orchestrator main turn" from "running in
+# subprocess" by filesystem state alone).
+#
+# Phase 4 structural fix: a new PreToolUse hook
+# (`itil-runtime-sid-marker.sh`) writes the runtime stdin session_id
+# to a per-machine marker on every tool call. The helper reads this
+# marker FIRST as the authoritative current-session SID, falling back
+# to the existing announce-marker priority logic when the marker is
+# absent (cold path — first tool call of a session, before any
+# PreToolUse fires).
+#
+# Sandbox path: when SESSION_MARKER_DIR is set (test override), the
+# runtime marker lives at `${SESSION_MARKER_DIR}/itil-runtime-sid.current`
+# — a single fixed filename, no per-user/per-project scoping. The
+# scoping suffix used in prod (`-${USER}-${proj_hash}`) is irrelevant
+# under sandbox because every test gets a fresh SANDBOX_TMP.
+
+@test "runtime-SID marker present: helper returns marker contents over newer announce markers" {
+  runtime_uuid="dddddddd-dddd-dddd-dddd-dddddddddddd"
+  decoy_uuid="eeeeeeee-eeee-eeee-eeee-eeeeeeeeeeee"
+  # Decoy: an architect-announced marker with a NEWER mtime than the
+  # runtime marker. The Phase 3 helper would have picked decoy_uuid;
+  # the Phase 4 helper picks runtime_uuid because the runtime-SID
+  # marker is authoritative.
+  printf '%s' "$runtime_uuid" > "$SANDBOX_TMP/itil-runtime-sid.current"
+  sleep 1
+  mark_announced "architect" "$decoy_uuid"
+  output=$(discover)
+  [[ "$output" == *"$runtime_uuid"* ]]
+  [[ "$output" != *"$decoy_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "runtime-SID marker empty: helper falls back to announce-marker priority" {
+  expected_uuid="ffffffff-ffff-ffff-ffff-ffffffffffff"
+  mark_announced "architect" "$expected_uuid"
+  # Empty runtime marker (zero-byte file) — helper must NOT return
+  # the empty contents; it must fall through to the announce-marker
+  # scrape. Empty marker can occur if the hook ran with empty
+  # session_id stdin (test harness, hook self-test) and would still
+  # leave the file at zero bytes per the hook's empty-input fail-open.
+  : > "$SANDBOX_TMP/itil-runtime-sid.current"
+  output=$(discover)
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "runtime-SID marker absent (cold path): helper uses announce-marker priority unchanged" {
+  expected_uuid="aaaaaaaa-bbbb-cccc-dddd-eeeeeeeeeeee"
+  mark_announced "architect" "$expected_uuid"
+  # No runtime marker created — cold path. Helper falls back to
+  # existing Phase 3 announce-marker priority. This test pins the
+  # backwards-compat contract: sessions whose first tool call hasn't
+  # yet fired the PreToolUse hook still discover their SID via the
+  # announce-marker fallback (the priority list is preserved as-is).
+  output=$(discover)
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "env var beats runtime-SID marker (env-var fast path preserved)" {
+  env_uuid="11111111-aaaa-bbbb-cccc-222222222222"
+  marker_uuid="22222222-aaaa-bbbb-cccc-333333333333"
+  printf '%s' "$marker_uuid" > "$SANDBOX_TMP/itil-runtime-sid.current"
+  output=$(CLAUDE_SESSION_ID="$env_uuid" SESSION_MARKER_DIR="$SANDBOX_TMP" bash -c "source '$HELPER'; get_current_session_id; echo \"EXIT:\$?\"")
+  [[ "$output" == *"$env_uuid"* ]]
+  [[ "$output" != *"$marker_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}

package/package.json

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

package/skills/manage-problem/SKILL.md

@@ -271,46 +271,7 @@ Before creating, search existing problems for similar issues. The user may not k
 
    **Why a helper instead of inline `${CLAUDE_SESSION_ID:-default}`**: the agent's process does NOT export `CLAUDE_SESSION_ID` today; the hook side reads `session_id` from its stdin JSON payload (per the Claude Code PreToolUse contract). The prior fallback wrote the marker under `default` while the hook checked the real UUID — mismatch caused the Write deny on every first ticket of a session until the agent ad-hoc scraped a UUID-bearing marker. The helper canonicalises that scrape so every agent context discovers the SID the same way. P124.
 
-   <!-- supersedes-when: P142 ships -->
-   **Recovery if hook denial persists** (P144 / ADR-048 — auto-supersedes when P142 ships):
-
-   The P124 helper has a Phase 3 regression in orchestrator sessions that have dispatched subprocesses: it sometimes returns a subprocess SID instead of the orchestrator SID, while the runtime hook stdin still contains the orchestrator SID. The marker lands under the wrong UUID; the next `Write` is denied even though `mark_step2_complete` succeeded. The hook deny message includes a `(Helper succeeded but SID mismatch detected — see manage-problem SKILL.md Step 2 substep 7.)` pointer when this signal is observable.
-
-   **Gate-misfire signal** — recovery applies ONLY when ALL three conditions hold:
-   1. The agent is **already executing** `/wr-itil:manage-problem` Step 2 in this turn (i.e., the SKILL contract has just ordered the grep for THIS ticket creation — not a marker carried over from a prior unrelated invocation in the same session).
-   2. `mark_step2_complete` succeeded (the helper exited zero — no SID-discovery error).
-   3. The subsequent `Write` to the new `.<status>.md` file is denied by the P119 hook.
-
-   Routine creation flow does NOT match these conditions and MUST continue through the standard `Write` path. The recovery is mechanical (deterministic from the gate-misfire signal — no `AskUserQuestion` required, per ADR-044's framework-mediated surface catalog extension).
-
-   **First-tier recovery — announce-marker scrape**:
-
-   ```bash
-   # Discover the orchestrator session UUID via the most-reliable per-session announce marker.
-   # The orchestrator SID is what the runtime hook stdin contains in the common subprocess case.
-   sid=$(ls -t /tmp/itil-assistant-gate-announced-* 2>/dev/null | head -1 | sed 's|.*itil-assistant-gate-announced-||')
-   [ -n "$sid" ] && touch "/tmp/manage-problem-grep-${sid}"
-   # Retry the Write.
-   ```
-
-   **Second-tier recovery — python3-via-Bash file-write** (2026-04-29 evidence: runtime hook stdin SID may not be in any announce-marker class; first-tier returns the orchestrator SID, but the runtime SID is a different per-Write SID surfaced only by `architect-reviewed-*` mtime, not by any announce-marker):
-
-   ```bash
-   # The hook is PreToolUse:Write; python3-in-Bash is not a Write tool call,
-   # so the hook never fires. Use only when first-tier fails.
-   python3 -c "from pathlib import Path; Path('docs/problems/<NNN>-<title>.open.md').write_text('''<file body>''')"
-   ```
-
-   **Audit-trail-preservation test** — the second-tier procedure is sanctioned ONLY in the audit-trail-preserved branch:
-
-   - ✅ **Audit-trail-preserved**: the agent is currently executing `/wr-itil:manage-problem` Step 2 for THIS ticket creation (gate-misfire signal condition 1), AND any `/tmp/manage-problem-grep-*` marker exists. The skill flow itself is the just-ran-grep witness; the marker existence corroborates it.
-   - ❌ **Audit-trail-violated**: the agent is NOT in `/wr-itil:manage-problem` Step 2 for this ticket creation, OR no marker exists for any SID. Routine first-creation flow MUST hit the gate; the recovery procedure does NOT apply.
-
-   **Anti-pattern bound** — the loose reading "any marker from any earlier `manage-problem` invocation in this session" would let the recovery procedure apply to a fresh ticket creation that happens to reuse a stale marker from a prior unrelated invocation. That is the P131 anti-pattern surface (gate state as a workaround target instead of as a directive). The bound holds because the recovery is invoked from inside an active manage-problem flow where Step 2 has just been ordered for THIS ticket, AND the python3-via-Bash branch is named in this substep so its invocation is itself audit-trail-emitting.
-
-   **DO NOT brute-force-touch markers for every announced UUID.** That pattern (139 markers in one session, 2026-04-28 P144 evidence) satisfies the marker shape while gaming the audit trail the marker is supposed to record. The user has explicitly rejected this pattern: *"WTF? Why did you bypass instead of using the skill?"* (P144 driver correction). Brute-forcing markers for SIDs that did not run Step 2 is the canonical bypass — the recovery procedure above is the canonical use of the skill.
-
-   **Cross-references**: P124 (helper Phase 3 regression — driver of the misfire); P142 (P124 Phase 4 — structural fix that auto-supersedes this recovery when shipped); P131 (gate-exclusions-as-write-permission — adjacent anti-pattern family); ADR-048 (sanctioning + scoping ADR); ADR-009 (gate marker lifecycle); ADR-044 (mechanical-decision framework-mediated surface catalog).
+   **Phase 4 (P142 / ADR-050)** — the helper now reads the runtime stdin `session_id` from a per-machine marker written by the `itil-runtime-sid-marker.sh` PreToolUse hook on every tool call. Because every Bash call that sources the helper is itself a PreToolUse:Bash event, the marker the helper reads was written moments earlier with the same `session_id` the runtime Write hook will see — so SID-mismatch denial is structurally impossible in the routine flow. The Phase 3 announce-marker priority logic is preserved as cold-path fallback (first tool call of a session, before any PreToolUse fires).
 
 **Search strategy**: Search problem filenames AND file content. A match on the filename (kebab-case title) or the Description/Symptoms sections counts. Cast a wide net — false positives are cheap (user chooses), but false negatives mean duplicate problems.
 

package/skills/manage-problem/test/manage-problem-p119-recovery-path.bats

@@ -1,165 +0,0 @@
-#!/usr/bin/env bats
-#
-# packages/itil/skills/manage-problem/test/manage-problem-p119-recovery-path.bats
-#
-# Behavioural tests for manage-problem Step 2 substep 7's P119 hook-misfire
-# recovery procedure (P144 / ADR-048).
-#
-# Step 2 substep 7 documents a two-tier recovery for the case where
-# `mark_step2_complete` succeeded but the P119 PreToolUse:Write hook still
-# denies the new ticket Write — typically because the P124 helper returned
-# a subprocess SID instead of the orchestrator SID (ADR-048 Phase 3
-# regression). Without documented recovery, the agent reaches for the
-# brute-force-touch-every-marker anti-pattern (139-marker incident,
-# 2026-04-28). User correction was emphatic: "WTF? Why did you bypass
-# instead of using the skill?"
-#
-# This bats fixes the contract:
-#   - Sub-block names the gate-misfire signal (active flow + helper-succeeded
-#     + Write-denied conjunction).
-#   - Two-tier procedure named (first-tier announce-marker scrape; second-tier
-#     python3-via-Bash file-write).
-#   - Audit-trail-preservation test as the gate-on-sanctioning rule.
-#   - Anti-pattern call-out ("DO NOT brute-force") in durable form.
-#   - ADR-048, P124, P142 cross-references.
-#   - <!-- supersedes-when: P142 ships --> HTML comment for cleanup
-#     discoverability.
-#
-# tdd-review: structural-permitted (justification: skill behavioural
-# harness pending P012 + P081 Phase 2; SKILL.md contract assertions
-# bridge until then; expected to migrate to behavioural form once
-# the harness exists).
-#
-# @problem P144
-# @adr ADR-048 (Documented recovery from gate misfire is the prescribed surface, not bypass)
-# @adr ADR-009 (gate marker lifecycle)
-# @adr ADR-013 Rule 5 (policy-authorised silent proceed)
-# @adr ADR-022 (problem lifecycle status suffixes)
-# @adr ADR-037 / P081 (testing strategy — bridge during harness build)
-# @adr ADR-038 (progressive disclosure — deny message terse)
-# @adr ADR-044 (decision-delegation — recovery is mechanical)
-# @jtbd JTBD-001 / JTBD-101 / JTBD-201
-
-SKILL_FILE="${BATS_TEST_DIRNAME}/../SKILL.md"
-
-setup() {
-  [ -f "$SKILL_FILE" ]
-}
-
-# Bound the search to Step 2 substep 7 region (between Step 2 heading and Step 3 heading).
-step2_text() {
-  awk '/^### 2\. /,/^### 3\. /' "$SKILL_FILE"
-}
-
-# ── Recovery sub-block presence ─────────────────────────────────────────────
-
-@test "Step 2 SKILL.md contains a Recovery sub-block for hook-denial misfire" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"Recovery"* ]]
-  [[ "$output" == *"hook denial"* ]] || [[ "$output" == *"hook still denies"* ]] || [[ "$output" == *"deny"* ]]
-}
-
-# ── Gate-misfire signal definition ──────────────────────────────────────────
-
-@test "Step 2 SKILL.md names the gate-misfire signal precondition (active manage-problem flow)" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  # The signal requires that the agent is already executing manage-problem
-  # Step 2 in the current turn — not just any prior session marker.
-  [[ "$output" == *"already executing"* ]] || [[ "$output" == *"active"* ]] || [[ "$output" == *"this turn"* ]]
-}
-
-@test "Step 2 SKILL.md names mark_step2_complete success as part of the misfire signal" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"mark_step2_complete"* ]]
-}
-
-# ── Two-tier procedure ──────────────────────────────────────────────────────
-
-@test "Step 2 SKILL.md names the first-tier recovery (announce-marker scrape)" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"first-tier"* ]] || [[ "$output" == *"First-tier"* ]]
-  [[ "$output" == *"itil-assistant-gate-announced"* ]]
-}
-
-@test "Step 2 SKILL.md names the second-tier recovery (python3-via-Bash file-write)" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"second-tier"* ]] || [[ "$output" == *"Second-tier"* ]]
-  [[ "$output" == *"python3"* ]]
-  [[ "$output" == *"Bash"* ]]
-}
-
-# ── Audit-trail-preservation test ───────────────────────────────────────────
-
-@test "Step 2 SKILL.md states the audit-trail-preservation test as the sanctioning rule" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"audit-trail"* ]] || [[ "$output" == *"audit trail"* ]]
-}
-
-@test "Step 2 SKILL.md names the anti-pattern bound (any-marker-anywhere is NOT the test)" {
-  # Architect advisory: the bound must rule out the loose "any marker from any
-  # earlier invocation in this session" reading — that's the P131 surface.
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"this ticket"* ]] || [[ "$output" == *"THIS ticket"* ]]
-}
-
-# ── Anti-pattern call-out (durable surface) ─────────────────────────────────
-
-@test "Step 2 SKILL.md contains the explicit DO-NOT-brute-force anti-pattern wording" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"DO NOT brute-force"* ]] || [[ "$output" == *"do not brute-force"* ]] || [[ "$output" == *"Do not brute-force"* ]]
-}
-
-@test "Step 2 SKILL.md cites the 2026-04-28 user correction context for the anti-pattern" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"P144"* ]]
-}
-
-# ── Cross-references ────────────────────────────────────────────────────────
-
-@test "Step 2 SKILL.md cites ADR-048 for the recovery procedure scope" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"ADR-048"* ]]
-}
-
-@test "Step 2 SKILL.md cites P124 as the helper-bug source" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"P124"* ]]
-}
-
-@test "Step 2 SKILL.md cites P142 as the structural fix (supersession trigger)" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"P142"* ]]
-}
-
-# ── Supersession comment (CI-enforced cleanup invariant) ────────────────────
-
-@test "Step 2 SKILL.md carries the supersedes-when HTML comment so cleanup is discoverable" {
-  # ADR-048 Reassessment Criteria: when P142's resolution ADR is accepted,
-  # this comment must be removed from SKILL.md source. Today the comment
-  # is present and this assertion passes; once P142 lands, the cleanup
-  # signal lives here.
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"supersedes-when"* ]]
-  [[ "$output" == *"P142"* ]]
-}
-
-# ── Mechanical (no-AskUserQuestion) per ADR-044 ─────────────────────────────
-
-@test "Step 2 SKILL.md states the recovery is mechanical (no AskUserQuestion required)" {
-  run step2_text
-  [ "$status" -eq 0 ]
-  [[ "$output" == *"mechanical"* ]] || [[ "$output" == *"ADR-044"* ]]
-}