pi-gauntlet 7.40.1 → 7.41.1

package/extensions/lib/plan-check.ts

@@ -13,8 +13,8 @@ export interface PlanCheckFinding {
 }
 
 export interface FsPort {
-  exists(path: string): boolean;
-  glob(pattern: string): string[];
+  exists(path: string, leg?: string): boolean;
+  glob(pattern: string, leg?: string): string[];
 }
 
 export function sha256(bytes: Uint8Array): string {
@@ -43,6 +43,7 @@ interface TestsBullet {
 }
 
 interface Task {
+  leg?: string;
   number: number;
   line: number;
   text: string;
@@ -221,7 +222,7 @@ function parsePlan(planText: string): ParsedPlan {
 
     for (let k = i; k <= bodyEndIdx; k++) {
       const line = lines[k];
-      if (filesLine === undefined && /^\*\*Files:\*\*/.test(line)) {
+      if (filesLine === undefined && /^(?:\*\*Files:\*\*|Files:)/.test(line)) {
         filesLine = k + 1;
         let p = k + 1;
         while (p <= bodyEndIdx) {
@@ -509,7 +510,7 @@ function checkTestsBlock(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
   const push = (task: Task, line: number, text: string, reason: string) =>
     findings.push({ check: "tests-block", line, text, reason: `Task ${task.number}: ${reason}` });
   const createPaths = new Set(
-    parsed.tasks.flatMap((t) => t.files.filter((f) => f.kind === "create").map((f) => stripLineSuffix(f.path))),
+    parsed.tasks.flatMap((t) => t.files.filter((f) => f.kind === "create").map((f) => `${t.leg ?? ""}\0${stripLineSuffix(f.path)}`)),
   );
   const header = headerSegments(parsed);
 
@@ -519,7 +520,7 @@ function checkTestsBlock(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
 
     for (const f of testEntries) {
       const p = stripLineSuffix(f.path);
-      if (!createPaths.has(p) && !fs.exists(p)) push(task, f.line, f.text, `unknown \`Test:\` path "${p}" (neither exists nor is a Create: path of any task)`);
+      if (!createPaths.has(`${task.leg ?? ""}\0${p}`) && !fs.exists(p, task.leg)) push(task, f.line, f.text, `unknown \`Test:\` path "${p}" (neither exists nor is a Create: path of any task)`);
     }
 
     if (task.testsMisplacedLines.length > 0) {
@@ -599,7 +600,7 @@ function checkBaselineLines(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[]
           const found = anchors(segment);
           const created = [...creates].filter(p => segment.split(" ").some(token => token === p || token.startsWith(p + "::") || token.startsWith(p + "#") || token.startsWith(p + ":")));
           for (const path of created) push(bullet, `baseline: pass via \`${match[2]}\` segment \`${segment}\` anchors Create: path ${path}`);
-          if (!found.some(p => !creates.has(p) && fs.exists(p))) push(bullet, `baseline: pass via \`${match[2]}\` segment \`${segment}\` anchors no existing Test: path`);
+          if (!found.some(p => !creates.has(p) && fs.exists(p, task.leg))) push(bullet, `baseline: pass via \`${match[2]}\` segment \`${segment}\` anchors no existing Test: path`);
         }
       }
     }
@@ -877,7 +878,7 @@ function checkPathsExist(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
       if (isGlob(path)) {
         let matches: string[];
         try {
-          matches = fs.glob(path);
+          matches = fs.glob(path, task.leg);
         } catch (err) {
           findings.push({
             check: "paths-exist",
@@ -895,7 +896,7 @@ function checkPathsExist(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
             reason: `Modify: glob "${path}" matched no files`,
           });
         }
-      } else if (!fs.exists(path)) {
+      } else if (!fs.exists(path, task.leg)) {
         findings.push({
           check: "paths-exist",
           line: f.line,
@@ -967,16 +968,17 @@ function fileEntries(task: Task): { path: string; kind: "literal" | "glob"; role
 function checkWaveFileDisjointness(parsed: ParsedPlan, fs: FsPort): PlanCheckFinding[] {
   const findings: PlanCheckFinding[] = [];
   const globCache = new Map<string, string[] | Error>();
-  const expand = (pattern: string): string[] | Error => {
-    const cached = globCache.get(pattern);
+  const expand = (pattern: string, leg?: string): string[] | Error => {
+    const key = `${leg ?? ""}\0${pattern}`;
+    const cached = globCache.get(key);
     if (cached !== undefined) return cached;
     let result: string[] | Error;
     try {
-      result = fs.glob(pattern);
+      result = fs.glob(pattern, leg);
     } catch (err) {
       result = err instanceof Error ? err : new Error(String(err));
     }
-    globCache.set(pattern, result);
+    globCache.set(key, result);
     return result;
   };
 
@@ -985,6 +987,7 @@ function checkWaveFileDisjointness(parsed: ParsedPlan, fs: FsPort): PlanCheckFin
     if (tasks.length < 2) continue;
     for (let i = 0; i < tasks.length; i++) {
       for (let j = i + 1; j < tasks.length; j++) {
+        if (tasks[i].leg !== tasks[j].leg) continue;
         const a = fileEntries(tasks[i]);
         const b = fileEntries(tasks[j]);
         for (const ea of a) {
@@ -995,16 +998,16 @@ function checkWaveFileDisjointness(parsed: ParsedPlan, fs: FsPort): PlanCheckFin
             if (ea.kind === "literal" && eb.kind === "literal") {
               overlap = ea.path === eb.path;
             } else if (ea.kind === "glob" && eb.kind === "literal") {
-              const exp = expand(ea.path);
+              const exp = expand(ea.path, tasks[i].leg);
               if (exp instanceof Error) errFinding = globErrFinding(wave, ea.path, exp);
               else overlap = exp.includes(eb.path);
             } else if (ea.kind === "literal" && eb.kind === "glob") {
-              const exp = expand(eb.path);
+              const exp = expand(eb.path, tasks[j].leg);
               if (exp instanceof Error) errFinding = globErrFinding(wave, eb.path, exp);
               else overlap = exp.includes(ea.path);
             } else {
-              const expA = expand(ea.path);
-              const expB = expand(eb.path);
+              const expA = expand(ea.path, tasks[i].leg);
+              const expB = expand(eb.path, tasks[j].leg);
               if (expA instanceof Error) errFinding = globErrFinding(wave, ea.path, expA);
               else if (expB instanceof Error) errFinding = globErrFinding(wave, eb.path, expB);
               else overlap = expA.some((p) => expB.includes(p));
@@ -1134,6 +1137,101 @@ function checkWaiverLiteral(parsed: ParsedPlan): PlanCheckFinding[] {
   return findings;
 }
 
+export function parseLegs(specText: string): { repo: string; body: string; line: number }[] {
+  const lines = specText.split("\n");
+  const mask = fenceMask(lines);
+  const legs: { repo: string; body: string; line: number }[] = [];
+  let inside = false;
+  let current: typeof legs[number] | undefined;
+  for (const [i, line] of lines.entries()) {
+    if (mask[i]) continue;
+    if (/^## /.test(line)) { inside = /^## Legs\s*$/.test(line); current = undefined; continue; }
+    if (!inside) continue;
+    const match = /^### Leg: (\S+)\s*$/.exec(line);
+    if (match) { current = { repo: match[1].toLowerCase(), body: "", line: i + 1 }; legs.push(current); }
+    else if (current) current.body += line + "\n";
+  }
+  return legs;
+}
+
+export function legOwnership(specText: string) {
+  const legs = parseLegs(specText);
+  const findings: PlanCheckFinding[] = [];
+  const lines = specText.split("\n");
+  const mask = fenceMask(lines);
+  let inAcceptance = false;
+  let count = 0;
+  for (const [i, line] of lines.entries()) {
+    if (mask[i]) continue;
+    if (/^##\s+/.test(line)) inAcceptance = /^## Acceptance criteria\s*$/i.test(line);
+    else if (inAcceptance && /^- \[[ xX]\]\s+/.test(line)) count++;
+  }
+  const owners = Array.from({ length: count }, () => [] as string[]);
+  if (legs.length > 1) {
+    const seen = new Set<string>();
+    for (const leg of legs) {
+      const scopes = leg.body.split("\n").filter(l => /^scope:/.test(l));
+      const value = scopes[0]?.slice(6).trim() ?? "";
+      const ids = [...value.matchAll(/AC ([1-9]\d*)/g)].map(m => Number(m[1]));
+      if (seen.has(leg.repo) || scopes.length !== 1 || (value !== "none" && (!/^AC [1-9]\d*(?:, AC [1-9]\d*)*$/.test(value) || new Set(ids).size !== ids.length || ids.some(n => n > count || !Number.isSafeInteger(n))))) {
+        findings.push({ check: "leg-scope", line: leg.line, text: leg.repo, reason: "expected exactly one scope: none or scope: AC n, AC m with unique original AC indices" });
+      } else for (const n of ids) owners[n - 1].push(leg.repo);
+      seen.add(leg.repo);
+    }
+    for (const owner of owners) if (!owner.length) owner.push(legs[0].repo);
+  }
+  return { legs, owners, findings };
+}
+
+function coordinatedMetadata(lines: string[], legs: ReturnType<typeof parseLegs>, pairs: { ac: number; leg: string }[], add: (i: number, reason: string) => void) {
+  const header = (key: string) => lines.flatMap((l, i) => l.startsWith(key + ":") ? [{ value: l.slice(key.length + 1).trim(), i }] : []);
+  const one = (key: string, pattern: RegExp) => {
+    const rows = header(key);
+    if (rows.length !== 1 || !pattern.test(rows[0]?.value ?? "")) add(rows[0]?.i ?? 0, `invalid or missing ${key} header`);
+    return rows[0]?.value;
+  };
+  const sha = /^[a-f0-9]{7,40}$/;
+  const base = one("base", sha);
+  const iterations = one("iterations", /^(?:0|[1-9]\d*)$/);
+  const cap = one("cap", /^[1-9]\d*$/);
+  if (!Number.isSafeInteger(Number(iterations))) add(0, "iterations must be a safe integer");
+  if (!Number.isSafeInteger(Number(cap))) add(0, "cap must be a safe integer");
+  for (const [i, l] of lines.entries()) {
+    const m = /^(base|seeded) ([^:]+):/.exec(l);
+    if (m && !legs.some(leg => leg.repo === m[2].toLowerCase())) add(i, "foreign member header");
+  }
+  for (const [index, leg] of legs.entries()) {
+    for (const key of ["base", "seeded"]) {
+      const rows = lines.flatMap((l, i) => {
+        const m = /^(base|seeded) ([^:]+):\s*(.*)$/.exec(l);
+        return m && m[1] === key && m[2].toLowerCase() === leg.repo ? [{ value: m[3], i }] : [];
+      });
+      if (rows.length !== 1 || !(key === "base" ? sha : /^(no|yes)$/).test(rows[0]?.value ?? "")) add(rows[0]?.i ?? 0, `invalid or missing ${key} ${leg.repo}`);
+      if (key === "base" && index === 0 && rows[0]?.value !== base) add(rows[0]?.i ?? 0, "home base mismatch");
+    }
+  }
+  const pending = header("pending");
+  if (pending.length > 1) add(pending[1].i, "duplicate pending tuple");
+  for (const row of pending) {
+    const m = /^(seed|[1-9]\d*) \| (\S+) \| ([a-f0-9]{7,40})$/.exec(row.value);
+    const repo = m?.[2].toLowerCase();
+    if (!m || !legs.slice(1).some(l => l.repo === repo) || (m[1] !== "seed" && pairs[Number(m[1]) - 1]?.leg !== repo)) add(row.i, "invalid pending tuple or target leg");
+  }
+  const mapping = lines.findIndex(l => l === "## Leg mapping");
+  if (lines.filter(l => l === "## Leg mapping").length > 1) add(mapping, "duplicate leg mapping section");
+  let i = mapping + 1;
+  while (lines[i]?.trim() === "") i++;
+  if (mapping < 0 || !/^\|\s*row\s*\|\s*ac\s*\|\s*leg\s*\|$/.test(lines[i] ?? "") || !/^\|\s*-+\s*\|\s*-+\s*\|\s*-+\s*\|$/.test(lines[i + 1] ?? "")) { add(Math.max(mapping, 0), "missing leg mapping table"); return; }
+  let count = 0;
+  for (i += 2; lines[i]?.startsWith("|"); i++) {
+    const cells = lines[i].split("|").slice(1, -1).map(c => c.trim());
+    const expected = pairs[count];
+    if (!expected || cells.length !== 3 || cells[0] !== String(count + 1) || cells[1] !== String(expected.ac) || cells[2].toLowerCase() !== expected.leg) add(i, "leg mapping must match original AC and membership order exactly once");
+    count++;
+  }
+  if (count !== pairs.length) add(Math.max(mapping, 0), "missing leg mapping entries");
+}
+
 function checkLedger(planText: string, specText: string): PlanCheckFinding[] {
   const findings: PlanCheckFinding[] = [];
   const dispositions: boolean[] = [];
@@ -1150,8 +1248,13 @@ function checkLedger(planText: string, specText: string): PlanCheckFinding[] {
     if (/^- \[[ xX]\]\s+/.test(line)) dispositions.push(false);
     else if (dispositions.length && /^\s*(?:deviates|deferred|elsewhere):/.test(line)) dispositions[dispositions.length - 1] = true;
   }
+  const ownership = legOwnership(specText);
+  const pairs = ownership.owners.flatMap((owners, i) => owners.map(leg => ({ ac: i + 1, leg })));
+  const coordinated = ownership.legs.length > 1;
+  const expectedDispositions = coordinated ? pairs.map(pair => dispositions[pair.ac - 1]) : dispositions;
   const lines = planText.split("\n");
   const add = (i: number, reason: string) => findings.push({ check: "ledger", line: i + 1, text: lines[i] ?? "", reason });
+  if (coordinated) coordinatedMetadata(lines, ownership.legs, pairs, add);
   const header = lines.findIndex(l => /^\|\s*row\s*\|\s*status\s*\|\s*attempts\s*\|\s*evidence\s*\|$/.test(l));
   if (header < 0) {
     add(0, "missing ledger table");
@@ -1164,22 +1267,35 @@ function checkLedger(planText: string, specText: string): PlanCheckFinding[] {
     const [row, status, attempts, evidence] = cells;
     count++;
     if (cells.length !== 4 || !lines[i].endsWith("|")) { add(i, "expected four ledger cells"); continue; }
-    if (row !== String(count) || count > dispositions.length) add(i, "expected exactly one row per spec AC in order");
+    if (row !== String(count) || count > expectedDispositions.length) add(i, "expected exactly one row per spec AC in order");
     if (!["open", "done", "failed", "cut"].includes(status)) add(i, "invalid ledger status");
-    else if ((status === "cut") !== dispositions[count - 1]) add(i, "status does not match spec disposition");
+    else if ((status === "cut") !== expectedDispositions[count - 1]) add(i, "status does not match spec disposition");
     if (!/^\d+$/.test(attempts) || !Number.isSafeInteger(Number(attempts))) add(i, "attempts must be a non-negative integer");
     if (!evidence && status !== "open") add(i, "evidence is required on non-open rows");
     if (/<[^>]*>|\b(?:TODO|TBD|probably)\b|etc\./i.test(evidence)) add(i, "placeholder in ledger evidence");
   }
-  if (count !== dispositions.length || count === 0) add(header, "expected exactly one row per spec AC");
+  if (count !== expectedDispositions.length || count === 0) add(header, "expected exactly one row per spec AC");
   return findings;
 }
 
 export function checkPlan(planText: string, specText: string, fs: FsPort): PlanCheckFinding[] {
   try {
+    const ownership = legOwnership(specText);
+    if (ownership.findings.length) return ownership.findings;
     if (planText.split("\n", 1)[0] === "# Ledger - loop engine") return checkLedger(planText, specText);
     const parsed = parsePlan(planText);
     const findings: PlanCheckFinding[] = [];
+    if (ownership.legs.length) {
+      for (const task of parsed.tasks) {
+        const first = parsed.lines[task.line];
+        const explicit = /^Leg: (\S+)\s*$/.exec(first ?? "");
+        task.leg = explicit?.[1].toLowerCase() ?? ownership.legs[0].repo;
+        if (!ownership.legs.some(l => l.repo === task.leg)) findings.push({ check: "leg-unknown", line: task.line + 1, text: first, reason: `unknown task leg ${task.leg}` });
+        if (parsed.lines.slice(task.line + (explicit ? 1 : 0), task.bodyEndLine).some(l => /^Leg:/.test(l))) findings.push({ check: "leg-unknown", line: task.line, text: task.text, reason: "Leg: must be the first line after the task heading" });
+      }
+      if (findings.length) return findings;
+      for (const wave of parsed.waves) if (new Set(parsed.tasks.filter(t => t.waveNumber === wave.number).map(t => t.leg)).size > 1) findings.push({ check: "wave-leg", line: wave.line, text: wave.text, reason: "wave mixes task legs" });
+    }
 
     if (parsed.waves.length === 0 && parsed.tasks.length === 0) {
       if (parsed.waves.length === 0) {
@@ -1206,7 +1322,20 @@ export function checkPlan(planText: string, specText: string, fs: FsPort): PlanC
     findings.push(...checkAnchorResolution(parsed, specLines));
     findings.push(...checkPathsExist(parsed, fs));
     findings.push(...checkTestsBlock(parsed, fs));
-    findings.push(...checkBaselineLines(parsed, fs));
+    if (ownership.legs.length) {
+      const declarations = parsed.lines.slice(0, parsed.header.separatorLine ?? 0).flatMap((line, i) => {
+        const m = /^Baseline (\S+): ([a-f0-9]{7,40})$/.exec(line);
+        return m ? [{ repo: m[1].toLowerCase(), sha: m[2], line: i + 1 }] : [];
+      });
+      for (const leg of ownership.legs) {
+        const tasks = parsed.tasks.filter(t => t.leg === leg.repo);
+        findings.push(...checkBaselineLines({ ...parsed, tasks }, fs));
+        const declarationsForLeg = declarations.filter(d => d.repo === leg.repo);
+        if (declarationsForLeg.length !== 1) findings.push({ check: "baseline-line", line: 0, text: leg.repo, reason: "expected one Baseline declaration per leg" });
+        for (const task of tasks) for (const bullet of task.testsBaseline) if (bullet.value.split(" ")[0] !== declarationsForLeg[0]?.sha) findings.push({ check: "baseline-line", line: bullet.line, text: bullet.text, reason: `Task ${task.number}: baseline differs from ${leg.repo} declaration` });
+      }
+      for (const declaration of declarations) if (!ownership.legs.some(l => l.repo === declaration.repo)) findings.push({ check: "baseline-line", line: declaration.line, text: declaration.repo, reason: "unknown baseline leg" });
+    } else findings.push(...checkBaselineLines(parsed, fs));
     findings.push(...parsed.openQuestions.findings);
     const requiredLiterals = computeRequiredLiteralsPerTask(parsed, specLines);
     findings.push(...checkPlaceholderScan(parsed, requiredLiterals));

package/extensions/lib/telemetry-record.test.ts

@@ -228,3 +228,14 @@ test("derive engine uses the latest event, defaults legacy runs, and counts loop
   assert.equal(derive(back, now).iterations, 3);
   assert.ok(capEvents(rec.events, 0).events.some((e) => e.kind === "engine"));
 });
+
+test("legs round-trip and malformed stored legs are rejected", () => {
+  const rec = newRecord({ spec: "x", session: "s", now: "now", runId: "r" });
+  for (const legs of [[{ repo: "one", sha: "abc" }, { repo: "two", pr: "https://example.test/pull/1" }]]) {
+    (rec as any).legs = legs;
+    assert.deepEqual((parseRecord(serializeRecord(rec)) as any).legs, legs);
+  }
+  for (const legs of [null, {}, [{ repo: "" , sha: "abc" }], [{ repo: "one" }], [{ repo: "one", sha: "" }]]) {
+    assert.equal(parseRecord(serializeRecord({ ...rec, legs } as any)), undefined);
+  }
+});

package/extensions/lib/telemetry-record.ts

@@ -97,7 +97,13 @@ export interface Derived {
   spec_edits_after_ship: number; diff?: DiffSummary; modified_files?: string[]; council?: CouncilBlock; spec_writes: Accumulators["spec_writes"]; events_dropped: number;
 }
 export type RecordStatus = "in_progress" | "shipped" | "abandoned";
+export type TelemetryLeg = { repo: string; sha: string; pr?: never } | { repo: string; pr: string; sha?: never };
+export const validLegs = (legs: unknown): legs is TelemetryLeg[] => Array.isArray(legs) && legs.every((leg) =>
+  leg && typeof leg.repo === "string" && leg.repo.trim().length > 0 &&
+  ((typeof leg.sha === "string" && leg.sha.trim().length > 0 && leg.pr === undefined) ||
+   (typeof leg.pr === "string" && /^https?:\/\/\S+$/.test(leg.pr) && leg.sha === undefined)));
 export interface TelemetryRecord {
+  legs?: TelemetryLeg[];
   schema: 1; spec: string; run_id: string; branch?: string; status: RecordStatus; created_at: string; approved_at?: string; shipped_at?: string; abandoned_at?: string;
   supersedes?: string[]; fixes?: string[]; versions?: Record<string, string>; author?: { name?: string; email?: string }; agent_overrides?: Record<string, unknown>;
   sessions: string[]; derived: Derived; accumulators: Record<string, Accumulators>; events: TelemetryEvent[];
@@ -179,6 +185,7 @@ export function parseRecord(text: string): TelemetryRecord | undefined {
   if (!doc || typeof doc !== "object") return undefined;
   const d = doc as Partial<TelemetryRecord>;
   if (d.schema !== 1 || typeof d.spec !== "string" || typeof d.run_id !== "string") return undefined;
+  if (d.legs !== undefined && !validLegs(d.legs)) return undefined;
   const accumulators = Object.fromEntries(Object.entries(d.accumulators ?? {}).flatMap(([session, block]) =>
     block && typeof block === "object" && !Array.isArray(block)
       ? [[session, { ...emptyAccumulators(), ...block }]]

package/extensions/phase-tracker.test.ts

@@ -1,6 +1,8 @@
 import assert from "node:assert/strict";
-import { after, test } from "node:test";
-import { execFileSync } from "node:child_process";
+import { after, mock, test } from "node:test";
+import childProcess, { execFileSync } from "node:child_process";
+import fs from "node:fs";
+import { syncBuiltinESMExports } from "node:module";
 import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
@@ -1546,7 +1548,7 @@ test("shape guard: a one-task tasks wave and a chain step are not the lone shape
   assert.equal(await firstCallResult(h, "s2", { chain: [{ agent: "implementer", task: "fix" }] }), undefined);
 });
 
-const waveResult = (id: string, results: { agent: string; exitCode: number }[], isError = false) => ({
+const waveResult = (id: string, results: { agent: string; exitCode: number; interrupted?: boolean }[], isError = false) => ({
   toolName: "subagent",
   toolCallId: id,
   isError,
@@ -1555,6 +1557,95 @@ const waveResult = (id: string, results: { agent: string; exitCode: number }[],
 });
 const okWave = (id: string) => waveResult(id, [{ agent: "implementer", exitCode: 0 }]);
 
+for (const delivery of ["live", "session_start", "session_switch", "session_fork", "session_tree"]) {
+  test(`closure completion excludes interrupted children per result: ${delivery}`, async () => {
+    const cwd = tempCwd();
+    const reviewer = { agent: "conformance-reviewer", exitCode: 0 };
+    for (const row of [
+      { name: "interrupted single/resumed child", results: [{ ...reviewer, interrupted: true }], qualifies: false },
+      { name: "legacy success", results: [reviewer], qualifies: true },
+      { name: "explicit uninterrupted", results: [{ ...reviewer, interrupted: false }], qualifies: true },
+      { name: "nonzero exit", results: [{ ...reviewer, exitCode: 1 }], qualifies: false },
+      { name: "exact agent match", results: [{ agent: "conformance-reviewer-extra", exitCode: 0 }], qualifies: false },
+      { name: "empty async/management", results: [], qualifies: false },
+      { name: "mixed parallel", results: [{ ...reviewer, interrupted: true }, reviewer], qualifies: true },
+      { name: "earlier success in errored chain", results: [reviewer, { agent: "implementer", exitCode: 1 }], isError: true, qualifies: true },
+    ]) {
+      const result = waveResult("review", row.results, row.isError);
+      const h = harness({ cwd, branch: verifyBranch() });
+      await h.emit("session_start");
+      if (delivery === "live") await h.emitEvent("tool_result", result);
+      else {
+        h.setBranch(verifyBranch([{ type: "message", message: { role: "toolResult", ...result } }]));
+        await h.emit(delivery);
+      }
+      assert.equal((await completePhase(h, "verify")).details.error,
+        row.qualifies ? undefined : "no conformance-reviewer dispatch observed", row.name);
+    }
+  });
+
+  test(`cadence completion excludes interrupted children and preserves ties: ${delivery}`, async () => {
+    const cwd = tempCwd();
+    const implementer = { agent: "implementer", exitCode: 0 };
+    for (const row of [
+      { name: "interrupted implementer", results: [{ ...implementer, interrupted: true }], prior: false, warns: false },
+      { name: "interrupted SR", results: [{ agent: "spec-reviewer", exitCode: 0, interrupted: true }], prior: true, warns: true },
+      { name: "interrupted CR", results: [{ agent: "code-reviewer", exitCode: 0, interrupted: true }], prior: true, warns: true },
+      { name: "legacy implementer", results: [implementer], prior: false, warns: true },
+      { name: "explicit uninterrupted SR", results: [{ agent: "spec-reviewer", exitCode: 0, interrupted: false }], prior: true, warns: false },
+      { name: "failed reviewer", results: [{ agent: "code-reviewer", exitCode: 1 }], prior: true, warns: true },
+      { name: "wrong agent", results: [{ agent: "spec-reviewer-extra", exitCode: 0 }], prior: true, warns: true },
+      { name: "empty async/management", results: [], prior: true, warns: true },
+      { name: "mixed parallel tie", results: [implementer, { agent: "spec-reviewer", exitCode: 0 }, { agent: "code-reviewer", exitCode: 0, interrupted: true }], prior: false, warns: false },
+      { name: "earlier review in errored chain", results: [{ agent: "code-reviewer", exitCode: 0 }, { ...implementer, interrupted: true }], prior: true, isError: true, warns: false },
+    ]) {
+      const prior = row.prior ? [subagentResult(["implementer"])] : [];
+      const result = waveResult("work", row.results, row.isError);
+      const h = harness({ cwd, branch: implementBranch(prior) });
+      await h.emit("session_start");
+      if (delivery === "live") await h.emitEvent("tool_result", result);
+      else {
+        h.setBranch(implementBranch([...prior, { type: "message", message: { role: "toolResult", ...result } }]));
+        await h.emit(delivery);
+      }
+      await h.emitEvent("tool_call", commitCall("commit"));
+      const [warning] = await h.emitEvent("tool_result", commitResult("commit")) as ({ content: { text: string }[] } | undefined)[];
+      assert.equal(warning !== undefined, row.warns, row.name);
+      if (warning) assert.match(warning.content[0].text, /no spec-reviewer or code-reviewer observed/, row.name);
+    }
+  });
+}
+
+test("interrupted implementer waves still spend rounds and granted credits and nudge open tasks live and on replay", async () => {
+  const cwd = tempCwd({ piGauntlet: { closureReview: { maxFixRounds: 1 } } });
+  const interrupted = waveResult("paused", [{ agent: "implementer", exitCode: 0, interrupted: true }]);
+  for (const delivery of ["live", "session_start"]) {
+    const trail = [subagentResult(["conformance-reviewer"]), taskSnapshot([{ name: "repair", status: "in_progress" }])];
+    const h = harness({ cwd, branch: verifyBranch(trail) });
+    await h.emit("session_start");
+    if (delivery === "live") {
+      const [nudge] = await h.emitEvent("tool_result", interrupted) as { content: { text: string }[] }[];
+      assert.match(nudge.content[0].text, /0: repair \(in_progress\)/);
+    } else {
+      h.setBranch(verifyBranch([...trail, { type: "message", message: { role: "toolResult", ...interrupted } }]));
+      await h.emit(delivery);
+    }
+    assert.equal((await firstCallResult(h, "blocked", implementerWave()))?.block, true);
+    assert.equal((await grant(h, "grant", { rounds: 1, reason: "one more repair" })).details.error, undefined);
+    assert.equal(await firstCallResult(h, "funded", implementerWave()), undefined);
+    if (delivery === "live") await h.emitEvent("tool_result", interrupted);
+    else {
+      h.setBranch(verifyBranch([...trail,
+        { type: "message", message: { role: "toolResult", ...interrupted } }, grantResult(1),
+        { type: "message", message: { role: "toolResult", ...interrupted } },
+      ]));
+      await h.emit(delivery);
+    }
+    assert.equal((await firstCallResult(h, "spent", implementerWave()))?.block, true);
+    assert.equal((await grant(h, "again", { rounds: 1, reason: "another repair" })).details.error, undefined);
+  }
+});
+
 const guardedHarness = (settings: unknown, extra: unknown[] = []) =>
   harness({ cwd: tempCwd(settings), branch: verifyBranch([subagentResult(["conformance-reviewer"]), ...extra]) });
 
@@ -2451,3 +2542,110 @@ for (const event of ["session_start", "session_switch", "session_fork", "session
     });
   }
 }
+
+for (const pattern of [".worktrees/<name>", "../companion-<name>"]) test(`plan_check resolves clone URL companions with ${pattern}`, async (t) => {
+  const primary = gitPrimary().primary;
+  const companion = gitPrimary().primary;
+  const unselected = gitPrimary().primary;
+  const name = companion.split("/").at(-1)!;
+  const repo = `team/${name}`;
+  const cloneUrl = `git@example.test:${repo}.git`;
+  execFileSync("git", ["config", "remote.origin.url", `https://example.test/${repo}.git`], { cwd: companion });
+  const branch = "feature/legs";
+  const companionRoot = join(companion, pattern.replace("<name>", "feature-legs"));
+  execFileSync("git", ["worktree", "add", "-b", branch, companionRoot], { cwd: companion, stdio: "pipe" });
+  if (pattern.startsWith("..")) tempDirs.push(companionRoot);
+  mkdirSync(join(primary, ".pi"), { recursive: true });
+  writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), `## shape-ticket\n- sibling: ${cloneUrl}\n- sibling: git@example.test:other/${unselected.split("/").at(-1)!}.git\n`);
+  const { planPath } = writePlanFixture(primary, {
+    mutateSpec: s => s + `\n## Legs\n### Leg: team/repo-a\nscope: none\nbranch: ${branch}\n### Leg: ${repo}\nscope: none\nbranch: ${branch}\ncontract: home: ${pattern}\n`,
+    mutatePlan: s => s.replace("---", `Baseline team/repo-a: abc1234\nBaseline ${repo}: def5678\n---`).replace("### Task 2: Implement naming", `## Wave 2 - Companion\n\n### Task 2: Implement naming\nLeg: ${repo.toUpperCase()}`).replace("abc1234 skipped - lib/task2", "def5678 skipped - lib/task2"),
+  });
+  rmSync(join(primary, "file-b.ts"));
+  writeFileSync(join(companionRoot, "file-b.ts"), "companion only\n");
+  const h = harness({ cwd: primary });
+  await h.emit("session_start");
+  const tool = h.tools.find(t => t.name === "plan_check")!;
+  const probes: string[] = [];
+  const spies: { mock: { restore(): void } }[] = [];
+  if (unselected) {
+    for (const method of ["existsSync", "realpathSync", "statSync", "readFileSync", "readdirSync"] as const) {
+      const original = fs[method];
+      spies.push(mock.method(fs, method, (...args: any[]) => {
+        if (String(args[0]).startsWith(unselected)) probes.push(`${method}: ${args[0]}`);
+        return (original as Function)(...args);
+      }));
+    }
+    const original = childProcess.execFileSync;
+    spies.push(mock.method(childProcess, "execFileSync", (...args: any[]) => {
+      if (String(args[2]?.cwd).startsWith(unselected)) probes.push(`git: ${args[2].cwd}`);
+      return (original as Function)(...args);
+    }));
+    syncBuiltinESMExports();
+  }
+  try {
+    const result = await tool.execute("legs", { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings?: unknown } };
+    assert.equal(result.details.status, "pass", JSON.stringify(result.details.findings));
+    assert.deepEqual(probes, [], "unselected sibling must receive no filesystem or Git probes");
+    writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), `## shape-ticket\n- sibling: https://user@example.test:7999/${repo}.git/\n`);
+    const https = await tool.execute("https", { planPath }, undefined, undefined, h.ctx) as { details: { status: string } };
+    assert.equal(https.details.status, "pass");
+    writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), "## shape-ticket\n- sibling: ../viewer\n");
+    const invalid = await tool.execute("invalid", { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings: { check: string; reason: string }[] } };
+    assert.equal(invalid.details.status, "fail");
+    assert.ok(invalid.details.findings.some(f => f.check === "input" && f.reason.includes("- sibling: ../viewer") && f.reason.includes("invalid configuration")));
+    const plain = realpathSync(tempCwd());
+    const missingName = `${name}-missing`;
+    const cases = [
+      { name: "PATH not found", value: `https://example.test/team/${missingName}.git`, reason: "PATH not found" },
+      { name: "not a checkout", value: `https://example.test/team/${plain.split("/").at(-1)}.git`, reason: "not a checkout" },
+      { name: "no origin", value: cloneUrl, origin: null, reason: "no origin" },
+      { name: "unparseable stored origin", value: cloneUrl, origin: "local-origin", reason: "unparseable origin" },
+      { name: "wrong repo", value: cloneUrl, origin: `https://example.test/other/${name}.git`, reason: "wrong repo" },
+      { name: "home primary", value: `https://example.test/team/${primary.split("/").at(-1)}.git`, reason: "PATH equals home primary" },
+      ...["viewer", "/srv/git/viewer.git", "file:///srv/git/viewer.git"].map(value => ({ name: `invalid ${value}`, value, reason: "invalid configuration" })),
+      { name: "stored trailing slash", value: cloneUrl, origin: `https://example.test/${repo}.git/` },
+      { name: "stored origin with insteadOf", value: cloneUrl, origin: `https://example.test/${repo}.git`, rewrite: true },
+    ];
+    for (const row of cases) await t.test(row.name, async () => {
+      const stored = "origin" in row ? row.origin : `https://example.test/${repo}.git`;
+      if (stored === null) execFileSync("git", ["config", "--unset", "remote.origin.url"], { cwd: companion });
+      else execFileSync("git", ["config", "remote.origin.url", stored!], { cwd: companion });
+      const rewriteKey = "url.https://rewritten.test/other/.insteadOf";
+      if ("rewrite" in row) execFileSync("git", ["config", rewriteKey, "https://example.test/team/"], { cwd: companion });
+      const line = `- sibling: ${row.value}`;
+      writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), `## shape-ticket\n${line}\n`);
+      try {
+        const result = await tool.execute(row.name, { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings?: { check: string; reason: string }[] } };
+        assert.equal(result.details.status, row.reason ? "fail" : "pass", JSON.stringify(result.details.findings));
+        if (row.reason) assert.ok(result.details.findings?.some(f => f.check === "input" && f.reason.includes(line) && f.reason.includes(row.reason!)), JSON.stringify(result.details.findings));
+      } finally {
+        if ("rewrite" in row) execFileSync("git", ["config", "--unset", rewriteKey], { cwd: companion });
+      }
+    });
+    execFileSync("git", ["config", "remote.origin.url", `https://example.test/${repo}.git`], { cwd: companion });
+    await t.test("identity precedes shared NAME without probing the other declaration", async () => {
+      writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), `## shape-ticket\n- sibling: git@example.test:other/${name}.git\n- sibling: ${cloneUrl}\n`);
+      const result = await tool.execute("identity", { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings?: unknown } };
+      assert.equal(result.details.status, "pass", JSON.stringify(result.details.findings));
+    });
+    writeFileSync(join(primary, ".pi/gauntlet-overrides.md"), `## shape-ticket\n- sibling: ${cloneUrl}\n`);
+  } finally {
+    for (const spy of spies) spy.mock.restore();
+    syncBuiltinESMExports();
+  }
+  const originalPlan = readFileSync(planPath, "utf8");
+  const foreignSpec = join(companionRoot, "foreign-spec.md");
+  writeFileSync(foreignSpec, readFileSync(join(primary, "doc/specs/spec.md")));
+  writeFileSync(planPath, originalPlan.replace("doc/specs/spec.md", foreignSpec));
+  const foreign = await tool.execute("foreign-spec", { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings: { check: string }[] } };
+  assert.equal(foreign.details.status, "fail");
+  assert.ok(foreign.details.findings.some(f => f.check === "input"));
+  writeFileSync(planPath, originalPlan);
+  rmSync(join(companionRoot, "file-b.ts"));
+  const failure = await tool.execute("legs-missing", { planPath }, undefined, undefined, h.ctx) as { details: { status: string; findings: { check: string }[] } };
+  assert.equal(failure.details.status, "fail");
+  execFileSync("git", ["worktree", "remove", "--force", companionRoot], { cwd: companion, stdio: "pipe" });
+  const missing = await tool.execute("legs-missing-root", { planPath }, undefined, undefined, h.ctx) as { details: { findings: { check: string }[] } };
+  assert.ok(missing.details.findings.some(f => f.check === "input"));
+});