pi-gauntlet 5.5.3 → 5.6.0

package/CHANGELOG.md

@@ -1,5 +1,17 @@
 # Changelog
 
+## v5.6.0 - 2026-09-16
+
+- `plan-tracker`: pending-suffix rule enforced at runtime - an `update` that would leave a `pending` task ahead of a started or finished one is rejected with a message naming every offending task, the legal fixes, and the current snapshot; state is unchanged and widget replay / `phase_tracker` ignore the rejection. `update` never sets `pending`. New terminal status `skipped` (`⊘`, not applicable in this run, counted done). `init` accepts `{ name, status }` elements (mixable with strings) to recreate a list with known statuses. Registered with sequential execution. Counts are labelled `done` (`complete + skipped`).
+- `phase-tracker`: `implement` auto-completes when every task is `complete` or `skipped`.
+- `check-delivery`, `gatekeep-pr`, `subagent-driven-development`, `brainstorming`: tracker usage aligned with the rule - a skipped stage is `skipped`, gatekeep-pr inits four stages and adds claims/review/consent progressively, wave fan-out marks `in_progress` in increasing index order, the amendment path re-inits with statuses instead of setting tasks back to `pending`.
+
+## 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)

package/extensions/phase-tracker.test.ts

@@ -58,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 ?? [];
@@ -76,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) {
@@ -370,6 +370,27 @@ test("all-complete plan activity auto-completes an active implement phase", asyn
   assert.equal(status.details.phases.implement.status, "complete");
 });
 
+test("plan activity auto-completes implement with complete+skipped, not with failed, not from an errored result", async () => {
+  const implementStatus = async (tasks: { status: string }[], isError = false) => {
+    const h = harness({ branch: implementBranch() });
+    await h.emit("session_start");
+    await h.emitEvent("tool_execution_end", {
+      toolName: "plan_tracker",
+      isError,
+      result: { details: { tasks } },
+    });
+    const tool = h.tools.find((t) => t.name === "phase_tracker")!;
+    const status = (await tool.execute("t1", { action: "status" }, undefined, undefined, h.ctx)) as {
+      details: { phases: { implement: { status: string } } };
+    };
+    return status.details.phases.implement.status;
+  };
+  assert.equal(await implementStatus([{ status: "complete" }, { status: "skipped" }]), "complete");
+  assert.equal(await implementStatus([{ status: "skipped" }, { status: "skipped" }]), "complete");
+  assert.equal(await implementStatus([{ status: "complete" }, { status: "failed" }]), "in_progress");
+  assert.equal(await implementStatus([{ status: "complete" }, { status: "skipped" }], true), "in_progress");
+});
+
 test("cold implement and verify completions ignore unfinished snapshots", async () => {
   for (const phase of ["implement", "verify"] as const) {
     const h = harness({
@@ -1275,7 +1296,7 @@ test("cap guard: default 3 waves pass, the fourth is blocked with the escalation
   }
   const blocked = await firstCallResult(h, "c4", implementerWave(1));
   assert.equal(blocked?.block, true);
-  assert.match(blocked?.reason ?? "", /fix round 3 of 3 already used; escalate to the human/);
+  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 () => {
@@ -1422,3 +1443,298 @@ test("replay: two implementer waves after the audit in verify restore fixRounds
   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 {
@@ -206,10 +208,14 @@ const loneImplementerBlockReason =
   "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): string =>
-  `Conformance fix loop: fix round ${used} of ${cap} already used; escalate to the human ` +
-  "with the verdict trail instead of re-looping. " +
-  "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"} ` +
@@ -255,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(
@@ -265,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(
@@ -328,6 +341,7 @@ 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
@@ -341,6 +355,7 @@ export default function (pi: ExtensionAPI) {
       isImplementerWave(details, isError) &&
       resolveClosureReview(loadGauntletSettings(ctx.cwd).gauntlet).enforce
     ) {
+      if (fixRoundCredits > 0) fixRoundCredits -= 1;
       fixRounds += 1;
     }
   };
@@ -402,7 +417,10 @@ export default function (pi: ExtensionAPI) {
   // skills; plan-tracker tracks tasks independently.
   const applyPlanActivity = (tasks?: { status: string }[]) => {
     if (!tasks || tasks.length === 0) return;
-    if (phases.implement.status === "in_progress" && tasks.every((t) => t.status === "complete")) {
+    if (
+      phases.implement.status === "in_progress" &&
+      tasks.every((t) => t.status === "complete" || t.status === "skipped")
+    ) {
       phases = { ...phases, implement: { status: "complete" } };
       firedGuards.clear();
     }
@@ -420,6 +438,7 @@ export default function (pi: ExtensionAPI) {
     phases = emptyPhases();
     conformanceDispatched = false;
     fixRounds = 0;
+    fixRoundCredits = 0;
     gauntletEntered = false;
     planCheckStamp = undefined;
     attemptedRecoveryEdges.clear();
@@ -444,14 +463,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;
           }
         }
@@ -544,7 +566,12 @@ export default function (pi: ExtensionAPI) {
       }
       if (fixLoopWindow && collectAgents(event.input, "implementer").length > 0) {
         const cap = resolveClosureReview(g()).maxFixRounds;
-        if (fixRounds >= cap) return { block: true, reason: fixRoundCapBlockReason(fixRounds, cap) };
+        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) {
@@ -730,6 +757,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 =
@@ -914,6 +942,7 @@ export default function (pi: ExtensionAPI) {
           if (params.phase === "implement") {
             conformanceDispatched = false;
             fixRounds = 0;
+            fixRoundCredits = 0;
           }
           gauntletEntered = nextGauntletEntered(gauntletEntered, "start", phases.brainstorm.status);
           firedGuards.clear();
@@ -1080,6 +1109,7 @@ export default function (pi: ExtensionAPI) {
           ) as PhaseMap;
           conformanceDispatched = false;
           fixRounds = 0;
+          fixRoundCredits = 0;
           gauntletEntered = nextGauntletEntered(gauntletEntered, "reset", phases.brainstorm.status);
           firedGuards.clear();
           updateWidget(ctx);
@@ -1089,6 +1119,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}` }],
@@ -1160,6 +1223,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/plan-tracker.test.ts

@@ -1,6 +1,6 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
-import registerPlanTracker from "./plan-tracker.ts";
+import registerPlanTracker, { validateSnapshot } from "./plan-tracker.ts";
 
 type ToolResult = {
   content: { type: string; text: string }[];
@@ -10,6 +10,9 @@ type ToolResult = {
 function harness(branch: unknown[] = []) {
   const tools: {
     name: string;
+    description: string;
+    executionMode?: string;
+    parameters: any;
     execute: (...args: any[]) => unknown;
     renderResult: (result: unknown, options: unknown, theme: unknown) => { text?: string };
   }[] = [];
@@ -39,7 +42,16 @@ function harness(branch: unknown[] = []) {
   const fire = async (event: string) => {
     for (const h of handlers) if (h.event === event) await h.handler({}, ctx);
   };
-  return { call, fire, tool: () => tools[0], theme, widget: () => widgetText };
+  return {
+    call,
+    fire,
+    tool: () => tools[0],
+    theme,
+    widget: () => widgetText,
+    parameters: () => tools[0].parameters,
+    description: () => tools[0].description,
+    executionMode: () => tools[0].executionMode,
+  };
 }
 
 test("add appends pending tasks and preserves existing statuses", async () => {
@@ -95,7 +107,7 @@ test("update to failed round-trips and is excluded from complete count", async (
     res.details.tasks.map((t) => [t.name, t.status]),
     [["a", "complete"], ["b", "failed"], ["c", "pending"]],
   );
-  assert.match(res.content[0].text, /1\/3 complete/);
+  assert.match(res.content[0].text, /1\/3 done/);
   assert.match(res.content[0].text, /1 failed/);
 });
 
@@ -140,11 +152,11 @@ test("widget renders failed as \u2717, keeps failed out of complete count and cu
 test("renderResult status path shows \u2717 for failed and excludes it from complete", async () => {
   const { call, tool, theme } = harness();
   await call({ action: "init", tasks: ["a", "b"] });
-  await call({ action: "update", index: 1, status: "failed" });
+  await call({ action: "update", index: 0, status: "failed" });
   const res = await call({ action: "status" });
   const rendered = tool().renderResult(res as any, {}, theme as any);
   const text = (rendered as any).text as string;
-  assert.match(text, /0\/2 complete/);
+  assert.match(text, /0\/2 done/);
   assert.match(text, /\u2717/);
 });
 
@@ -156,7 +168,7 @@ test("renderResult status header appends failed count when a task has failed", a
   const res = await call({ action: "status" });
   const rendered = tool().renderResult(res as any, {}, theme as any);
   const text = (rendered as any).text as string;
-  assert.match(text, /1\/3 complete, 1 failed/);
+  assert.match(text, /1\/3 done, 1 failed/);
 });
 
 test("renderResult status header omits failed count when no task has failed", async () => {
@@ -166,7 +178,7 @@ test("renderResult status header omits failed count when no task has failed", as
   const res = await call({ action: "status" });
   const rendered = tool().renderResult(res as any, {}, theme as any);
   const text = (rendered as any).text as string;
-  assert.match(text, /^1\/2 complete\n/);
+  assert.match(text, /^1\/2 done\n/);
   assert.doesNotMatch(text, /failed/);
 });
 
@@ -177,7 +189,7 @@ test("renderResult update case appends failed count when a task has failed", asy
   const res = await call({ action: "update", index: 1, status: "failed" });
   const rendered = tool().renderResult(res as any, {}, theme as any);
   const text = (rendered as any).text as string;
-  assert.match(text, /^\u2713 Updated \(1\/3 complete, 1 failed\)$/);
+  assert.match(text, /^\u2713 Updated \(1\/3 done, 1 failed\)$/);
 });
 
 test("renderResult update case omits failed count when no task has failed", async () => {
@@ -186,6 +198,196 @@ test("renderResult update case omits failed count when no task has failed", asyn
   const res = await call({ action: "update", index: 0, status: "complete" });
   const rendered = tool().renderResult(res as any, {}, theme as any);
   const text = (rendered as any).text as string;
-  assert.match(text, /^\u2713 Updated \(1\/2 complete\)$/);
+  assert.match(text, /^\u2713 Updated \(1\/2 done\)$/);
   assert.doesNotMatch(text, /failed/);
 });
+
+const S = (code: string) =>
+  [...code].map((c, i) => ({
+    name: `t${i}`,
+    status: ({ o: "pending", ">": "in_progress", k: "complete", x: "failed", "/": "skipped" } as const)[c as "o" | ">" | "k" | "x" | "/"],
+  }));
+
+test("validateSnapshot: pending must trail every non-pending task", () => {
+  for (const code of ["kkkoo", "kk>>oo", "kk>kk", "x>o", "ooo", "///", "", "k"]) {
+    assert.deepEqual(validateSnapshot(S(code)), [], code);
+  }
+  assert.deepEqual(validateSnapshot(S("okoo")), [0]);
+  assert.deepEqual(validateSnapshot(S("kkk>ookkkk")), [4, 5]);
+  assert.deepEqual(validateSnapshot(S("o>")), [0]);
+  assert.deepEqual(validateSnapshot(S("ook")), [0, 1]);
+});
+
+test("update past a pending index is rejected with every offender, fixes, and the current snapshot", async () => {
+  const { call } = harness();
+  await call({ action: "init", tasks: ["gather", "resolve evidence", "claim-check", "provision worktree", "review", "verify claims"] });
+  for (const i of [0, 1, 2]) await call({ action: "update", index: i, status: "complete" });
+  const res = await call({ action: "update", index: 5, status: "complete" });
+  assert.equal(res.details.error, "pending-suffix violation: 3,4");
+  assert.deepEqual(
+    res.details.tasks.map((t) => t.status),
+    ["complete", "complete", "complete", "pending", "pending", "pending"],
+  );
+  const text = res.content[0].text;
+  assert.equal(
+    text,
+    [
+      'Error: cannot set task 5 "verify claims" to complete: pending tasks precede it: 3 "provision worktree", 4 "review".',
+      "Rule: pending tasks must trail every started or finished task.",
+      "Fix first, then retry: update each listed task to in_progress (working on it now), complete, failed, or skipped (not applicable in this run); or, if the list order itself is wrong, re-init with {name, status}[] keeping every task and its true status so the untouched ones trail.",
+      "Never clear, drop tasks, or record a status the work has not actually reached.",
+      "Current: 0 gather=complete, 1 resolve evidence=complete, 2 claim-check=complete, 3 provision worktree=pending, 4 review=pending, 5 verify claims=pending",
+    ].join("\n"),
+  );
+  const after = await call({ action: "status" });
+  assert.deepEqual(after.details.tasks.map((t) => t.status), ["complete", "complete", "complete", "pending", "pending", "pending"]);
+});
+
+test("update -> pending is rejected in execute and names reopen and re-init", async () => {
+  const { call } = harness();
+  await call({ action: "init", tasks: ["a", "b", "claim-check"] });
+  for (const i of [0, 1, 2]) await call({ action: "update", index: i, status: "complete" });
+  const res = await call({ action: "update", index: 2, status: "pending" });
+  assert.equal(res.details.error, "update cannot set pending");
+  assert.deepEqual(res.details.tasks.map((t) => t.status), ["complete", "complete", "complete"]);
+  assert.equal(
+    res.content[0].text,
+    [
+      'Error: cannot set task 2 "claim-check" to pending: update never sets pending; a task is pending only from init/add.',
+      "To redo it, update it to in_progress. To recreate the whole list, re-init with {name, status}[].",
+      "Current: 0 a=complete, 1 b=complete, 2 claim-check=complete",
+    ].join("\n"),
+  );
+});
+
+test("update at index 0 / first pending index, direct jumps, and reopens are accepted", async () => {
+  const { call } = harness();
+  await call({ action: "init", tasks: ["a", "b", "c", "d"] });
+  assert.equal((await call({ action: "update", index: 0, status: "complete" })).details.error, undefined);
+  assert.equal((await call({ action: "update", index: 1, status: "failed" })).details.error, undefined);
+  assert.equal((await call({ action: "update", index: 2, status: "skipped" })).details.error, undefined);
+  assert.equal((await call({ action: "update", index: 0, status: "in_progress" })).details.error, undefined);
+  assert.equal((await call({ action: "update", index: 1, status: "in_progress" })).details.error, undefined);
+  const res = await call({ action: "status" });
+  assert.deepEqual(res.details.tasks.map((t) => t.status), ["in_progress", "in_progress", "skipped", "pending"]);
+});
+
+test("wave fan-out: in_progress in increasing order succeeds, out of order is rejected naming earlier pending indices", async () => {
+  const ok = harness();
+  await ok.call({ action: "init", tasks: ["a", "b", "c"] });
+  for (const i of [0, 1, 2]) assert.equal((await ok.call({ action: "update", index: i, status: "in_progress" })).details.error, undefined);
+  const bad = harness();
+  await bad.call({ action: "init", tasks: ["a", "b", "c"] });
+  const res = await bad.call({ action: "update", index: 2, status: "in_progress" });
+  assert.equal(res.details.error, "pending-suffix violation: 0,1");
+  assert.match(res.content[0].text, /pending tasks precede it: 0 "a", 1 "b"\./);
+});
+
+test("init: strings, objects, and mixed forms normalize; ordering violation rejects the whole list", async () => {
+  const { call } = harness();
+  const strings = await call({ action: "init", tasks: ["a", "b"] });
+  assert.deepEqual(strings.details.tasks, [{ name: "a", status: "pending" }, { name: "b", status: "pending" }]);
+  const objects = await call({ action: "init", tasks: [{ name: "a", status: "complete" }, { name: "b", status: "skipped" }, "c"] });
+  assert.equal(objects.details.error, undefined);
+  assert.deepEqual(objects.details.tasks, [
+    { name: "a", status: "complete" },
+    { name: "b", status: "skipped" },
+    { name: "c", status: "pending" },
+  ]);
+  const bad = await call({ action: "init", tasks: [{ name: "a", status: "complete" }, "b", { name: "c", status: "complete" }] });
+  assert.equal(bad.details.error, "pending-suffix violation: 1");
+  assert.equal(
+    bad.content[0].text,
+    [
+      'Error: cannot init: pending tasks precede started or finished ones: 1 "b".',
+      "Rule: pending tasks must trail every started or finished task.",
+      "Reorder the list or restate those statuses truthfully, then retry.",
+      "Proposed: 0 a=complete, 1 b=pending, 2 c=complete",
+    ].join("\n"),
+  );
+  assert.doesNotMatch(bad.content[0].text, /Current:/);
+  assert.deepEqual(bad.details.tasks.map((t) => t.status), ["complete", "skipped", "pending"]);
+});
+
+test("init ordering violation with no prior plan leaves no plan", async () => {
+  const { call, widget } = harness();
+  const bad = await call({ action: "init", tasks: ["a", { name: "b", status: "complete" }] });
+  assert.equal(bad.details.error, "pending-suffix violation: 0");
+  assert.deepEqual(bad.details.tasks, []);
+  assert.equal(widget(), undefined);
+});
+
+test("skipped round-trips, replays, renders \u2298, counts as done, and is never current", async () => {
+  const { call, widget, tool, theme } = harness();
+  await call({ action: "init", tasks: ["a", "b", "c"] });
+  await call({ action: "update", index: 0, status: "complete" });
+  const res = await call({ action: "update", index: 1, status: "skipped" });
+  assert.equal(res.details.error, undefined);
+  assert.match(res.content[0].text, /Plan: 2\/3 done \(1 pending, 1 skipped\)/);
+  assert.match(res.content[0].text, /\u2298 \[1\] b/);
+  const w = widget()!;
+  assert.match(w, /\u2298/);
+  assert.match(w, /\(2\/3\)/);
+  assert.match(w, /c$/);
+  const rendered = (tool().renderResult(res as any, {}, theme as any) as any).text as string;
+  assert.match(rendered, /^\u2713 Updated \(2\/3 done, 1 skipped\)$/);
+  const status = await call({ action: "status" });
+  const statusText = (tool().renderResult(status as any, {}, theme as any) as any).text as string;
+  assert.match(statusText, /^2\/3 done, 1 skipped\n/);
+
+  const replay = harness([{ type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: res.details } }]);
+  await replay.fire("session_start");
+  const after = await replay.call({ action: "status" });
+  assert.deepEqual(after.details.tasks.map((t) => t.status), ["complete", "skipped", "pending"]);
+});
+
+test("all tasks skipped renders (M/M)", async () => {
+  const { call, widget } = harness();
+  await call({ action: "init", tasks: ["a", "b"] });
+  await call({ action: "update", index: 0, status: "skipped" });
+  await call({ action: "update", index: 1, status: "skipped" });
+  assert.match(widget()!, /\(2\/2\)/);
+});
+
+test("legacy-invalid snapshot: first update is rejected listing legacy offenders; truthful object-form re-init repairs it", async () => {
+  const branch = [
+    {
+      type: "message",
+      message: {
+        role: "toolResult",
+        toolName: "plan_tracker",
+        details: {
+          action: "update",
+          tasks: [
+            { name: "a", status: "pending" },
+            { name: "b", status: "pending" },
+            { name: "c", status: "complete" },
+          ],
+        },
+      },
+    },
+  ];
+  const { call, fire } = harness(branch);
+  await fire("session_start");
+  const rejected = await call({ action: "update", index: 0, status: "complete" });
+  assert.equal(rejected.details.error, "pending-suffix violation: 1");
+  assert.deepEqual(rejected.details.tasks.map((t) => t.status), ["pending", "pending", "complete"]);
+  const repaired = await call({
+    action: "init",
+    tasks: [{ name: "a", status: "complete" }, { name: "b", status: "skipped" }, { name: "c", status: "complete" }],
+  });
+  assert.equal(repaired.details.error, undefined);
+  assert.deepEqual(repaired.details.tasks.map((t) => t.status), ["complete", "skipped", "complete"]);
+});
+
+test("registration: sequential, tasks schema is Array<Union<String, Object>>, description carries the contract", () => {
+  const { executionMode, parameters, description } = harness();
+  assert.equal(executionMode(), "sequential");
+  const tasksSchema = parameters().args[0].tasks.args[0];
+  assert.equal(tasksSchema.kind, "Array");
+  assert.equal(tasksSchema.args[0].kind, "Union");
+  assert.deepEqual(tasksSchema.args[0].args[0].map((s: { kind: string }) => s.kind), ["String", "Object"]);
+  assert.match(description(), /skipped/);
+  assert.match(description(), /pending tasks must trail every started or finished task/);
+  assert.match(description(), /update never sets pending/);
+});

package/extensions/plan-tracker.ts

@@ -11,87 +11,68 @@ import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-c
 import { Text } from "@earendil-works/pi-tui";
 import { type Static, Type } from "@sinclair/typebox";
 
-type TaskStatus = "pending" | "in_progress" | "complete" | "failed";
+const TASK_STATUSES = ["pending", "in_progress", "complete", "failed", "skipped"] as const;
+type TaskStatus = (typeof TASK_STATUSES)[number];
 
-interface Task {
-  name: string;
-  status: TaskStatus;
-}
-
-interface PlanTrackerDetails {
-  action: "init" | "add" | "update" | "status" | "clear";
-  tasks: Task[];
-  error?: string;
-}
+interface Task { name: string; status: TaskStatus; }
+interface PlanTrackerDetails { action: "init" | "add" | "update" | "status" | "clear"; tasks: Task[]; error?: string; }
 
 const PlanTrackerParams = Type.Object({
-  action: StringEnum(["init", "add", "update", "status", "clear"] as const, {
-    description: "Action to perform",
-  }),
-  tasks: Type.Optional(
-    Type.Array(Type.String(), {
-      description: "Task names (for init and add)",
-    }),
-  ),
-  index: Type.Optional(
-    Type.Integer({
-      minimum: 0,
-      description: "Task index, 0-based (for update)",
-    }),
-  ),
-  status: Type.Optional(
-    StringEnum(["pending", "in_progress", "complete", "failed"] as const, {
-      description: "New status (for update); failed is terminal-negative (ran and did not pass)",
-    }),
-  ),
+  action: StringEnum(["init", "add", "update", "status", "clear"] as const, { description: "Action to perform" }),
+  tasks: Type.Optional(Type.Array(Type.Union([
+    Type.String(),
+    Type.Object({ name: Type.String(), status: StringEnum(TASK_STATUSES, { description: "Status to recreate the task with (init only)" }) }),
+  ]), { description: "Tasks for init and add. A string is a pending task. init also accepts { name, status } to recreate a list with known statuses (fresh session, amendment re-init); the whole list must satisfy the pending-suffix rule." })),
+  index: Type.Optional(Type.Integer({ minimum: 0, description: "Task index, 0-based (for update)" })),
+  status: Type.Optional(StringEnum(TASK_STATUSES, { description: "New status (for update). failed is terminal-negative (ran and did not pass); skipped is terminal, not applicable in this run, counted as done. pending is set only by init/add; to redo a task, reopen it as in_progress, or re-init with {name, status}[] to recreate a whole list." })),
 });
 
 export type PlanTrackerInput = Static<typeof PlanTrackerParams>;
 
-function formatWidget(tasks: Task[], theme: Theme): string {
-  if (tasks.length === 0) return "";
+/** Indices of every pending task that has a non-pending task after it (empty = valid snapshot). */
+export function validateSnapshot(tasks: Task[]): number[] {
+  const offenders: number[] = [];
+  let seenNonPending = false;
+  for (let i = tasks.length - 1; i >= 0; i--) {
+    if (tasks[i].status !== "pending") seenNonPending = true;
+    else if (seenNonPending) offenders.unshift(i);
+  }
+  return offenders;
+}
 
-  const complete = tasks.filter((t) => t.status === "complete").length;
-  const icons = tasks
-    .map((t) => {
-      switch (t.status) {
-        case "complete":
-          return theme.fg("success", "✓");
-        case "in_progress":
-          return theme.fg("warning", "→");
-        case "failed":
-          return theme.fg("error", "✗");
-        default:
-          return theme.fg("dim", "○");
-      }
-    })
-    .join("");
+const RULE_LINE = "Rule: pending tasks must trail every started or finished task.";
+const snapshotLine = (tasks: Task[]): string => tasks.map((t, i) => `${i} ${t.name}=${t.status}`).join(", ");
+const offenderList = (tasks: Task[], indices: number[]): string => indices.map((i) => `${i} "${tasks[i].name}"`).join(", ");
+const normalizeTask = (t: string | { name: string; status: TaskStatus }): Task => typeof t === "string" ? { name: t, status: "pending" } : { name: t.name, status: t.status };
+
+const glyph = (status: TaskStatus, theme?: Theme): string => {
+  const [color, icon]: [string, string] = status === "complete" ? ["success", "✓"] : status === "in_progress" ? ["warning", "→"] : status === "failed" ? ["error", "✗"] : status === "skipped" ? ["dim", "⊘"] : ["dim", "○"];
+  return theme ? theme.fg(color as Parameters<Theme["fg"]>[0], icon) : icon;
+};
 
-  // Find current task (first in_progress, or first pending)
+const counts = (tasks: Task[]) => {
+  const by = (s: TaskStatus) => tasks.filter((t) => t.status === s).length;
+  const failed = by("failed");
+  const skipped = by("skipped");
+  return { done: by("complete") + skipped, inProgress: by("in_progress"), pending: by("pending"), failed, skipped, suffix: `${failed > 0 ? `, ${failed} failed` : ""}${skipped > 0 ? `, ${skipped} skipped` : ""}` };
+};
+
+function formatWidget(tasks: Task[], theme: Theme): string {
+  if (tasks.length === 0) return "";
+  const { done } = counts(tasks);
+  const icons = tasks.map((t) => glyph(t.status, theme)).join("");
   const current = tasks.find((t) => t.status === "in_progress") ?? tasks.find((t) => t.status === "pending");
   const currentName = current ? `  ${current.name}` : "";
-
-  return `${theme.fg("muted", "Tasks:")} ${icons} ${theme.fg("muted", `(${complete}/${tasks.length})`)}${currentName}`;
+  return `${theme.fg("muted", "Tasks:")} ${icons} ${theme.fg("muted", `(${done}/${tasks.length})`)}${currentName}`;
 }
 
 function formatStatus(tasks: Task[]): string {
   if (tasks.length === 0) return "No plan active.";
-
-  const complete = tasks.filter((t) => t.status === "complete").length;
-  const inProgress = tasks.filter((t) => t.status === "in_progress").length;
-  const pending = tasks.filter((t) => t.status === "pending").length;
-  const failed = tasks.filter((t) => t.status === "failed").length;
-
-  const lines: string[] = [];
-  lines.push(
-    `Plan: ${complete}/${tasks.length} complete (${inProgress} in progress, ${pending} pending, ${failed} failed)`,
-  );
-  lines.push("");
-  for (let i = 0; i < tasks.length; i++) {
-    const t = tasks[i];
-    const icon = t.status === "complete" ? "✓" : t.status === "in_progress" ? "→" : t.status === "failed" ? "✗" : "○";
-    lines.push(`  ${icon} [${i}] ${t.name}`);
-  }
+  const c = counts(tasks);
+  const groups = [[c.inProgress, "in progress"], [c.pending, "pending"], [c.failed, "failed"], [c.skipped, "skipped"]] as const;
+  const detail = groups.filter(([n]) => n > 0).map(([n, label]) => `${n} ${label}`);
+  const lines: string[] = [`Plan: ${c.done}/${tasks.length} done${detail.length > 0 ? ` (${detail.join(", ")})` : ""}`, ""];
+  for (let i = 0; i < tasks.length; i++) lines.push(`  ${glyph(tasks[i].status)} [${i}] ${tasks[i].name}`);
   return lines.join("\n");
 }
 
@@ -134,8 +115,9 @@ export default function (pi: ExtensionAPI) {
     name: "plan_tracker",
     label: "Plan Tracker",
     description:
-      "Track progress while EXECUTING an implementation plan (the implement phase), a verify-phase conformance fix wave, or another bounded gate checklist (e.g. pre-merge PR verification). Statuses: pending, in_progress, complete, failed (terminal-negative: the task ran and did not pass; never counted complete). Actions: init (set task list), add (append tasks as pending; existing statuses preserved), update (change task status), status (show current state), clear (remove plan). Do NOT use for brainstorming, research, or planning checklists: those phases are open-ended and a bounded task list misrepresents them as a fixed N-step process.",
+      "Track progress while EXECUTING an implementation plan (the implement phase), a verify-phase conformance fix wave, or another bounded gate checklist (e.g. pre-merge PR verification). Statuses: pending (not yet touched), in_progress (started; several at once is fine), complete, failed (terminal-negative: ran and did not pass; never counted done), skipped (terminal: not applicable in this run; counted done). Rule: pending tasks must trail every started or finished task - an update that would leave a pending task ahead of a non-pending one is rejected with the fix. update never sets pending; init and add do. Actions: init (set task list; elements are task-name strings or { name, status } to recreate a list with known statuses), add (append tasks as pending; existing statuses preserved), update (change task status), status (show current state), clear (remove plan). Do NOT use for brainstorming, research, or planning checklists: those phases are open-ended and a bounded task list misrepresents them as a fixed N-step process.",
     parameters: PlanTrackerParams,
+    executionMode: "sequential",
 
     async execute(_toolCallId, params, _signal, _onUpdate, ctx) {
       switch (params.action) {
@@ -150,7 +132,20 @@ export default function (pi: ExtensionAPI) {
               } as PlanTrackerDetails,
             };
           }
-          tasks = params.tasks.map((name) => ({ name, status: "pending" as TaskStatus }));
+          const proposed = params.tasks.map(normalizeTask);
+          const offenders = validateSnapshot(proposed);
+          if (offenders.length > 0) {
+            return {
+              content: [{ type: "text", text: [
+                `Error: cannot init: pending tasks precede started or finished ones: ${offenderList(proposed, offenders)}.`,
+                RULE_LINE,
+                "Reorder the list or restate those statuses truthfully, then retry.",
+                `Proposed: ${snapshotLine(proposed)}`,
+              ].join("\n") }],
+              details: { action: "init", tasks: tasks.map((t) => ({ ...t })), error: `pending-suffix violation: ${offenders.join(",")}` } as PlanTrackerDetails,
+            };
+          }
+          tasks = proposed;
           updateWidget(ctx);
           return {
             content: [
@@ -174,7 +169,7 @@ export default function (pi: ExtensionAPI) {
               } as PlanTrackerDetails,
             };
           }
-          tasks.push(...params.tasks.map((name) => ({ name, status: "pending" as TaskStatus })));
+          tasks.push(...params.tasks.map((t) => ({ name: normalizeTask(t).name, status: "pending" as TaskStatus })));
           updateWidget(ctx);
           return {
             content: [
@@ -223,7 +218,32 @@ export default function (pi: ExtensionAPI) {
               } as PlanTrackerDetails,
             };
           }
-          tasks[params.index].status = params.status;
+          const target = tasks[params.index];
+          if (params.status === "pending") {
+            return {
+              content: [{ type: "text", text: [
+                `Error: cannot set task ${params.index} "${target.name}" to pending: update never sets pending; a task is pending only from init/add.`,
+                "To redo it, update it to in_progress. To recreate the whole list, re-init with {name, status}[].",
+                `Current: ${snapshotLine(tasks)}`,
+              ].join("\n") }],
+              details: { action: "update", tasks: tasks.map((t) => ({ ...t })), error: "update cannot set pending" } as PlanTrackerDetails,
+            };
+          }
+          const candidate = tasks.map((t, i) => (i === params.index ? { ...t, status: params.status as TaskStatus } : { ...t }));
+          const offenders = validateSnapshot(candidate);
+          if (offenders.length > 0) {
+            return {
+              content: [{ type: "text", text: [
+                `Error: cannot set task ${params.index} "${target.name}" to ${params.status}: pending tasks precede it: ${offenderList(tasks, offenders)}.`,
+                RULE_LINE,
+                "Fix first, then retry: update each listed task to in_progress (working on it now), complete, failed, or skipped (not applicable in this run); or, if the list order itself is wrong, re-init with {name, status}[] keeping every task and its true status so the untouched ones trail.",
+                "Never clear, drop tasks, or record a status the work has not actually reached.",
+                `Current: ${snapshotLine(tasks)}`,
+              ].join("\n") }],
+              details: { action: "update", tasks: tasks.map((t) => ({ ...t })), error: `pending-suffix violation: ${offenders.join(",")}` } as PlanTrackerDetails,
+            };
+          }
+          tasks = candidate;
           updateWidget(ctx);
           return {
             content: [
@@ -309,12 +329,9 @@ export default function (pi: ExtensionAPI) {
             0,
           );
         case "update": {
-          const complete = taskList.filter((t) => t.status === "complete").length;
-          const failed = taskList.filter((t) => t.status === "failed").length;
-          const suffix = failed > 0 ? `, ${failed} failed` : "";
+          const c = counts(taskList);
           return new Text(
-            theme.fg("success", "✓ ") +
-              theme.fg("muted", `Updated (${complete}/${taskList.length} complete${suffix})`),
+            theme.fg("success", "✓ ") + theme.fg("muted", `Updated (${c.done}/${taskList.length} done${c.suffix})`),
             0,
             0,
           );
@@ -323,19 +340,10 @@ export default function (pi: ExtensionAPI) {
           if (taskList.length === 0) {
             return new Text(theme.fg("dim", "No plan active"), 0, 0);
           }
-          const complete = taskList.filter((t) => t.status === "complete").length;
-          const failed = taskList.filter((t) => t.status === "failed").length;
-          const suffix = failed > 0 ? `, ${failed} failed` : "";
-          let text = theme.fg("muted", `${complete}/${taskList.length} complete${suffix}`);
+          const c = counts(taskList);
+          let text = theme.fg("muted", `${c.done}/${taskList.length} done${c.suffix}`);
           for (const t of taskList) {
-            const icon =
-              t.status === "complete"
-                ? theme.fg("success", "✓")
-                : t.status === "in_progress"
-                  ? theme.fg("warning", "→")
-                  : t.status === "failed"
-                    ? theme.fg("error", "✗")
-                    : theme.fg("dim", "○");
+            const icon = glyph(t.status, theme);
             text += `\n${icon} ${theme.fg("muted", t.name)}`;
           }
           return new Text(text, 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.3",
+  "version": "5.6.0",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",

package/skills/brainstorming/SKILL.md

@@ -354,7 +354,7 @@ Execute this section in place from any later phase. Do not invoke `/skill:brains
 
 1. Edit the spec. Show `git --no-pager diff -- <spec path>` and one line of impact (affected plan tasks / waves, or "no plan yet").
 2. Wait for approval. Change request -> revise, re-show.
-3. No plan yet -> commit the spec; continue. Plan exists -> update affected anchors and tasks: `plan_tracker` `add` for new tasks, `update` for changed ones; anchor-changed completed tasks go back to `pending` and re-run the task loop. A removed task is deleted from the plan; then re-`init` the tracker with the remaining tasks in wave order and `update` every already-completed task back to `complete` (the only permitted `init` after handoff; never `clear`). Re-run `plan_check` until it passes, commit spec + plan together; continue. A task reopened while `verify` or `ship` is in progress: `phase_tracker({ action: "skip", phase: "<current>", reason: "amendment reopened Task N" })`, then `phase_tracker({ action: "start", phase: "implement", force: true })`; later phases re-enter with `force: true` and rerun in full.
+3. No plan yet -> commit the spec; continue. Plan exists -> update affected anchors and tasks: `plan_tracker` `add` for new tasks; anchor-changed completed tasks are reopened as `in_progress` and re-run the task loop (`update` never sets `pending`). A removed task is deleted from the plan; then re-`init` the tracker with `{ name, status }` elements: preserved tasks keep their order and statuses, reopened tasks are `in_progress` in place, every still-`pending` task (including newly added ones, whatever wave label they carry) trails the non-pending ones, removed tasks are the only deletions (the only permitted `init` after handoff; never `clear`). Re-run `plan_check` until it passes, commit spec + plan together; continue. A task reopened while `verify` or `ship` is in progress: `phase_tracker({ action: "skip", phase: "<current>", reason: "amendment reopened Task N" })`, then `phase_tracker({ action: "start", phase: "implement", force: true })`; later phases re-enter with `force: true` and rerun in full.
 
 Redraw test: the diff changes the problem statement, adds or removes a component, or moves a component boundary -> redraw. A change inside one component (a persistence mechanism, a worker's HTTP client, dropping a fallback and its task) -> amend. State the call in the same message as the diff; the user overrides either way.
 

package/skills/check-delivery/SKILL.md

@@ -125,11 +125,12 @@ configured) all emitted for manual execution, none auto-posted.
 stage plus one task per AC - status mappings below apply only after that
 init: pass / `satisfied` / `not externally observable` /
 `unverified: no delivery target` / `allowed gap` / `proposed descope` ->
-`complete`; failed stage / `unexplained gap` -> `failed`; skipped stage 2 -> `complete`, skip named in
-the task title (e.g. "delivery target - skipped, none configured"), so a
-successful zero-config run still renders finished. Optional-degrading: a
-native task list, or no tracking at all, on harnesses without
-`plan_tracker`; absence is never a hard stop.
+`complete`; failed stage / `unexplained gap` -> `failed`; skipped stage 2 ->
+`skipped` (rendered ⊘, counted as done - never `complete` under a renamed
+title). AC tasks follow the four stage tasks; record each AC verdict while
+stage 3 is `in_progress` - the tracker rejects a verdict recorded behind a
+still-pending stage. Optional-degrading: a native task list, or no tracking
+at all, on harnesses without `plan_tracker`; absence is never a hard stop.
 
 **Stage 0 - Pre-flight.** Fetch the ticket and all comments. Check the
 current tracker status first: if it is already in a terminal/done state,

package/skills/gatekeep-pr/SKILL.md

@@ -83,14 +83,18 @@ configuration.
 
 ## Progress tracking
 
-Use `plan_tracker`, never `phase_tracker`. Init with the stage names: `gather`,
-`provision worktree`, `resolve evidence`, `claim-check`, `review`, `consent menu`.
-Append one task per material claim as the Verifier enumerates them. A passing stage or
-a matched claim -> `complete`. A failed stage or a contradicted claim -> `failed`
-(shown crossed, error color) and stays failed while the skill stops at the menu -
-never marked complete to move on. On a harness without the `plan_tracker` tool: fall
-back to a plain checklist (or skip if none is available); functionality is unchanged
-either way.
+Use `plan_tracker`, never `phase_tracker`. Init with the first four stages:
+`gather`, `provision worktree`, `resolve evidence`, `claim-check`. While
+`claim-check` is `in_progress`, `add` one task per material claim as the
+Verifier enumerates them and record each verdict: a matched claim ->
+`complete`, a contradicted claim -> `failed` (shown crossed, error color).
+Once every claim is terminal and `claim-check` is closed, `add` `review` and
+`consent menu` and continue. Stages are never inited ahead of the claims:
+the tracker rejects a verdict recorded behind a still-pending stage. A
+failed stage or claim stays `failed` while the skill stops at the menu -
+never marked complete to move on. On a harness without the `plan_tracker`
+tool: fall back to a plain checklist (or skip if none is available);
+functionality is unchanged either way.
 
 ## Assessment
 

package/skills/subagent-driven-development/SKILL.md

@@ -171,9 +171,9 @@ Auto-selected at handoff by `writing-plans` (any wave with ≥2 tasks) when the
 **Progress tracking (`plan_tracker`).** `plan_tracker` is a flat list with no native group concept, so waves are *encoded*, not modeled:
 
 - **Consume, preserve, recover only if absent:** consume the wave-ordered list initialized at writing-plans handoff; indices are positional and stable, so never re-init on continuation or mid-run. Only direct recovery with no tracker initializes the full plan list once before dispatch.
-- **Wave fan-out → `in_progress`:** unconditionally mark every task index in the wave `in_progress` before dispatch. Multiple simultaneous entries are expected (sequential mode has one).
+- **Wave fan-out → `in_progress`:** unconditionally mark every task index in the wave `in_progress` before dispatch, in increasing index order (the tracker validates each call against the previous one and rejects a start while an earlier index is still `pending`). Multiple simultaneous entries are expected (sequential mode has one).
 - **Wave commit → `complete`:** after the wave's gate passes and it commits, unconditionally mark all those same indices `complete`. `complete` = durably committed, so a task in conflict fallback stays `in_progress` until its wave commits.
-- **Lifecycle per task:** `pending → in_progress (wave fan-out) → complete (wave commit)`.
+- **Lifecycle per task:** `pending → in_progress (wave fan-out) → complete (wave commit)`; `failed` when a task ran and did not pass; `skipped` when the plan drops it as not applicable (terminal, counted done). A rejected `update` names the earlier pending tasks and the legal fixes - record those tasks' true state, never `clear` or re-`init` to move on.
 - **Widget caveat (known, deliberately unfixed).** The persistent `plan_tracker` widget's icon strip (`○ → ✓`) and `(c/total)` count reflect every task, but its trailing *name* shows only the **first** `in_progress` task. In parallel mode the icon strip and the `status` action are the full in-flight view; a richer multi-task widget is a separate extension change, out of scope (YAGNI).
 - **Sequential mode:** consume the same existing full list, one `in_progress` index at a time; wave prefixes are harmless.
 

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
@@ -141,7 +143,7 @@ prerequisites hold.
 
 Per round:
 
-1. **Synchronize gap tasks** — append only a genuinely new gap that is entering remediation, named `Gn: <gap origin clause verbatim, truncated>`; never `init`. Find existing gaps by their exact `Gn:` prefix and reuse that index even if origin wording changes. Carried-OPEN inventory-only gaps add nothing. Before dispatch, mark every remediated gap's existing index `in_progress`; a re-audit needing more work reopens that same `Gn` index. The lifecycle traces `[T1,T2]`, then `[T1,T2,G1]`, then `[T1,T2,G1,G2]`; no test-retry or review-round wrapper task.
+1. **Synchronize gap tasks** — append only a genuinely new gap that is entering remediation, named `Gn: <gap origin clause verbatim, truncated>`; never `init`. Find existing gaps by their exact `Gn:` prefix and reuse that index even if origin wording changes. Carried-OPEN inventory-only gaps add nothing. Before dispatch, mark every remediated gap's existing index `in_progress`, in increasing index order (the tracker rejects a start while a lower index is still `pending`); a re-audit needing more work reopens that same `Gn` index. The lifecycle traces `[T1,T2]`, then `[T1,T2,G1]`, then `[T1,T2,G1,G2]`; no test-retry or review-round wrapper task.
 2. **Fix wave** — select gaps greedily in `Gn` order: take each `fix` gap unless a gap it `conflicts` with (per the report's `Parallel-safe:` line) is already taken; the certificate's `disjoint` grouping is ignored, and a certificate still malformed after the one re-ask means every gap `conflicts` with every other. Held gaps carry to the next round; the wave is never empty while an eligible `fix` gap exists. Dispatch **one** call - `subagent({ context: "fresh", async: false, tasks: [...] })` - with one `implementer` task per selected gap (`worktree: true`, `cwd` = the conformance worktree, task = the gap block verbatim with `touched-files` as the ownership boundary). A single gap is a one-task `tasks` call; a lone `agent: "implementer"` call never appears in this loop. For an `UNAUTHORIZED` `fix` gap
    whose `evidence` opens with the over-spec provenance (`spec "<section>" - "<clause>" (over-spec)`), the orchestrator adds the spec path to that gap's `touched-files` before dispatch,
    so the implementer deletes the surface **and** the clause/AC line in the same
@@ -178,8 +180,11 @@ Per round:
    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. Inside a
-   brainstorming-entered flow the phase tracker enforces both rules at
+   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).
 
@@ -187,7 +192,7 @@ Per round:
 
 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.