pi-gauntlet 5.9.0 → 5.10.0

package/extensions/phase-tracker.test.ts

@@ -1,6 +1,7 @@
 import assert from "node:assert/strict";
 import { after, test } from "node:test";
-import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync } from "node:fs";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync, readFileSync, realpathSync } from "node:fs";
 import { createHash } from "node:crypto";
 import { tmpdir } from "node:os";
 import { isAbsolute, join } from "node:path";
@@ -26,6 +27,18 @@ const tempCwd = (settings?: unknown) => {
   return dir;
 };
 
+// Primary checkout with one linked worktree at .worktrees/x. Real git: plan_check and Guard 2
+// resolve checkouts with gitSync, and macOS temp paths need realpath to compare toplevels.
+const gitPrimary = () => {
+  const primary = realpathSync(tempCwd());
+  const git = (...args: string[]) => execFileSync("git", ["-C", primary, ...args], { stdio: "pipe" });
+  git("init", "-q");
+  git("-c", "user.email=t@example.com", "-c", "user.name=t", "commit", "-q", "--allow-empty", "-m", "init");
+  mkdirSync(join(primary, "doc"));
+  git("worktree", "add", "-q", join(primary, ".worktrees", "x"), "-b", "x");
+  return { primary, worktree: join(primary, ".worktrees", "x") };
+};
+
 const PHASES = ["brainstorm", "plan", "implement", "verify", "ship"] as const;
 type Phase = (typeof PHASES)[number];
 type Status = "pending" | "in_progress" | "complete" | "skipped";
@@ -720,7 +733,7 @@ const FIXTURE_SPEC = [
 
 const FIXTURE_PLAN = `# Fixture Plan
 
-**Spec:** \`spec.md\`
+**Spec:** \`doc/specs/spec.md\`
 
 **Verification:** npm test
 
@@ -772,8 +785,10 @@ function writePlanFixture(
 ) {
   const planText = opts.mutatePlan ? opts.mutatePlan(FIXTURE_PLAN) : FIXTURE_PLAN;
   const specText = opts.mutateSpec ? opts.mutateSpec(FIXTURE_SPEC) : FIXTURE_SPEC;
-  const planPath = join(dir, "plan.md");
-  const specPath = join(dir, "spec.md");
+  const planPath = join(dir, "doc/plans/plan.md");
+  const specPath = join(dir, "doc/specs/spec.md");
+  mkdirSync(join(dir, "doc/plans"), { recursive: true });
+  mkdirSync(join(dir, "doc/specs"), { recursive: true });
   writeFileSync(planPath, planText);
   writeFileSync(specPath, specText);
   writeFileSync(join(dir, "file-a.ts"), "// a\n");
@@ -793,8 +808,45 @@ test("plan_check is registered", () => {
   assert.ok(h.tools.some((t) => t.name === "plan_check"));
 });
 
-test("plan_check pass: text, details, and stamp arming when a flow is entered", async () => {
+test("plan_check roots at the plan's checkout: worktree plan passes from <primary>/doc (AC 1)", async () => {
+  const { primary, worktree } = gitPrimary();
+  const { planPath } = writePlanFixture(worktree);
+  const h = harness({ cwd: join(primary, "doc") });
+  await h.emit("session_start");
+  const tool = h.tools.find((t) => t.name === "plan_check")!;
+  const res = (await tool.execute("t1", { planPath }, undefined, undefined, h.ctx)) as { content: { text: string }[]; details: { status: string; specPath: string } };
+  assert.match(res.content[0].text, /^PASS/);
+  assert.equal(res.details.specPath, join(worktree, "doc/specs/spec.md"));
+});
+
+test("plan_check outside any checkout: input finding", async () => {
   const dir = tempCwd();
+  const { planPath } = writePlanFixture(dir);
+  const h = harness({ cwd: dir });
+  await h.emit("session_start");
+  const tool = h.tools.find((t) => t.name === "plan_check")!;
+  const res = (await tool.execute("t1", { planPath }, undefined, undefined, h.ctx)) as { content: { text: string }[]; details: { status: string } };
+  assert.equal(res.details.status, "fail");
+  assert.match(res.content[0].text, /input @ line 0: plan is not inside a git checkout/);
+});
+
+const bashCall = (id: string, command: string) => ({ toolName: "bash", toolCallId: id, input: { command } });
+const blocked = (results: unknown[]) => (results[0] as { block?: boolean } | undefined)?.block === true;
+
+test("Guard 2 evaluates the command's target checkout (AC 3)", async () => {
+  const { primary, worktree } = gitPrimary();
+  const h = harness({ cwd: join(primary, "doc"), branch: [phaseResult("start", phases({ brainstorm: "in_progress" }))] });
+  await h.emit("session_start");
+  assert.ok(blocked(await h.emitEvent("tool_call", bashCall("b1", "git switch -c y"))), "bare switch from <primary>/doc blocks");
+  assert.ok(blocked(await h.emitEvent("tool_call", bashCall("b2", `git -C ${primary} switch -c y`))), "-C <primary> blocks");
+  assert.ok(!blocked(await h.emitEvent("tool_call", bashCall("b3", `git -C ${worktree} switch -c y`))), "-C <worktree> passes");
+  assert.ok(!blocked(await h.emitEvent("tool_call", bashCall("b4", `cd ${worktree} && git checkout -b y`))), "cd <worktree> passes");
+  assert.ok(!blocked(await h.emitEvent("tool_call", bashCall("b5", "git -C /nonexistent/dir switch -c y"))), "unresolvable target passes");
+  assert.ok(!blocked(await h.emitEvent("tool_call", bashCall("b6", "git worktree add .worktrees/y -b y"))), "git worktree is exempt");
+});
+
+test("plan_check pass: text, details, and stamp arming when a flow is entered", async () => {
+  const dir = gitPrimary().primary;
   const { planPath, specPath, planText, specText } = writePlanFixture(dir);
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -824,7 +876,7 @@ test("plan_check pass: text, details, and stamp arming when a flow is entered",
 });
 
 test("plan_check pass outside a flow: no stamp, plain-linter text", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir);
   const h = harness({ cwd: dir });
   await h.emit("session_start");
@@ -834,7 +886,7 @@ test("plan_check pass outside a flow: no stamp, plain-linter text", async () =>
 });
 
 test("plan_check fail: mutated plan body, no error key, clears stamp", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir, {
     mutatePlan: (t) => t.replace("implements helperFn() for parsing.", "implements the helper for parsing."),
   });
@@ -857,9 +909,9 @@ test("plan_check fail: mutated plan body, no error key, clears stamp", async ()
 });
 
 test("plan_check fail: unresolvable spec path", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir, {
-    mutatePlan: (t) => t.replace("**Spec:** `spec.md`", "**Spec:** `missing-spec.md`"),
+    mutatePlan: (t) => t.replace("**Spec:** `doc/specs/spec.md`", "**Spec:** `missing-spec.md`"),
   });
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -881,11 +933,11 @@ test("plan_check fail: unresolvable spec path", async () => {
 });
 
 test("plan_check fail: header **Spec:** extraction is confined to the header (a path-only-looking line below the separator does not count)", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir, {
     mutatePlan: (t) =>
       t
-        .replace("**Spec:** `spec.md`\n\n", "")
+        .replace("**Spec:** `doc/specs/spec.md`\n\n", "")
         .replace(
           "## Wave 1 - Two parallel tasks",
           "## Wave 1 - Two parallel tasks\n\n**Spec:** `not-the-header-spec.md`\n",
@@ -907,9 +959,9 @@ test("plan_check fail: header **Spec:** extraction is confined to the header (a
 });
 
 test("plan_check fail: plan header has no path-only **Spec:** line at all", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir, {
-    mutatePlan: (t) => t.replace("**Spec:** `spec.md`\n\n", ""),
+    mutatePlan: (t) => t.replace("**Spec:** `doc/specs/spec.md`\n\n", ""),
   });
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -942,7 +994,7 @@ test("implement-start gate: rejects with no stamp, names plan_check remedy", asy
 });
 
 test("implement-start gate: stale plan bytes rejected, names the stale file", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir);
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -958,7 +1010,7 @@ test("implement-start gate: stale plan bytes rejected, names the stale file", as
 });
 
 test("implement-start gate: stale spec bytes rejected, names the stale file", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -974,7 +1026,7 @@ test("implement-start gate: stale spec bytes rejected, names the stale file", as
 });
 
 test("implement-start gate: missing stamped file rejected, names the missing path", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath } = writePlanFixture(dir);
   const h = harness({ cwd: dir, branch: readyForImplementBranch });
   await h.emit("session_start");
@@ -1002,7 +1054,7 @@ test("implement-start gate: enforce false skips the gate entirely", async () =>
 });
 
 test("replay: a passing plan_check result restores the stamp without re-running the tool", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1022,7 +1074,7 @@ test("replay: a passing plan_check result restores the stamp without re-running
 });
 
 test("replay: pass then fail clears the stamp", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1045,7 +1097,7 @@ test("replay: pass then fail clears the stamp", async () => {
 });
 
 test("replay: a plan_check pass observed before any flow entry does not arm the stamp, and a live walk with no live plan_check is rejected", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1070,7 +1122,7 @@ test("replay: a plan_check pass observed before any flow entry does not arm the
 });
 
 test("replay: a phase_tracker reset clears the stamp", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1097,7 +1149,7 @@ test("replay: a phase_tracker reset clears the stamp", async () => {
 });
 
 test("replay via session_fork: a passing plan_check result restores the stamp without re-running the tool", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1124,7 +1176,7 @@ test("replay via session_fork: a passing plan_check result restores the stamp wi
 });
 
 test("replay via session_tree: a passing plan_check result restores the stamp without re-running the tool", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",
@@ -1152,7 +1204,7 @@ test("replay via session_tree: a passing plan_check result restores the stamp wi
 });
 
 test("replay via session_switch: pass then fail clears the stamp, rebuilt from replay rather than a live run", async () => {
-  const dir = tempCwd();
+  const dir = gitPrimary().primary;
   const { planPath, specPath } = writePlanFixture(dir);
   const passDetails = {
     status: "pass",

package/extensions/phase-tracker.ts

@@ -9,7 +9,6 @@
  * Use phase_tracker for "what stage am I in?", plan_tracker for "which task?".
  */
 
-import { execSync } from "node:child_process";
 import { existsSync, globSync, readdirSync, readFileSync, readFileSync as readFileBytes } from "node:fs";
 import { isAbsolute, join, resolve } from "node:path";
 import { StringEnum } from "@earendil-works/pi-ai";
@@ -25,6 +24,7 @@ import {
   settingsErrorWarning,
 } 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 {
   checkSubstep,
@@ -34,6 +34,7 @@ import {
   implementWriteGuardApplies,
   markerBlockReason,
   nextGauntletEntered,
+  parseGitCommand,
   parseGitCommit,
   phaseLabel,
   recoverableEdge,
@@ -159,8 +160,8 @@ const GUARD_PHASES: Phase[] = ["brainstorm", "plan", "implement"];
 // Guard 2 — branch ops in place. `git switch` never targets a file path;
 // `git checkout -b/-B` is explicit branch creation. Bare `git checkout <x>`
 // is excluded (ambiguous with file checkout). `git worktree ...` is exempt.
-const BRANCH_SWITCH = new RegExp(STMT_START + "git\\s+switch\\b");
-const BRANCH_CHECKOUT = new RegExp(STMT_START + "git\\s+checkout\\s+-[bB]\\b");
+const SWITCH_SUB = /switch(?=\s|$)/;
+const CHECKOUT_BRANCH_SUB = /checkout\s+-[bB](?=\s|$)/;
 const GIT_WORKTREE = /\bgit\s+worktree\b/;
 
 // Guard 3 — bash mutation forms during brainstorm.
@@ -394,21 +395,6 @@ export default function (pi: ExtensionAPI) {
   // implementer's first write would trip a spurious advisory.
   const isSubagentChild = Number(process.env.PI_SUBAGENT_DEPTH ?? "0") > 0;
 
-  const inPrimaryCheckout = (() => {
-    try {
-      const lines = execSync("git rev-parse --git-dir --git-common-dir", {
-        encoding: "utf8",
-        stdio: ["ignore", "pipe", "ignore"],
-        timeout: 5000,
-      })
-        .trim()
-        .split("\n");
-      return lines.length === 2 && lines[0] === lines[1];
-    } catch {
-      return false;
-    }
-  })();
-
   // Auto-complete the implement phase from plan_tracker once every task is done,
   // but only when a skill has explicitly started it (TDD, or the SDD
   // execution preamble). The tracker never *fabricates* implement from task activity:
@@ -630,15 +616,16 @@ export default function (pi: ExtensionAPI) {
 
     const warnings: string[] = [];
 
-    // Guard 2 — branch op in place (primary checkout only, brainstorm/plan/implement).
+    // Guard 2 - branch op in the primary checkout (brainstorm/plan/implement). The target
+    // is the command's own -C / leading-cd dir, else the session cwd; a linked worktree
+    // target passes, an unresolvable one passes (the guard protects the primary only).
     const gphase = activeGuardPhase();
-    if (
-      inPrimaryCheckout &&
-      gphase &&
-      !GIT_WORKTREE.test(command) &&
-      (BRANCH_SWITCH.test(command) || BRANCH_CHECKOUT.test(command))
-    ) {
-      return { block: true, reason: branchBlockReason(gphase) };
+    if (gphase && !GIT_WORKTREE.test(command)) {
+      const form = parseGitCommand(command, SWITCH_SUB) ?? parseGitCommand(command, CHECKOUT_BRANCH_SUB);
+      if (form) {
+        const target = resolveRepoDir(form, ctx.cwd);
+        if ((await checkoutOf(target, gitSync))?.isPrimary === true) return { block: true, reason: branchBlockReason(gphase) };
+      }
     }
 
     // Marker commit guard — the context draft (brainstorming gather step) must be
@@ -805,6 +792,10 @@ export default function (pi: ExtensionAPI) {
         } catch {
           return fail([{ check: "input", line: 0, text: "", reason: `plan file unreadable at ${planAbs}` }], planAbs);
         }
+        const root = (await checkoutOf(planAbs, gitSync))?.toplevel;
+        if (!root) {
+          return fail([{ check: "input", line: 0, text: "", reason: "plan is not inside a git checkout" }], planAbs);
+        }
         const planText = planBytes.toString("utf8");
         const planLines = planText.split("\n");
         const planSeparatorIdx = planLines.findIndex((l) => l.trim() === "---");
@@ -820,7 +811,7 @@ export default function (pi: ExtensionAPI) {
             planAbs,
           );
         }
-        const specAbs = isAbsolute(specPathRaw) ? specPathRaw : resolve(ctx.cwd, specPathRaw);
+        const specAbs = isAbsolute(specPathRaw) ? specPathRaw : resolve(root, specPathRaw);
         let specBytes: Buffer;
         try {
           specBytes = readFileBytes(specAbs);
@@ -829,8 +820,8 @@ export default function (pi: ExtensionAPI) {
         }
         const specText = specBytes.toString("utf8");
         const port: FsPort = {
-          exists: (p) => existsSync(resolve(ctx.cwd, p)),
-          glob: (pattern) => globSync(pattern, { cwd: ctx.cwd }),
+          exists: (p) => existsSync(resolve(root, p)),
+          glob: (pattern) => globSync(pattern, { cwd: root }),
         };
         const findings = checkPlan(planText, specText, port);
         if (findings.length > 0) return fail(findings, planAbs);

package/extensions/telemetry.test.ts

@@ -20,13 +20,15 @@
 
   type Handler = (event: any, ctx: any) => unknown;
 
-  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[]) => GitResult | undefined; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
+  function harness(o: { branch?: unknown[]; enabled?: boolean; gitFail?: (args: string[], cwd: string) => GitResult | undefined; cwdSub?: string; sessionId?: string; model?: { provider: string; id: string }; thinkingLevel?: string; contextTokens?: number | null; telemetryWarning?: string; telemetryDir?: string } = {}) {
     const root = mkdtempSync(join(tmpdir(), "telemetry-test-"));
     tempDirs.push(root);
     mkdirSync(join(root, "doc/specs"), { recursive: true });
     mkdirSync(join(root, "doc/plans"), { recursive: true });
+    mkdirSync(join(root, ".worktrees/x/doc/specs"), { recursive: true });
     const handlers = new Map<string, Handler[]>();
     const gitCalls: string[][] = [];
+    const gitCwds: string[] = [];
     const readFileCalls: string[] = [];
     let clock = Date.parse("2026-09-17T10:00:00Z");
     const deps: Deps = {
@@ -34,11 +36,15 @@
       now: () => new Date((clock += 1000)).toISOString().replace(/\.\d{3}Z$/, "Z"),
       git: async (args, cwd) => {
         gitCalls.push(args);
-        const forced = o.gitFail?.(args);
+        gitCwds.push(cwd);
+        const forced = o.gitFail?.(args, cwd);
         if (forced) return forced;
-        if (args[0] === "rev-parse" && args.includes("--show-toplevel")) {
-          const toplevel = o.cwdSub && cwd === join(root, o.cwdSub) ? root : cwd;
-          return { code: 0, stdout: toplevel + "\n", stderr: "" };
+        if (args[0] === "rev-parse" && args.includes("--path-format=absolute")) {
+          const wt = /^(.*\/\.worktrees\/[^/]+)(\/|$)/.exec(cwd)?.[1];
+          const primary = cwd === root || cwd.startsWith(root + "/") ? root : cwd.replace(/\/(?:doc|\.pi)(?:\/.*)?$/, "");
+          const toplevel = wt ?? primary;
+          const gitDir = wt ? `${primary}/.git/worktrees/${wt.split("/").pop()}` : `${primary}/.git`;
+          return { code: 0, stdout: `${toplevel}\n${gitDir}\n${primary}/.git\n`, stderr: "" };
         }
         if (args[0] === "rev-parse" && args.includes("--abbrev-ref")) return { code: 0, stdout: "gh-33\n", stderr: "" };
         if (args[0] === "config") return { code: 0, stdout: (args[1] === "user.name" ? "Tester" : "t@example.com") + "\n", stderr: "" };
@@ -71,7 +77,7 @@
       await emit("tool_call", { toolName: "write", toolCallId: "w", input: { path: rel, content: body } });
       return emit("tool_result", { toolName: "write", toolCallId: "w", input: { path: rel, content: body }, content: [], isError: false, details: undefined });
     };
-    return { root, handlers, emit, gitCalls, readFileCalls, commits, recordPath, readRecord, phaseResult, writeSpec, setBranch: (b: unknown[]) => (branch = b), ctx };
+    return { root, handlers, emit, gitCalls, gitCwds, readFileCalls, commits, recordPath, readRecord, phaseResult, writeSpec, setBranch: (b: unknown[]) => (branch = b), ctx };
   }
 
   const P = (over: Record<string, string> = {}) => Object.fromEntries(["brainstorm", "plan", "implement", "verify", "ship"].map((p) => [p, { status: over[p] ?? "pending" }]));
@@ -265,12 +271,47 @@
     fail = false;
     await h.phaseResult("complete", P({ brainstorm: "complete" }));
     assert.equal(h.commits().length, 2);
-    const nogit = harness({ gitFail: (args) => (args[0] === "rev-parse" ? { code: 128, stdout: "", stderr: "fatal: not a git repository" } : undefined) });
+    const outside = mkdtempSync(join(tmpdir(), "telemetry-outside-"));
+    tempDirs.push(outside);
+    const outsideSpec = join(outside, "doc/specs/outside.md");
+    const nogit = harness({ gitFail: (args, cwd) => (args[0] === "rev-parse" && cwd.startsWith(outside) ? { code: 128, stdout: "", stderr: "fatal: not a git repository" } : undefined) });
     await nogit.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await nogit.emit("tool_result", { toolName: "write", toolCallId: "outside", input: { path: outsideSpec }, content: [], isError: false, details: undefined });
     await nogit.writeSpec("doc/specs/a.md");
-    rec = nogit.readRecord();
-    assert.equal(nogit.commits().length, 0);
-    assert.equal(rec.events.filter((e) => e.kind === "warning").length, 1);
+    assert.deepEqual(nogit.readRecord().events.filter((e) => e.kind === "warning").map((e: any) => e.message), [`spec ${outsideSpec} is outside a git checkout; telemetry not recorded`]);
+  });
+
+  test("worktree spec from a primary cwd: record keyed under the worktree, committed there (AC 8)", async () => {
+    const h = harness();
+    await h.emit("session_start", { type: "session_start", reason: "startup" });
+    await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+    await h.writeSpec(".worktrees/x/doc/specs/a.md");
+    const wt = join(h.root, ".worktrees/x");
+    assert.ok(existsSync(join(wt, ".pi/gauntlet/telemetry/doc/specs/a.yaml")), "record lives under the worktree toplevel");
+    assert.equal(existsSync(join(h.root, ".pi/gauntlet")), false, "nothing written under the primary checkout");
+    assert.ok(h.gitCwds.every((c) => c === wt || c.startsWith(wt + "/")), "no git call runs in the primary");
+    const commitIdx = h.gitCalls.findIndex((a) => a[0] === "commit");
+    assert.ok(commitIdx >= 0);
+    assert.equal(h.gitCwds[commitIdx], wt);
+    assert.deepEqual(h.gitCalls[commitIdx].slice(-1), [".pi/gauntlet/telemetry/doc/specs/a.yaml"]);
+  });
+
+  test("a spec in another checkout is a fresh bind, never a git mv", async () => {
+    for (const tool of ["write", "edit"] as const) {
+      const h = harness();
+      await h.phaseResult("start", P({ brainstorm: "in_progress" }));
+      await h.writeSpec(".worktrees/x/doc/specs/a.md", "# CONTEXT DRAFT - NOT A SPEC - fully replaced at spec-writing\n");
+      if (tool === "write") {
+        await h.writeSpec("doc/specs/a.md");
+      } else {
+        writeFileSync(join(h.root, "doc/specs/a.md"), "# Spec\n");
+        await h.emit("tool_result", { toolName: "edit", toolCallId: "e", input: { path: "doc/specs/a.md", oldText: "# Old\n", newText: "# Spec\n" }, content: [], isError: false, details: undefined });
+      }
+      assert.ok(existsSync(h.recordPath("doc/specs/a.md")), `primary record created for ${tool}`);
+      assert.ok(existsSync(join(h.root, ".worktrees/x/.pi/gauntlet/telemetry/doc/specs/a.yaml")), `worktree record left in place for ${tool}`);
+      assert.equal(h.gitCalls.some((a) => a[0] === "mv"), false);
+      assert.equal(h.readRecord("doc/specs/a.md").events.some((e) => e.kind === "spec_renamed"), false);
+    }
   });
 
   test("second session rehydrates all derived accumulators with exactly total and live blocks", async () => {