@windyroad/itil 0.22.0-preview.243 → 0.22.1-preview.246

package/.claude-plugin/plugin.json

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

package/hooks/lib/detectors.sh

@@ -32,6 +32,10 @@ PROSE_ASK_PATTERNS=(
   '\([a-c]\) ?/ ?\([a-c]\)'
   '\(1\) .*\(2\)'
   'Which (do you|option|one|path) .*\?'
+  'Awaiting your (direction|input|decision|response|confirmation|answer|reply)'
+  'Pending your (direction|input|decision|response|confirmation|answer|reply)'
+  'Once you confirm'
+  'Awaiting your direction on whether'
 )
 
 # Direction-pinning patterns — signals in the user's incoming prompt

package/hooks/lib/session-id.sh

@@ -88,25 +88,38 @@ get_current_session_id() {
     voice-tone
   )
 
-  local system marker f
+  local system marker
   for system in "${systems[@]}"; do
-    # Portable existence-check loop. The previous implementation used
-    # `shopt -s nullglob` in a subshell — bash-only, errors under zsh
-    # with `command not found: shopt` and lets the glob fall through to
-    # the literal unmatched-pattern string, returning a wrong UUID.
-    # P124 Phase 2: the for-loop existence check works identically
-    # under bash, zsh, and POSIX dash. The first existing match wins
-    # (selection by fixed marker-system priority order, NOT mtime —
-    # `-announced-` markers are write-once-per-session per ADR-038
-    # so any present marker is the active SID; mtime selection would
-    # reintroduce the `-reviewed-` marker fragility ADR-009 + P111
-    # describe).
-    marker=""
-    for f in "${marker_dir}/${system}-announced-"*; do
-      [ -e "$f" ] || continue
-      marker="$f"
-      break
-    done
+    # Two-axis selection:
+    #   ACROSS systems — fixed priority order (architect first, then
+    #     jtbd, ...). The outer for-loop encodes this. The first system
+    #     with any present marker wins; later systems are not consulted.
+    #   WITHIN a system — most-recent-mtime wins (`ls -t | head -1`).
+    #     Multi-session developer machines accumulate one
+    #     `${system}-announced-${SID}` marker per past session in /tmp;
+    #     the live session's marker is by construction the most-recently-
+    #     created one. P124 Phase 2 used first-glob-match (alphabetical),
+    #     which returned the lexically-first stale UUID when /tmp had
+    #     accumulated markers from prior sessions — observed regression
+    #     2026-04-28 with 103 stale architect markers selecting the
+    #     wrong UUID, denying the create-gate (P119).
+    #
+    # Why mtime is safe here even though Phase 1 architect rejected it:
+    #   The Phase 1 rejection applied to `-reviewed-` markers, which
+    #   `touch`-refresh on every gate check (ADR-009 sliding TTL +
+    #   P111 subprocess refresh). Mtime on a `-reviewed-` marker is
+    #   "last seen", not "first written" — selecting newest-mtime can
+    #   surface a stale session whose marker was just touch-refreshed.
+    #   `-announced-` markers are write-once-per-session per ADR-038
+    #   (no `touch`-refresh, no TTL); their mtime IS the announcing
+    #   session's first-prompt timestamp. Newest mtime within a single
+    #   `-announced-` glob unambiguously identifies the live session.
+    #
+    # Portability: `ls -t` is POSIX (sort by modification time, newest
+    # first). 2>/dev/null suppresses "no such file" when the glob
+    # expands to nothing under both bash and zsh; head -1 gracefully
+    # returns empty in that case.
+    marker=$(ls -t "${marker_dir}/${system}-announced-"* 2>/dev/null | head -1)
     if [ -n "$marker" ]; then
       # Strip the prefix to recover the trailing UUID.
       basename "$marker" | sed "s/^${system}-announced-//"

package/hooks/test/itil-assistant-output-review.bats

@@ -134,3 +134,43 @@ JSON
   [ "$status" -eq 0 ]
   [[ "$output" == *"stopReason"* ]]
 }
+
+# 2026-04-28 regression evidence (P085 reopen, Citation 1).
+# Orchestrator main turn emitted a halt-summary ending with "Awaiting your
+# direction on whether to add it + resume on P123, or end the session."
+# The Stop hook should have caught this binary-choice prose-ask but the
+# pattern list did not match. Detector extension closes the gap.
+@test "review: 'Awaiting your direction on whether ... or ...' (Citation 1 shape) triggers stopReason" {
+  write_transcript "ok" "Loop is still halted. Remaining open item: missing changeset for b9da37e. Awaiting your direction on whether to add it + resume on P123, or end the session."
+  run run_hook
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"stopReason"* ]]
+}
+
+@test "review: 'Awaiting your input' triggers stopReason nudge" {
+  write_transcript "ok" "Plan staged. Awaiting your input on the next step."
+  run run_hook
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"stopReason"* ]]
+}
+
+@test "review: 'Pending your decision' triggers stopReason nudge" {
+  write_transcript "review" "Refactor scoped to three files. Pending your decision before I continue."
+  run run_hook
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"stopReason"* ]]
+}
+
+@test "review: 'Once you confirm' triggers stopReason nudge" {
+  write_transcript "look" "Rename ready. Once you confirm, I will proceed with the rename."
+  run run_hook
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"stopReason"* ]]
+}
+
+@test "review: 'Awaiting your response' triggers stopReason nudge" {
+  write_transcript "go" "Two paths identified. Awaiting your response so I know which to take."
+  run run_hook
+  [ "$status" -eq 0 ]
+  [[ "$output" == *"stopReason"* ]]
+}

package/hooks/test/session-id.bats

@@ -135,3 +135,44 @@ mark_announced() {
   [[ "$zsh_run" != *"shopt: command not found"* ]]
   [[ "$zsh_run" != *"command not found: shopt"* ]]
 }
+
+# --- Behavioural contract: within-system mtime selection (P124 Phase 3) ---
+#
+# Phase 2 portability fix (shopt-portable for-loop existence check) shipped
+# 2026-04-28 morning, restoring zsh compatibility but introducing a
+# regression on multi-session developer machines: glob expansion enumerates
+# matches in ASCII-alphabetical order, and the inner "first match wins"
+# heuristic returned the lexically-first stale UUID when /tmp had
+# accumulated `${system}-announced-*` markers from prior sessions. Ticket
+# regression block cites 103 stale architect markers selecting the wrong
+# UUID, denying the create-gate (P119) and forcing a brute-force recovery.
+#
+# Phase 3 selection contract: WITHIN a single system's marker namespace,
+# the most-recent-mtime marker wins. ACROSS systems, the fixed priority
+# order is preserved (asserted by the existing "deterministic priority"
+# test above). `-announced-` markers are write-once-per-session per ADR-038
+# (no `touch`-refresh sliding TTL), so mtime IS the announcing session's
+# first-prompt timestamp — newest mtime unambiguously identifies the live
+# session within that system's marker glob.
+
+@test "within-system mtime: newest architect-announced marker wins over older same-system markers" {
+  oldest_uuid="00000000-0000-0000-0000-000000000001"  # ASCII-first
+  middle_uuid="11111111-1111-1111-1111-111111111111"
+  newest_uuid="22222222-2222-2222-2222-222222222222"  # ASCII-last of the three
+  # Fixture intent: alphabetical-first UUID has the OLDEST mtime; the
+  # newest-mtime UUID is alphabetically last. Phase 2 first-glob-match
+  # would pick `oldest_uuid` (alphabetical first); Phase 3 mtime
+  # selection picks `newest_uuid` (most-recent mtime). The sleep
+  # boundaries guarantee distinct mtimes across filesystems with
+  # 1-second mtime resolution (e.g. older HFS+).
+  mark_announced "architect" "$oldest_uuid"
+  sleep 1
+  mark_announced "architect" "$middle_uuid"
+  sleep 1
+  mark_announced "architect" "$newest_uuid"
+  output=$(discover)
+  [[ "$output" == *"$newest_uuid"* ]]
+  [[ "$output" != *"$oldest_uuid"* ]]
+  [[ "$output" != *"$middle_uuid"* ]]
+  [[ "$output" == *"EXIT:0"* ]]
+}

package/package.json

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

package/skills/work-problems/SKILL.md

@@ -270,7 +270,7 @@ rm -f "$ITER_JSON"
 
 1. **Context**: this is one iteration of the AFK work-problems loop. The user is AFK. The orchestrator selected `P<NNN> (<title>)` as the highest-WSJF actionable ticket.
 2. **Task**: apply the `/wr-itil:manage-problem` workflow for `work highest WSJF problem that can be progressed non-interactively as the user is AFK`. Follow manage-problem SKILL.md verbatim, including architect / jtbd / style-guide / voice-tone gate reviews and the commit gate (manage-problem Step 11). Because this subprocess has the Agent tool in its own surface, the normal review-via-subagent paths work — no inline-verdict fallback needed.
-3. **Constraints**: commit the completed work per ADR-014. Do NOT push, do NOT run `push:watch`, do NOT run `release:watch` — the orchestrator's Step 6.5 owns release cadence. Do NOT invoke `capture-*` background skills (AFK carve-out — ADR-032). Do NOT use `ScheduleWakeup` under any circumstance (P083 — iteration workers must not self-reschedule). **NEVER call `AskUserQuestion` mid-loop in AFK** (P135 / ADR-044): direction / deviation-approval / one-time-override / silent-framework observations queue at `ITERATION_SUMMARY.outstanding_questions` for loop-end batched presentation. Per-iter `AskUserQuestion` calls are sub-contracting framework-resolved decisions back to the user (lazy deferral per Step 2d Ask Hygiene Pass classification). Non-interactive defaults apply per ADR-013 Rule 6 + ADR-044's framework-resolution boundary.
+3. **Constraints**: commit the completed work per ADR-014. Do NOT push, do NOT run `push:watch`, do NOT run `release:watch` — the orchestrator's Step 6.5 owns release cadence. Do NOT invoke `capture-*` background skills (AFK carve-out — ADR-032). Do NOT use `ScheduleWakeup` under any circumstance (P083 — iteration workers must not self-reschedule). **NEVER call `AskUserQuestion` mid-loop in AFK** (P135 / ADR-044): direction / deviation-approval / one-time-override / silent-framework observations queue at `ITERATION_SUMMARY.outstanding_questions` for loop-end batched presentation. Per-iter `AskUserQuestion` calls are sub-contracting framework-resolved decisions back to the user (lazy deferral per Step 2d Ask Hygiene Pass classification). Non-interactive defaults apply per ADR-013 Rule 6 + ADR-044's framework-resolution boundary. **Treat the user as transient** (P130): even when observably present at orchestrator dispatch time, the user may answer one question and disappear for hours; presence is not a reliable signal and is not the goal. The iter's job is to progress the ticket and accumulate questions for batched surfacing — not to ask "is it OK to proceed?" at a mechanical-stage boundary.
 4. **Retro-on-exit (P086)**: before emitting `ITERATION_SUMMARY`, invoke `/wr-retrospective:run-retro`. Retro runs INSIDE this subprocess so its Step 2b pipeline-instability scan has access to the iteration's rich tool-call history (hook misbehaviour, repeat-workaround patterns, subagent-delegation friction, release-path instability). Retro may create tickets or update `docs/BRIEFING.md` — run-retro commits its own work per ADR-014; any tickets it creates ride into either the iteration's own commit (if retro runs before the main commit) or a retro-owned follow-up commit, and the orchestrator picks them up on the next Step 1 scan. Proceed to `ITERATION_SUMMARY` emission regardless of retro findings — retro is non-blocking (do not block on retro): if retro fails or surfaces findings, the iteration still returns a summary so the AFK loop does not silently halt on a flaky retro run.
 5. **Output**: end the final message with the `ITERATION_SUMMARY` block defined below — this is how the orchestrator consumes the iteration's result.
 
@@ -505,6 +505,36 @@ When `AskUserQuestion` is unavailable or the user is AFK, the skill (and the del
 | Halt-path final summary with accumulated user-answerable skips (CI failure / Rule 5 above-appetite / dirty-unknown / session-continuity / fetch failure) | Run Step 2.5b's surfacing routine before emitting the halt path's final AFK summary. Step 2.5b is gated on ≥1 accumulated user-answerable skip — empty-skip halts skip the routine. Step 2.5b surfaces *prior-iter accumulated user-answerable skips only*; it does NOT ask the user how to remediate the halt cause itself (CI failure / above-appetite state / dirty-unknown state remain halt-with-bug-signal). Per ADR-013 Rule 1 + ADR-032 + P126 (`halt-paths-must-route-design-questions-through-Step-2.5b`). |
 | Unexpected dirty state between iterations | Halt the loop. Report the `git status --porcelain` output, the last iteration's reported outcome, and the divergence — per P036 (Step 6.75). Run Step 2.5b before emitting the halt summary if ≥1 accumulated user-answerable skip from prior iters (P126). Do NOT attempt non-interactive recovery of the dirty state itself. |
 | External root cause detected at Open → Known Error, or at park with `upstream-blocked` reason | Append the stable `- **Upstream report pending** — external dependency identified; invoke /wr-itil:report-upstream when ready` marker to the ticket's `## Related` section; do NOT auto-invoke `/wr-itil:report-upstream` (Step 6 security-path branch is interactive — per ADR-024 Consequences). Use the already-noted grep check to avoid duplicate lines. Per P063 + ADR-013 Rule 6. |
+| Mid-loop ask between iters in the orchestrator's main turn | Forbidden except at framework-prescribed halt points (Step 0 session-continuity / fetch-failure halt; Step 2.5 / 2.5b loop-end emit; Step 6.5 above-appetite Rule 5 halt; Step 6.5 CI-failure / release:watch halt; Step 6.75 dirty-for-unknown-reason halt). The loop's purpose is **progress + accumulation**; mechanical-stage transitions between iters are framework-resolved and MUST NOT prompt the user. Per ADR-044 framework-resolution boundary + ADR-013 Rule 1 (as amended by ADR-044) + P130. |
+
+### Mid-loop ask discipline (orchestrator main turn) — P130
+
+The orchestrator MUST NOT call `AskUserQuestion` between iterations except at the framework-prescribed user-interaction halt points listed below. The loop's purpose is **progress + accumulation** — progress every ticket the agent can advance autonomously, accumulate user-answerable questions as a side-effect, and surface the accumulated batch only at a halt point. This rule applies whether the user is observably present or not, because **presence-detection is unreliable** and is not the goal — the user may answer one question and disappear for hours; the orchestrator's job is to keep advancing the backlog and stage the user-interaction surface for whenever the user actually returns. Treat the user as transient.
+
+**Framework-prescribed halt points (the only orchestrator-main-turn surfaces where `AskUserQuestion` is permitted):**
+
+- **Step 0 session-continuity halt** — Prior-Session State report; user routes resume / discard / leave-and-lower / halt (interactive branch only; AFK branch halts with the structured report per ADR-013 Rule 6).
+- **Step 0 fetch-failure halt** — `git fetch origin` network failure; halt-with-report so the user retries on return.
+- **Step 2.5 / Step 2.5b loop-end emit** — accumulated `outstanding_questions` queue presented as batched `AskUserQuestion` (or fallback Outstanding Design Questions table per ADR-013 Rule 6). This is the framework's prescribed user-interaction point; do NOT dilute it by asking earlier.
+- **Step 6.5 above-appetite Rule 5 halt** — auto-apply loop exhausted without convergence; halt-with-batched-questions per the Step 2.5b cross-reference (Step 2.5b surfaces *prior-iter accumulated user-answerable skips only* — the halt-causing scorer-gap remains a halt-with-bug-signal per ADR-042 Rule 5).
+- **Step 6.5 CI-failure / `release:watch` failure halt** — push:watch or release:watch failed; halt-with-batched-questions per the Step 2.5b cross-reference.
+- **Step 6.75 dirty-for-unknown-reason halt** — `git status --porcelain` divergence; halt-with-batched-questions per the Step 2.5b cross-reference.
+
+**No mid-iter ask points.** Every other point in the orchestrator's main turn (between Step 5 dispatch completing and Step 6.5 release-cadence check; between Step 6.75 verification and Step 7 loop-back; between Step 7 and Step 1 next-iteration; between consecutive iters generally) is a mechanical-stage transition that the framework has already resolved. Do NOT introduce ad-hoc `AskUserQuestion` calls at those points to confirm "is it OK to proceed?" or "want me to start the next iter?" — proceeding IS the framework-resolved default. Continue iterating until quota or stop-condition #1/#2/#3 fires.
+
+**Accumulated-question discipline at surface time** (per ADR-044's six-class authority taxonomy — questions that reach the user must be load-bearing):
+
+- **Direction-setting only** — questions that ONLY the user can answer because they reflect goals, intent, or trade-offs the framework has not yet captured. Other accumulated observations (deviation-approval, one-time-override, silent-framework, taste, correction-followup) follow the same shape as the deviation-candidate schema in Step 5's `outstanding_questions` contract.
+- **No BUFD** — don't pre-judge architectural decisions before evidence accumulates. Small, actionable questions; not galaxy-brain ones. The deviation-candidate surface (per ADR-044's anti-BUFD-for-framework-evolution clause) is the place where iter-discovered misfits accumulate; the user resolves with full context at loop end.
+- **No questions answerable by research / exploration / experimentation** — the agent should prototype, read code, run experiments to answer those itself rather than sub-contracting routine investigative work back to the user. The user is the source for genuine direction-setting decisions, not for "what does this hook do" or "which file holds X" — those are research questions the agent owns.
+
+**Cross-references:**
+
+- **Step 5's iteration-prompt body** carries the per-subprocess "Do not call `AskUserQuestion`" constraint; this subsection carries the orchestrator-main-turn equivalent. Together they enforce the same discipline at both the subprocess layer and the main-turn layer end-to-end.
+- **ADR-044** is the parent decision narrowing ADR-013 Rule 1 to framework-unresolved decisions; this subsection is one of its load-bearing implementation surfaces.
+- **ADR-013 Rule 1** (as amended by ADR-044) restricts `AskUserQuestion` to framework-unresolved decisions; the framework-prescribed halt enumeration above is the orchestrator-layer interpretation of that narrowing.
+- **ADR-013 Rule 6** is the non-interactive fail-safe — when `AskUserQuestion` is unavailable (restricted permission mode, hook-disabled tool surface), the framework-prescribed halts fall back to structured-summary table emission rather than skipping the user-interaction.
+- **ADR-032** subprocess-boundary contract is unchanged — this subsection is orchestrator-main-turn discipline; the iteration-subprocess dispatch shape (P084 + P121 + P086 + P089) is untouched.
 
 ## Edge Cases
 

package/skills/work-problems/test/work-problems-no-mid-loop-asking.bats

@@ -0,0 +1,192 @@
+#!/usr/bin/env bats
+
+# P130: /wr-itil:work-problems orchestrator must NOT call AskUserQuestion
+# mid-loop. The loop's purpose is progress + accumulation; user-interaction
+# is reserved for framework-prescribed halt points (Step 0, Step 2.5/2.5b,
+# Step 6.5 Rule 5 + CI-failure, Step 6.75 dirty-unknown). The user is
+# transient — presence-detection is unreliable and is not the goal; the
+# orchestrator must accumulate questions and surface them at halt points.
+#
+# Per the user's reframe (ticket P130 lines 95-123), the original dual-mode
+# dispatch fix-shape was rejected. The fix is SKILL.md prose discipline:
+# enumerate the framework-prescribed halt points + assert no mid-iter asks
+# elsewhere + state the accumulated-question discipline (direction-setting
+# only; no BUFD; no questions answerable by research/exploration/
+# experimentation).
+#
+# Doc-lint contract assertions per ADR-037 Permitted Exception (structural
+# checks on prose contract, sibling shape with P126 / P135 fixtures).
+#
+# @problem P130
+# @adr ADR-044 (Decision-Delegation Contract — framework-resolution boundary)
+# @adr ADR-013 Rule 1 (as amended by ADR-044) + Rule 6 (non-interactive fail-safe)
+# @adr ADR-032 (subprocess-boundary contract — unchanged)
+# @adr ADR-037 (skill-testing-strategy — Permitted Exception for prose contract)
+# @jtbd JTBD-006 (Progress the Backlog While I'm Away)
+# @jtbd JTBD-001 (Enforce Governance Without Slowing Down)
+
+setup() {
+  REPO_ROOT="$(cd "$(dirname "$BATS_TEST_FILENAME")/../../../../.." && pwd)"
+  SKILL_MD="$REPO_ROOT/packages/itil/skills/work-problems/SKILL.md"
+}
+
+@test "work-problems P130: SKILL.md exists" {
+  [ -f "$SKILL_MD" ]
+}
+
+# ── Mid-loop ask discipline subsection presence ─────────────────────────────
+
+@test "work-problems P130: SKILL.md names a 'Mid-loop ask discipline' subsection (orchestrator main turn)" {
+  # The architect-approved placement is inside Non-Interactive Decision
+  # Making section as a subsection. The heading must exist as a navigable
+  # markdown anchor so cross-references resolve.
+  run grep -nE '^#{3,4} Mid-loop ask discipline' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection scopes itself to the orchestrator main turn (not the subprocess)" {
+  # The subprocess-layer constraint (Step 5's iteration-prompt body)
+  # already exists; this subsection is the orchestrator-main-turn
+  # equivalent. The scope must be explicit so future readers do not
+  # confuse the layers.
+  run grep -nE 'orchestrator main turn|orchestrator.s main turn' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Core invariant: no mid-iter AskUserQuestion ─────────────────────────────
+
+@test "work-problems P130: subsection asserts no mid-loop AskUserQuestion between iters except at framework halts" {
+  # The load-bearing rule. The orchestrator must NOT call AskUserQuestion
+  # between iterations EXCEPT at the framework-prescribed halt points.
+  run grep -nE 'MUST NOT call .?AskUserQuestion.? between iter' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection cites the loop's purpose as progress + accumulation" {
+  # The reframed direction (ticket lines 95-123): the loop's purpose is
+  # progress + accumulation, not interactive-vs-AFK routing. This phrasing
+  # must appear so future authors do not re-introduce mid-loop asks under
+  # 'the user might be present' rationalisations.
+  run grep -nE 'progress \+ accumulation|progress and accumulation' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection states presence-detection is unreliable and not the goal" {
+  # The transient-user framing. Without this, future authors may try to
+  # add presence-detection (the originally-rejected fix-shape).
+  run grep -nE 'presence[- ]detection is unreliable|presence is unreliable|user as transient|treat the user as transient' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Halt-point enumeration ──────────────────────────────────────────────────
+
+@test "work-problems P130: subsection enumerates Step 0 session-continuity as a permitted halt point" {
+  run grep -nE 'Step 0.*session[- ]continuity' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection enumerates Step 2.5 / 2.5b loop-end emit as a permitted halt point" {
+  run grep -nE 'Step 2\.5.*loop[- ]end|Step 2\.5b' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection enumerates Step 6.5 above-appetite Rule 5 halt as a permitted halt point" {
+  run grep -nE 'Step 6\.5.*Rule 5|above[- ]appetite Rule 5' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection enumerates Step 6.75 dirty-for-unknown-reason as a permitted halt point" {
+  run grep -nE 'Step 6\.75.*dirty[- ]for[- ]unknown|Step 6\.75.*unknown reason' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Accumulated-question discipline at surface time ─────────────────────────
+
+@test "work-problems P130: subsection states direction-setting only at surface time" {
+  # ADR-044's six-class taxonomy: only the user-answerable categories
+  # qualify. Direction-setting is the canonical example.
+  run grep -nE 'Direction[- ]setting only|direction[- ]setting only' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection forbids BUFD-style questions" {
+  # No big-design-up-front; small actionable questions. Anti-BUFD is a
+  # project-wide value (cited in ADR-044's anti-BUFD-for-framework-
+  # evolution clause).
+  run grep -nE 'No BUFD|no BUFD' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection forbids questions answerable by research / exploration / experimentation" {
+  # The agent should investigate itself rather than sub-contract routine
+  # work back to the user.
+  run grep -nE 'research.*exploration.*experimentation|prototype.*read code.*experiments' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── ADR citations ──────────────────────────────────────────────────────────
+
+@test "work-problems P130: subsection cites ADR-044 (primary) as the framework-resolution authority" {
+  # ADR-044 is the parent decision narrowing ADR-013 Rule 1 to framework-
+  # unresolved decisions. The subsection must cite it so future readers
+  # follow the cross-reference for the full picture.
+  run grep -nE 'ADR-044' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection cites ADR-013 Rule 1 as amended by ADR-044" {
+  # The narrowing happens at ADR-013 Rule 1's amendment. The subsection
+  # must name the rule so the chain is traceable.
+  run grep -nE 'ADR-013.*Rule 1|Rule 1.*amended by ADR-044' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+@test "work-problems P130: subsection cites ADR-013 Rule 6 as the non-interactive fail-safe underlying constraint" {
+  # When AFK, Rule 6 is the underlying constraint that forbids
+  # AskUserQuestion. The subsection cites it so the subprocess-boundary
+  # connection is explicit.
+  run grep -nE 'ADR-013.*Rule 6|Rule 6.*non[- ]interactive fail[- ]safe' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── ADR-032 subprocess-boundary unchanged ──────────────────────────────────
+
+@test "work-problems P130: subsection cross-references ADR-032 subprocess-boundary contract as unchanged" {
+  # The architect's flag: this fix does NOT amend ADR-032. The subsection
+  # must say so explicitly to prevent future readers thinking the
+  # subprocess-boundary contract is in scope.
+  run grep -nE 'subprocess[- ]boundary contract.*unchanged|ADR-032.*unchanged' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Subprocess vs orchestrator layer cross-reference ───────────────────────
+
+@test "work-problems P130: subsection cross-references Step 5's per-subprocess constraint as the parallel layer" {
+  # The orchestrator-main-turn discipline parallels Step 5's iteration-
+  # prompt-body 'Do not call AskUserQuestion' constraint. Both layers
+  # together enforce the discipline end-to-end.
+  run grep -nE "Step 5.*iteration[- ]prompt.*AskUserQuestion|Step 5's iteration[- ]prompt" "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Step 5's iteration-prompt body augmented with transient-user framing ───
+
+@test "work-problems P130: Step 5 iteration-prompt body includes transient-user framing" {
+  # The reframed direction's core insight: the user is transient even
+  # when present. The iteration-prompt body (already-existing
+  # 'NEVER call AskUserQuestion mid-loop in AFK') gains the transient
+  # framing so future iter authors understand why the constraint is
+  # absolute.
+  run grep -nE 'transient|disappear for hours' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}
+
+# ── Decision Table row reflects the discipline ─────────────────────────────
+
+@test "work-problems P130: Non-Interactive Decision Making table carries a row for mid-loop ask discipline" {
+  # The decisions table (line ~487) summarises the orchestrator's
+  # non-interactive defaults. A row naming mid-loop ask discipline keeps
+  # the table consistent with the new subsection.
+  run grep -nE '\| Mid-loop ask|mid[- ]loop AskUserQuestion|mid-loop ask between iter' "$SKILL_MD"
+  [ "$status" -eq 0 ]
+}