@windyroad/itil 0.7.0-preview.120 → 0.7.1-preview.122

package/.claude-plugin/plugin.json

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

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@windyroad/itil",
-  "version": "0.7.0-preview.120",
+  "version": "0.7.1-preview.122",
   "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

@@ -169,6 +169,25 @@ After the iteration's commit lands but before starting the next iteration, check
 
 `push:watch` and `release:watch` are policy-authorised actions when residual risk is within appetite per RISK-POLICY.md, so no `AskUserQuestion` is required for the drain itself (ADR-013 Rule 6).
 
+### Step 6.75: Inter-iteration verification (P036)
+
+Before spawning the next iteration's subagent, verify the working tree state against the expected outcome of the iteration that just completed. This is defence-in-depth: P035 closed the most-likely commit-gate failure path, but a subagent could still fail to commit for reasons the fallback does not cover (a failure inside `/wr-risk-scorer:assess-release`, a git conflict, a malformed commit message). Without this check, silent failures accumulate across iterations and the final summary reports commits that did not land.
+
+**Mechanism:**
+
+1. Run `git status --porcelain`.
+2. Classify the output into one of three cases:
+
+| Status | Expected when | Action |
+|---|---|---|
+| Clean (empty output) | The subagent committed successfully (the default happy path) | Proceed to Step 7 |
+| Dirty for a known reason | A deliberate hand-off to the next iteration (e.g. the subagent chose to skip the commit and report "uncommitted state" because risk was above appetite — per the Non-Interactive Decision Making table above). Reason MUST be stated in the iteration report. | Include the dirty state in the next iteration's subagent context and proceed to Step 7 |
+| Dirty for an unknown reason | Neither of the above — the subagent reported success but the tree is not clean, or the tree is dirty without a documented reason in the iteration report | **Halt the loop.** Report the `git status --porcelain` output, the last subagent's reported outcome, and the divergence. Do NOT spawn the next iteration. |
+
+**Rationale**: the orchestrator previously treated the subagent's reported outcome as truth. Any lie, partial write, or silent failure in the subagent propagated into the summary. The `git status --porcelain` check is the cheapest possible independent verification — policy-authorised, no network, no judgement required — and it catches exactly the class of failure the subagent cannot self-report.
+
+**Out of scope for this step**: attempting recovery from an unknown-reason dirty state. Per ADR-013 Rule 6, conflict resolution and ambiguous state require user input; non-interactive recovery would mask the bug this check is meant to surface.
+
 ### Step 7: Loop
 
 Go back to step 1. The backlog may have changed — new problems may have been created during fixes, priorities may have shifted, and the README.md cache will be stale.
@@ -188,6 +207,7 @@ When `AskUserQuestion` is unavailable or the user is AFK, the skill (and the del
 | Origin diverged before start | Pull `--ff-only` if trivial; stop with report (`git log HEAD..origin/<base>` and reverse) if non-fast-forward — per ADR-019 (Step 0) |
 | Fix verification needed | Skip problem, add to "needs verification" list |
 | Stop-condition #2 with user-answerable skip-reasons | Emit Outstanding Design Questions table in summary (do NOT call AskUserQuestion). The persona is AFK by definition — per JTBD-006 and ADR-013 Rule 6 — so the table is the default. Interactive invocations may batch up to 4 questions through AskUserQuestion instead — per ADR-013 Rule 1 (Step 2.5). |
+| 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). Do NOT attempt non-interactive recovery. |
 
 ## Edge Cases
 

package/skills/work-problems/test/work-problems-inter-iteration-verify.bats

@@ -0,0 +1,59 @@
+#!/usr/bin/env bats
+# Doc-lint guard: work-problems SKILL.md must include an inter-iteration
+# verification check (P036). After each subagent returns, the orchestrator
+# must verify via `git status --porcelain` that the tree is clean (or
+# dirty for a known deliberate reason) before spawning the next iteration.
+#
+# Structural assertion — Permitted Exception to the source-grep ban
+# (ADR-005 / P011). Asserts the skill specification document contains the
+# inter-iteration check so a silent subagent commit failure cannot
+# compound across iterations.
+#
+# Cross-reference:
+#   P036 (work-problems orchestrator does not verify commit-landing between iterations)
+#   P035 (commit-gate fallback, the primary mitigation this backstops)
+#   @jtbd JTBD-006 (progress the backlog while I'm away)
+
+setup() {
+  SKILL_DIR="$(cd "$(dirname "$BATS_TEST_FILENAME")/.." && pwd)"
+  SKILL_FILE="${SKILL_DIR}/SKILL.md"
+}
+
+@test "SKILL.md cites P036 (inter-iteration verification)" {
+  run grep -n "P036" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md has an inter-iteration verification step (after commit, before next iteration)" {
+  # The step should appear between the commit/release-cadence step and
+  # the "Step 7: Loop" section, with a recognisable heading.
+  run grep -niE "inter-iteration verification|verif.*iteration|post-iteration verif" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md inter-iteration check uses git status --porcelain" {
+  run grep -n "git status --porcelain" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md inter-iteration check halts the loop on unexpected dirty state" {
+  # Must describe halting / stopping when the tree is dirty without a
+  # known-deliberate reason.
+  run grep -niE "halt|stop the loop|dirty.*(halt|stop|block)|uncommitted.*(halt|stop|block|detected)" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md inter-iteration check distinguishes clean tree from deliberate dirty state" {
+  # Not all dirty states are errors — e.g. a governance doc transition
+  # the subagent deliberately left for the next iteration to pick up.
+  # The check should permit a documented dirty state and halt on an
+  # undocumented one.
+  run grep -niE "deliberate|known reason|expected|documented.*dirty|known.*dirty" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}
+
+@test "SKILL.md Non-Interactive Decision Making table covers unexpected dirty state" {
+  # AFK mode: inter-iteration dirty state should have a default action.
+  run grep -niE "inter[- ]iteration|unexpected dirty" "$SKILL_FILE"
+  [ "$status" -eq 0 ]
+}