@windyroad/itil 0.19.6 → 0.19.7-preview.208

package/.claude-plugin/plugin.json

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

package/hooks/hooks.json

@@ -11,6 +11,10 @@
       {
         "matcher": "Write",
         "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/manage-problem-enforce-create.sh" }]
+      },
+      {
+        "matcher": "Bash",
+        "hooks": [{ "type": "command", "command": "${CLAUDE_PLUGIN_ROOT}/hooks/p057-staging-trap-detect.sh" }]
       }
     ],
     "Stop": [

package/hooks/lib/session-id.sh

@@ -0,0 +1,108 @@
+#!/bin/bash
+# P124: agent-side session-ID discovery helper.
+#
+# `get_current_session_id` returns the canonical Claude Code session UUID
+# for the current invocation, used by /wr-itil:manage-problem Step 2
+# substep 7 to write the create-gate marker (`/tmp/manage-problem-grep-${SID}`)
+# under the same SID the manage-problem-enforce-create.sh hook reads from
+# its stdin JSON payload.
+#
+# Why this helper exists:
+#   The agent's process does NOT export CLAUDE_SESSION_ID. The hook side
+#   reads session_id from its stdin JSON payload (per the Claude Code
+#   PreToolUse contract); the agent side has no equivalent surface, so
+#   /wr-itil:manage-problem Step 2's prior fallback `${CLAUDE_SESSION_ID:-default}`
+#   wrote the marker under "default" while the hook checked the real UUID.
+#   Marker mismatch -> Write deny -> agent had to scrape an existing
+#   announce marker filename ad-hoc to recover. P124.
+#
+# Discovery strategy (announce markers preferred over reviewed markers):
+#   /tmp/${SYSTEM}-announced-${SESSION_ID} markers are write-once-per-session
+#   per ADR-038 and are emitted on the FIRST UserPromptSubmit of every
+#   session by every active plugin (architect, jtbd, tdd, style-guide,
+#   voice-tone, itil-assistant-gate, itil-correction-detect). They have
+#   no mtime sliding (unlike `-reviewed-` gate markers, which `touch`-refresh
+#   on every gate check per ADR-009 sliding TTL + P111 subprocess refresh),
+#   so the announce-marker UUID is the most reliable per-session signal
+#   reachable from agent-side code without an env var.
+#
+# Why itil-local instead of packages/shared (cf. ADR-017):
+#   The discovery direction is the OPPOSITE of ADR-038's announce helper —
+#   ADR-038's session-marker.sh WRITES announce markers from hook side;
+#   this helper READS them from agent side. Only manage-problem SKILL.md
+#   needs agent-side discovery today (Step 2 substep 7), so the helper
+#   is itil-local with read-only fallbacks across other plugins' marker
+#   filenames (no write coupling, no sync obligation). If a second skill
+#   adopts agent-side SID discovery, promote to packages/shared/ at that
+#   point per ADR-017 shared-code-sync. Mirrors create-gate.sh's "Why a
+#   separate helper from lib/review-gate.sh" precedent.
+#
+# Empty SESSION_ID fallback:
+#   No env-var + no markers -> echo nothing, return 1. Callers MUST check
+#   the return code; a marker-write under an empty SID would land at
+#   /tmp/manage-problem-grep- which the hook never matches. Fail-closed.
+#
+# References:
+#   ADR-038 — progressive disclosure / session-marker pattern (announce
+#             markers, /tmp/${SYSTEM}-announced-${SESSION_ID} convention).
+#   ADR-009 — gate marker lifecycle (covers /tmp marker conventions).
+#   ADR-017 — shared-code-sync (consulted; itil-local is the right home today).
+#   P119    — create-gate hook this discovery helper feeds.
+#   P124    — this helper.
+#
+# Test override: SESSION_MARKER_DIR (defaults to /tmp) lets bats run
+# under a sandboxed marker directory without polluting real session
+# state in /tmp.
+
+# Returns the canonical session UUID for the current invocation.
+# Echoes the UUID on stdout. Exit 0 if discovered, 1 if not.
+#
+# Usage:
+#   source packages/itil/hooks/lib/session-id.sh
+#   sid=$(get_current_session_id) || { echo "no SID available" >&2; exit 1; }
+get_current_session_id() {
+  # Env-var fast path. CLAUDE_SESSION_ID is not exported in agent
+  # contexts today, but if a future Claude Code release adds it,
+  # this branch picks it up for free.
+  if [ -n "${CLAUDE_SESSION_ID:-}" ]; then
+    echo "$CLAUDE_SESSION_ID"
+    return 0
+  fi
+
+  local marker_dir="${SESSION_MARKER_DIR:-/tmp}"
+
+  # Marker-system priority order. Architect first because architect-
+  # enforce-edit.sh fires on virtually every project edit and so its
+  # announce marker is the most reliably present early in any session
+  # touching this repo. JTBD second for the same reason on this project.
+  # The remaining systems give graceful degradation if the higher-
+  # priority hooks haven't yet announced (rare — UserPromptSubmit
+  # announces fire on prompt 1).
+  local systems=(
+    architect
+    jtbd
+    tdd
+    itil-assistant-gate
+    itil-correction-detect
+    style-guide
+    voice-tone
+  )
+
+  local system marker
+  for system in "${systems[@]}"; do
+    # Glob expansion: nullglob avoids the literal-pattern-on-no-match
+    # pitfall. Subshell isolates the shopt change.
+    marker=$(
+      shopt -s nullglob
+      set -- "${marker_dir}/${system}-announced-"*
+      [ "$#" -gt 0 ] && printf '%s\n' "$1"
+    )
+    if [ -n "$marker" ]; then
+      # Strip the prefix to recover the trailing UUID.
+      basename "$marker" | sed "s/^${system}-announced-//"
+      return 0
+    fi
+  done
+
+  return 1
+}

package/hooks/lib/staging-detect.sh

@@ -0,0 +1,107 @@
+#!/bin/bash
+# P125: shared staging-trap detection helper.
+#
+# `detect_p057_trap` returns 0 (no trap detected — allow) / 1 (trap
+# detected — caller should deny). On 1, the trap'd path is echoed on
+# stdout and a one-line recovery hint is emitted on stderr so callers
+# can surface both in deny messages without re-parsing diff output.
+#
+# Trap shape (P057):
+#   `git mv A B` stages the rename atomically. If the agent then
+#   modifies B via the Edit tool (or any other working-tree edit),
+#   git's index still carries only the rename — the post-rename
+#   content edit is a working-tree modification needing a separate
+#   `git add B`. Without that re-stage, only the rename lands at
+#   commit time and the edit leaks into the next commit (audit-trail
+#   corruption — the original P057 concern).
+#
+# Detection logic:
+#   - `git diff --staged --name-status` enumerates staged changes;
+#     rename rows start with `R<num>\t<old>\t<new>`.
+#   - `git diff --name-only` enumerates working-tree modifications.
+#   - If any rename's `<new>` path also appears in the working-tree
+#     modification list, the trap shape is present.
+#
+# Cost: two `git diff` invocations per check (~10-50ms on this repo's
+# working tree; bounded by repo size, not commit batch size). Per
+# architect verdict on P125: cheaper than a session-marker variant
+# and deterministic — runs on every `git commit` invocation rather
+# than relying on per-tool-call session state tracking.
+#
+# Fail-open contract:
+#   - Outside a git working tree, or when `git diff` fails for any
+#     reason (parse error, broken index, permissions), return 0
+#     (allow). Mirrors `lib/create-gate.sh`'s exit-0 fallback on
+#     parse-incomplete input — a hook that fails-closed on hostile
+#     environments would block legitimate commits in non-git contexts
+#     (e.g. agent-driven scripts that happen to mention `git commit`
+#     in unrelated contexts).
+#
+# References:
+#   ADR-005 — plugin testing strategy (hook bats live under hooks/test/).
+#   ADR-009 — gate marker lifecycle (this helper deliberately does NOT
+#             use markers; detection is per-invocation deterministic,
+#             not per-session trust window).
+#   ADR-013 Rule 1 — deny redirects with mechanical recovery (the deny
+#                    text names the file + the literal `git add <new>`
+#                    recovery; no skill round-trip required).
+#   ADR-038 — progressive disclosure / deny-message terseness.
+#   P057    — original staging-trap ticket (closed; documentation fix).
+#   P119    — sibling create-gate hook + lib/create-gate.sh helper
+#             (precedent for the deny + helper-pair shape).
+#   P125    — this helper.
+
+# Detect the P057 staging trap in the current git working tree.
+#
+# Echoes the trap'd path on stdout when detected; emits a one-line
+# recovery hint on stderr.
+#
+# Returns:
+#   0 — no trap (allow / fail-open)
+#   1 — trap detected (caller should deny)
+#
+# Usage:
+#   if trapped=$(detect_p057_trap 2>/dev/null); then
+#     echo "no trap"
+#   else
+#     echo "trap on $trapped"
+#   fi
+detect_p057_trap() {
+  # Fail-open if not inside a git working tree.
+  git rev-parse --is-inside-work-tree >/dev/null 2>&1 || return 0
+
+  # Staged renames: rows shaped `R<num>\t<old>\t<new>`.
+  local staged_renames
+  staged_renames=$(git diff --staged --name-status 2>/dev/null) || return 0
+
+  # Working-tree modifications: one path per line.
+  local wt_mods
+  wt_mods=$(git diff --name-only 2>/dev/null) || return 0
+
+  # No working-tree mods at all => nothing can be the post-rename
+  # content edit. Fast bail.
+  [ -n "$wt_mods" ] || return 0
+
+  # Walk staged renames; if any `<new>` path also appears in the
+  # working-tree mod list, the trap is present.
+  local line new_path
+  while IFS= read -r line; do
+    case "$line" in
+      R*)
+        # Tab-delimited: status \t old \t new — take the third field.
+        new_path=$(printf '%s' "$line" | awk -F'\t' '{print $3}')
+        [ -n "$new_path" ] || continue
+        # Match against working-tree mod list (full-line match).
+        if printf '%s\n' "$wt_mods" | grep -Fxq "$new_path"; then
+          printf '%s\n' "$new_path"
+          echo "P057 staging-trap: re-stage with: git add $new_path" >&2
+          return 1
+        fi
+        ;;
+    esac
+  done <<EOF
+$staged_renames
+EOF
+
+  return 0
+}

package/hooks/p057-staging-trap-detect.sh

@@ -0,0 +1,89 @@
+#!/bin/bash
+# P125: PreToolUse:Bash hook — denies `git commit` invocations that
+# would land in the P057 staging-trap shape (rename + post-rename
+# Edit without re-stage).
+#
+# Detection delegates to `lib/staging-detect.sh::detect_p057_trap`.
+# When the helper returns 1, this hook emits PreToolUse deny JSON
+# with the trap'd path inline and the literal `git add <path>`
+# recovery command, satisfying ADR-013 Rule 1's "deny redirects to
+# a recovery path" contract via the mechanical-recovery shape (no
+# skill wrapper required — re-staging a file is a single command).
+#
+# Allow paths (exit 0 without deny):
+#   - tool_name != "Bash"          (only Bash invocations are gated)
+#   - command does not contain     `git commit` substring (non-commit
+#                                  Bash bypasses entirely)
+#   - working tree clean of trap  (helper returns 0)
+#   - outside a git work tree     (helper fails-open)
+#   - parse failure on stdin      (mirrors create-gate.sh fail-open)
+#
+# References:
+#   ADR-005 — plugin testing strategy (hook bats live under hooks/test/).
+#   ADR-009 — gate marker lifecycle (this hook deliberately does NOT
+#             use markers; detection is per-invocation deterministic).
+#   ADR-013 Rule 1 — deny redirects with mechanical recovery.
+#   ADR-038 — progressive disclosure / deny-message terseness budget.
+#   P057    — original staging-trap ticket; this hook is the
+#             enforcement layer the documentation alone didn't provide.
+#   P119    — sibling create-gate hook (PreToolUse:Write + lib/create-gate.sh).
+#   P125    — this hook.
+
+SCRIPT_DIR="$(cd "$(dirname "$0")" && pwd)"
+# shellcheck source=lib/staging-detect.sh
+source "$SCRIPT_DIR/lib/staging-detect.sh"
+
+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 "")
+
+# Only fire on `git commit` invocations. Substring match catches
+# common shapes (`git commit -m`, `git commit --amend`, leading
+# `cd && git commit`, etc.) without over-matching unrelated bash.
+case "$COMMAND" in
+  *"git commit"*) ;;
+  *) exit 0 ;;
+esac
+
+# Run detection. Helper echoes trap'd path on stdout when detected;
+# returns 1 in that case. Returns 0 (allow) on no-trap or fail-open
+# (non-git tree, parse error).
+TRAPPED_PATH=$(detect_p057_trap 2>/dev/null) && exit 0
+
+# Trap detected — emit deny with terse recovery.
+# Voice-tone draft target ~245 bytes; ADR-038 progressive-disclosure
+# budget. Keeps the rule cite (P057), the trap'd file path, and the
+# literal recovery command inline.
+REASON="BLOCKED: P057 staging-trap. Renamed file has unstaged post-rename edits: ${TRAPPED_PATH}. Run \`git add ${TRAPPED_PATH}\` then retry commit. Otherwise rename lands without the edit; edit drifts into next commit (audit-trail break)."
+
+cat <<EOF
+{
+  "hookSpecificOutput": {
+    "hookEventName": "PreToolUse",
+    "permissionDecision": "deny",
+    "permissionDecisionReason": "${REASON}"
+  }
+}
+EOF
+exit 0

package/hooks/test/p057-staging-trap-detect.bats

@@ -0,0 +1,141 @@
+#!/usr/bin/env bats
+
+# P125: p057-staging-trap-detect.sh PreToolUse:Bash hook must detect the
+# rename-then-edit-without-re-stage pattern that drops post-rename edits
+# into the next commit (P057 staging trap).
+#
+# Detection logic (per ticket Fix Strategy):
+#   On `git commit` invocations, run `git diff --staged --name-status`
+#   and `git diff --name-only`. If a file appears in --staged with an
+#   `R<num>` (rename) status AND in working-tree `git diff --name-only`
+#   as modified, the trap shape is present — emit a deny with recovery
+#   command `git add <new-path>` and the P057 cite.
+#
+# Per ADR-005 (plugin testing strategy) — hook bats live under
+# packages/<plugin>/hooks/test/ and assert behaviour on emitted JSON,
+# not source-content. ADR-037 partitions skill tests separately.
+#
+# Per feedback_behavioural_tests.md (P081) — no source-grep on hook
+# text. Simulate the PreToolUse:Bash payload on stdin and assert on
+# the emitted permissionDecision.
+
+setup() {
+  SCRIPT_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  HOOK="$SCRIPT_DIR/p057-staging-trap-detect.sh"
+  ORIG_DIR="$PWD"
+  TEST_DIR=$(mktemp -d)
+  cd "$TEST_DIR"
+  git init --quiet -b main
+  git config user.email "test@example.com"
+  git config user.name "Test"
+  echo "original" > foo.md
+  git add foo.md
+  git -c commit.gpgsign=false commit --quiet -m "initial"
+}
+
+teardown() {
+  cd "$ORIG_DIR"
+  rm -rf "$TEST_DIR"
+}
+
+# Helper: simulate the PreToolUse:Bash payload on stdin.
+run_bash_hook() {
+  local cmd="$1"
+  local json
+  json=$(printf '{"tool_name":"Bash","tool_input":{"command":"%s"}}' "$cmd")
+  echo "$json" | bash "$HOOK"
+}
+
+# --- Trap detection: the canonical P057 shape ---
+
+@test "deny: rename + post-rename edit without re-stage triggers deny on git commit" {
+  git mv foo.md bar.md
+  echo "modified content" > bar.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"\"permissionDecision\": \"deny\""* ]]
+  [[ "$output" == *"P057"* ]]
+  [[ "$output" == *"bar.md"* ]]
+  [[ "$output" == *"git add bar.md"* ]]
+}
+
+# --- Allow paths: each non-trap shape must NOT deny ---
+
+@test "allow: rename + post-rename edit + re-stage allows the commit" {
+  git mv foo.md bar.md
+  echo "modified content" > bar.md
+  git add bar.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: pure rename without subsequent edit allows the commit" {
+  git mv foo.md bar.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: modify-only batch (no rename) allows the commit" {
+  echo "modified" > foo.md
+  git add foo.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+@test "allow: empty batch (nothing staged, nothing modified) allows the commit" {
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Tool-name and command-shape 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\""* ]]
+}
+
+@test "allow: Bash command that is NOT git commit (e.g., git status) bypasses detection" {
+  # Trap shape IS present in the working tree, but the command isn't
+  # `git commit` — the hook only fires on commit invocations.
+  git mv foo.md bar.md
+  echo "modified" > bar.md
+  run run_bash_hook "git status"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Parse / fail-open (mirror create-gate.sh's exit-0 on parse failure) ---
+
+@test "allow: empty JSON exits 0 without deny (fail-open on parse-incomplete)" {
+  run bash -c "echo '{}' | bash $HOOK"
+  [ "$status" -eq 0 ]
+  [[ "$output" != *"\"permissionDecision\": \"deny\""* ]]
+}
+
+# --- Deny message contract (ADR-038 progressive disclosure budget) ---
+
+@test "deny message names the file, recovery command, and P057 cite" {
+  git mv foo.md bar.md
+  echo "modified" > bar.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"P057"* ]]
+  [[ "$output" == *"git add bar.md"* ]]
+  [[ "$output" == *"bar.md"* ]]
+}
+
+@test "deny message stays under ADR-038 progressive-disclosure budget (<400 bytes)" {
+  # Voice-tone draft target is ~245 bytes; allow generous headroom for
+  # JSON envelope. Hard cap at 400 keeps the message terse per
+  # ADR-038 — fail loudly if the message bloats over time.
+  git mv foo.md bar.md
+  echo "modified" > bar.md
+  run run_bash_hook "git commit -m 'test'"
+  [ "$status" -eq 0 ]
+  [ "${#output}" -lt 400 ]
+}

package/hooks/test/session-id.bats

@@ -0,0 +1,108 @@
+#!/usr/bin/env bats
+
+# P124: session-id.sh helper must canonicalise per-session UUID discovery
+# for agent-side code paths (e.g. /wr-itil:manage-problem Step 2 substep 7
+# marker write) that today fall back to the brittle ${CLAUDE_SESSION_ID:-default}
+# pattern when the env var is not exported in the agent's process.
+#
+# Behavioural contract:
+#   1. CLAUDE_SESSION_ID exported -> echo it (env-var fast path).
+#   2. CLAUDE_SESSION_ID absent + an /tmp/<system>-announced-<UUID> marker
+#      present -> echo the UUID parsed from the marker filename.
+#   3. CLAUDE_SESSION_ID absent + no markers anywhere -> echo nothing,
+#      exit non-zero (so callers can detect "could not discover").
+#   4. Multiple announce markers across systems -> deterministic selection
+#      (architect first, then jtbd, then tdd, then itil-assistant-gate,
+#      then itil-correction-detect, then style-guide, then voice-tone)
+#      so the discovery is reproducible across invocations.
+#
+# Per feedback_behavioural_tests.md (P081): tests assert the helper's
+# emitted output and exit code, not the source content of the helper.
+# The marker-system selection order is asserted by constructing only the
+# higher-priority marker and checking the helper picks it.
+
+setup() {
+  SCRIPT_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  HELPER="$SCRIPT_DIR/lib/session-id.sh"
+  # Use a sandbox /tmp so we never leak across real session markers.
+  SANDBOX_TMP=$(mktemp -d)
+  # session-id.sh reads from /tmp by default; SESSION_MARKER_DIR
+  # overrides that for sandboxed bats runs without touching real
+  # session state in /tmp.
+  export SESSION_MARKER_DIR="$SANDBOX_TMP"
+  unset CLAUDE_SESSION_ID
+}
+
+teardown() {
+  rm -rf "$SANDBOX_TMP"
+  unset SESSION_MARKER_DIR
+  unset CLAUDE_SESSION_ID
+}
+
+# Helper: source the helper and emit the discovered SID + exit code.
+discover() {
+  bash -c "source '$HELPER'; get_current_session_id; echo \"EXIT:\$?\""
+}
+
+# Helper: write an announce marker with a known UUID under SESSION_MARKER_DIR.
+mark_announced() {
+  local system="$1"
+  local uuid="$2"
+  : > "$SESSION_MARKER_DIR/${system}-announced-${uuid}"
+}
+
+# --- Behavioural contract: env-var fast path ---
+
+@test "env-var present -> returns the env-var value verbatim" {
+  expected_uuid="11111111-1111-1111-1111-111111111111"
+  output=$(CLAUDE_SESSION_ID="$expected_uuid" bash -c "source '$HELPER'; get_current_session_id; echo \"EXIT:\$?\"")
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "env-var present -> ignores any markers (no scrape)" {
+  expected_uuid="22222222-2222-2222-2222-222222222222"
+  decoy_uuid="33333333-3333-3333-3333-333333333333"
+  mark_announced "architect" "$decoy_uuid"
+  output=$(CLAUDE_SESSION_ID="$expected_uuid" bash -c "source '$HELPER'; get_current_session_id; echo \"EXIT:\$?\"")
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" != *"$decoy_uuid"* ]]
+}
+
+# --- Behavioural contract: marker-scrape fallback ---
+
+@test "env-var absent + architect-announced marker present -> returns marker UUID" {
+  expected_uuid="44444444-4444-4444-4444-444444444444"
+  mark_announced "architect" "$expected_uuid"
+  output=$(discover)
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "env-var absent + only jtbd-announced marker present -> returns marker UUID (fallback chain works)" {
+  expected_uuid="55555555-5555-5555-5555-555555555555"
+  mark_announced "jtbd" "$expected_uuid"
+  output=$(discover)
+  [[ "$output" == *"$expected_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}
+
+@test "env-var absent + no markers anywhere -> empty output, non-zero exit" {
+  output=$(discover)
+  # Output should be just "EXIT:<non-zero>" with no UUID before it.
+  [[ "$output" =~ ^EXIT:[1-9] ]]
+}
+
+@test "deterministic priority: architect-announced beats jtbd-announced when both present" {
+  architect_uuid="aaaaaaaa-aaaa-aaaa-aaaa-aaaaaaaaaaaa"
+  jtbd_uuid="bbbbbbbb-bbbb-bbbb-bbbb-bbbbbbbbbbbb"
+  mark_announced "jtbd" "$jtbd_uuid"
+  # Sleep so jtbd marker has older mtime — proves selection is by
+  # marker-system priority, not by mtime (the architect-flagged
+  # mtime fragility from session 2026-04-26 review).
+  sleep 1
+  mark_announced "architect" "$architect_uuid"
+  output=$(discover)
+  [[ "$output" == *"$architect_uuid"* ]]
+  [[ "$output" != *"$jtbd_uuid"* ]]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/itil",
-  "version": "0.19.6",
+  "version": "0.19.7-preview.208",
   "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

@@ -238,13 +238,17 @@ Before creating, search existing problems for similar issues. The user may not k
    - "I found existing problems that may be related: P011 (stuck saving, CLOSED), P023 (foul drawn garbled, OPEN). Would you like to: (a) Update an existing problem, (b) Create a new problem anyway, (c) Cancel?"
 5. If the user chooses to update, switch to the update flow for that problem ID
 6. If no matches found, proceed to create
-7. **After the grep completes** (whether duplicates were found or not), write the per-session create-gate marker so the `PreToolUse:Write` hook (`packages/itil/hooks/manage-problem-enforce-create.sh`, P119) allows the subsequent Write of the new `.open.md` file. The marker is `/tmp/manage-problem-grep-${SESSION_ID}` and the agent should write it via Bash:
+7. **After the grep completes** (whether duplicates were found or not), write the per-session create-gate marker so the `PreToolUse:Write` hook (`packages/itil/hooks/manage-problem-enforce-create.sh`, P119) allows the subsequent Write of the new `.open.md` file. The marker is `/tmp/manage-problem-grep-${SESSION_ID}` and the agent writes it via Bash by sourcing the session-id discovery helper (P124) and calling the existing `mark_step2_complete` helper:
 
    ```bash
-   : > "/tmp/manage-problem-grep-${CLAUDE_SESSION_ID:-$(echo "${CLAUDE_HOOK_SESSION_ID:-default}")}"
+   source packages/itil/hooks/lib/session-id.sh
+   source packages/itil/hooks/lib/create-gate.sh
+   sid=$(get_current_session_id) && mark_step2_complete "$sid"
    ```
 
-   In practice the session ID is supplied by the hook payload, not as an env var — the simplest portable pattern is to ask Claude Code to run a one-line Bash that touches the marker using whatever session_id is available in the current invocation. The exact command shape depends on the runtime; the contract is that the file `/tmp/manage-problem-grep-<session-id>` exists by the time Step 5's Write fires. Per architect direction, the marker is per-session (single marker covers all new tickets for the rest of this session), enabling Step 4b multi-concern splits and same-session unrelated-ticket creation without re-running the grep.
+   `get_current_session_id` (P124) returns the canonical session UUID by reading `CLAUDE_SESSION_ID` if exported, else by scraping the most-reliable per-session announce marker (`/tmp/<system>-announced-<UUID>`, set on prompt 1 of every session per ADR-038 by architect / jtbd / tdd / style-guide / voice-tone / itil-assistant-gate / itil-correction-detect hooks). It exits non-zero if no session can be discovered — the `&&` short-circuits the marker write so the agent never lands `/tmp/manage-problem-grep-` (an empty UUID would never match the hook's stdin-JSON `session_id` and would silently fail later). `mark_step2_complete` (existing helper from `create-gate.sh`) writes the marker file under the canonical path; the marker is per-session (single marker covers all new tickets for the rest of this session), enabling Step 4b multi-concern splits and same-session unrelated-ticket creation without re-running the grep.
+
+   **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.
 
 **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.