pi-gauntlet 5.5.2 → 5.5.4

package/CHANGELOG.md

@@ -1,5 +1,18 @@
 # Changelog
 
+## v5.5.4 - 2026-09-14
+
+- `phase-tracker`: new `phase_tracker` action `grant_fix_rounds` records an explicit human approval of N more conformance fix rounds (reason quotes the human), accepted only while the cap block is live; each qualifying implementer wave spends one granted round, credits replay with the session and reset with the audit latch. The cap-block message now leads with that action and names the exact `.pi/settings.json` for the `enforce: false` last resort (applies without restart, whole-block precedence).
+- `gauntlet_setting` is registered with sequential execution, so a settings write and a verifying read batched in one message run in order.
+- `conformance-check.md`: an explicit human approval re-enters the fix loop via `grant_fix_rounds`; without it escalation stays terminal.
+
+## v5.5.3 - 2026-09-13
+
+- `code-reviewer`: verdict is a stated function of severity - a Critical or Moderate finding means `FIX_FIRST`, Minor-only and clean reports mean `SHIP`, matching the orchestrating skills. (#30)
+- `phase-tracker`: two new closure-review blocks inside a brainstorming-entered flow once `verify` is in progress and a conformance audit has been observed - a lone top-level `agent: "implementer"` `subagent` dispatch is blocked (one-task `tasks` wave is the only isolated shape), and an implementer dispatch past `closureReview.maxFixRounds` is blocked with the escalation text. Rounds are counted from non-error results carrying an implementer child; the counter resets with the audit latch. `closureReview.enforce: false` disables both.
+- `closureReview.maxFixRounds` default 2 -> 3.
+- `conformance-check.md` / `dispatching-parallel-agents`: retries inside the conformance loop are one-task `tasks` waves and count against the cap.
+
 ## v5.5.2 - 2026-09-13
 
 - `release.sh <level>` promotes the CHANGELOG `## Unreleased` section to `## vX.Y.Z - <date>` and commits it with `package.json` in the single `Release X.Y.Z` commit, so `patch`/`minor`/`major` now work here (the `current`-only path is gone). New CONFIG field `CHANGELOG_HEADING`.

package/agents/code-reviewer.md

@@ -1,6 +1,6 @@
 ---
 name: code-reviewer
-description: Production-readiness code review with prioritized findings (Critical blocks merge, Minor is a nit). Read-only — does not edit.
+description: Production-readiness code review with prioritized findings (Critical and Moderate block merge, Minor is a nit). Read-only — does not edit.
 tools: read, grep, find, ls, bash
 defaultContext: fresh
 inheritProjectContext: true
@@ -44,11 +44,15 @@ Parallel-safe: F1,F3 disjoint; F2 conflicts F1 (both touch auth.ts)
 Behaviour-change: yes | no
 ```
 
+Severity decides SHIP versus FIX_FIRST. A Critical or Moderate finding means
+FIX_FIRST. Minor-only findings and clean reports mean SHIP. REJECT overrides
+both: refuse a change that must not land at all.
+
 Severity:
 
 - **Critical** — must fix before merge (data loss, security, broken correctness on a common path, broken contract).
-- **Moderate** — should fix; open for discussion (significant but not strictly blocking).
-- **Minor** — nit, style, preference, suggestion.
+- **Moderate** — must fix before merge (significant defect or drift that does not rise to Critical).
+- **Minor** — nit, style, preference, suggestion; the only severity declinable without a fix round or re-review.
 
 Label every finding with a globally unique `F1..Fn` ID (no restart per severity),
 and a `touched-files:`/`touched-resources:` pair (files/resources a fix would

package/extensions/lib/gauntlet-settings.test.ts

@@ -122,11 +122,12 @@ test("closureReview: enforce default true; false only when explicitly false", ()
   assert.equal(resolveClosureReview({ closureReview: { enforce: true } }).enforce, true);
 });
 
-test("closureReview: maxFixRounds default 2, <0 -> 0, non-int -> 2", () => {
-  assert.equal(resolveClosureReview({}).maxFixRounds, 2);
+test("closureReview: maxFixRounds default 3, <0 -> 0, non-int -> 3", () => {
+  assert.equal(resolveClosureReview({}).maxFixRounds, 3);
   assert.equal(resolveClosureReview({ closureReview: { maxFixRounds: 5 } }).maxFixRounds, 5);
+  assert.equal(resolveClosureReview({ closureReview: { maxFixRounds: 0 } }).maxFixRounds, 0);
   assert.equal(resolveClosureReview({ closureReview: { maxFixRounds: -3 } }).maxFixRounds, 0);
-  assert.equal(resolveClosureReview({ closureReview: { maxFixRounds: 1.5 } }).maxFixRounds, 2);
+  assert.equal(resolveClosureReview({ closureReview: { maxFixRounds: 1.5 } }).maxFixRounds, 3);
 });
 
 test("flowGuards: defaults + overrides", () => {

package/extensions/lib/gauntlet-settings.ts

@@ -84,7 +84,7 @@ export function resolveClosureReview(g: PiGauntlet): ClosureReviewResolved {
   const model = nonEmptyString(cr?.model) ? cr!.model.trim() : undefined;
   const enforce = cr?.enforce !== false;
   const raw = cr?.maxFixRounds;
-  const maxFixRounds = typeof raw === "number" && Number.isInteger(raw) ? (raw < 0 ? 0 : raw) : 2;
+  const maxFixRounds = typeof raw === "number" && Number.isInteger(raw) ? (raw < 0 ? 0 : raw) : 3;
   return { model, enforce, maxFixRounds };
 }
 

package/extensions/phase-tracker.test.ts

@@ -6,9 +6,14 @@ import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import registerPhaseTracker from "./phase-tracker.ts";
 
+const originalSubagentDepth = process.env.PI_SUBAGENT_DEPTH;
+process.env.PI_SUBAGENT_DEPTH = "0";
+
 const tempDirs: string[] = [];
 after(() => {
   for (const dir of tempDirs) rmSync(dir, { recursive: true, force: true });
+  if (originalSubagentDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+  else process.env.PI_SUBAGENT_DEPTH = originalSubagentDepth;
 });
 
 const tempCwd = (settings?: unknown) => {
@@ -53,7 +58,7 @@ const resumedBranch = (rest: Partial<Record<Phase, Status>>) => [
 
 function harness(options: { cwd?: string; branch?: unknown[]; idle?: boolean; beforeSettled?: (setIdle: (idle: boolean) => void) => void; sendThrows?: boolean; model?: { provider: string; id: string }; thinkingLevel?: string } = {}) {
   const handlers = new Map<string, ((event: unknown, ctx: unknown) => unknown)[]>();
-  const tools: { name: string; execute: (...args: any[]) => unknown }[] = [];
+  const tools: { name: string; executionMode?: string; parameters?: any; execute: (...args: any[]) => unknown }[] = [];
   const sent: { message: any; options: any }[] = [];
   let idle = options.idle ?? true;
   let branch = options.branch ?? [];
@@ -71,7 +76,7 @@ function harness(options: { cwd?: string; branch?: unknown[]; idle?: boolean; be
       registered.push(handler);
       handlers.set(event, registered);
     },
-    registerTool(tool: { name: string; executionMode?: string; execute: (...args: any[]) => unknown }) {
+    registerTool(tool: { name: string; executionMode?: string; parameters?: any; execute: (...args: any[]) => unknown }) {
       tools.push(tool);
     },
     sendMessage(message: unknown, sendOptions: unknown) {
@@ -529,7 +534,8 @@ test("implement-phase commit with implementer newer than both reviewers warns",
     const warned = (await h.emitEvent("tool_result", commitResult("c1")))[0] as { content: { text: string }[] };
     assert.match(warned.content[0].text, /no spec-reviewer or code-reviewer observed/);
   } finally {
-    if (priorDepth !== undefined) process.env.PI_SUBAGENT_DEPTH = priorDepth;
+    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
   }
 });
 
@@ -1164,3 +1170,550 @@ test("gauntlet_setting escalationLoop: setting absent -> ctx-derived main-loop m
   const res = (await set.tools.find((t) => t.name === "gauntlet_setting")!.execute("g2", { key: "escalationLoop" }, undefined, undefined, set.ctx)) as { details: { implModel?: string } };
   assert.equal(res.details.implModel, "p/strong:high");
 });
+
+// --- Conformance fix-loop dispatch guard (spec 2026-09-13-conformance-dispatch-guard) ---
+
+const verifyBranch = (extra: unknown[] = []) => [
+  ...implementBranch(),
+  phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete" })),
+  phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress" })),
+  ...extra,
+];
+
+const subagentCall = (id: string, input: unknown) => ({ toolName: "subagent", toolCallId: id, input });
+const loneImplementer = (extra: Record<string, unknown> = {}) => ({ agent: "implementer", task: "fix G1", ...extra });
+const implementerWave = (n = 1) => ({
+  tasks: Array.from({ length: n }, (_, i) => ({ agent: "implementer", task: `fix G${i + 1}`, worktree: true })),
+});
+
+const firstCallResult = async (h: ReturnType<typeof harness>, id: string, input: unknown) =>
+  (await h.emitEvent("tool_call", subagentCall(id, input)))[0] as { block?: boolean; reason?: string } | undefined;
+
+test("shape guard: lone implementer blocked in verify after the audit, with and without closureReview.model, async or not", async () => {
+  for (const settings of [
+    { piGauntlet: { closureReview: { enforce: true } } },
+    { piGauntlet: { closureReview: { enforce: true, model: "x/y" } } },
+  ]) {
+    const h = harness({ cwd: tempCwd(settings), branch: verifyBranch([subagentResult(["conformance-reviewer"])]) });
+    await h.emit("session_start");
+    const sync = await firstCallResult(h, "s1", loneImplementer());
+    assert.equal(sync?.block, true);
+    assert.match(sync?.reason ?? "", /dispatch implementers as a one-task tasks wave/);
+    assert.match(sync?.reason ?? "", /piGauntlet\.closureReview\.enforce: false/);
+    const async = await firstCallResult(h, "s2", loneImplementer({ async: true }));
+    assert.equal(async?.block, true);
+  }
+});
+
+test("shape guard: lone implementer passes before the audit, in implement, in ship, and on management calls", async () => {
+  const preLatch = harness({ branch: verifyBranch() });
+  await preLatch.emit("session_start");
+  assert.equal(await firstCallResult(preLatch, "s1", loneImplementer()), undefined);
+
+  const implement = harness({ branch: implementBranch([subagentResult(["conformance-reviewer"])]) });
+  await implement.emit("session_start");
+  assert.equal(await firstCallResult(implement, "s1", loneImplementer()), undefined);
+
+  const ship = harness({
+    branch: verifyBranch([
+      subagentResult(["conformance-reviewer"]),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" })),
+    ]),
+  });
+  await ship.emit("session_start");
+  assert.equal(await firstCallResult(ship, "s1", loneImplementer()), undefined);
+
+  const mgmt = harness({ branch: verifyBranch([subagentResult(["conformance-reviewer"])]) });
+  await mgmt.emit("session_start");
+  assert.equal(await firstCallResult(mgmt, "s1", { action: "status", agent: "implementer" }), undefined);
+});
+
+test("shape guard: dormant when the flow was never entered (cold start verify) and when closureReview.enforce is false", async () => {
+  const cold = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 0 } } }),
+    branch: [phaseResult("start", phases({ verify: "in_progress" })), subagentResult(["conformance-reviewer"])],
+  });
+  await cold.emit("session_start");
+  assert.equal(await firstCallResult(cold, "s1", loneImplementer()), undefined);
+  assert.equal(await firstCallResult(cold, "s2", implementerWave(1)), undefined);
+  assert.equal(await firstCallResult(cold, "s3", { chain: [{ agent: "implementer", task: "fix" }] }), undefined);
+
+  const off = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { enforce: false } } }),
+    branch: verifyBranch([subagentResult(["conformance-reviewer"])]),
+  });
+  await off.emit("session_start");
+  assert.equal(await firstCallResult(off, "s1", loneImplementer()), undefined);
+});
+
+test("shape guard: a one-task tasks wave and a chain step are not the lone shape", async () => {
+  const h = harness({ branch: verifyBranch([subagentResult(["conformance-reviewer"])]) });
+  await h.emit("session_start");
+  assert.equal(await firstCallResult(h, "s1", implementerWave(1)), undefined);
+  assert.equal(await firstCallResult(h, "s2", { chain: [{ agent: "implementer", task: "fix" }] }), undefined);
+});
+
+const waveResult = (id: string, results: { agent: string; exitCode: number }[], isError = false) => ({
+  toolName: "subagent",
+  toolCallId: id,
+  isError,
+  content: [],
+  details: { results },
+});
+const okWave = (id: string) => waveResult(id, [{ agent: "implementer", exitCode: 0 }]);
+
+const guardedHarness = (settings: unknown, extra: unknown[] = []) =>
+  harness({ cwd: tempCwd(settings), branch: verifyBranch([subagentResult(["conformance-reviewer"]), ...extra]) });
+
+test("cap guard: default 3 waves pass, the fourth is blocked with the escalation text", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { enforce: true } } });
+  await h.emit("session_start");
+  for (let i = 1; i <= 3; i++) {
+    assert.equal(await firstCallResult(h, `c${i}`, implementerWave(2)), undefined, `round ${i} passes`);
+    await h.emitEvent("tool_result", okWave(`c${i}`));
+  }
+  const blocked = await firstCallResult(h, "c4", implementerWave(1));
+  assert.equal(blocked?.block, true);
+  assert.match(blocked?.reason ?? "", /3 fix round\(s\) used against a cap of 3 \(granted rounds included\); escalate to the human/);
+});
+
+test("cap guard: maxFixRounds 0 blocks the first wave; 1 blocks the second; a chain implementer is cap-checked and counted", async () => {
+  const zero = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await zero.emit("session_start");
+  assert.equal((await firstCallResult(zero, "c1", implementerWave(1)))?.block, true);
+
+  const one = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 1 } } });
+  await one.emit("session_start");
+  assert.equal(await firstCallResult(one, "c1", { chain: [{ agent: "implementer", task: "fix" }] }), undefined);
+  await one.emitEvent("tool_result", okWave("c1"));
+  assert.equal((await firstCallResult(one, "c2", implementerWave(1)))?.block, true);
+});
+
+test("counter: results while closure review enforcement is off do not consume budget", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { enforce: false, maxFixRounds: 1 } } });
+  await h.emit("session_start");
+  await h.emitEvent("tool_result", okWave("c1"));
+  await h.emitEvent("tool_result", okWave("c2"));
+  writeFileSync(
+    join(h.ctx.cwd, ".pi", "settings.json"),
+    JSON.stringify({ piGauntlet: { closureReview: { enforce: true, maxFixRounds: 1 } } }),
+  );
+  assert.equal(await firstCallResult(h, "c3", implementerWave(1)), undefined);
+});
+
+test("fix-loop guard and counter are dormant in subagent children", async () => {
+  const priorDepth = process.env.PI_SUBAGENT_DEPTH;
+  process.env.PI_SUBAGENT_DEPTH = "1";
+  let live: ReturnType<typeof harness>;
+  let replay: ReturnType<typeof harness>;
+  try {
+    live = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+    replay = guardedHarness(
+      { piGauntlet: { closureReview: { maxFixRounds: 2 } } },
+      [subagentResult(["implementer"]), subagentResult(["implementer"])],
+    );
+  } finally {
+    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+  }
+
+  await live.emit("session_start");
+  assert.equal(await firstCallResult(live, "c1", loneImplementer()), undefined);
+  assert.equal(await firstCallResult(live, "c2", implementerWave(1)), undefined);
+  await live.emitEvent("tool_result", okWave("c2"));
+  await replay.emit("session_start");
+  assert.equal(await firstCallResult(replay, "c3", implementerWave(1)), undefined);
+});
+
+test("cap guard: non-implementer dispatches never blocked; enforce false passes everything", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  assert.equal(await firstCallResult(h, "r1", { agent: "conformance-reviewer", task: "re-audit" }), undefined);
+  assert.equal(await firstCallResult(h, "r2", { agent: "code-reviewer", task: "review" }), undefined);
+
+  const off = guardedHarness({ piGauntlet: { closureReview: { enforce: false, maxFixRounds: 0 } } });
+  await off.emit("session_start");
+  assert.equal(await firstCallResult(off, "c1", implementerWave(1)), undefined);
+  assert.equal(await firstCallResult(off, "c2", loneImplementer()), undefined);
+});
+
+test("counter: blocked, errored, empty, non-implementer, and out-of-window results do not count; non-zero exit does", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 1 } } });
+  await h.emit("session_start");
+  await h.emitEvent("tool_result", waveResult("e1", [{ agent: "implementer", exitCode: 0 }], true));
+  await h.emitEvent("tool_result", waveResult("e2", []));
+  await h.emitEvent("tool_result", waveResult("e3", [{ agent: "code-reviewer", exitCode: 0 }]));
+  const blockedLone = await firstCallResult(h, "b1", loneImplementer());
+  assert.equal(blockedLone?.block, true);
+  assert.equal(await firstCallResult(h, "c1", implementerWave(1)), undefined, "budget untouched");
+  await h.emitEvent("tool_result", waveResult("c1", [{ agent: "implementer", exitCode: 1 }]));
+  assert.equal((await firstCallResult(h, "c2", implementerWave(1)))?.block, true);
+});
+
+test("counter: a ship-phase implementer wave with the latch set does not count", async () => {
+  const h = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 1 } } }),
+    branch: verifyBranch([
+      subagentResult(["conformance-reviewer"]),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" })),
+      subagentResult(["implementer"]),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress", ship: "in_progress" })),
+    ]),
+  });
+  await h.emit("session_start");
+  assert.equal(await firstCallResult(h, "c1", implementerWave(1)), undefined);
+});
+
+test("counter reset: start implement and reset zero it; start verify --force keeps it", async () => {
+  const mk = () => guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 1 }, flowGuards: { enforce: false } } }, [subagentResult(["implementer"])]);
+
+  const force = mk();
+  await force.emit("session_start");
+  const forceTool = force.tools.find((t) => t.name === "phase_tracker")!;
+  const forced = (await forceTool.execute("p1", { action: "start", phase: "verify", force: true }, undefined, undefined, force.ctx)) as { details: { error?: string } };
+  assert.equal(forced.details.error, undefined);
+  assert.equal((await firstCallResult(force, "c1", implementerWave(1)))?.block, true, "budget survives verify --force");
+
+  const impl = mk();
+  await impl.emit("session_start");
+  const implTool = impl.tools.find((t) => t.name === "phase_tracker")!;
+  for (const [id, input] of [
+    ["p1", { action: "skip", phase: "verify", reason: "amendment" }],
+    ["p2", { action: "start", phase: "implement", force: true }],
+    ["p3", { action: "complete", phase: "implement" }],
+    ["p4", { action: "start", phase: "verify", force: true }],
+  ] as const) {
+    const result = (await implTool.execute(id, input, undefined, undefined, impl.ctx)) as { details: { error?: string } };
+    assert.equal(result.details.error, undefined);
+  }
+  assert.equal(await firstCallResult(impl, "c1", loneImplementer()), undefined, "latch cleared by start implement");
+  await impl.emitEvent("tool_result", waveResult("audit", [{ agent: "conformance-reviewer", exitCode: 0 }]));
+  assert.equal(await firstCallResult(impl, "c2", implementerWave(1)), undefined, "counter cleared by start implement");
+
+  const reset = mk();
+  await reset.emit("session_start");
+  const resetTool = reset.tools.find((t) => t.name === "phase_tracker")!;
+  const resetResult = (await resetTool.execute("p1", { action: "reset" }, undefined, undefined, reset.ctx)) as { details: { error?: string } };
+  assert.equal(resetResult.details.error, undefined);
+  assert.equal(await firstCallResult(reset, "c1", loneImplementer()), undefined, "dormant after reset");
+});
+
+test("replay: two implementer waves after the audit in verify restore fixRounds 2; the same waves in ship restore 0", async () => {
+  const inVerify = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 2 } } }, [
+    subagentResult(["implementer"]),
+    subagentResult(["implementer", "code-reviewer"]),
+  ]);
+  await inVerify.emit("session_start");
+  assert.equal((await firstCallResult(inVerify, "c1", implementerWave(1)))?.block, true);
+
+  const inShip = harness({
+    cwd: tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 2 } } }),
+    branch: verifyBranch([
+      subagentResult(["conformance-reviewer"]),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" })),
+      subagentResult(["implementer"]),
+      subagentResult(["implementer"]),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress", ship: "in_progress" })),
+    ]),
+  });
+  await inShip.emit("session_start");
+  assert.equal(await firstCallResult(inShip, "c1", implementerWave(1)), undefined);
+});
+
+// --- Human overrule of the fix-round cap (spec 2026-09-14-fix-round-human-overrule) ---
+
+const grantResult = (rounds: number, reason = "human approved") => ({
+  type: "message",
+  message: { role: "toolResult", toolName: "phase_tracker", details: {
+    action: "grant_fix_rounds", rounds, reason,
+    phases: phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress" }),
+  } },
+});
+
+const grant = async (h: ReturnType<typeof harness>, id: string, input: Record<string, unknown>) =>
+  (await h.tools.find((t) => t.name === "phase_tracker")!.execute(id, { action: "grant_fix_rounds", ...input }, undefined, undefined, h.ctx)) as {
+    content: { type: string; text: string }[];
+    details: { action: string; rounds?: number; reason?: string; error?: string };
+  };
+
+const exhaust = async (h: ReturnType<typeof harness>, rounds: number, prefix = "x") => {
+  for (let i = 1; i <= rounds; i++) {
+    assert.equal(await firstCallResult(h, `${prefix}${i}`, implementerWave(1)), undefined);
+    await h.emitEvent("tool_result", okWave(`${prefix}${i}`));
+  }
+};
+
+test("grant: funds extra waves and rejects another grant while credits remain", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { enforce: true } } });
+  await h.emit("session_start");
+  await exhaust(h, 3);
+  const res = await grant(h, "g1", { rounds: 2, reason: "I'm approving 2 more rounds" });
+  assert.equal(res.details.error, undefined);
+  assert.deepEqual([res.details.rounds, res.details.reason], [2, "I'm approving 2 more rounds"]);
+  assert.equal((await grant(h, "g2", { rounds: 1, reason: "more" })).details.error, "grant_fix_rounds: 2 granted round(s) still unused; spend them before granting more");
+  await exhaust(h, 2, "c");
+  const blocked = await firstCallResult(h, "c3", implementerWave(1));
+  assert.equal(blocked?.block, true);
+  assert.match(blocked?.reason ?? "", /5 fix round\(s\) used against a cap of 3 \(granted rounds included\)/);
+});
+
+test("grant: schema declares rounds as integer 1..MAX_SAFE_INTEGER; missing rounds or empty reason error without state change", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  const params = h.tools.find((t) => t.name === "phase_tracker")!.parameters;
+  const roundOptions = params.args[0].rounds.args[0].args[0];
+  assert.equal(params.args[0].rounds.args[0].kind, "Integer");
+  assert.deepEqual([roundOptions.minimum, roundOptions.maximum], [1, Number.MAX_SAFE_INTEGER]);
+  assert.ok(params.args[0].action.values.includes("grant_fix_rounds"));
+
+  const noRounds = await grant(h, "g1", { reason: "ok" });
+  assert.equal(noRounds.details.error, "grant_fix_rounds requires rounds: a positive integer");
+  assert.equal(noRounds.details.rounds, undefined);
+  const noReason = await grant(h, "g2", { rounds: 1, reason: "   " });
+  assert.equal(noReason.details.error, "grant_fix_rounds requires reason: the human's approval, quoted");
+  assert.equal(noReason.details.rounds, undefined);
+  assert.equal((await firstCallResult(h, "c1", implementerWave(1)))?.block, true, "no credit was granted");
+});
+
+test("grant: rejected when no cap block is live - before the audit, in implement, below the cap, enforce off, and in a child", async () => {
+  const expectNotLive = async (h: ReturnType<typeof harness>, used: number, cap: number) => {
+    const res = await grant(h, "g", { rounds: 1, reason: "ok" });
+    assert.equal(res.details.error, `grant_fix_rounds: no fix-round cap block is active (${used} used, cap ${cap}); nothing to overrule`);
+  };
+
+  const preAudit = harness({ cwd: tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 0 } } }), branch: verifyBranch() });
+  await preAudit.emit("session_start");
+  await expectNotLive(preAudit, 0, 0);
+
+  const implement = harness({ cwd: tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 0 } } }), branch: implementBranch([subagentResult(["conformance-reviewer"])]) });
+  await implement.emit("session_start");
+  await expectNotLive(implement, 0, 0);
+
+  const below = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 3 } } });
+  await below.emit("session_start");
+  await exhaust(below, 2);
+  await expectNotLive(below, 2, 3);
+
+  const off = guardedHarness({ piGauntlet: { closureReview: { enforce: false, maxFixRounds: 0 } } });
+  await off.emit("session_start");
+  await expectNotLive(off, 0, 0);
+
+  const priorDepth = process.env.PI_SUBAGENT_DEPTH;
+  process.env.PI_SUBAGENT_DEPTH = "1";
+  let child: ReturnType<typeof harness>;
+  try {
+    child = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  } finally {
+    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+  }
+  await child.emit("session_start");
+  await expectNotLive(child, 0, 0);
+});
+
+test("grant: only qualifying synchronous parent task waves spend credits", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  await grant(h, "g", { rounds: 1, reason: "ok" });
+  await h.emitEvent("tool_result", waveResult("e1", [{ agent: "code-reviewer", exitCode: 0 }]));
+  await h.emitEvent("tool_result", waveResult("e2", [{ agent: "implementer", exitCode: 0 }], true));
+  await h.emitEvent("tool_result", waveResult("e3", []));
+  assert.equal((await firstCallResult(h, "a", { ...implementerWave(1), async: true }))?.block, true);
+  assert.equal((await firstCallResult(h, "l", loneImplementer()))?.block, true);
+  assert.equal(await firstCallResult(h, "c", implementerWave(1)), undefined);
+  await h.emitEvent("tool_result", okWave("c"));
+  assert.equal((await firstCallResult(h, "d", implementerWave(1)))?.block, true);
+
+  // In a child (PI_SUBAGENT_DEPTH >= 1, fixed at registration) both the cap gate and observeFixWave
+  // are dormant, so credit consumption has no public effect; the observable contract is dormancy.
+  const priorDepth = process.env.PI_SUBAGENT_DEPTH;
+  process.env.PI_SUBAGENT_DEPTH = "1";
+  let child: ReturnType<typeof harness>;
+  try {
+    child = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } }, [grantResult(1), subagentResult(["implementer"])]);
+  } finally {
+    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+  }
+  await child.emit("session_start");
+  assert.equal(await firstCallResult(child, "child-wave", implementerWave(1)), undefined, "child session: cap gate and observer are dormant, so the replayed grant and implementer result have no observable effect");
+});
+
+test("grant replay restores and spends the recorded pool independent of current cap; rejected grants restore no credit", async () => {
+  const trail = [subagentResult(["implementer"]), subagentResult(["implementer"]), subagentResult(["implementer"]), grantResult(2), subagentResult(["implementer"])];
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 3 } } }, trail);
+  await h.emit("session_start");
+  assert.equal(
+    (await grant(h, "g", { rounds: 1, reason: "more" })).details.error,
+    "grant_fix_rounds: 1 granted round(s) still unused; spend them before granting more",
+  );
+  assert.equal(await firstCallResult(h, "c", implementerWave(1)), undefined);
+  await h.emitEvent("tool_result", okWave("c"));
+  const blocked = await firstCallResult(h, "d", implementerWave(1));
+  assert.equal(blocked?.block, true);
+  assert.match(blocked?.reason ?? "", /5 fix round\(s\) used against a cap of 3 \(granted rounds included\)/);
+
+  // Same trail at cap 5: replay yields fixRounds = 4 (cap not live yet); lowering the live cap
+  // exposes the one replayed credit, then wave 5 passes on the counter and wave 6 blocks.
+  const capChanged = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 5 } } }, trail);
+  await capChanged.emit("session_start");
+  assert.equal(
+    (await grant(capChanged, "g", { rounds: 1, reason: "more" })).details.error,
+    "grant_fix_rounds: no fix-round cap block is active (4 used, cap 5); nothing to overrule",
+    "replayed fixRounds = 4 regardless of cap on disk",
+  );
+  // Lower the cap on disk without spending a wave: the block goes live at 4 >= 3 and the grant
+  // probe now reads the replayed pool - exactly one credit, independent of the cap at replay time.
+  writeFileSync(join(capChanged.ctx.cwd, ".pi", "settings.json"), JSON.stringify({ piGauntlet: { closureReview: { maxFixRounds: 3 } } }));
+  assert.equal(
+    (await grant(capChanged, "g2", { rounds: 1, reason: "more" })).details.error,
+    "grant_fix_rounds: 1 granted round(s) still unused; spend them before granting more",
+    "same credits regardless of cap on disk",
+  );
+  writeFileSync(join(capChanged.ctx.cwd, ".pi", "settings.json"), JSON.stringify({ piGauntlet: { closureReview: { maxFixRounds: 5 } } }));
+  assert.equal(await firstCallResult(capChanged, "c", implementerWave(1)), undefined);
+  await capChanged.emitEvent("tool_result", okWave("c"));
+  const blockedAt5 = await firstCallResult(capChanged, "d", implementerWave(1));
+  assert.equal(blockedAt5?.block, true);
+  assert.match(blockedAt5?.reason ?? "", /5 fix round\(s\) used against a cap of 5 \(granted rounds included\)/);
+
+  const rejected = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } }, [{
+    type: "message",
+    message: {
+      role: "toolResult",
+      toolName: "phase_tracker",
+      details: { action: "grant_fix_rounds", error: "grant_fix_rounds requires rounds: a positive integer", phases: phases({ verify: "in_progress" }) },
+    },
+  }]);
+  await rejected.emit("session_start");
+  assert.equal((await firstCallResult(rejected, "c1", implementerWave(1)))?.block, true, "no credits from a rejected grant");
+});
+
+test("grant reset: start implement and reset zero credits (live and replay); start verify --force keeps them", async () => {
+  const settings = { piGauntlet: { closureReview: { maxFixRounds: 0 }, flowGuards: { enforce: false } } };
+
+  const force = guardedHarness(settings, [grantResult(1)]);
+  await force.emit("session_start");
+  await force.tools.find((t) => t.name === "phase_tracker")!.execute("p", { action: "start", phase: "verify", force: true }, undefined, undefined, force.ctx);
+  assert.equal(await firstCallResult(force, "c", implementerWave(1)), undefined);
+
+  const liveImpl = guardedHarness(settings);
+  await liveImpl.emit("session_start");
+  await grant(liveImpl, "g", { rounds: 1, reason: "ok" });
+  const tool = liveImpl.tools.find((t) => t.name === "phase_tracker")!;
+  for (const [id, input] of [
+    ["p1", { action: "skip", phase: "verify", reason: "amendment" }],
+    ["p2", { action: "start", phase: "implement", force: true }],
+    ["p3", { action: "complete", phase: "implement" }],
+    ["p4", { action: "start", phase: "verify", force: true }],
+  ] as const) {
+    assert.equal(((await tool.execute(id, input, undefined, undefined, liveImpl.ctx)) as { details: { error?: string } }).details.error, undefined);
+  }
+  await liveImpl.emitEvent("tool_result", waveResult("audit", [{ agent: "conformance-reviewer", exitCode: 0 }]));
+  assert.equal((await firstCallResult(liveImpl, "c1", implementerWave(1)))?.block, true, "credits zeroed by start implement (cap 0 blocks)");
+
+  const reset = guardedHarness(settings);
+  await reset.emit("session_start");
+  await grant(reset, "g", { rounds: 1, reason: "ok" });
+  const resetTool = reset.tools.find((t) => t.name === "phase_tracker")!;
+  await resetTool.execute("p", { action: "reset" }, undefined, undefined, reset.ctx);
+  assert.match((await grant(reset, "g2", { rounds: 1, reason: "ok" })).details.error ?? "", /no fix-round cap block is active/);
+  for (const [id, input] of [
+    ["p1", { action: "start", phase: "brainstorm" }],
+    ["p2", { action: "complete", phase: "brainstorm" }],
+    ["p3", { action: "start", phase: "plan" }],
+    ["p4", { action: "complete", phase: "plan" }],
+    ["p5", { action: "start", phase: "implement" }],
+    ["p6", { action: "complete", phase: "implement" }],
+    ["p7", { action: "start", phase: "verify" }],
+  ] as const) {
+    assert.equal(((await resetTool.execute(id, input, undefined, undefined, reset.ctx)) as { details: { error?: string } }).details.error, undefined);
+  }
+  await reset.emitEvent("tool_result", waveResult("audit", [{ agent: "conformance-reviewer", exitCode: 0 }]));
+  assert.equal((await firstCallResult(reset, "c1", implementerWave(1)))?.block, true, "credits zeroed by reset (cap 0 blocks)");
+
+  const replayImpl = harness({
+    cwd: tempCwd(settings),
+    branch: verifyBranch([
+      subagentResult(["conformance-reviewer"]),
+      grantResult(1),
+      phaseResult("skip", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "skipped" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "in_progress", verify: "skipped" })),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "skipped" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress" })),
+      subagentResult(["conformance-reviewer"]),
+    ]),
+  });
+  await replayImpl.emit("session_start");
+  assert.equal((await firstCallResult(replayImpl, "c1", implementerWave(1)))?.block, true, "replayed start implement zeroed credits");
+
+  const replayReset = harness({
+    cwd: tempCwd(settings),
+    branch: verifyBranch([
+      subagentResult(["conformance-reviewer"]),
+      grantResult(1),
+      phaseResult("reset", phases({})),
+      phaseResult("start", phases({ brainstorm: "in_progress" })),
+      phaseResult("complete", phases({ brainstorm: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "in_progress" })),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "in_progress" })),
+      phaseResult("complete", phases({ brainstorm: "complete", plan: "complete", implement: "complete" })),
+      phaseResult("start", phases({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress" })),
+      subagentResult(["conformance-reviewer"]),
+    ]),
+  });
+  await replayReset.emit("session_start");
+  assert.equal((await firstCallResult(replayReset, "c1", implementerWave(1)))?.block, true, "replayed reset zeroed credits");
+});
+
+test("grant: block reason gives action, settings path, and live-read guidance", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  const reason = (await firstCallResult(h, "c", implementerWave(1)))?.reason ?? "";
+  assert.match(reason, /phase_tracker\(\{ action: "grant_fix_rounds"/);
+  assert.ok(reason.includes(join(h.ctx.cwd, ".pi", "settings.json")));
+  assert.match(reason, /no restart.*restate model and maxFixRounds/s);
+});
+
+test("gauntlet_setting registration requests sequential execution", () => {
+  assert.equal(harness().tools.find((t) => t.name === "gauntlet_setting")!.executionMode, "sequential");
+});
+
+test("grant renderResult shows count and reason", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  const res = await grant(h, "g", { rounds: 2, reason: "go on" });
+  const tool = h.tools.find((t) => t.name === "phase_tracker")! as any;
+  const rendered = tool.renderResult(res, {}, { fg: (_c: string, s: string) => s, bold: (s: string) => s });
+  assert.match(JSON.stringify(rendered), /2.*go on/);
+});
+
+test("grant: child sessions cannot overrule even a zero cap", async () => {
+  const priorDepth = process.env.PI_SUBAGENT_DEPTH;
+  process.env.PI_SUBAGENT_DEPTH = "1";
+  let child: ReturnType<typeof harness>;
+  try {
+    child = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  } finally {
+    if (priorDepth === undefined) delete process.env.PI_SUBAGENT_DEPTH;
+    else process.env.PI_SUBAGENT_DEPTH = priorDepth;
+  }
+  await child.emit("session_start");
+  assert.match((await grant(child, "g", { rounds: 1, reason: "ok" })).details.error ?? "", /no fix-round cap block is active/);
+});
+
+test("grant: accepts MAX_SAFE_INTEGER and current on-disk cap controls whether the block is live", async () => {
+  const h = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await h.emit("session_start");
+  const result = await grant(h, "g", { rounds: Number.MAX_SAFE_INTEGER, reason: "approved" });
+  assert.equal(result.details.rounds, Number.MAX_SAFE_INTEGER);
+
+  const changed = guardedHarness({ piGauntlet: { closureReview: { maxFixRounds: 0 } } });
+  await changed.emit("session_start");
+  writeFileSync(join(changed.ctx.cwd, ".pi", "settings.json"), JSON.stringify({ piGauntlet: { closureReview: { maxFixRounds: 1 } } }));
+  assert.match((await grant(changed, "g", { rounds: 1, reason: "ok" })).details.error ?? "", /0 used, cap 1/);
+});

package/extensions/phase-tracker.ts

@@ -56,9 +56,11 @@ interface PhaseState {
 type PhaseMap = Record<Phase, PhaseState>;
 
 interface PhaseTrackerDetails {
-  action: "start" | "complete" | "skip" | "status" | "reset" | "substep";
+  action: "start" | "complete" | "skip" | "status" | "reset" | "substep" | "grant_fix_rounds";
   phases: PhaseMap;
   error?: string;
+  rounds?: number;
+  reason?: string;
 }
 
 interface PlanCheckStamp {
@@ -86,6 +88,17 @@ const qualifiesAsClosureDispatch = (details: unknown): boolean => {
   return d.results.some((r) => r?.agent === "conformance-reviewer" && r?.exitCode === 0);
 };
 
+// One conformance fix round = one non-error subagent result carrying at least one
+// implementer child, regardless of dispatch mode or per-child exit code (a failed
+// implementer still spent the round; its retry is the next one). Async and
+// management dispatches return results: [] and never count.
+const isImplementerWave = (details: unknown, isError: boolean | undefined): boolean => {
+  if (isError === true) return false;
+  const d = details as { results?: { agent?: unknown }[] } | undefined;
+  if (!d || !Array.isArray(d.results) || d.results.length === 0) return false;
+  return d.results.some((r) => r?.agent === "implementer");
+};
+
 // Review-cadence guard (spec 2026-08-12-execution-fidelity-hardening): presence-only
 // advisory ledger of the most recent completed implementer / spec-reviewer /
 // code-reviewer dispatch. Agents completing in the SAME dispatch share a sequence
@@ -164,22 +177,14 @@ const branchBlockReason = (phase: Phase): string =>
   "create/enter one with /skill:using-git-worktrees and run this there. " +
   "To override, set piGauntlet.flowGuards.enforce: false.";
 
-// Closure-review model guard: when piGauntlet.closureReview.model is configured,
-// a conformance-reviewer dispatch should inject that model call-site. The persona
-// ships model-free, so a bare omission silently inherits the parent session's
-// builder model - defeating the point of an independent closing gate. Walk the
-// single / tasks / chain / parallel dispatch shapes and collect the model of every
-// conformance-reviewer entry (undefined = absent/empty/non-string). A bare omission
-// is BLOCKED; an explicit model that differs from the configured one is WARNED
-// (non-blocking), preserving the documented retry-with-fallback hatch while
-// surfacing drift.
-const conformanceModels = (input: unknown): (string | undefined)[] => {
-  const models: (string | undefined)[] = [];
-  const norm = (m: unknown) => (typeof m === "string" && m.trim() ? m.trim() : undefined);
+// Walk the single / tasks / chain / parallel dispatch shapes and return every
+// entry whose `agent` matches `name` (the raw node, so callers can read its model).
+const collectAgents = (input: unknown, name: string): Record<string, unknown>[] => {
+  const hits: Record<string, unknown>[] = [];
   const collect = (node: unknown): void => {
     if (!node || typeof node !== "object") return;
     const o = node as Record<string, unknown>;
-    if (o.agent === "conformance-reviewer") models.push(norm(o.model));
+    if (o.agent === name) hits.push(o);
     for (const key of ["tasks", "chain", "parallel"] as const) {
       const v = o[key];
       if (Array.isArray(v)) for (const item of v) collect(item);
@@ -187,9 +192,31 @@ const conformanceModels = (input: unknown): (string | undefined)[] => {
     }
   };
   collect(input);
-  return models;
+  return hits;
 };
 
+const conformanceModels = (input: unknown): (string | undefined)[] =>
+  collectAgents(input, "conformance-reviewer").map((o) =>
+    typeof o.model === "string" && o.model.trim() ? o.model.trim() : undefined,
+  );
+
+// Conformance fix-loop dispatch guard (spec 2026-09-13-conformance-dispatch-guard):
+// after the first audit, pi-cohort honours worktree: true only in tasks mode, so a
+// lone implementer runs unisolated and yields no patch for the integrate step.
+const loneImplementerBlockReason =
+  'Conformance fix loop: dispatch implementers as a one-task tasks wave (tasks: [{ agent: "implementer", worktree: true, ... }]); ' +
+  "a lone agent call runs unisolated and produces no worktree diff. " +
+  "To disable this gate, set piGauntlet.closureReview.enforce: false.";
+
+const fixRoundCapBlockReason = (used: number, cap: number, settingsPath: string): string =>
+  `Conformance fix loop: ${used} fix round(s) used against a cap of ${cap} (granted rounds included); ` +
+  "escalate to the human with the verdict trail instead of re-looping.\n" +
+  "If the human explicitly approves more rounds, record it and retry as a tasks wave: " +
+  'phase_tracker({ action: "grant_fix_rounds", rounds: <N>, reason: "<their words>" }).\n' +
+  `Last resort: set piGauntlet.closureReview.enforce: false in ${settingsPath} (disables all closure guards; ` +
+  "applies on the next tool call, no restart - a gauntlet_setting read in the same message sees the write; " +
+  "a repo closureReview block replaces the preset's whole block, so restate model and maxFixRounds alongside).";
+
 const closureModelBlockReason = (model: string, missing: number, total: number): string =>
   `Blocked: ${missing} of ${total} conformance-reviewer ${total === 1 ? "dispatch" : "entries"} ` +
   `omitted a model while piGauntlet.closureReview.model is set to "${model}".\n` +
@@ -234,7 +261,7 @@ const pathInSpecDirs = (rawPath: string, specDirs: string[]): boolean => {
 };
 
 const PhaseTrackerParams = Type.Object({
-  action: StringEnum(["start", "complete", "skip", "status", "reset", "substep"] as const, {
+  action: StringEnum(["start", "complete", "skip", "status", "reset", "substep", "grant_fix_rounds"] as const, {
     description: "Action to perform",
   }),
   phase: Type.Optional(
@@ -244,7 +271,14 @@ const PhaseTrackerParams = Type.Object({
   ),
   reason: Type.Optional(
     Type.String({
-      description: "Reason for skipping (required for skip action)",
+      description: "Reason (required for skip and grant_fix_rounds; for grant, the human's approval quoted)",
+    }),
+  ),
+  rounds: Type.Optional(
+    Type.Integer({
+      minimum: 1,
+      maximum: Number.MAX_SAFE_INTEGER,
+      description: "Extra fix rounds the human explicitly approved (grant_fix_rounds only)",
     }),
   ),
   force: Type.Optional(
@@ -306,7 +340,25 @@ function formatStatus(phases: PhaseMap): string {
 export default function (pi: ExtensionAPI) {
   let phases: PhaseMap = emptyPhases();
   let conformanceDispatched = false;
+  let fixRounds = 0;
+  let fixRoundCredits = 0;
   let gauntletEntered = false;
+  // Shared by replay and the live tool_result hook so a resumed session enforces
+  // the same budget. Evaluated BEFORE the same result may set the latch, so the
+  // R0 audit result itself never counts as a wave.
+  const observeFixWave = (details: unknown, isError: boolean | undefined, ctx: ExtensionContext) => {
+    if (
+      !isSubagentChild &&
+      gauntletEntered &&
+      phases.verify.status === "in_progress" &&
+      conformanceDispatched &&
+      isImplementerWave(details, isError) &&
+      resolveClosureReview(loadGauntletSettings(ctx.cwd).gauntlet).enforce
+    ) {
+      if (fixRoundCredits > 0) fixRoundCredits -= 1;
+      fixRounds += 1;
+    }
+  };
   let planCheckStamp: PlanCheckStamp | undefined;
   const attemptedRecoveryEdges = new Set<RecoveryEdge>();
 
@@ -382,6 +434,8 @@ export default function (pi: ExtensionAPI) {
   const reconstructState = (ctx: ExtensionContext) => {
     phases = emptyPhases();
     conformanceDispatched = false;
+    fixRounds = 0;
+    fixRoundCredits = 0;
     gauntletEntered = false;
     planCheckStamp = undefined;
     attemptedRecoveryEdges.clear();
@@ -406,12 +460,17 @@ export default function (pi: ExtensionAPI) {
         const details = msg.details as PhaseTrackerDetails | undefined;
         if (details && !details.error) {
           phases = details.phases;
+          if (details.action === "grant_fix_rounds" && typeof details.rounds === "number") fixRoundCredits = details.rounds;
           gauntletEntered = nextGauntletEntered(gauntletEntered, details.action, details.phases.brainstorm.status);
           if (details.action === "start" && details.phases.implement.status === "in_progress") {
             conformanceDispatched = false;
+            fixRounds = 0;
+            fixRoundCredits = 0;
           }
           if (details.action === "reset") {
             conformanceDispatched = false;
+            fixRounds = 0;
+            fixRoundCredits = 0;
             planCheckStamp = undefined;
           }
         }
@@ -423,6 +482,7 @@ export default function (pi: ExtensionAPI) {
           planCheckStamp = undefined;
         }
       } else if (msg.toolName === "subagent") {
+        observeFixWave(msg.details, msg.isError, ctx);
         if (qualifiesAsClosureDispatch(msg.details)) conformanceDispatched = true;
         observeCadence(msg.details);
       } else if (msg.toolName === "plan_tracker") {
@@ -492,10 +552,25 @@ export default function (pi: ExtensionAPI) {
     // subagent dispatch never loads settings or leaks a settingsErrorWarning onto its result.
     // Inline-matched (not called) so closureEnforced() stays a lazy second conjunct.
     if (event.toolName === "subagent" && gauntletEntered && closureEnforced()) {
-      const model = closureReviewModel();
-      // Only execution-mode dispatches carry a model; management/control modes
-      // (action: list/get/create/update/delete/status/...) execute nothing, so skip them.
+      // Only execution-mode dispatches carry a model or run agents; management/control
+      // modes (action: list/get/create/update/delete/status/...) execute nothing, so skip them.
       const hasAction = !!(event.input as { action?: unknown })?.action;
+      // Fix-loop window: verify in progress and the R0 audit observed. Read directly,
+      // not via activeGuardPhase() - verify is not a GUARD_PHASES member.
+      const fixLoopWindow = !isSubagentChild && !hasAction && phases.verify.status === "in_progress" && conformanceDispatched;
+      if (fixLoopWindow && (event.input as { agent?: unknown })?.agent === "implementer") {
+        return { block: true, reason: loneImplementerBlockReason };
+      }
+      if (fixLoopWindow && collectAgents(event.input, "implementer").length > 0) {
+        const cap = resolveClosureReview(g()).maxFixRounds;
+        if (fixRounds >= cap) {
+          const funded = fixRoundCredits > 0 && (event.input as { async?: unknown })?.async !== true;
+          if (!funded) {
+            return { block: true, reason: fixRoundCapBlockReason(fixRounds, cap, join(ctx.cwd, ".pi", "settings.json")) };
+          }
+        }
+      }
+      const model = closureReviewModel();
       if (model && !hasAction) {
         const configured = model.trim();
         const models = conformanceModels(event.input);
@@ -635,8 +710,9 @@ export default function (pi: ExtensionAPI) {
     return undefined;
   });
 
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => {
     if (event.toolName === "subagent") {
+      observeFixWave(event.details, event.isError, ctx);
       if (qualifiesAsClosureDispatch(event.details)) conformanceDispatched = true;
       observeCadence(event.details);
       const warning = pendingGuardWarnings.get(event.toolCallId);
@@ -678,6 +754,7 @@ export default function (pi: ExtensionAPI) {
     label: "Gauntlet Setting",
     description: "Resolve merged piGauntlet.* settings (repo over preset); for skill use only.",
     parameters: GauntletSettingParams,
+    executionMode: "sequential",
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       const { gauntlet, errors } = loadGauntletSettings(ctx.cwd);
       const payload =
@@ -859,7 +936,11 @@ export default function (pi: ExtensionAPI) {
           }
           phases = { ...phases, [params.phase]: transitionPhaseState("in_progress") as PhaseState };
           // A rewind must not inherit the prior verify's conformance latch.
-          if (params.phase === "implement") conformanceDispatched = false;
+          if (params.phase === "implement") {
+            conformanceDispatched = false;
+            fixRounds = 0;
+            fixRoundCredits = 0;
+          }
           gauntletEntered = nextGauntletEntered(gauntletEntered, "start", phases.brainstorm.status);
           firedGuards.clear();
           updateWidget(ctx);
@@ -1024,6 +1105,8 @@ export default function (pi: ExtensionAPI) {
             PHASES.map((p) => [p, transitionPhaseState("pending")]),
           ) as PhaseMap;
           conformanceDispatched = false;
+          fixRounds = 0;
+          fixRoundCredits = 0;
           gauntletEntered = nextGauntletEntered(gauntletEntered, "reset", phases.brainstorm.status);
           firedGuards.clear();
           updateWidget(ctx);
@@ -1033,6 +1116,39 @@ export default function (pi: ExtensionAPI) {
           };
         }
 
+        case "grant_fix_rounds": {
+          const reject = (error: string) => ({
+            content: [{ type: "text" as const, text: `Error: ${error}` }],
+            details: { action: "grant_fix_rounds", phases: { ...phases }, error } as PhaseTrackerDetails,
+          });
+          if (params.rounds === undefined) return reject("grant_fix_rounds requires rounds: a positive integer");
+          const reason = params.reason?.trim() ?? "";
+          if (reason.length === 0) return reject("grant_fix_rounds requires reason: the human's approval, quoted");
+          const closure = resolveClosureReview(loadGauntletSettings(ctx.cwd).gauntlet);
+          const capLive =
+            !isSubagentChild &&
+            gauntletEntered &&
+            phases.verify.status === "in_progress" &&
+            conformanceDispatched &&
+            closure.enforce &&
+            fixRounds >= closure.maxFixRounds;
+          if (!capLive) {
+            return reject(
+              `grant_fix_rounds: no fix-round cap block is active (${fixRounds} used, cap ${closure.maxFixRounds}); nothing to overrule`,
+            );
+          }
+          if (fixRoundCredits > 0) {
+            return reject(`grant_fix_rounds: ${fixRoundCredits} granted round(s) still unused; spend them before granting more`);
+          }
+          fixRoundCredits = params.rounds;
+          return {
+            content: [
+              { type: "text", text: `Granted ${params.rounds} extra fix round(s) - reason: "${reason}"\n${formatStatus(phases)}` },
+            ],
+            details: { action: "grant_fix_rounds", rounds: params.rounds, reason, phases: { ...phases } } as PhaseTrackerDetails,
+          };
+        }
+
         default:
           return {
             content: [{ type: "text", text: `Unknown action: ${params.action}` }],
@@ -1104,6 +1220,14 @@ export default function (pi: ExtensionAPI) {
         }
         case "reset":
           return new Text(theme.fg("success", "✓ ") + theme.fg("muted", "Phase tracker reset"), 0, 0);
+        case "grant_fix_rounds":
+          return new Text(
+            theme.fg("success", "+ ") +
+              theme.fg("muted", `${details.rounds} extra fix round(s) granted`) +
+              theme.fg("dim", ` (${details.reason})`),
+            0,
+            0,
+          );
         default:
           return new Text(theme.fg("dim", "Done"), 0, 0);
       }

package/extensions/test-support/pi-stubs.mjs

@@ -22,16 +22,16 @@ const sources = {
     }
   `,
   "@sinclair/typebox": `
-    const schema = (...args) => ({ args });
+    const schema = (kind) => (...args) => ({ kind, args });
     export const Type = {
-      Object: schema,
-      Optional: schema,
-      String: schema,
-      Boolean: schema,
-      Union: schema,
-      Null: schema,
-      Array: schema,
-      Integer: schema,
+      Object: schema("Object"),
+      Optional: schema("Optional"),
+      String: schema("String"),
+      Boolean: schema("Boolean"),
+      Union: schema("Union"),
+      Null: schema("Null"),
+      Array: schema("Array"),
+      Integer: schema("Integer"),
     };
   `,
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "5.5.2",
+  "version": "5.5.4",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/dispatching-parallel-agents/SKILL.md

@@ -105,7 +105,7 @@ When agents return:
 
 **If integrated changes apply cleanly but the suite fails (semantic conflict):** agents made incompatible assumptions across disjoint files (renamed symbol, changed shape). Diagnose the incompatible pair and re-run the offending task sequentially on the integrated HEAD.
 
-**If some agents failed:** Integrate successful agents first (commit their work). Then retry the failed agent with fresh context that includes the integrated changes.
+**If some agents failed:** Integrate successful agents first (commit their work). Then retry the failed agent with fresh context that includes the integrated changes. Inside the conformance loop the retry is a one-task `tasks` wave, never a lone `agent: "implementer"`.
 
 ## Fix fan-out
 

package/skills/verification-before-completion/reference/conformance-check.md

@@ -126,8 +126,10 @@ partition from an earlier round.
 
 Mirrors `subagent-driven-development` Parallel-Wave Mode and reuses its
 `plan_tracker` progress surface. Runs entirely inside the gate — it invokes
-**no** `phase_tracker` calls (`phase_tracker({ phase: "implement" })` errors
-while verify is `in_progress`) and does **not** enter SDD's phase machinery.
+**no** phase-transition `phase_tracker` calls (`start`/`complete`/`skip`/`reset`
+- `phase_tracker({ phase: "implement" })` errors while verify is `in_progress`;
+the only `phase_tracker` call inside the loop is the human-approval
+`grant_fix_rounds` in step 6) and does **not** enter SDD's phase machinery.
 Only the fan-out/integrate/review shape and `plan_tracker` are reused. Every execution dispatch is foreground with top-level `async: false`, including retries and prose-described dispatches; an unexpected async handle is a configuration failure: stop and report, never poll or relaunch. `forceTopLevelAsync` is incompatible; see [pi-cohort dispatch configuration](https://github.com/jjuraszek/pi-cohort/blob/main/doc/configuration.md).
 
 **Precondition — worktree required.** The loop needs a worktree HEAD to branch
@@ -157,7 +159,9 @@ Per round:
    context; semantic conflict (applies clean, suite fails) → re-run the
    offending task sequentially on integrated HEAD; a failed agent → integrate
    the successes, then retry the failure with fresh context including the
-   integrated changes. A `BLOCKED`/`NEEDS_CONTEXT` return surfaces to the user.
+   integrated changes. Every re-run or retry inside this loop is itself a
+   one-task `tasks` wave (never a lone `agent: "implementer"`) and counts as a
+   wave against `maxFixRounds`. A `BLOCKED`/`NEEDS_CONTEXT` return surfaces to the user.
 4. **Scoped tests** on the integrated tree: the round's `SCOPED_TEST_COMMANDS` union. A failure re-enters the failure-handling rules above.
 5. **Re-audit**: foreground re-dispatch `conformance-reviewer` with `async: false` over the fixes **plus** the
    regression guard (any prior-`DELIVERED` requirement whose `evidence` file
@@ -173,16 +177,22 @@ Per round:
 6. **Converge or continue**: verdict `CONFORMS` → Convergence below. Open gaps
    within the cap → re-partition (per the rule above) and start the next
    round. Cap (`gauntlet_setting({ key: "closureReview" }).maxFixRounds`,
-   default `2`, floors negatives at `0`, coerces non-integers to `2`) reached
+   default `3`, floors negatives at `0`, coerces non-integers to `3`) reached
    with an open `fix` gap or repair item → **escalate to the human** with the per-gap
    round-by-round verdict trail. Escalation is the sole non-completing
-   terminal state — no silent re-loop, no auto-ship.
+   terminal state — no silent re-loop, no auto-ship. If the human explicitly
+   approves N more rounds, record `phase_tracker({ action: "grant_fix_rounds",
+   rounds: N, reason: "<their words>" })` and re-enter step 2; without that
+   approval, escalation stays terminal. Inside a brainstorming-entered flow
+   the phase tracker enforces both rules at
+   tool-call time: a lone `agent: "implementer"` dispatch is blocked, and the
+   wave after the cap is blocked (`closureReview.enforce: false` disables).
 
 **Convergence** — runs after R0 `CONFORMS` and after every `CONFORMS` re-audit. `r0-head` is HEAD when the loop was entered (the R0 dispatch, or the finish-time `fix-now` entry) - the parent of the oldest `conformance fix` commit; `audited-base` stays the last audit's HEAD SHA.
 
 a. Run the full plan-header `Verification` set once (ad-hoc: the project's canonical test command). After R0 `CONFORMS` with no round run, the pre-R0 full run counts.
 b. Dispatch `code-reviewer` directly (foreground, `async: false`, `SCOPED_TEST_COMMANDS: none`) over `git diff <r0-head>..HEAD`; never via `/skill:requesting-code-review`. An empty diff is nothing to review - no dispatch.
-c. Repair items = every failing command from a + every Critical/Moderate finding from b (`Behaviour-change: yes` included; the re-audit is its origin check). None → write the closure block; done. Any at the cap → escalate per step 6 with the test/CR trail. Any under the cap → re-enter step 2 as a one-task `tasks` wave: one `implementer` whose task is every repair item verbatim (ownership boundary = the files in `git diff <r0-head>..HEAD`, the CR findings' `touched-files`, and the files each failing command's output names, `SCOPED_TEST_COMMANDS: none`, no `Gn` tracker task, no gap selection), integrate as one `conformance fix CR`, re-audit, then Convergence again. That wave counts against `maxFixRounds`. Later Convergence CRs keep the same `<r0-head>..HEAD` range.
+c. Repair items = every failing command from a + every Critical/Moderate finding from b (`Behaviour-change: yes` included; the re-audit is its origin check). None → write the closure block; done. Any at the cap → escalate per step 6 with the test/CR trail (an explicit human approval re-enters via `grant_fix_rounds`, as step 6 describes). Any under the cap → re-enter step 2 as a one-task `tasks` wave: one `implementer` whose task is every repair item verbatim (ownership boundary = the files in `git diff <r0-head>..HEAD`, the CR findings' `touched-files`, and the files each failing command's output names, `SCOPED_TEST_COMMANDS: none`, no `Gn` tracker task, no gap selection), integrate as one `conformance fix CR`, re-audit, then Convergence again. That wave counts against `maxFixRounds`. Later Convergence CRs keep the same `<r0-head>..HEAD` range.
 
 `conformance fix CR` is not a gap fix: it is absent from the `auto-applied fix commits` index and has no `revert conformance fix Gn` action at the finish gate.
 

package/skills/verification-before-completion/reference/settings-precedence.md

@@ -22,7 +22,7 @@ does not recurse into their leaves.
 whole-object, a repo file that sets only *one* leaf of a key silently drops the
 preset's other leaves for that key. A repo `closureReview: { "model": "..." }` with
 no `enforce`/`maxFixRounds` makes those fall back to their code defaults
-(`enforce` true, `maxFixRounds` 2), **not** to the preset's values. Define every
+(`enforce` true, `maxFixRounds` 3), **not** to the preset's values. Define every
 leaf you care about together in the file that owns the key. (Sibling keys are
 unaffected - only the key the repo redefines is replaced.)