pi-gauntlet 7.40.0 → 7.41.0

package/extensions/phase-tracker.ts

@@ -9,8 +9,8 @@
  * Use phase_tracker for "what stage am I in?", plan_tracker for "which task?".
  */
 
-import { existsSync, globSync, readdirSync, readFileSync, readFileSync as readFileBytes } from "node:fs";
-import { isAbsolute, join, resolve } from "node:path";
+import { existsSync, realpathSync, globSync, readdirSync, readFileSync, readFileSync as readFileBytes } from "node:fs";
+import { basename, dirname, isAbsolute, join, relative, 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";
@@ -29,7 +29,7 @@ import {
 } from "./lib/gauntlet-settings.ts";
 import { loadGauntletSettings } from "./lib/gauntlet-settings-loader.ts";
 import { checkoutOf, gitSync } from "./lib/checkout.ts";
-import { checkPlan, sha256, type FsPort, type PlanCheckFinding } from "./lib/plan-check.ts";
+import { checkPlan, legOwnership, sha256, type FsPort, type PlanCheckFinding } from "./lib/plan-check.ts";
 import {
   checkSubstep,
   dispatchLabel,
@@ -89,9 +89,9 @@ interface PlanCheckDetails {
 // child run in the result details (pi-cohort SingleResult: { agent, exitCode }).
 // Management mode and async dispatches return results: [] and fail this check.
 const qualifiesAsClosureDispatch = (details: unknown): boolean => {
-  const d = details as { results?: { agent?: unknown; exitCode?: unknown }[] } | undefined;
+  const d = details as { results?: { agent?: unknown; exitCode?: unknown; interrupted?: unknown }[] } | undefined;
   if (!d || !Array.isArray(d.results)) return false;
-  return d.results.some((r) => r?.agent === "conformance-reviewer" && r?.exitCode === 0);
+  return d.results.some((r) => r?.agent === "conformance-reviewer" && r?.exitCode === 0 && r?.interrupted !== true);
 };
 
 // One conformance fix round = one non-error subagent result carrying at least one
@@ -140,11 +140,11 @@ const CADENCE_AGENTS = ["implementer", "spec-reviewer", "code-reviewer"] as cons
 type CadenceAgent = (typeof CADENCE_AGENTS)[number];
 
 const completedCadenceAgents = (details: unknown): CadenceAgent[] => {
-  const d = details as { results?: { agent?: unknown; exitCode?: unknown }[] } | undefined;
+  const d = details as { results?: { agent?: unknown; exitCode?: unknown; interrupted?: unknown }[] } | undefined;
   if (!d || !Array.isArray(d.results)) return [];
   const seen = new Set<CadenceAgent>();
   for (const r of d.results) {
-    if (r?.exitCode === 0 && (CADENCE_AGENTS as readonly unknown[]).includes(r?.agent)) {
+    if (r?.exitCode === 0 && r?.interrupted !== true && (CADENCE_AGENTS as readonly unknown[]).includes(r?.agent)) {
       seen.add(r.agent as CadenceAgent);
     }
   }
@@ -982,9 +982,77 @@ export default function (pi: ExtensionAPI) {
           return fail([{ check: "input", line: 0, text: "", reason: `spec file unreadable at ${specAbs}` }], planAbs);
         }
         const specText = specBytes.toString("utf8");
+        const ownership = legOwnership(specText);
+        if (ownership.findings.length) return fail(ownership.findings, planAbs);
+        const specRelative = relative(root, specAbs);
+        if (ownership.legs.length && (specRelative === ".." || specRelative.startsWith("../") || isAbsolute(specRelative))) return fail([{ check: "input", line: 0, text: specPathRaw, reason: "coordinated spec must stay in the home checkout" }], planAbs);
+        const roots = new Map<string, string>();
+        if (ownership.legs.length) roots.set(ownership.legs[0].repo, root);
+        if (ownership.legs.length > 1) {
+          const inputFailure = (reason: string) => fail([{ check: "input", line: 0, text: "", reason }], planAbs);
+          const worktrees = gitSync(["worktree", "list", "--porcelain"], root);
+          const primary = /^worktree (.+)$/m.exec(worktrees.stdout)?.[1];
+          if (worktrees.code !== 0 || !primary) return inputFailure("cannot resolve home primary");
+          const overridesPath = [".pi/gauntlet-overrides.md", "gauntlet-overrides.md", "doc/gauntlet-overrides.md"].map(p => resolve(primary, p)).find(p => existsSync(p));
+          const overrides = overridesPath ? readFileSync(overridesPath, "utf8") : "";
+          const section = /^## shape-ticket\s*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m.exec(overrides)?.[1] ?? "";
+          const parseClone = (value: string) => {
+            let host: string, path: string;
+            if (/^(ssh|https?|git):\/\//.test(value)) {
+              try {
+                const url = new URL(value);
+                host = url.hostname;
+                path = url.pathname.slice(1);
+                if (url.search || url.hash) return undefined;
+              } catch { return undefined; }
+            } else {
+              if (value.includes("://")) return undefined;
+              const scp = /^(?:[^@/:\s]+@)?([^/:\s]+):([^\s]+)$/.exec(value);
+              if (!scp) return undefined;
+              [, host, path] = scp;
+            }
+            path = path.replace(/\/+$/, "").replace(/\.git$/, "");
+            const name = path.split("/").at(-1);
+            if (!host || !name || host === "." || host === ".." || name === "." || name === "..") return undefined;
+            return { name, identity: `${host}/${path}`.toLowerCase() };
+          };
+          const siblings = [...section.matchAll(/^- sibling:([^\n]*)$/gm)].map(m => ({ line: m[0], parsed: parseClone(m[1].trim()) }));
+          for (const leg of ownership.legs.slice(1)) {
+            const identifier = leg.repo.toLowerCase();
+            const byIdentity = siblings.filter(s => s.parsed?.identity.split("/").slice(-2).join("/") === identifier);
+            const matching = byIdentity.length ? byIdentity : siblings.filter(s => s.parsed?.name.toLowerCase() === basename(identifier));
+            const candidates: string[] = [];
+            for (const sibling of matching.length ? matching : siblings) {
+              const reject = (reason: string) => inputFailure(`${sibling.line}: ${reason}`);
+              if (!sibling.parsed) return reject("invalid configuration");
+              const path = join(dirname(primary), sibling.parsed.name);
+              if (!existsSync(path)) return reject(`PATH not found: ${path}`);
+              if (realpathSync(path) === realpathSync(primary)) return reject("PATH equals home primary");
+              const top = gitSync(["rev-parse", "--show-toplevel"], path);
+              if (top.code !== 0 || top.stdout.trim() !== realpathSync(path)) return reject("not a checkout");
+              const origin = gitSync(["config", "--get", "remote.origin.url"], path);
+              if (origin.code !== 0) return reject("no origin");
+              const parsedOrigin = parseClone(origin.stdout.trim());
+              if (!parsedOrigin) return reject("unparseable origin");
+              if (parsedOrigin.identity !== sibling.parsed.identity) return reject("wrong repo");
+              const repo = parsedOrigin.identity.split("/").slice(-2).join("/");
+              if (repo === identifier) candidates.push(path);
+            }
+            if (candidates.length !== 1) return inputFailure(`cannot resolve selected sibling ${leg.repo}`);
+            const branch = /^branch:\s*(\S+)\s*$/m.exec(leg.body)?.[1];
+            const home = /^(?:contract:\s*)?(?:-\s*)?home:\s*(\S+)\s*$/m.exec(leg.body)?.[1];
+            if (!branch || !home || home.split("<name>").length !== 2 || /<[^>]+>/.test(home.replace("<name>", ""))) return inputFailure(`invalid recorded branch or home pattern for ${leg.repo}`);
+            const legRoot = resolve(candidates[0], home.replace("<name>", branch.replaceAll("/", "-")));
+            const checkout = existsSync(legRoot) ? await checkoutOf(legRoot, gitSync) : undefined;
+            const expected = gitSync(["rev-parse", "--path-format=absolute", "--git-common-dir"], candidates[0]);
+            const actual = checkout ? gitSync(["rev-parse", "--path-format=absolute", "--git-common-dir"], legRoot) : undefined;
+            if (!checkout || checkout.toplevel !== legRoot || expected.code !== 0 || actual?.code !== 0 || actual.stdout.trim() !== expected.stdout.trim()) return inputFailure(`cannot resolve worktree for ${leg.repo}`);
+            roots.set(leg.repo, legRoot);
+          }
+        }
         const port: FsPort = {
-          exists: (p) => existsSync(resolve(root, p)),
-          glob: (pattern) => globSync(pattern, { cwd: root }),
+          exists: (p, leg) => existsSync(resolve(leg ? roots.get(leg)! : root, p)),
+          glob: (pattern, leg) => globSync(pattern, { cwd: leg ? roots.get(leg)! : root }),
         };
         const findings = checkPlan(planText, specText, port);
         if (findings.length > 0) return fail(findings, planAbs);

package/extensions/verify-before-ship.test.ts

@@ -1,9 +1,10 @@
 import assert from "node:assert/strict";
 import { after, test } from "node:test";
-import { mkdtempSync, rmSync } from "node:fs";
+import { mkdtempSync, rmSync, mkdirSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import registerVerifyBeforeShip from "./verify-before-ship.ts";
+import { execFileSync } from "node:child_process";
 
 const tempDirs: string[] = [];
 after(() => {
@@ -28,7 +29,7 @@ function harness() {
     for (const handler of handlers.get(name) ?? []) results.push(await handler(event, ctx));
     return results;
   };
-  return { emitEvent };
+  return { emitEvent, dir };
 }
 
 const bashCall = (id: string, command: string) => ({ toolName: "bash", toolCallId: id, input: { command } });
@@ -106,3 +107,240 @@ test("a failing recognised run does not clear", async () => {
   const warning = warningOf(await h.emitEvent("tool_result", bashResult("p1")));
   assert.match(warning ?? "", /ran without verification/);
 });
+
+test("verification belongs to its checkout and interleaved calls retain ownership", async () => {
+  const h = harness();
+  await h.emitEvent("tool_call", bashCall("a", "(cd /tmp/home-leg && npm test)"));
+  await h.emitEvent("tool_call", bashCall("b", "(cd /tmp/other-leg && npm test)"));
+  await h.emitEvent("tool_result", bashResult("a"));
+  await h.emitEvent("tool_result", bashResult("b", true));
+  await h.emitEvent("tool_call", bashCall("p", "git -C /tmp/other-leg push"));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("p"))) ?? "", /ran without verification/);
+  await h.emitEvent("tool_call", bashCall("q", "git -C /tmp/home-leg push"));
+  assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("q"))), undefined);
+});
+
+
+test("checkout policies and source invalidation stay local; chained shipping requires prior evidence", async () => {
+  const h = harness();
+  const other = mkdtempSync(join(tmpdir(), "verify-other-")); tempDirs.push(other);
+  mkdirSync(join(other, ".pi"));
+  writeFileSync(join(other, ".pi/settings.json"), JSON.stringify({ piGauntlet: { verifyBeforeShip: { testCommands: ["custom-check"] } } }));
+  for (const [id, command] of [["home", "npm test"], ["other", `(cd ${other} && custom-check)`]]) {
+    await h.emitEvent("tool_call", bashCall(id, command));
+    await h.emitEvent("tool_result", bashResult(id));
+  }
+  await h.emitEvent("tool_call", writeCall("edit", join(other, "source.ts")));
+  await h.emitEvent("tool_call", bashCall("p", `git -C ${other} push`));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("p"))) ?? "", /custom-check/);
+  await h.emitEvent("tool_call", bashCall("h", "git push"));
+  assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("h"))), undefined);
+  await h.emitEvent("tool_call", bashCall("chain", `(cd ${other} && custom-check && git push)`));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("chain"))) ?? "", /ran without verification/);
+});
+
+test("unresolved shipping targets never borrow home verification", async () => {
+  const h = harness();
+  await h.emitEvent("tool_call", bashCall("test", "npm test"));
+  await h.emitEvent("tool_result", bashResult("test"));
+  for (const command of ['git -C "$X" push', 'cd $X && git push']) {
+    await h.emitEvent("tool_call", bashCall("ship", command));
+    assert.match(warningOf(await h.emitEvent("tool_result", bashResult("ship"))) ?? "", /ran without verification/, command);
+  }
+});
+
+test("quoted test mentions do not supply evidence", async () => {
+  for (const command of ['git commit -m "npm test"', "printf 'npm test'", 'rg "npm test" .']) {
+    const h = harness();
+    await h.emitEvent("tool_call", bashCall("mention", command));
+    await h.emitEvent("tool_result", bashResult("mention"));
+    await h.emitEvent("tool_call", bashCall("ship", "git push"));
+    assert.match(warningOf(await h.emitEvent("tool_result", bashResult("ship"))) ?? "", /ran without verification/, command);
+  }
+});
+
+test("skipped or masked companion tests never supply verification", async () => {
+  // `unreached` rows never run the test in real bash; the others stay uncredited even with a successful tool result.
+  const rows: { wrap: (target: string) => string; unreached: boolean }[] = [
+    { wrap: (target) => `false && (cd ${target} && npm test); true`, unreached: true },
+    { wrap: (target) => `f() (cd ${target} && npm test)`, unreached: true },
+    { wrap: (target) => `f() { cd ${target} && npm test; }`, unreached: true },
+    { wrap: (target) => `function f { cd ${target} && npm test; }`, unreached: true },
+    { wrap: (target) => `if false; then (cd ${target} && npm test); fi`, unreached: true },
+    { wrap: (target) => `(cd ${target} && npm test) || true`, unreached: false },
+    { wrap: (target) => `false || (cd ${target} && npm test)`, unreached: false },
+    { wrap: (target) => `(cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `set +o pipefail; (cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `set -o pipefail | cat; (cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `set -o pipefail; (cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `(set -o pipefail; cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `set -o pipefail; (set +o pipefail); (cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `set -eo pipefail\n(cd ${target} && npm test | tail -50)`, unreached: false },
+    { wrap: (target) => `(cd ${target} && npm test; true)`, unreached: false },
+  ];
+  for (const { wrap, unreached } of rows) {
+    const h = harness();
+    const companion = mkdtempSync(join(tmpdir(), "verify-skipped-"));
+    tempDirs.push(companion);
+    const command = wrap(companion);
+    if (unreached) assert.equal(execFileSync("bash", ["-c", command], { encoding: "utf8" }), "", command);
+    await h.emitEvent("tool_call", bashCall("masked", command));
+    await h.emitEvent("tool_result", bashResult("masked"));
+    await h.emitEvent("tool_call", bashCall("ship", `git -C ${companion} push`));
+    assert.match(warningOf(await h.emitEvent("tool_result", bashResult("ship"))) ?? "", /ran without verification/, command);
+  }
+});
+
+test("unconditional companion test statements supply verification", async () => {
+  for (const prefix of ["true; ", "true\n", "true && "]) {
+    const h = harness();
+    const companion = mkdtempSync(join(tmpdir(), "verify-unconditional-"));
+    tempDirs.push(companion);
+    await h.emitEvent("tool_call", bashCall("test", `${prefix}(cd ${companion} && npm test)`));
+    await h.emitEvent("tool_result", bashResult("test"));
+    await h.emitEvent("tool_call", bashCall("ship", `git -C ${companion} push`));
+    assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("ship"))), undefined, prefix);
+  }
+});
+
+test("masked pipeline exits 0 in bash while npm test fails, and still warns", async () => {
+  const h = harness();
+  const companion = mkdtempSync(join(tmpdir(), "verify-pipeline-"));
+  tempDirs.push(companion);
+  const command = `set +o pipefail; (cd ${companion} && npm test | tail -50)`;
+  assert.equal(execFileSync("bash", ["-c", `${command}; echo status=$?`], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim(), "status=0");
+  assert.throws(() => execFileSync("bash", ["-c", `cd ${companion} && npm test`], { stdio: "ignore" }));
+  await h.emitEvent("tool_call", bashCall("masked", command));
+  await h.emitEvent("tool_result", bashResult("masked"));
+  await h.emitEvent("tool_call", bashCall("ship", `git -C ${companion} push`));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("ship"))) ?? "", /ran without verification/);
+});
+
+test("redirections, pipelines, and env-assignment prefixes keep baseline credit", async () => {
+  const rows: { command: (leg: string) => string; leg: boolean }[] = [
+    { command: () => "npm test 2>&1", leg: false },
+    { command: () => "npm test > log", leg: false },
+    { command: () => "cat /dev/null | npm test", leg: false },
+    { command: (leg) => `(cd ${leg} && tail -50 | npm test)`, leg: true },
+    { command: () => "CI=1 npm test", leg: false },
+    { command: (leg) => `(cd ${leg} && CI=1 npm test 2>&1)`, leg: true },
+  ];
+  for (const row of rows) {
+    const h = harness();
+    const leg = mkdtempSync(join(tmpdir(), "verify-redirect-"));
+    tempDirs.push(leg);
+    const command = row.command(leg);
+    await h.emitEvent("tool_call", bashCall("test", command));
+    await h.emitEvent("tool_result", bashResult("test"));
+    await h.emitEvent("tool_call", bashCall("ship", row.leg ? `git -C ${leg} push` : "git push"));
+    assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("ship"))), undefined, command);
+  }
+});
+
+test("settings errors appear once per chained call", async () => {
+  const h = harness();
+  mkdirSync(join(h.dir, ".pi"));
+  writeFileSync(join(h.dir, ".pi/settings.json"), "{");
+  await h.emitEvent("tool_call", bashCall("chain", "npm test && git push"));
+  const warning = warningOf(await h.emitEvent("tool_result", bashResult("chain"))) ?? "";
+  assert.equal(warning.split("gauntlet settings load error").length - 1, 1, warning);
+});
+
+test("coordinated linked worktree verification uses its primary's custom policy", async () => {
+  const h = harness();
+  const git = (...args: string[]) => execFileSync("git", ["-C", h.dir, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  git("init", "-b", "main");
+  git("-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "--allow-empty", "-m", "base");
+  const worktree = join(h.dir, "linked-feature");
+  git("worktree", "add", "-b", "feature", worktree);
+  mkdirSync(join(h.dir, ".pi"));
+  writeFileSync(join(h.dir, ".pi/settings.json"), JSON.stringify({ piGauntlet: { verifyBeforeShip: { testCommands: ["custom-check"] } } }));
+  git("remote", "add", "origin", "https://example.invalid/team/companion.git");
+  const spec = join(h.dir, "spec.md");
+  writeFileSync(spec, "## Legs\n### Leg: team/home\n### Leg: team/companion\nbranch: feature\nhome: linked-<name>\n");
+  await h.emitEvent("tool_result", { toolName: "plan_check", isError: false, details: { status: "pass", specPath: spec } });
+  for (const [id, command, warns] of [["default", "npm test", true], ["custom", "custom-check", false]] as const) {
+    await h.emitEvent("tool_call", bashCall(id, `(cd ${worktree} && ${command})`));
+    await h.emitEvent("tool_result", bashResult(id));
+    await h.emitEvent("tool_call", bashCall("ship", `git -C ${worktree} push`));
+    const warning = warningOf(await h.emitEvent("tool_result", bashResult("ship")));
+    if (warns) assert.match(warning ?? "", /custom-check/);
+    else assert.equal(warning, undefined);
+  }
+});
+
+test("real linked worktree evidence stays separate from primary post-squash verification", async () => {
+  const h = harness();
+  const git = (cwd: string, ...args: string[]) => execFileSync("git", ["-C", cwd, ...args], { encoding: "utf8", stdio: ["ignore", "pipe", "pipe"] });
+  git(h.dir, "init", "-b", "main");
+  git(h.dir, "config", "user.name", "Test");
+  git(h.dir, "config", "user.email", "test@example.invalid");
+  writeFileSync(join(h.dir, "source.ts"), "export const value = 1;\n");
+  git(h.dir, "add", ".");
+  git(h.dir, "commit", "-m", "base");
+  const worktree = join(h.dir, "linked");
+  git(h.dir, "worktree", "add", "-b", "feature", worktree);
+  writeFileSync(join(worktree, "source.ts"), "export const value = 2;\n");
+  git(worktree, "commit", "-am", "change");
+  await h.emitEvent("tool_call", bashCall("feature-test", `(cd ${worktree} && npm test)`));
+  await h.emitEvent("tool_result", bashResult("feature-test"));
+  git(h.dir, "merge", "--squash", "feature");
+  git(h.dir, "commit", "-m", "squash");
+  await h.emitEvent("tool_call", bashCall("primary-ship", "git push"));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("primary-ship"))) ?? "", /ran without verification/);
+  await h.emitEvent("tool_call", bashCall("post-squash", "npm test"));
+  await h.emitEvent("tool_result", bashResult("post-squash", true));
+  await h.emitEvent("tool_call", bashCall("failed-ship", "git push"));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("failed-ship"))) ?? "", /ran without verification/);
+  await h.emitEvent("tool_call", bashCall("retry", "npm test"));
+  await h.emitEvent("tool_result", bashResult("retry"));
+  await h.emitEvent("tool_call", bashCall("verified-ship", "git push"));
+  assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("verified-ship"))), undefined);
+  await h.emitEvent("tool_call", writeCall("feature-edit", join(worktree, "source.ts")));
+  await h.emitEvent("tool_call", bashCall("primary-still-verified", "git push"));
+  assert.equal(warningOf(await h.emitEvent("tool_result", bashResult("primary-still-verified"))), undefined);
+  await h.emitEvent("tool_call", bashCall("feature-stale", `git -C ${worktree} push`));
+  assert.match(warningOf(await h.emitEvent("tool_result", bashResult("feature-stale"))) ?? "", /ran without verification/);
+});
+
+test("fresh-session ship retry restores the home primary's policy from resume arming", async () => {
+  const h = harness();
+  const git = (...args: string[]) => execFileSync("git", ["-C", h.dir, ...args], { stdio: "ignore" });
+  git("init", "-b", "main");
+  git("-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "--allow-empty", "-m", "base");
+  const worktree = join(h.dir, "linked");
+  git("worktree", "add", "-b", "feature", worktree);
+  mkdirSync(join(h.dir, ".pi"));
+  writeFileSync(join(h.dir, ".pi/settings.json"), JSON.stringify({ piGauntlet: { verifyBeforeShip: { testCommands: ["custom-check"] } } }));
+  const spec = join(worktree, "spec.md");
+  writeFileSync(spec, "## Legs\n### Leg: team/home\n### Leg: team/companion\nbranch: feature\nhome: linked-<name>\n");
+  await h.emitEvent("tool_result", { toolName: "phase_tracker", details: { action: "start", phases: { brainstorm: { status: "in_progress" } } } });
+  await h.emitEvent("tool_result", { toolName: "phase_tracker", details: { action: "skip", phases: { brainstorm: { status: "skipped", reason: `resume: ${spec}` } } } });
+  for (const [id, command, warns] of [["default", "npm test", true], ["custom", "custom-check", false]] as const) {
+    await h.emitEvent("tool_call", bashCall(id, `(cd ${worktree} && ${command})`));
+    await h.emitEvent("tool_result", bashResult(id));
+    await h.emitEvent("tool_call", bashCall("ship", `git -C ${worktree} push`));
+    const warning = warningOf(await h.emitEvent("tool_result", bashResult("ship")));
+    if (warns) assert.match(warning ?? "", /custom-check/);
+    else assert.equal(warning, undefined);
+  }
+});
+
+test("legacy linked worktree verification uses its local custom policy", async () => {
+  const h = harness();
+  const git = (...args: string[]) => execFileSync("git", ["-C", h.dir, ...args], { stdio: "ignore" });
+  git("init", "-b", "main");
+  git("-c", "user.name=Test", "-c", "user.email=test@example.invalid", "commit", "--allow-empty", "-m", "base");
+  const worktree = join(h.dir, "linked");
+  git("worktree", "add", "-b", "feature", worktree);
+  mkdirSync(join(worktree, ".pi"));
+  writeFileSync(join(worktree, ".pi/settings.json"), JSON.stringify({ piGauntlet: { verifyBeforeShip: { testCommands: ["custom-check"] } } }));
+  for (const [id, command, warns] of [["default", "npm test", true], ["custom", "custom-check", false]] as const) {
+    await h.emitEvent("tool_call", bashCall(id, `(cd ${worktree} && ${command})`));
+    await h.emitEvent("tool_result", bashResult(id));
+    await h.emitEvent("tool_call", bashCall("ship", `git -C ${worktree} push`));
+    const warning = warningOf(await h.emitEvent("tool_result", bashResult("ship")));
+    if (warns) assert.match(warning ?? "", /custom-check/);
+    else assert.equal(warning, undefined);
+  }
+});

package/extensions/verify-before-ship.ts

@@ -25,6 +25,9 @@
  * `testCommands` to match your project's conventions.
  */
 
+import { resolve, dirname } from "node:path";
+import { existsSync, realpathSync, readFileSync } from "node:fs";
+import { spawnSync } from "node:child_process";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import {
   DEFAULT_TEST_COMMANDS,
@@ -34,6 +37,8 @@ import {
 } from "./lib/gauntlet-settings.ts";
 import { loadGauntletSettings } from "./lib/gauntlet-settings-loader.ts";
 import { matchShipStatement } from "./lib/telemetry-paths.ts";
+import { checkoutOfSync, gitSync } from "./lib/checkout.ts";
+import { parseLegs } from "./lib/plan-check.ts";
 
 const SOURCE_EXT = /\.(ts|tsx|js|jsx|py|rb|go|rs|java|swift|kt)$/;
 const TEST_PATH = /(^|\/)(tests?|__tests__)\/|\.(test|spec)\.|_test\.(py|go|rb)$/;
@@ -56,9 +61,159 @@ const formatWarning = (command: string, testCommands: string[], reference: strin
   );
 };
 
+const checkout = (path: string): string => {
+  let existing = resolve(path);
+  while (!existsSync(existing) && dirname(existing) !== existing) existing = dirname(existing);
+  const result = spawnSync("git", ["-C", existing, "rev-parse", "--show-toplevel"], { encoding: "utf8" });
+  const root = result.status === 0 ? result.stdout.trim() : resolve(path);
+  try { return realpathSync(root); } catch { return root; }
+};
+
+// Only literal shell directories can supply evidence; expansions remain untrusted.
+const statements = (command: string, cwd: string): { command: string; testCommand: string; target: string; trusted: boolean }[] => {
+  const tokens = command.match(/"[^"\n]*"|'[^'\n]*'|&&|\|\||[;()\n]|[^\s;()]+/g) ?? [];
+  // Allow only literal simple commands and subshells. Only the final list in
+  // each sequence can prove success: earlier failures can be masked by a separator.
+  const literalWord = /^(?:[a-zA-Z0-9_./:=+,%@-]+|'[^'\\\n$`]*'|"[^"\\\n$`]*")$/;
+  // Redirections and leading assignments do not mask a command's exit status.
+  const redirection = /^(?:[0-9]*[<>]{1,2}(?:&[0-9]*)?|&>>?)[a-zA-Z0-9_./-]*$/;
+  const assignment = /^[a-zA-Z_][a-zA-Z0-9_]*=/;
+  const reservedWord = /^(?:if|then|else|elif|fi|for|while|until|do|done|case|esac|in|function|select|time|coproc)$/;
+  let position = 0;
+  const parseCommand = (): boolean => {
+    if (tokens[position] === "(") {
+      position++;
+      if (!parseSequence() || tokens[position] !== ")") return false;
+      position++;
+      return true;
+    }
+    let named = false;
+    for (; position < tokens.length; position++) {
+      const token = tokens[position];
+      if (redirection.test(token)) continue;
+      if (!literalWord.test(token)) break;
+      if (named || assignment.test(token)) continue;
+      if (reservedWord.test(token) || token === "false") return false;
+      named = true;
+    }
+    return named;
+  };
+  // Earlier pipeline segments cannot prove success because their exit status may be masked.
+  const masked = new Set<number>();
+  const parsePipeline = (): boolean => {
+    const start = position;
+    let lastStart = position;
+    if (!parseCommand()) return false;
+    while (tokens[position] === "|") {
+      position++;
+      lastStart = position;
+      if (!parseCommand()) return false;
+    }
+    for (let i = start; i < lastStart; i++) masked.add(i);
+    return true;
+  };
+  const parseAndList = (): boolean => {
+    if (!parsePipeline()) return false;
+    while (tokens[position] === "&&") {
+      position++;
+      if (!parsePipeline()) return false;
+    }
+    return true;
+  };
+  const parseSequence = (): boolean => {
+    let start = position;
+    if (!parseAndList()) return false;
+    while (tokens[position] === ";" || tokens[position] === "\n") {
+      position++;
+      for (let i = start; i < position; i++) masked.add(i);
+      start = position;
+      if (position !== tokens.length && !parseAndList()) return false;
+    }
+    return true;
+  };
+  const canCredit = parseSequence() && position === tokens.length;
+  const out: { command: string; testCommand: string; target: string; trusted: boolean }[] = [];
+  const stack: string[] = [];
+  let dir = cwd, words: string[] = [], testWords: string[] = [];
+  const flush = () => {
+    if (!words.length) return;
+    const literal = (word: string) => !/[$`]/.test(word);
+    if (words[0] === "cd" && words.length === 2) {
+      dir = literal(words[1]) ? resolve(dir, words[1]) : "";
+    } else {
+      let target = dir;
+      if (words[0] === "git") {
+        for (let i = 1; i < words.length - 1; i++) if (words[i] === "-C") target = literal(words[i + 1]) ? resolve(target, words[++i]) : "";
+      }
+      out.push({ command: words.join(" "), testCommand: canCredit ? testWords.join(" ") : "", target: checkout(target || cwd), trusted: !!target });
+    }
+    words = [];
+    testWords = [];
+  };
+  for (const [index, token] of tokens.entries()) {
+    if (["&&", "||", ";", "\n", "(", ")"].includes(token)) {
+      flush();
+      if (token === "(") stack.push(dir);
+      if (token === ")") dir = stack.pop() ?? cwd;
+    } else {
+      const quoted = /^["']/.test(token);
+      words.push(quoted ? token.slice(1, -1) : token);
+      testWords.push(quoted || masked.has(index) ? '""' : token);
+    }
+  }
+  flush();
+  return out;
+};
+
 export default function (pi: ExtensionAPI) {
-  let verified = false;
-  let pendingTestCallId: string | null = null;
+  const verified = new Set<string>();
+  let homeSpec: string | undefined;
+  const rememberPlan = (event: { toolName: string; isError?: boolean; details?: unknown }, cwd: string) => {
+    if (event.toolName === "phase_tracker" && !homeSpec && !event.isError) {
+      const details = event.details as { action?: string; error?: string; phases?: Record<string, { status?: string; reason?: string }> } | undefined;
+      if (details?.action === "skip" && !details.error) {
+        for (const phase of ["brainstorm", "plan"]) {
+          const state = details.phases?.[phase];
+          const spec = state?.status === "skipped" ? /^resume: (.+?)(?: \(loop engine\))?$/.exec(state.reason ?? "")?.[1] : undefined;
+          if (spec) {
+            homeSpec = resolve(cwd, spec);
+            break;
+          }
+        }
+      }
+    }
+    if (event.toolName !== "plan_check") return;
+    const details = event.details as { status?: string; specPath?: string } | undefined;
+    homeSpec = !event.isError && details?.status === "pass" ? details.specPath : undefined;
+  };
+  pi.on("session_start", async (_event, ctx) => {
+    homeSpec = undefined;
+    for (const entry of ctx.sessionManager.getBranch()) {
+      if (entry.type === "message" && entry.message.role === "toolResult") rememberPlan(entry.message, ctx.cwd);
+    }
+  });
+  const coordinatedMember = (target: string, primary: string): boolean => {
+    if (!homeSpec) return false;
+    let legs: ReturnType<typeof parseLegs>;
+    try { legs = parseLegs(readFileSync(homeSpec, "utf8")); } catch { return false; }
+    if (legs.length < 2) return false;
+    if (target === checkout(dirname(homeSpec))) return true;
+    const remote = gitSync(["remote", "get-url", "origin"], primary);
+    let repo = remote.stdout.trim().replace(/\.git$/, "").replace(/^.*[:/]([^/:]+\/[^/]+)$/, "$1").toLowerCase();
+    if (remote.code !== 0) {
+      const overridesPath = [".pi/gauntlet-overrides.md", "gauntlet-overrides.md", "doc/gauntlet-overrides.md"].map(p => resolve(primary, p)).find(p => existsSync(p));
+      const overrides = overridesPath ? readFileSync(overridesPath, "utf8") : "";
+      const tracker = /^## Issue tracker\s*\n([\s\S]*?)(?=^## |$(?![\s\S]))/m.exec(overrides)?.[1] ?? "";
+      repo = (/^- repo:\s*(\S+)\s*$/m.exec(tracker)?.[1] ?? primary.split("/").at(-1) ?? "").toLowerCase();
+    }
+    return legs.slice(1).some(leg => {
+      const branch = /^branch:\s*(\S+)\s*$/m.exec(leg.body)?.[1];
+      const home = /^(?:contract:\s*)?(?:-\s*)?home:\s*(\S+)\s*$/m.exec(leg.body)?.[1];
+      return leg.repo === repo && !!branch && !!home && home.split("<name>").length === 2 &&
+        target === checkout(resolve(primary, home.replace("<name>", branch.replaceAll("/", "-"))));
+    });
+  };
+  const pendingTests = new Map<string, Set<string>>();
   const pendingShipWarnings = new Map<string, string>();
 
   const getCommand = (event: { input: unknown }): string => {
@@ -73,7 +228,7 @@ export default function (pi: ExtensionAPI) {
 
   pi.on("tool_call", async (event, ctx) => {
     if (event.toolName === "write" || event.toolName === "edit") {
-      if (isSourceWrite(getPath(event))) verified = false;
+      if (isSourceWrite(getPath(event))) verified.delete(checkout(dirname(resolve(ctx.cwd, getPath(event)!))));
       return undefined;
     }
 
@@ -86,38 +241,38 @@ export default function (pi: ExtensionAPI) {
       pendingShipWarnings.set(id, prior ? prior + "\n\n" + text : text);
     };
 
-    const { gauntlet, errors } = loadGauntletSettings(ctx.cwd);
-    const { testCommands, warningReference } = resolveVerifyBeforeShip(gauntlet, DEFAULT_TEST_COMMANDS);
-    const settingsWarned = errors.length > 0 ? settingsErrorWarning(errors) : undefined;
+    const targets = new Set<string>();
     let settingsErrShown = false;
-    const testRegex = buildTestCmdRegex(testCommands);
-
-    if (testRegex.test(command)) {
-      pendingTestCallId = event.toolCallId;
-      if (settingsWarned && !settingsErrShown) {
-        addShipWarning(event.toolCallId, settingsWarned);
-        settingsErrShown = true;
+    for (const statement of statements(command, ctx.cwd)) {
+      const targetCheckout = checkoutOfSync(statement.target);
+      let settingsRoot = statement.target;
+      if (targetCheckout?.via === "git" && !targetCheckout.isPrimary) {
+        const common = gitSync(["rev-parse", "--path-format=absolute", "--git-common-dir"], statement.target);
+        if (common.code === 0 && coordinatedMember(statement.target, dirname(common.stdout.trim()))) settingsRoot = dirname(common.stdout.trim());
       }
-      return undefined;
-    }
-
-    if (matchShipStatement(command) && !verified) {
-      if (settingsWarned && !settingsErrShown) {
-        addShipWarning(event.toolCallId, settingsWarned);
+      const { gauntlet, errors } = loadGauntletSettings(settingsRoot);
+      const { testCommands, warningReference } = resolveVerifyBeforeShip(gauntlet, DEFAULT_TEST_COMMANDS);
+      const isTest = buildTestCmdRegex(testCommands).test(statement.testCommand) && !/^(?:echo|printf|rg|grep)\b/.test(statement.command);
+      if (isTest && statement.trusted) targets.add(statement.target);
+      if ((isTest || matchShipStatement(statement.command)) && errors.length && !settingsErrShown) {
+        addShipWarning(event.toolCallId, settingsErrorWarning(errors));
         settingsErrShown = true;
       }
-      addShipWarning(event.toolCallId, formatWarning(command, testCommands, warningReference));
+      if (matchShipStatement(statement.command) && (!statement.trusted || !verified.has(statement.target))) {
+        addShipWarning(event.toolCallId, formatWarning(command, testCommands, warningReference));
+      }
     }
+    if (targets.size) pendingTests.set(event.toolCallId, targets);
     return undefined;
   });
 
-  pi.on("tool_result", async (event) => {
+  pi.on("tool_result", async (event, ctx) => {
+    rememberPlan(event, ctx.cwd);
     if (event.toolName !== "bash") return undefined;
 
-    if (pendingTestCallId === event.toolCallId) {
-      pendingTestCallId = null;
-      if (!event.isError) verified = true;
-    }
+    const targets = pendingTests.get(event.toolCallId);
+    pendingTests.delete(event.toolCallId);
+    if (!event.isError) for (const target of targets ?? []) verified.add(target);
 
     const warning = pendingShipWarnings.get(event.toolCallId);
     if (!warning) return undefined;