pi-gauntlet 8.0.2 → 8.1.1

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.2",
+  "version": "8.1.1",
   "description": "Opinionated, gated workflow skills, subagent personas, and runtime extensions for the pi coding agent.",
   "author": "Jacek Juraszek",
   "type": "module",
@@ -62,7 +62,7 @@
     "test": "node scripts/ci.mjs"
   },
   "peerDependencies": {
-    "pi-cohort": ">=7.6.5"
+    "pi-cohort": ">=7.6.6"
   },
   "dependencies": {
     "yaml": "^2.9.0"

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

@@ -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.
 

package/skills/finishing-a-development-branch/SKILL.md

@@ -33,8 +33,7 @@ Then call `phase_tracker({ action: "start", phase: "ship" })`.
 **Hard verification gate.** Tests/format/lint must pass before presenting any options — including Discard. The user's stated intent to throw the branch away does not change whether the diff is in a verifiable state; verifying first surfaces accidental damage to unrelated code before the branch is gone forever. The skip rule below is the only exception.
 Read [coordinated finish](reference/legs.md) once for `## Legs` activation, recorded contracts, per-leg Steps 1/3.5, the single Step 4 choice, Step 5 receipts and home strip-and-seal, and Step 6 cleanup. Apply its coordinated mechanics for multiple members; retain the ordinary path for one member or no section.
 Reuse the selected run spec read in Input. Detect a rework PR subject by its `## Rework record`; use Input's header-linked route for `**PR:**`, never discover by an open PR on `$FEATURE`. For the rework route only, read every top-level `PR:`/`Pre-rework head:` pair, home first, retaining each full SHA; missing pre-head -> stop naming the spec path. Set `PRE_REWORK_HEAD` to home's SHA. Read only combined capitalized `Base:`, `Keeps:`, `Changes:`, `Dropped claims:`, `Scoped tests:` fields; ignore lowercase provenance under `### PR #<N>`. For N=1, read `Threads:` directly after `Pre-rework head:` and retain the provenance subsection without changing finish output. Confirm only home with `gh pr view <N> --json number,url,headRefName,baseRefName,state` (use the record's repository): non-`OPEN` -> stop: `PR #N is <state>; the rework cannot be pushed to it.`; headRefName != `$FEATURE` -> stop naming both branches. Retain baseRefName for Step 3.
-Recognize a ledger by line 1 exactly `# Ledger - loop engine`. For a ledger, use its `verification:` command throughout finish, including the minors round. For a rework PR subject with a task plan, use the union of every plan task's `Tests:` commands plus the executable lint/format commands in the header's `**Verification:**` line; treat `none - PR subject, scoped` as no header commands, not an empty task union. Capture this set and accepted-complete task evidence before stripping the plan. Apply the hard gate and skip rule below to this set. For every other subject with a task plan, run the plan header's `**Verification:**` set in the worktree: `(cd "$WORKTREE" && <command>)`. With no plan in this session, run the verification command(s) of the affected services from the gauntlet overrides file or `AGENTS.md` (look for "verification", "CI", or "test" sections).
-**Skip rule.** Skip the run only when this set passed on a known clean commit in the verify phase of this session and no edit or write landed outside `<telemetry.dir>` since. Check the current tree: `git -C "$WORKTREE" diff --quiet <commit the run passed on> -- . ':!<telemetry.dir>'` must exit 0, and `git -C "$WORKTREE" status --porcelain --untracked-files=all -- . ':!<telemetry.dir>'` must exit 0 with empty output (`<telemetry.dir>` defaults to `.pi/gauntlet/telemetry`). These checks cover committed, staged, unstaged, and untracked changes outside telemetry. Otherwise run it once; a missing verified commit, a failed check, or uncertainty means run.
+Resolve the verification set and skip rule now: use `read` at the absolute path of [verification-set.md](reference/verification-set.md), resolved from this skill's location. Retain the resolved set through minors fixes, plan stripping and delivery; apply that reference's ledger recovery and log handling.
 **Scoping caveat — pre-existing findings.** Some services carry lint findings unrelated to the diff. If verification fails on lines you didn't touch:
 Confirm with `git -C "$WORKTREE" diff <base>...HEAD --name-only` that the offending file isn't in your diff. Surface the pre-existing finding to the user as a separate issue - do **not** auto-fix it in this completion ("surface, don't auto-fix"). Proceed only after the user acknowledges.
 **If tests fail (within your diff):**
@@ -221,7 +220,7 @@ Rows 1-2 run the Option 1/2 blocks; row 3 runs the Keep block and row 4 the Disc
 
 **Don't add explanation** - keep options concise. When the minors line lists findings and the block has no `whole-diff minors fix:` line, add only this line under the menu: `Or reply "fix minors" (or "fix minors F3, F9") for one Minor fix round.` This line is the only addition to the exact numbered options.
 
-**Standalone extra reply - `fix minors`.** When the rendered `whole-diff minors` line lists findings, `fix minors` (all) or `fix minors F3, F9` (a subset by `Fn`) is a valid reply beside the numbered options. It dispatches one `implementer` round (`cwd` = the worktree; task = the selected finding lines verbatim; `SCOPED_TEST_COMMANDS` = for PR subjects, the executable scoped union captured in Step 1, excluding `none - PR subject, scoped`; for other subjects, the plan-header verification set). For a ledger, supply its `verification:` command instead. For PR subjects, require successful evidence for every supplied command after the fix; failed or missing evidence stops before returning to the menu. Commit `whole-diff minors fix` and return to Step 3.5, where the freshness rule re-audits conformance as for any working-tree change and the regenerated block records the spent round (`whole-diff minors fix: <full SHA>`); Step 4 then re-renders. No code review follows this round: the whole-diff review is an unscoped first review, so its Minors are graded Minors. A block that already carries `whole-diff minors fix:` refuses the reply with "minors round already spent". Any numbered choice ships without them.
+**Standalone extra reply - `fix minors`.** When the rendered `whole-diff minors` line lists findings, `fix minors` (all) or `fix minors F3, F9` (a subset by `Fn`) is a valid reply beside the numbered options. It dispatches one `implementer` round (`cwd` = the worktree; task = the selected finding lines verbatim; `SCOPED_TEST_COMMANDS` = for PR subjects, the executable scoped union captured in Step 1, excluding `none - PR subject, scoped`; for other subjects, the plan-header verification set). For a ledger, supply the gate set as `SCOPED_TEST_COMMANDS`, retaining owning checkouts per [verification-set.md](reference/verification-set.md). For PR subjects, require successful evidence for every supplied command after the fix; failed or missing evidence stops before returning to the menu. Commit `whole-diff minors fix` and return to Step 3.5, where the freshness rule re-audits conformance as for any working-tree change and the regenerated block records the spent round (`whole-diff minors fix: <full SHA>`); Step 4 then re-renders. No code review follows this round: the whole-diff review is an unscoped first review, so its Minors are graded Minors. A block that already carries `whole-diff minors fix:` refuses the reply with "minors round already spent". Any numbered choice ships without them.
 
 ### Step 5: Execute Choice
 
@@ -319,7 +318,7 @@ EOF
 )")
 ```
 
-When the spec's `## Acceptance criteria` has at least one `venue:`, `deferred:`, or `elsewhere:` row, append this block after `## Test Plan`, listing those rows verbatim with their disposition, so the reader knows what `/skill:check-delivery` verifies before the prod deploy and what a follow-up or another repo owns. With no such rows the body ends at `## Test Plan`, byte-identical to today. Option 3's squash commit message is unchanged.
+For a ledger, render `Verification: scoped - <commands>; CI on this push holds the full run` as the last `## Summary` bullet, listing that PR's gate commands; keep `## Test Plan` and the rest of the body unchanged. Keep the `Telemetry: whole PR against <baseRefName>.` suffix rework-only; print no verification line on squash or discard. When the spec's `## Acceptance criteria` has at least one `venue:`, `deferred:`, or `elsewhere:` row, append this block after `## Test Plan`, listing those rows verbatim with their disposition, so the reader knows what `/skill:check-delivery` verifies before the prod deploy and what a follow-up or another repo owns. With no such rows the body ends at `## Test Plan`, byte-identical to today. Option 3's squash commit message is unchanged.
 
 ```markdown
 ## Acceptance criteria
@@ -343,12 +342,13 @@ git -C "$PRIMARY" checkout <base-branch>
 git -C "$PRIMARY" pull
 git -C "$PRIMARY" merge --squash "$FEATURE"
 git -C "$PRIMARY" commit -m "<imperative summary> (ref <ticket-id>)"
+# Non-ledger subjects only; for ledgers use the per-pair post-squash recipe below.
 (cd "$PRIMARY" && <the Step 1 set>)
 ```
 
 The plan was already removed and the telemetry record sealed on the branch, so the staged squash tree carries the spec, the telemetry record, and the implementation - never the plan.
 
-The post-squash re-verify is not optional - `git merge --squash` can surface conflict-resolution mistakes the worktree-side run couldn't catch.
+The post-squash re-verify is not optional - `git merge --squash` can surface conflict-resolution mistakes the worktree-side run couldn't catch. For a ledger, run the per-pair post-squash recipe in [verification-set.md](reference/verification-set.md) instead of the non-ledger subshell above.
 
 Cleanup worktree (Step 6), then, if Step 6 removed the worktree, `git -C "$PRIMARY" branch -D "$FEATURE"`.
 

package/skills/finishing-a-development-branch/reference/legs.md

@@ -20,7 +20,7 @@ delivered: pr <url> <full delivered PR head> | squash <full squash SHA>
 verification: passed | <actual verification failure>
 ```
 
-Choose one `delivered:` alternative. Use `verification: passed` only for successful verification; preserve the error otherwise. Retain the selected spec path, recorded commands, membership and accepted task evidence before stripping the plan, and carry the receipt locations into the brief. On fresh-session retry admit a stripped plan only when every companion has a receipt; validate each receipt rather than inferring delivery from missing files. Recover commands from the spec's recorded contract, not the absent plan.
+Choose one `delivered:` alternative. Use `verification: passed` only for successful verification; preserve the error otherwise. Retain the selected spec path, recorded commands, membership and accepted task evidence before stripping the plan, and carry the receipt locations into the brief. On fresh-session retry admit a stripped plan only when every companion has a receipt; validate each receipt rather than inferring delivery from missing files. For a ledger subject, recover the gate pairs from the committed pre-strip ledger per [verification-set.md](verification-set.md#post-strip-recovery), not the spec's full verification contract. For non-ledger subjects, recover commands from the spec's recorded contract, not the absent plan.
 
 Before checkout-based verification and conformance fan-out, validate receipt identity against the selected spec, repo and recorded delivery choice; reconcile it with the selected action before delivery. Malformed, mismatched or unverifiable receipts leave the leg unlanded; stop on an unavailable boundary rather than creating duplicate delivery. Apply these proofs:
 
@@ -35,11 +35,11 @@ Never use feature-head ancestry as proof of squash delivery. Resolve the actual
 
 Exempt a leg with a validated receipt and a missing worktree from checkout-based verification and conformance. Run fresh checks for every unlanded leg; stop on a missing unlanded worktree. Handle failed-squash verification in the delivered primary through the receipt retry action above; replace feature-checkout checks with that primary verification even when the feature tree still exists.
 
-Before Step 4, run every leg's recorded verification set with that leg's worktree as command cwd, except the receipt-proven exemptions above, then perform conformance review with that leg's `cwd`, Rules and owned AC rows. Use original AC indices from `scope:`; shared rows belong to each named owner and unclaimed rows default home. Apply Step 1's hard gate and skip proof independently per leg. Route fixes and commits through `git -C <owning worktree>`, never home's checkout for companion code.
+Before Step 4, run every leg's recorded verification set with that leg's worktree as command cwd, except the receipt-proven exemptions above; for a ledger subject, use the gate pairs resolved from the ledger (the pre-strip ledger on retry) per [verification-set.md](verification-set.md). Then perform conformance review with that leg's `cwd`, Rules and owned AC rows. Use original AC indices from `scope:`; shared rows belong to each named owner and unclaimed rows default home. Apply Step 1's hard gate and skip proof independently per leg. Route fixes and commits through `git -C <owning worktree>`, never home's checkout for companion code.
 
 Retain each present member's audited head and tree, including staged, unstaged and untracked state. Immediately before delivery compare them to the current checkout; re-verify and re-review every changed leg before its delivery. Apply the same freshness check after disposition fixes and minors fixes. Aggregate closure before presenting one menu; no leg bypasses open dispositions.
 
-Apply leg-local `piGauntlet.verifyBeforeShip` evidence to commands targeting that checkout. Read each primary's `.pi/settings.json` by file and merge the preset using the existing settings rules; do not use home's `gauntlet_setting` result or home's successful test flag as companion evidence. Use the recorded verification set, including when a retry has no plan.
+Apply leg-local `piGauntlet.verifyBeforeShip` evidence to commands targeting that checkout. Read each primary's `.pi/settings.json` by file and merge the preset using the existing settings rules; do not use home's `gauntlet_setting` result or home's successful test flag as companion evidence. Use the resolved gate pairs for ledger subjects, including pre-strip ledger recovery when a retry has no plan; use the recorded verification set for non-ledger subjects. Apply [verification-set.md](verification-set.md)'s matcher advisory without adding a full-suite run.
 
 ## Execute one choice - Steps 4 and 5
 
@@ -50,7 +50,7 @@ For a PR-subject home, compose the supported existing home action with companion
 For PR, draft and squash:
 
 1. Validate existing receipts first. Skip only receipt-proven delivery. Check freshness for every unlanded leg before its delivery.
-2. Deliver each companion: for PR/draft, push with `git -C <worktree> push -u origin <branch>`, then run `gh pr create` in that worktree's cwd, adding `--draft` on every draft create. On retry of an existing PR use its URL and edit rather than duplicate create. For squash, use the existing Option 3 primary checkout/pull/merge/commit recipe and run that leg's recorded post-squash commands in the primary. Write its receipt even when those commands fail. No companion plan strip or telemetry seal runs.
+2. Deliver each companion: for PR/draft, push with `git -C <worktree> push -u origin <branch>`, then run `gh pr create` in that worktree's cwd, adding `--draft` on every draft create. On retry of an existing PR use its URL and edit rather than duplicate create. For squash, use the existing Option 3 primary checkout/pull/merge/commit recipe and run that leg's recorded post-squash commands in the primary; for a ledger, run that leg's gate pairs through [verification-set.md](verification-set.md#post-squash-execution). Write its receipt even when those commands fail. No companion plan strip or telemetry seal runs.
 3. Collect complete companion results, including validated skips. Capture the spec path and evidence before the home plan strip. Run home's strip-and-seal block with repeated `--leg <repo>=<sha|pr-url>`, one per companion. Never seal partial results. Compare collected `{ repo, sha }` or `{ repo, pr }` entries with an existing seal's `legs:` set; differences stop naming stored and collected results. Retain all receipts when the bin fails and print its output. Never write companion `.pi/gauntlet/telemetry/`.
 4. Deliver home through the selected existing recipe after successful sealing, without running a second seal lacking the companion arguments. For PR-subject row 1 retain the whole-PR base and all body-edit/closure rules. Write home's receipt, including post-squash failures. Run cleanup only for squash, after successful post-squash verification.