pi-gauntlet 8.0.1 → 8.1.0

package/extensions/phase-tracker.test.ts

@@ -8,6 +8,7 @@ import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
 import registerPhaseTracker from "./phase-tracker.ts";
+import registerPlanTracker from "./plan-tracker.ts";
 
 const originalSubagentDepth = process.env.PI_SUBAGENT_DEPTH;
 process.env.PI_SUBAGENT_DEPTH = "0";
@@ -531,6 +532,50 @@ test("plan activity auto-completes implement with complete+skipped, not with fai
   assert.equal(await implementStatus([{ status: "complete" }, { status: "skipped" }], true), "in_progress");
 });
 
+test("ledger refresh completes only started implement and keeps failed, in-flight and Gn work open", async () => {
+  for (const allCut of [true, false]) {
+    const dir = tempCwd({ piGauntlet: { flowGuards: { enforce: false } } });
+    const path = join(dir, "ledger.md");
+    const save = (status: string, pending = "") => writeFileSync(path, `# Ledger - loop engine\n${pending}\n| row | status | attempts | evidence |\n|---|---|---|---|\n| 1 | ${status} | 0 | check |\n\n## Decisions\n`);
+    save(allCut ? "cut" : "failed");
+    const branch = implementBranch().slice(0, -1);
+    const h = harness({ cwd: dir, branch });
+    registerPlanTracker(h.pi as any);
+    await h.emit("session_start");
+    const tracker = h.tools.find(t => t.name === "plan_tracker")!;
+    const phase = h.tools.find(t => t.name === "phase_tracker")!;
+    const status = async () => (await phase.execute("status", { action: "status" }, undefined, undefined, h.ctx) as any).details.phases.implement.status;
+    const refresh = async (target = path) => {
+      const result = await tracker.execute("refresh", { action: "refresh", path: target }, undefined, undefined, h.ctx) as any;
+      branch.push({ type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: result.details } } as any);
+      await h.emitEvent("tool_execution_end", { toolName: "plan_tracker", result });
+      return result;
+    };
+    assert.equal((await refresh()).details.error, undefined);
+    assert.equal(await status(), "pending", "refresh before start cannot complete implement");
+    assert.equal((await startPhase(h, "implement")).status, "in_progress");
+    await refresh();
+    if (!allCut) {
+      assert.equal(await status(), "in_progress", "failed row keeps implement active");
+      save("failed", "pending: 1 | home | abc1234");
+      const inFlight = await refresh();
+      assert.equal(inFlight.details.tasks[0].status, "in_progress");
+      assert.equal(await status(), "in_progress");
+      assert.ok((await refresh(join(dir, "missing.md"))).details.error);
+      assert.equal(await status(), "in_progress", "invalid refresh cannot complete implement");
+      await tracker.execute("add", { action: "add", tasks: ["G1: conformance"] }, undefined, undefined, h.ctx);
+      save("done");
+      const withGap = await refresh();
+      assert.equal(withGap.details.tasks[1].status, "pending");
+      assert.equal(await status(), "in_progress", "kept Gn task blocks completion");
+      await tracker.execute("update", { action: "update", index: 1, status: "complete" }, undefined, undefined, h.ctx);
+      await refresh();
+    }
+    assert.equal(await status(), "complete");
+    assert.equal((await startPhase(h, "verify")).status, "in_progress");
+  }
+});
+
 test("cold implement and verify completions ignore unfinished snapshots", async () => {
   for (const phase of ["implement", "verify"] as const) {
     const h = harness({

package/extensions/plan-tracker.test.ts

@@ -1,5 +1,8 @@
 import assert from "node:assert/strict";
 import { test } from "node:test";
+import { mkdtempSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 import registerPlanTracker, { validateSnapshot } from "./plan-tracker.ts";
 
 type ToolResult = {
@@ -7,7 +10,7 @@ type ToolResult = {
   details: { action: string; tasks: { name: string; status: string }[]; error?: string };
 };
 
-function harness(branch: unknown[] = []) {
+function harness(branch: unknown[] = [], cwd = process.cwd()) {
   const tools: {
     name: string;
     description: string;
@@ -29,6 +32,7 @@ function harness(branch: unknown[] = []) {
   let widgetText: string | undefined;
   const theme = { fg: (_c: string, s: string) => s, bold: (s: string) => s };
   const ctx = {
+    cwd,
     hasUI: true,
     ui: {
       setWidget(_id: string, cb?: (tui: unknown, theme: unknown) => { text: string }) {
@@ -380,6 +384,101 @@ test("legacy-invalid snapshot: first update is rejected listing legacy offenders
   assert.deepEqual(repaired.details.tasks.map((t) => t.status), ["complete", "skipped", "complete"]);
 });
 
+const ledger = (rows: string[], tail = "", pending = "") => [
+  "# Ledger - loop engine", pending,
+  "| row | status | attempts | evidence |", "|---|---|---|---|",
+  ...rows.map(row => `| ${row} |`), "", "## Decisions", tail,
+].join("\n");
+
+test("refresh projects ledger states, numeric pending targets and live leg mappings", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "plan-refresh-"));
+  const path = join(dir, "ledger.md");
+  const cases = [
+    {
+      name: "cut, baseline, dispatched, failed, in flight and pending without cap",
+      text: ledger(["1 | cut | 0 | deferred: #1", "2 | done | 0 | baseline", "3 | done | 1 | check \\| passed", "4 | failed | 1 | check failed", "5 | open | 0 |", "6 | open | 0 |"], "row 3 done | passed | row 4\n## Notes\nrow 2 done | not a decision | none", "pending: 5 | home | abc1234"),
+      expected: [["row 1", "skipped"], ["row 2", "skipped"], ["row 3", "complete"], ["row 4", "failed"], ["row 5", "in_progress"], ["row 6", "pending"]],
+    },
+    { name: "retry overrides failed", text: ledger(["1 | failed | 1 | failed"], "", "pending: 1 | home | abc1234"), expected: [["row 1", "in_progress"]] },
+    { name: "leading-zero target names its numeric row", text: ledger(["1 | open | 0 |"], "", "pending: 01 | home | abc1234"), expected: [["row 1", "in_progress"]] },
+    { name: "done beats stale pending", text: ledger(["1 | done | 1 | passed"], "row 1 done | passed | none", "pending: 1 | home | abc1234"), expected: [["row 1", "complete"]] },
+    { name: "cut beats stale pending and all cut are skipped", text: ledger(["1 | cut | 0 | deferred: #1"], "", "pending: 1 | home | abc1234"), expected: [["row 1", "skipped"]] },
+    { name: "seed names no row", text: ledger(["1 | failed | 1 | failed", "2 | open | 0 |"], "", "pending: seed | home | abc1234"), expected: [["row 1", "failed"], ["row 2", "pending"]] },
+    {
+      name: "mapped home and companion tasks sort non-pending first",
+      text: ledger(["1 | open | 0 |", "2 | done | 1 | passed", "3 | failed | 1 | failed"], "row 2 done | passed | row 3\n\n## Leg mapping\n| row | ac | leg |\n|---|---|---|\n| 1 | 1 | repo-a |\n| 2 | 1 | repo-b |\n| 3 | 2 | repo-a |", "pending: 3 | repo-a | abc1234"),
+      expected: [["row 2 (repo-b)", "complete"], ["row 3 (repo-a)", "in_progress"], ["row 1 (repo-a)", "pending"]],
+    },
+  ];
+  for (const row of cases) {
+    writeFileSync(path, row.text);
+    const h = harness([], dir);
+    const result = await h.call({ action: "refresh", path: "ledger.md" });
+    assert.equal(result.details.error, undefined, row.name);
+    assert.equal(result.details.action, "refresh", row.name);
+    assert.deepEqual(result.details.tasks.map(t => [t.name, t.status]), row.expected, row.name);
+    assert.deepEqual(validateSnapshot(result.details.tasks as any), [], row.name);
+    assert.deepEqual((await h.call({ action: "status" })).details.tasks, result.details.tasks, row.name);
+    const done = result.details.tasks.filter(t => ["complete", "skipped"].includes(t.status)).length;
+    assert.ok(h.widget()!.includes(`(${done}/${row.expected.length})`), row.name);
+  }
+});
+
+test("refresh replaces only whole ledger names, preserves Gn statuses and replays its snapshot", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "plan-refresh-kept-"));
+  const path = join(dir, "ledger.md");
+  writeFileSync(path, ledger(["1 | open | 0 |", "2 | open | 0 |", "3 | done | 1 | passed"], "row 3 done | passed | row 1"));
+  const h = harness();
+  await h.call({ action: "init", tasks: [
+    { name: "row 99", status: "complete" }, { name: "row 8 (old-repo)", status: "failed" },
+    { name: "G1: closed", status: "complete" }, { name: "G2: working", status: "in_progress" },
+    "row 4 notes", "G3: pending",
+  ] });
+  const result = await h.call({ action: "refresh", path });
+  assert.equal(result.details.error, undefined);
+  assert.deepEqual(result.details.tasks, [
+    { name: "row 3", status: "complete" },
+    { name: "G1: closed", status: "complete" }, { name: "G2: working", status: "in_progress" },
+    { name: "row 1", status: "pending" }, { name: "row 2", status: "pending" },
+    { name: "row 4 notes", status: "pending" }, { name: "G3: pending", status: "pending" },
+  ]);
+  assert.deepEqual(validateSnapshot(result.details.tasks as any), []);
+  const replay = harness([{ type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: result.details } }]);
+  await replay.fire("session_start");
+  assert.deepEqual((await replay.call({ action: "status" })).details.tasks, result.details.tasks);
+  assert.equal(replay.widget(), h.widget());
+});
+
+test("refresh rejects unreadable or malformed ledgers atomically, including absent numeric pending rows", async () => {
+  const dir = mkdtempSync(join(tmpdir(), "plan-refresh-error-"));
+  const path = join(dir, "ledger.md");
+  const valid = ledger(["1 | open | 0 |"]);
+  const h = harness();
+  const initial = await h.call({ action: "init", tasks: [{ name: "G1: closed", status: "complete" }, "G2: pending"] });
+  const widget = h.widget();
+  const cases = [
+    { name: "missing path", path: undefined, text: valid, error: /refresh: cannot read .*path required/ },
+    { name: "unreadable path", path: join(dir, "absent.md"), text: valid, error: /refresh: cannot read .*absent\.md:/ },
+    { name: "wrong discriminator", path, text: "# Plan", error: /line 1 is "# Plan", not a loop ledger/ },
+    { name: "missing header", path, text: valid.replace("| row | status | attempts | evidence |", "| row | state | attempts | evidence |"), error: /row table malformed at line \d+/ },
+    { name: "nonnumeric row", path, text: valid.replace("| 1 | open", "| x | open"), error: /row table malformed at line 5/ },
+    { name: "invalid status", path, text: valid.replace("| 1 | open", "| 1 | unknown"), error: /row table malformed at line 5/ },
+    { name: "absent pending row", path, text: "pending: 2 | home | abc1234", error: /pending: names row 2 which is absent/ },
+    { name: "zero pending row", path, text: "pending: 0 | home | abc1234", error: /pending: names row 0 which is absent/ },
+    { name: "leading-zero absent row", path, text: "pending: 02 | home | abc1234", error: /pending: names row 2 which is absent/ },
+    { name: "absent mapping row", path, text: valid + "\n## Leg mapping\n| row | ac | leg |\n|---|---|---|\n| 2 | 1 | repo-a |", error: /leg mapping names row 2 which is absent/ },
+  ];
+  for (const row of cases) {
+    writeFileSync(path, row.text.startsWith("pending:") ? ledger(["1 | open | 0 |"], "", row.text) : row.text);
+    const result = await h.call({ action: "refresh", path: row.path });
+    assert.match(result.details.error!, row.error, row.name);
+    assert.equal(result.details.tasks, undefined, row.name);
+    assert.equal(h.widget(), widget, row.name);
+    assert.deepEqual((await h.call({ action: "status" })).details.tasks, initial.details.tasks, row.name);
+    if (row.path) assert.ok(result.content[0].text.includes(row.path), row.name);
+  }
+});
+
 test("registration: sequential, tasks schema is Array<Union<String, Object>>, description carries the contract", () => {
   const { executionMode, parameters, description } = harness();
   assert.equal(executionMode(), "sequential");

package/extensions/plan-tracker.ts

@@ -6,6 +6,8 @@
  * Shows a persistent TUI widget above the editor.
  */
 
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
 import type { ExtensionAPI, ExtensionContext, Theme } from "@earendil-works/pi-coding-agent";
 import { Text } from "@earendil-works/pi-tui";
@@ -15,10 +17,11 @@ const TASK_STATUSES = ["pending", "in_progress", "complete", "failed", "skipped"
 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 PlanTrackerDetails { action: "init" | "add" | "update" | "status" | "clear" | "refresh"; tasks: Task[]; error?: string; }
 
 const PlanTrackerParams = Type.Object({
-  action: StringEnum(["init", "add", "update", "status", "clear"] as const, { description: "Action to perform" }),
+  action: StringEnum(["init", "add", "update", "status", "clear", "refresh"] as const, { description: "Action to perform" }),
+  path: Type.Optional(Type.String({ description: "Artifact path for refresh; relative paths resolve against the session cwd" })),
   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)" }) }),
@@ -40,6 +43,62 @@ export function validateSnapshot(tasks: Task[]): number[] {
   return offenders;
 }
 
+function ledgerTasks(text: string, path: string): Task[] {
+  const lines = text.split("\n");
+  if (lines[0] !== "# Ledger - loop engine") {
+    throw new Error(`refresh: ${path} line 1 is ${JSON.stringify(lines[0])}, not a loop ledger`);
+  }
+  const malformed = (index: number): never => { throw new Error(`refresh: ${path} row table malformed at line ${index + 1}`); };
+  const header = lines.findIndex(line => /^\|\s*row\s*\|\s*status\s*\|\s*attempts\s*\|\s*evidence\s*\|$/.test(line));
+  if (header < 0) malformed(0);
+  if (!/^\|\s*-+\s*\|\s*-+\s*\|\s*-+\s*\|\s*-+\s*\|$/.test(lines[header + 1] ?? "")) malformed(header + 1);
+  const rows: { row: number; status: string }[] = [];
+  for (let i = header + 2; i < lines.length && lines[i].trim() && !/^#{1,2}\s/.test(lines[i]); i++) {
+    const cells = lines[i].split(/(?<!\\)\|/).slice(1, -1).map(cell => cell.trim());
+    if (!lines[i].startsWith("|") || !lines[i].endsWith("|") || cells.length !== 4 || !/^\d+$/.test(cells[0]) || !/^(open|done|failed|cut)$/.test(cells[1])) malformed(i);
+    rows.push({ row: Number(cells[0]), status: cells[1] });
+  }
+  if (!rows.length) malformed(header + 2);
+  const byRow = new Map(rows.map(row => [row.row, row]));
+  const pendingMatch = lines.map(line => /^pending: (seed|\d+) \| (\S+) \| ([a-f0-9]{7,40})$/.exec(line)).find(Boolean);
+  const pending = pendingMatch && pendingMatch[1] !== "seed" ? Number(pendingMatch[1]) : undefined;
+  if (pending !== undefined && !byRow.has(pending)) {
+    throw new Error(`refresh: ${path} pending: names row ${pending} which is absent`);
+  }
+  const dispatched = new Set<number>();
+  let mapping: { row: number; repo: string }[] | undefined;
+  let section = "";
+  for (const line of lines) {
+    if (/^#{1,2}\s/.test(line)) {
+      section = line;
+      if (section === "## Leg mapping") mapping = [];
+      continue;
+    }
+    if (section === "## Decisions") {
+      const decision = /^row (\d+) done \| .+ \| .+$/.exec(line);
+      if (decision) dispatched.add(Number(decision[1]));
+    } else if (section === "## Leg mapping") {
+      const entry = /^\|\s*(\d+)\s*\|\s*\d+\s*\|\s*(\S+)\s*\|$/.exec(line);
+      if (!entry) continue;
+      const row = Number(entry[1]);
+      if (!byRow.has(row)) throw new Error(`refresh: ${path} leg mapping names row ${row} which is absent`);
+      mapping!.push({ row, repo: entry[2] });
+    }
+  }
+  const status = (row: number): TaskStatus => {
+    const value = byRow.get(row)!.status;
+    if (value === "cut") return "skipped";
+    if (value === "done") return dispatched.has(row) ? "complete" : "skipped";
+    if (row === pending) return "in_progress";
+    return value === "failed" ? "failed" : "pending";
+  };
+  const entries = mapping ?? rows.map(({ row }) => ({ row, repo: undefined }));
+  return entries.sort((a, b) => a.row - b.row).map(({ row, repo }) => ({
+    name: `row ${row}${repo === undefined ? "" : ` (${repo})`}`,
+    status: status(row),
+  }));
+}
+
 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(", ");
@@ -115,12 +174,47 @@ 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 (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.",
+      "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), refresh (derive tasks from an artifact path while retaining other tasks). 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) {
+        case "refresh": {
+          let proposed: Task[];
+          try {
+            if (!params.path) throw new Error("refresh: cannot read <missing>: path required");
+            const path = resolve(ctx.cwd, params.path);
+            let text: string;
+            try {
+              text = readFileSync(path, "utf8");
+            } catch (error) {
+              throw new Error(`refresh: cannot read ${path}: ${error instanceof Error ? error.message : String(error)}`);
+            }
+            const projected = ledgerTasks(text, path);
+            const kept = tasks.filter(task => !/^row \d+(?: \(\S+\))?$/.test(task.name));
+            proposed = [
+              ...projected.filter(task => task.status !== "pending"),
+              ...kept.filter(task => task.status !== "pending"),
+              ...projected.filter(task => task.status === "pending"),
+              ...kept.filter(task => task.status === "pending"),
+            ];
+            if (validateSnapshot(proposed).length) throw new Error(`refresh: ${path}: ${RULE_LINE}`);
+          } catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            return {
+              content: [{ type: "text", text: `Error: ${message}` }],
+              details: { action: "refresh", error: message } as PlanTrackerDetails,
+            };
+          }
+          tasks = proposed;
+          updateWidget(ctx);
+          return {
+            content: [{ type: "text", text: `Plan refreshed with ${tasks.length} tasks.\n${formatStatus(tasks)}` }],
+            details: { action: "refresh", tasks: tasks.map(t => ({ ...t })) } as PlanTrackerDetails,
+          };
+        }
+
         case "init": {
           if (!params.tasks || params.tasks.length === 0) {
             return {
@@ -316,6 +410,8 @@ export default function (pi: ExtensionAPI) {
 
       const taskList = details.tasks;
       switch (details.action) {
+        case "refresh":
+          return new Text(theme.fg("success", "✓ ") + theme.fg("muted", `Plan refreshed with ${taskList.length} tasks`), 0, 0);
         case "init":
           return new Text(
             theme.fg("success", "✓ ") + theme.fg("muted", `Plan initialized with ${taskList.length} tasks`),

package/extensions/telemetry.test.ts

@@ -284,6 +284,27 @@
     assert.deepEqual([resumed.gauntletEntered, resumed.lastSpecWrite], [true, "/repo/doc/specs/a.md"]);
   });
 
+  test("session resume restores the last successful plan snapshot for reopen counting", async () => {
+    const first = await boundInPlan();
+    const closed = [{ name: "a", status: "complete" }];
+    const planResult = (tasks: { name: string; status: string }[], error?: string) => ({
+      type: "message", message: { role: "toolResult", toolName: "plan_tracker", details: { action: "update", tasks, error } },
+    });
+    const branch = [
+      { type: "message", message: { role: "toolResult", toolName: "phase_tracker", details: { action: "start", phases: P({ brainstorm: "in_progress" }) } } },
+      { type: "message", message: { role: "toolResult", toolName: "plan_check", details: { status: "pass", specPath: join(first.root, "doc/specs/a.md") } } },
+      planResult([{ name: "a", status: "pending" }]),
+      planResult(closed),
+      planResult([{ name: "a", status: "failed" }], "failed"),
+    ];
+    const second = harness({ sessionId: "s2", branch });
+    second.ctx.cwd = first.root;
+    await second.emit("session_start", { type: "session_start", reason: "resume" });
+    await second.emit("tool_result", { toolName: "plan_tracker", toolCallId: "pt", input: { action: "update" }, content: [], isError: false, details: { action: "update", tasks: [{ name: "a", status: "in_progress" }] } });
+    assert.equal(second.readRecord().derived.gates.task_reopens, 1);
+    assert.deepEqual(replayBranch(branch, ["doc/specs"]).lastPlanTasks, closed);
+  });
+
   test("replayBranch honors a custom spec dir list", () => {
     const branch = [
       { type: "message", message: { role: "toolResult", toolName: "phase_tracker", details: { action: "start", phases: P({ brainstorm: "in_progress" }) } } },
@@ -1340,3 +1361,85 @@ test("resume skip reads engine from bound spec live and on branch replay", async
     }
   }
 });
+
+  test("any successful tracker action counts named transitions once and ignores retries and amendments", async () => {
+    const h = await boundInPlan();
+    const pt = (action: string, tasks: { name: string; status: string }[], isError = false) => h.emit("tool_result", { toolName: "plan_tracker", input: { action }, details: { action, tasks }, content: [], isError });
+    const closed = [{ name: "a", status: "complete" }, { name: "b", status: "complete" }];
+    const reopened = [{ name: "b", status: "failed" }, { name: "a", status: "in_progress" }];
+    await pt("init", closed);
+    await pt("refresh", reopened, true);
+    assert.equal(h.readRecord().derived.gates.task_reopens, 0);
+    await pt("refresh", reopened);
+    await pt("refresh", reopened);
+    await pt("status", [{ name: "a", status: "in_progress" }, { name: "b", status: "in_progress" }]);
+    assert.equal(h.readRecord().derived.gates.task_reopens, 2);
+    assert.equal(h.readRecord().events.filter((e) => e.kind === "gate" && e.gate === "task_reopen").length, 1);
+    await pt("add", closed);
+    await pt("refresh", [{ name: "a", status: "skipped" }, { name: "b", status: "pending" }]);
+    await pt("clear", []);
+    await pt("init", reopened);
+    assert.equal(h.readRecord().derived.gates.task_reopens, 2);
+  });
+
+  test("verification calls count from implement start through seal, reload and flush", async () => {
+    const h = await boundInPlan();
+    await h.bash("before", "npm test");
+    assert.equal(h.readRecord().derived.verification_runs, undefined);
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "complete", implement: "in_progress" }));
+    assert.equal(h.readRecord().derived.verification_runs, 0);
+    await h.bash("implement", "npm test", true);
+    assert.equal(h.readRecord().derived.verification_runs, 1);
+    assert.equal(h.readRecord().derived.tests, undefined);
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "complete", implement: "complete", verify: "in_progress" }));
+    await h.bash("verify1", "npm test");
+    await h.bash("verify2", "cd x && npm test", true);
+    await h.bash("unmatched", "echo verification: custom-check");
+    assert.equal(h.readRecord().derived.verification_runs, 3);
+    assert.deepEqual(h.readRecord().derived.tests, { command: "npm test", result: "fail" });
+    const branch = [{ type: "message", message: { role: "toolResult", toolName: "phase_tracker", isError: false, details: { action: "start", phases: P({ brainstorm: "in_progress" }) } } },
+      { type: "message", message: { role: "toolResult", toolName: "phase_tracker", isError: false, details: { action: "skip", phases: { ...P({ brainstorm: "skipped", plan: "complete", implement: "complete", verify: "in_progress" }), brainstorm: { status: "skipped", reason: "resume: doc/specs/a.md" } } } } }];
+    const resumed = harness({ branch, sessionId: "s2" });
+    resumed.ctx.cwd = h.root;
+    await resumed.emit("session_start", {});
+    await resumed.bash("resumed", "npm test");
+    assert.equal(resumed.readRecord().derived.verification_runs, 4);
+    await resumed.phaseResult("start", P({ brainstorm: "skipped", plan: "complete", implement: "complete", verify: "complete", ship: "in_progress" }));
+    await resumed.bash("ship", "npm test");
+    process.env.PI_SUBAGENT_DEPTH = "1";
+    try { await resumed.bash("child", "npm test"); } finally { process.env.PI_SUBAGENT_DEPTH = "0"; }
+    await resumed.emit("session_shutdown", {});
+    assert.equal(resumed.readRecord().derived.verification_runs, 5);
+    const sealed = { ...resumed.readRecord(), status: "shipped" as const, shipped_at: "2026-09-17T18:00:00Z" };
+    writeFileSync(resumed.recordPath(), serializeRecord(sealed));
+    const before = readFileSync(resumed.recordPath(), "utf8");
+    await resumed.bash("sealed", "npm test");
+    assert.equal(readFileSync(resumed.recordPath(), "utf8"), before);
+    const unbound = harness();
+    await unbound.bash("unbound", "npm test");
+    assert.equal(existsSync(unbound.recordPath()), false);
+  });
+
+  test("sealed loop fixture keeps dispatch iterations, skipped plan rows and verification runs", async () => {
+    const h = harness({ jjWorkspace: true, gitFail: (args) => args[0] === "rev-parse" ? { code: 1, stdout: "", stderr: "not git" } : undefined });
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec("doc/specs/a.md", "# Spec\n\n**Engine:** loop\n\n## Scope\nSynthetic run.\n");
+    await h.phaseResult("complete", P({ brainstorm: "complete" }));
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "skipped", implement: "in_progress" }));
+    const pt = (tasks: { name: string; status: string }[]) => h.emit("tool_result", { toolName: "plan_tracker", input: { action: "refresh" }, details: { action: "refresh", tasks }, isError: false, content: [] });
+    await pt([{ name: "row 1", status: "skipped" }, { name: "row 2", status: "complete" }, { name: "row 3", status: "in_progress" }]);
+    await h.emit("tool_result", { toolName: "subagent", input: {}, details: { results: [{ agent: "loop-implementer", exitCode: 0 }] }, content: [], isError: false });
+    await pt([{ name: "row 1", status: "skipped" }, { name: "row 2", status: "complete" }, { name: "row 3", status: "complete" }]);
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "skipped", implement: "complete", verify: "in_progress" }));
+    await h.bash("verify", "npm test");
+    await h.phaseResult("start", P({ brainstorm: "complete", plan: "skipped", implement: "complete", verify: "complete", ship: "in_progress" }));
+    await h.phaseResult("complete", P({ brainstorm: "complete", plan: "skipped", implement: "complete", verify: "complete", ship: "complete" }));
+    const rec = h.readRecord();
+    assert.equal(rec.status, "shipped");
+    assert.equal(rec.derived.engine, "loop");
+    assert.equal(rec.derived.iterations, 1);
+    assert.equal(rec.events.filter((e) => e.kind === "dispatch" && e.agent === "loop-implementer").length, 1);
+    assert.deepEqual(rec.derived.plan, { tasks: 3, complete: 2, failed: 0, skipped: 1 });
+    assert.equal(rec.derived.verification_runs, 1);
+    assert.equal(rec.derived.events_dropped, 0);
+  });

package/extensions/telemetry.ts

@@ -21,7 +21,7 @@
   import { sha256 } from "./lib/plan-check.ts";
   import { SUPERSEDED_BY_RE, isPlanPath, isSpecPath, isSupersededByBanner, matchTestStatement, parseSpecLinks, planSpecHeader, recordPathFor, repoRelativeToolPath, toPosix, truncateCommand } from "./lib/telemetry-paths.ts";
   import { computeJjDiff } from "./lib/telemetry-diff.ts";
-  import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countStructuredFindings, countOpenGaps, hasReopen, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
+  import { COUNTED_USER_PHASES, REVIEWER_AGENTS, countFindings, countStructuredFindings, countOpenGaps, countReopens, insertedText, planTotals, textOf, usageToTokens } from "./lib/telemetry-collect.ts";
   import { addTokens, capEvents, compact, currentPhase, derive, diffPhases, emptyAccumulators, emptyPhases, foldAccumulators, implementAutoCompletes, liveShipEvent, newRecord, parseRecord, serializeRecord, type Accumulators, type BaseEvent, type PhaseAcc, type PhaseKey, type PhaseMap, type TelemetryEvent, type TelemetryRecord, type Tokens } from "./lib/telemetry-record.ts";
   import { guardReason } from "./lib/telemetry-ship.ts";
   import { buildCouncil, parseAudit, parseChairReport, resolveMembers, type Cluster, type MemberResult } from "./lib/telemetry-council.ts";
@@ -141,6 +141,7 @@
     gauntletEntered: boolean;
     planCheckSpec?: string;
     lastSpecWrite?: string;
+    lastPlanTasks?: { name?: string; status: string }[];
   }
 
   // gauntlet-resume's reconstruction skips brainstorm with `resume: <spec path>`; the path
@@ -179,6 +180,9 @@
         }
         const resumed = d.action === "skip" ? resumeSpecOf(d.phases, specDirs) : undefined;
         if (out.gauntletEntered && resumed) out.lastSpecWrite = resumed;
+      } else if (msg.toolName === "plan_tracker") {
+        const d = msg.details as { tasks?: { name?: string; status: string }[]; error?: string } | undefined;
+        if (d && !d.error && Array.isArray(d.tasks)) out.lastPlanTasks = d.tasks;
       } else if (msg.toolName === "plan_check") {
         const d = msg.details as { status?: string; specPath?: string } | undefined;
         if (out.gauntletEntered && d?.status === "pass" && typeof d.specPath === "string") out.planCheckSpec = d.specPath;
@@ -445,6 +449,7 @@
               : { kind: "phase", action: t.action, name: t.name },
         );
         if (t.action === "start" && t.name === "brainstorm") councilPending = undefined;
+        if (record && t.action === "start" && t.name === "implement") record.derived.verification_runs ??= 0;
         phases = details.phases;
         if (record && boundSpec && t.name === "brainstorm" && (t.action === "complete" || t.action === "skip")) {
           if (e) record.approved_at ??= e.ts;
@@ -491,6 +496,7 @@
       sessionId = ctx.sessionManager.getSessionId();
       currentDir = snap.telemetry.dir;
       const replay = replayBranch(ctx.sessionManager.getBranch(), snap.specDirs);
+      lastPlanTasks = replay.lastPlanTasks;
       phases = replay.phases;
       gauntletEntered = replay.gauntletEntered;
       if (!canBind()) return;
@@ -632,7 +638,7 @@
     let onOtherSpecEdit: (rel: string, event: { input: unknown }, specDirs: string[]) => void;
 
     let amendmentOpen = false;
-    let lastPlanTasks: { status: string }[] | undefined;
+    let lastPlanTasks: { name?: string; status: string }[] | undefined;
     const pendingTest = new Map<string, string>(); // toolCallId -> matched statement
 
     const phaseAcc = (k: PhaseKey = phaseNow()): PhaseAcc => (live().phases[k] ??= {});
@@ -724,8 +730,9 @@
     const onPlanTracker = async (details: unknown, snap: SettingsSnapshot) => {
       const d = details as { tasks?: { name?: string; status: string }[]; error?: string; action?: string } | undefined;
       if (!d || d.error || !Array.isArray(d.tasks)) return;
-      if (d.action === "update" && hasReopen(lastPlanTasks, d.tasks)) {
-        live().gates.task_reopens += 1;
+      const reopens = countReopens(lastPlanTasks, d.tasks);
+      if (reopens) {
+        live().gates.task_reopens += reopens;
         pushEvent({ kind: "gate", gate: "task_reopen" });
       }
       lastPlanTasks = d.tasks;
@@ -771,9 +778,15 @@
       if (event.toolName === "bash") {
         const command = String((event.input as { command?: unknown }).command ?? "");
         if (phaseNow() === "brainstorm" && /\bgit\b[^\n]*\bcommit\b/.test(command)) onCouncilAudit(command);
-        if (record && (phases.verify.status === "in_progress" || phases.ship.status === "in_progress")) {
+        if (record && !frozen) {
           const statement = matchTestStatement(command, snap.testCommands ?? DEFAULT_TEST_COMMANDS);
-          if (statement) pendingTest.set(event.toolCallId, statement);
+          if (statement) {
+            if (record.events.some((e) => e.kind === "phase" && e.action === "start" && e.name === "implement")) {
+              record.derived.verification_runs = (record.derived.verification_runs ?? 0) + 1;
+              flush();
+            }
+            if (phases.verify.status === "in_progress" || phases.ship.status === "in_progress") pendingTest.set(event.toolCallId, statement);
+          }
         }
       }
       return undefined;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-gauntlet",
-  "version": "8.0.1",
+  "version": "8.1.0",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",
@@ -62,13 +62,14 @@
     "test": "node scripts/ci.mjs"
   },
   "peerDependencies": {
-    "pi-cohort": ">=7.6.5"
+    "pi-cohort": ">=7.6.6"
   },
   "dependencies": {
     "yaml": "^2.9.0"
   },
   "devDependencies": {
     "@anthropic-ai/claude-code": "2.1.309",
-    "esbuild": "0.28.2"
+    "esbuild": "0.28.2",
+    "typebox": "^1.3.11"
   }
 }

package/skills/brainstorming/reference/amendment-surface.md

@@ -40,7 +40,7 @@ When the spec file is mid-batch (uncommitted amend edits), the consent edit ride
 
 ## Implement-local maintenance boundaries
 
-Apply this specialization only to implement callers with a task plan; keep planning callers and ordinary attribution/restoration below unchanged. Patch only affected task entries, coverage and shifted anchors, preserving unaffected ids, titles, wave order, state and historical evidence. Capture anchored obligation text, task bodies and Tests alongside the original inventory in the saved apply report; retain it on failure and use it on idempotent retry. Interpret `tasksAnchorChanged` semantically, not as offset-only or meaning-preserving rewording changes.
+Apply this specialization only to implement callers with a task plan; keep planning callers and ordinary attribution/restoration below unchanged. Patch only affected task entries, coverage and shifted anchors, preserving unaffected ids, titles, wave order, state and historical evidence. Use committed home plan/spec originals read via home-relative `git -C "<abs home worktree>" show HEAD:<path>` before edits and on every retry for original task inventory, anchored obligation text, task bodies and Tests; retain prior findings in the report, not baseline copies. Interpret `tasksAnchorChanged` semantically, not as offset-only or meaning-preserving rewording changes.
 
 For spec/plan maintenance requiring no test execution, admit declared `In-flight:` repairs and preserve staged repairs; never commit, restore or discard them merely to plan. Retain original declarations and unchanged evidence at measured revisions under `**Baseline policy:** implement-local`. Execute changed/added/missing/invalid evidence only on an identified execution tree, recording leg, checkout, revision, admitted changes, command, exit and nonzero executed-test count. Never call dirty execution clean HEAD; stop on unidentified trees, unknown dirty paths, contamination or moved test revision.
 
@@ -153,7 +153,7 @@ Reply grammar: one line per item, `<n>. <letter or free text>`; bare `1` applies
 
 Before the aftermath, `read` this section again; never run it from memory.
 
-**Implement callers only, with a task plan:** replace parent spec edits and the ordinary plan aftermath with a one-step chain to `plan-writer` carrying an implement-only `Amend-apply:` block, the granted items verbatim, the five absolute paths, and the parent's explicit `In-flight:` list. Authorize only those named spec sections. Require implement-local patching and historical Baseline under the boundaries above, preservation of unaffected titles and wave positions, Baseline ownership, dirty-baseline safety, and the child's self-check. Consume `{ amendedSections: string[], tasksAdded: number[], tasksAnchorChanged: number[], tasksRemoved: number[], passed: boolean, failLines?: string[] }`; use pre-apply task numbers, never tracker positions. Require the child to capture the original task numbers, titles, spec anchors, and wave positions in the existing saved apply report before the first apply and retain that original inventory on every return, including failures; add no sidecar. On `passed: false`, repeat once with `failLines` as the rule and `previousApplyReport` set to the first apply report path. Require the fresh retry worker to read that original inventory, apply granted edits idempotently without duplicating already-applied edits, and compute deltas against that original inventory rather than the already-mutated plan. Missing original inventory fails the retry; send a second failure to the human with verbatim findings, including substantive baseline failures. Keep the attribution, protected-path, and dirty-baseline exits below; no delegated restoration permission is granted. On pass, print `amended the spec: <title> - <location>` for each applied item, run the parent's `plan_check` for stamping, and use its fresh manifest with the returned task numbers without reading the plan or spec. Add `tasksAdded`, reopen completed `tasksAnchorChanged` as `in_progress`, and handle `tasksRemoved` through the removal rules below. Require parent PASS before tracker changes. Skip the ordinary parent edit, `Amend:` dispatch, and amended-plan read; preserve companion aftermath, audit, and the single batch commit below. Planning callers keep the ordinary apply and aftermath below; ledger and no-plan routes stay unchanged.
+**Implement callers only, with a task plan:** replace parent spec edits and the ordinary plan aftermath with a one-step chain to `plan-writer` carrying an implement-only `Amend-apply:` block, the granted items verbatim, the five absolute paths, and the parent's explicit `In-flight:` list. Authorize only those named spec sections. Require implement-local patching and historical Baseline under the boundaries above, preservation of unaffected titles and wave positions, Baseline ownership, dirty-baseline safety, and the child's self-check. Consume `{ amendedSections: string[], tasksAdded: number[], tasksAnchorChanged: number[], tasksRemoved: number[], passed: boolean, failLines?: string[] }`; use pre-apply task numbers, never tracker positions. Require both committed home plan/spec originals before the first edit and on every retry, with home-relative HEAD paths; add no sidecar or report-carried inventory. When structured apply JSON is suppressed, read the sole capture at `<Artifacts>/structured-output/*/output.json` with the existing `read` bound `limit: 300`, no offset or pagination for that one-task dispatch and require a success envelope satisfying unchanged `APPLY_SCHEMA`. Stop on zero or two files naming paths, or malformed values; never recover from prose. Route captured `passed`/`failLines` like printed JSON. Only a failLines entry beginning exactly `baseline read failed: git -C ` bypasses retry: stop quoting the exact command and actual stderr. For every other `passed: false`, retry once with `failLines` as the rule and `previousApplyReport` set to the first apply report path for prior findings only. Require the fresh retry worker to reread both committed originals, apply granted edits idempotently without duplicating already-applied edits, and compute semantic deltas against those originals rather than the already-mutated plan/spec. Send a second failure to the human with verbatim findings, including substantive baseline failures. Keep the attribution, protected-path, and dirty-baseline exits below; no delegated restoration permission is granted. On pass, print `amended the spec: <title> - <location>` for each applied item, run the parent's `plan_check` for stamping, and use its fresh manifest with the returned task numbers without reading the plan or spec. Add `tasksAdded`, reopen completed `tasksAnchorChanged` as `in_progress`, and handle `tasksRemoved` through the removal rules below. Require parent PASS before tracker changes. Skip the ordinary parent edit, `Amend:` dispatch, and amended-plan read; preserve companion aftermath, audit, and the single batch commit below. Planning callers keep the ordinary apply and aftermath below; ledger and no-plan routes stay unchanged.
 
 Apply accepted items only: reviewer clears, `accept`, `alt-n`, and state-changing `custom`. Print one line per applied item: `amended the spec: <title> - <what>`.
 
@@ -169,7 +169,7 @@ reread rule; amend the block before using a changed contract. Legacy specs
 without that section retain finish-time rereading. A one-member run has no
 companion artifact or companion aftermath.
 
-Aftermath, once per batch, only when at least one item applied (nothing applied -> skip to the commit below). Ledger exists (line 1 `# Ledger - loop engine` in the resolved plan dir) -> skip `plan-writer`, `plan_check`, and `plan_tracker`. Reconcile the ledger against the approved spec dispositions: `deviates:`, `deferred:`, or `elsewhere:` -> `cut`, evidence = the disposition; factual or requirement-preserving amendment -> preserve rows; re-bounded `done` row -> `open`, evidence = `reopened by amendment`. Preserve every row's attempts and the ledger's iterations and cap. Apply evidenced drafted-row text corrections as amend items while preserving row identity; retain the cut/reopen rules above. Ticket text and row add/remove changes remain redraws. Commit spec + ledger together with subject `loop: cut row <n>` for a batch containing only one cut, otherwise `loop: amend` (including mixed batches), carrying the amendment audit body below (including each `granted` record and granting sentence); continue without task-plan aftermath. No plan yet -> commit the spec; continue. Plan exists -> read `git -C "<abs worktree path>" status --porcelain` (plain jj: `jj -R "<abs worktree path>" diff --summary`); collect the parent's in-flight workflow edits as worktree-relative paths, including the amended spec and staged in-place wave-repair deliverables. Dispatch `plan-writer` per `writing-plans` `## Author the plan` step 3 with an `Amend:` block naming the amended spec sections, an `In-flight:` list of those paths (the parent supplies the set; the child never infers it), and the rule "preserve every task title and wave position the amendment does not touch; edit only affected anchors and tasks", then run that section's steps 5-6 (the parent `plan_check` and its branches).
+Aftermath, once per batch, only when at least one item applied (nothing applied -> skip to the commit below). Ledger exists (line 1 `# Ledger - loop engine` in the resolved plan dir) -> skip `plan-writer` and `plan_check`. Reconcile the ledger against the approved spec dispositions: `deviates:`, `deferred:`, or `elsewhere:` -> `cut`, evidence = the disposition; factual or requirement-preserving amendment -> preserve rows; re-bounded `done` row -> `open`, evidence = `reopened by amendment`. Preserve every row's attempts and the ledger's iterations and cap. Apply evidenced drafted-row text corrections as amend items while preserving row identity; retain the cut/reopen rules above. Ticket text and row add/remove changes remain redraws. Commit spec + ledger together with subject `loop: cut row <n>` for a batch containing only one cut, otherwise `loop: amend` (including mixed batches), carrying the amendment audit body below (including each `granted` record and granting sentence); after the commit, use the driver's next ledger-path refresh to project the new statuses and continue without task-plan aftermath. Keep task-plan `add`/`update`/`init` out of this route. Project `done -> cut` as `complete -> skipped` and a re-bound `done -> open` as `complete -> pending`; count neither as a reopen. During verify, stop on a re-bound row with `Stopped: row <n> reopened by amendment during verify`; keep verify active and offer authorization to return that row to ledger implementation or stop. On authorization, invoke `loop-implementer` through the driver's `## Dispatch` and `## Validate the return` (tuple, refresh, admission, refresh), with no phase reset; close the row on disk, then rerun the step 1 gate before verify continues. Never close it with `plan_tracker update`. No plan yet -> commit the spec; continue. Plan exists -> read `git -C "<abs worktree path>" status --porcelain` (plain jj: `jj -R "<abs worktree path>" diff --summary`); collect the parent's in-flight workflow edits as worktree-relative paths, including the amended spec and staged in-place wave-repair deliverables. Dispatch `plan-writer` per `writing-plans` `## Author the plan` step 3 with an `Amend:` block naming the amended spec sections, an `In-flight:` list of those paths (the parent supplies the set; the child never infers it), and the rule "preserve every task title and wave position the amendment does not touch; edit only affected anchors and tasks", then run that section's steps 5-6 (the parent `plan_check` and its branches).
 
 At that return point, classify human-facing outcomes with this table; let writing-plans' first `Findings:` repair run as written.