gsd-pi 2.81.0 → 2.82.0-dev.20138ae42

package/src/resources/extensions/gsd/tests/verification-retry-policy.test.ts

@@ -0,0 +1,83 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for auto-mode verification retry backoff decisions.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import {
+  decideVerificationRetry,
+  hashVerificationFailureContext,
+  verificationRetryDelayMs,
+  verificationRetryKey,
+  VERIFICATION_RETRY_MAX_DELAY_MS,
+} from "../auto/verification-retry-policy.ts";
+
+test("verificationRetryDelayMs uses exponential backoff with cap", () => {
+  assert.deepEqual(verificationRetryDelayMs(1, () => 0.5), {
+    delayMs: 2_000,
+    baseDelayMs: 2_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(2, () => 0.5), {
+    delayMs: 4_000,
+    baseDelayMs: 4_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(3, () => 0.5), {
+    delayMs: 8_000,
+    baseDelayMs: 8_000,
+  });
+  assert.deepEqual(verificationRetryDelayMs(99, () => 0.5), {
+    delayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+    baseDelayMs: VERIFICATION_RETRY_MAX_DELAY_MS,
+  });
+});
+
+test("decideVerificationRetry pauses on duplicate failure context", () => {
+  const failureContext = "lint failed\n";
+  const failureHash = hashVerificationFailureContext(failureContext);
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext,
+      attempt: 2,
+    },
+    previousFailureHash: failureHash,
+    random: () => 0.5,
+  });
+
+  assert.deepEqual(decision, {
+    action: "pause",
+    reason: "duplicate-failure-context",
+    key: verificationRetryKey("execute-task", "M001/S01/T01"),
+    failureHash,
+  });
+});
+
+test("decideVerificationRetry delays changed failure context", () => {
+  const decision = decideVerificationRetry({
+    unitType: "execute-task",
+    retryInfo: {
+      unitId: "M001/S01/T01",
+      failureContext: "test failed differently",
+      attempt: 2,
+    },
+    previousFailureHash: hashVerificationFailureContext("test failed"),
+    random: () => 0.5,
+  });
+
+  assert.equal(decision.action, "delay");
+  assert.equal(decision.key, verificationRetryKey("execute-task", "M001/S01/T01"));
+  assert.equal(decision.delayMs, 4_000);
+  assert.equal(decision.baseDelayMs, 4_000);
+});
+
+test("decideVerificationRetry pauses when retry context is missing", () => {
+  assert.deepEqual(
+    decideVerificationRetry({
+      unitType: "execute-task",
+      retryInfo: null,
+      previousFailureHash: undefined,
+    }),
+    { action: "pause", reason: "missing-retry-context" },
+  );
+});

package/src/resources/extensions/gsd/tests/verification-verdict.test.ts

@@ -0,0 +1,78 @@
+// Project/App: GSD-2
+// File Purpose: Tests for host-owned auto-mode verification verdict policy.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { decideVerificationVerdict } from "../verification-verdict.ts";
+import type { VerificationResult } from "../types.ts";
+
+function makeResult(overrides: Partial<VerificationResult> = {}): VerificationResult {
+  return {
+    passed: true,
+    checks: [],
+    discoverySource: "none",
+    timestamp: 1,
+    ...overrides,
+  };
+}
+
+test("execute-task fails closed when no host-owned checks are discovered", () => {
+  const verdict = decideVerificationVerdict("execute-task", makeResult());
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "no-host-checks");
+  assert.equal(verdict.retryable, false);
+  assert.match(verdict.failureContext, /No runnable host-owned verification command/);
+});
+
+test("non execute-task units preserve no-check pass semantics", () => {
+  const verdict = decideVerificationVerdict("plan-slice", makeResult());
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});
+
+test("execute-task command failure remains retryable verification failure", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      passed: false,
+      discoverySource: "package-json",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 1,
+          stdout: "",
+          stderr: "failed",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, false);
+  assert.equal(verdict.reason, "checks-failed");
+  assert.equal(verdict.retryable, true);
+});
+
+test("execute-task passes when a discovered host check succeeds", () => {
+  const verdict = decideVerificationVerdict(
+    "execute-task",
+    makeResult({
+      discoverySource: "preference",
+      checks: [
+        {
+          command: "npm test",
+          exitCode: 0,
+          stdout: "ok",
+          stderr: "",
+          durationMs: 10,
+        },
+      ],
+    }),
+  );
+
+  assert.equal(verdict.passed, true);
+  assert.equal(verdict.reason, "passed");
+});

package/src/resources/extensions/gsd/tests/workflow-mcp.test.ts

@@ -35,6 +35,12 @@ test("auto execute-task requires canonical task completion tool", () => {
   assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("execute-task"), ["gsd_task_complete"]);
 });
 
+test("complete-slice requires closeout and execution handoff tools", () => {
+  const expected = ["gsd_slice_complete", "gsd_task_reopen", "gsd_replan_slice"];
+  assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("complete-slice"), expected);
+  assert.deepEqual(getRequiredWorkflowToolsForAutoUnit("complete-slice"), expected);
+});
+
 test("deep project setup units declare required workflow MCP tools", () => {
   assert.deepEqual(getRequiredWorkflowToolsForGuidedUnit("discuss-project"), [
     "ask_user_questions",
@@ -369,7 +375,7 @@ test("workflow MCP launch config reaches mutation tools over stdio", async () =>
               estimate: "10m",
               files: ["src/resources/extensions/gsd/workflow-mcp.ts"],
               verify: "node --test",
-              inputs: ["M001-ROADMAP.md"],
+              inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
               expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
             },
           ],

package/src/resources/extensions/gsd/tests/workflow-memory-pressure.test.ts

@@ -4,7 +4,10 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { measureMemoryPressure } from "../auto/workflow-memory-pressure.ts";
+import {
+  measureMemoryPressure,
+  shouldCheckMemoryPressure,
+} from "../auto/workflow-memory-pressure.ts";
 
 const mb = 1024 * 1024;
 
@@ -69,3 +72,20 @@ test("measureMemoryPressure falls back when heap limit cannot be read", () => {
     pct: 0.25,
   });
 });
+
+test("shouldCheckMemoryPressure covers the first auto-mode iteration", () => {
+  assert.equal(shouldCheckMemoryPressure(1, 5), true);
+  assert.equal(shouldCheckMemoryPressure(2, 5), false);
+  assert.equal(shouldCheckMemoryPressure(5, 5), true);
+});
+
+test("shouldCheckMemoryPressure rejects invalid intervals", () => {
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 0),
+    /positive integer/,
+  );
+  assert.throws(
+    () => shouldCheckMemoryPressure(1, 1.5),
+    /positive integer/,
+  );
+});

package/src/resources/extensions/gsd/tests/workflow-tool-executors.test.ts

@@ -246,7 +246,7 @@ test("executePlanSlice writes task planning state and rendered plan artifacts",
           estimate: "15m",
           files: ["src/resources/extensions/gsd/tools/workflow-tool-executors.ts"],
           verify: "node --test",
-          inputs: ["ROADMAP.md"],
+          inputs: [".gsd/milestones/M001/M001-ROADMAP.md"],
           expectedOutput: ["S01-PLAN.md", "T01-PLAN.md"],
         },
       ],

package/src/resources/extensions/gsd/tests/worktree-git-pathspec.test.ts

@@ -0,0 +1,39 @@
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync, existsSync, realpathSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+import { _gitPathspecForWorktreePath } from "../auto-worktree.ts";
+
+function run(cmd: string, args: string[], cwd: string): string {
+  return execFileSync(cmd, args, { cwd, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" }).trim();
+}
+
+describe("worktree git pathspec", () => {
+  test("skips external GSD bookkeeping directories outside the git work-tree", () => {
+    const root = realpathSync(mkdtempSync(join(tmpdir(), "gsd-pathspec-")));
+    const repo = join(root, "project");
+    const externalGsd = join(root, ".gsd", "projects", "abc123");
+
+    try {
+      mkdirSync(repo, { recursive: true });
+      mkdirSync(join(externalGsd, "milestones", "M002-wa00fm"), { recursive: true });
+      mkdirSync(join(externalGsd, "runtime", "units"), { recursive: true });
+      run("git", ["init"], repo);
+      writeFileSync(join(repo, "README.md"), "# test\n");
+
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "milestones", "M002-wa00fm")),
+        null,
+      );
+      assert.equal(
+        _gitPathspecForWorktreePath(repo, join(externalGsd, "runtime", "units")),
+        null,
+      );
+    } finally {
+      if (existsSync(root)) rmSync(root, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/worktree-journal-events.test.ts

@@ -1,20 +1,59 @@
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, rmSync, readFileSync, readdirSync } from "node:fs";
+import { mkdirSync, mkdtempSync, rmSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { execFileSync } from "node:child_process";
+
+/**
+ * Initialize the temp dir as a real git repo with a `.gsd/preferences.md`
+ * declaring the requested isolation mode. Required after ADR-016 phase 2 /
+ * C1+C2+C3 inlined the worktree-manager + cache + preferences primitives —
+ * tests can no longer stub them via deps.
+ */
+function initGitRepoIn(base: string, isolation: "worktree" | "branch" | "none"): void {
+  const git = (args: string[]): void => {
+    execFileSync("git", args, { cwd: base, stdio: "pipe" });
+  };
+  git(["init", "-b", "main"]);
+  git(["config", "user.email", "test@test.com"]);
+  git(["config", "user.name", "Test"]);
+  writeFileSync(join(base, "README.md"), "# test\n");
+  writeFileSync(join(base, ".gitignore"), ".gsd/worktrees/\n");
+  mkdirSync(join(base, ".gsd"), { recursive: true });
+  writeFileSync(
+    join(base, ".gsd", "preferences.md"),
+    `## Git\n- isolation: ${isolation}\n`,
+  );
+  git(["add", "."]);
+  git(["commit", "-m", "init"]);
+}
 import {
   WorktreeLifecycle,
+  resetRecentWorktreeMergeFailuresForTest,
   type WorktreeLifecycleDeps,
   type NotifyCtx,
 } from "../worktree-lifecycle.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
+import { type TaskCommitContext } from "../worktree.js";
+import { MergeConflictError } from "../git-service.js";
 
-// Test-local: LegacyTestDeps had three fields Lifecycle does not need
-// (shouldUseWorktreeIsolation, syncWorktreeStateBack, captureIntegrationBranch).
-// Permit them in test fixtures so existing override patterns keep working —
-// Lifecycle ignores the extras via structural typing.
+// ADR-016 phase 2 / C-track retired all worktree-manager + cache + prefs
+// fields from `WorktreeLifecycleDeps`. Tests still pass them as overrides
+// via the structural-typing escape hatch — listed here as optional so
+// fixtures can stub or omit them.
 type LegacyTestDeps = WorktreeLifecycleDeps & {
+  enterAutoWorktree?: (basePath: string, milestoneId: string) => string;
+  createAutoWorktree?: (basePath: string, milestoneId: string) => string;
+  enterBranchModeForMilestone?: (basePath: string, milestoneId: string) => void;
+  getAutoWorktreePath?: (basePath: string, milestoneId: string) => string | null;
+  isInAutoWorktree?: (basePath: string) => boolean;
+  autoWorktreeBranch?: (milestoneId: string) => string;
+  teardownAutoWorktree?: (
+    basePath: string,
+    milestoneId: string,
+    opts?: { preserveBranch?: boolean },
+  ) => void;
   shouldUseWorktreeIsolation?: () => boolean;
   syncWorktreeStateBack?: (
     mainBasePath: string,
@@ -22,6 +61,27 @@ type LegacyTestDeps = WorktreeLifecycleDeps & {
     milestoneId: string,
   ) => { synced: string[] };
   captureIntegrationBranch?: (basePath: string, mid: string | undefined) => void;
+  autoCommitCurrentBranch?: (
+    basePath: string,
+    unitType: string,
+    unitId: string,
+    taskContext?: TaskCommitContext,
+  ) => string | null;
+  getCurrentBranch?: (basePath: string) => string;
+  checkoutBranch?: (basePath: string, branch: string) => void;
+  readFileSync?: (path: string, encoding: BufferEncoding) => string;
+  getIsolationMode?: (basePath?: string) => "worktree" | "branch" | "none";
+  resolveMilestoneFile?: (
+    basePath: string,
+    milestoneId: string,
+    fileType: string,
+  ) => string | null;
+  GitServiceImpl?: new (basePath: string, gitConfig: unknown) => unknown;
+  loadEffectiveGSDPreferences?: () =>
+    | { preferences?: { git?: Record<string, unknown> } }
+    | null
+    | undefined;
+  invalidateAllCaches?: () => void;
 };
 import { AutoSession } from "../auto/session.js";
 import type { JournalEntry } from "../journal.js";
@@ -40,33 +100,19 @@ function makeSession(
 function makeDeps(
   overrides?: Partial<LegacyTestDeps>,
 ): LegacyTestDeps {
+  // ADR-016 phase 2 / C-track retired the worktree-manager + cache + prefs
+  // primitives from `WorktreeLifecycleDeps`. Tests in this file drive
+  // Lifecycle against real git fixtures (initGitRepoIn) — do NOT stub the
+  // C-track primitives here, or the override pattern will pre-empt the
+  // real `getAutoWorktreePath` / `createAutoWorktree` / etc. and the
+  // success/existing/failure branches won't fire as expected.
   const deps: LegacyTestDeps = {
-    isInAutoWorktree: () => false,
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
     mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
-    syncWorktreeStateBack: () => ({ synced: [] }),
-    teardownAutoWorktree: () => {},
-    createAutoWorktree: (_basePath: string, milestoneId: string) =>
-      `/project/.gsd/worktrees/${milestoneId}`,
-    enterAutoWorktree: (_basePath: string, milestoneId: string) =>
-      `/project/.gsd/worktrees/${milestoneId}`,
-    getAutoWorktreePath: () => null,
-    autoCommitCurrentBranch: () => {},
-    getCurrentBranch: () => "main",
-    checkoutBranch: () => {},
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (_basePath: string, milestoneId: string) =>
-      `/project/.gsd/milestones/${milestoneId}/${milestoneId}-ROADMAP.md`,
-    readFileSync: () => "# Roadmap\n- [x] S01: Slice one\n",
-    GitServiceImpl: class {
-      constructor() {}
-    } as unknown as LegacyTestDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => {},
-    captureIntegrationBranch: () => {},
-    enterBranchModeForMilestone: () => {},
     worktreeProjection: new WorktreeStateProjection(),
+    // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
+    gitServiceFactory: () => ({}) as unknown as ReturnType<
+      WorktreeLifecycleDeps["gitServiceFactory"]
+    >,
     ...overrides,
   };
   return deps;
@@ -97,6 +143,20 @@ function readJournalEntries(basePath: string): JournalEntry[] {
   }
 }
 
+function setupMergeWorktree(basePath: string, milestoneId: string): string {
+  initGitRepoIn(basePath, "worktree");
+  execFileSync("git", ["checkout", "-b", `milestone/${milestoneId}`], { cwd: basePath, stdio: "pipe" });
+  execFileSync("git", ["checkout", "main"], { cwd: basePath, stdio: "pipe" });
+  const wt = join(basePath, ".gsd", "worktrees", milestoneId);
+  execFileSync("git", ["worktree", "add", wt, `milestone/${milestoneId}`], { cwd: basePath, stdio: "pipe" });
+  mkdirSync(join(basePath, ".gsd", "milestones", milestoneId), { recursive: true });
+  writeFileSync(
+    join(basePath, ".gsd", "milestones", milestoneId, `${milestoneId}-ROADMAP.md`),
+    `# ${milestoneId}\n- [x] S01: Slice one\n`,
+  );
+  return wt;
+}
+
 // ─── Tests ───────────────────────────────────────────────────────────────────
 
 describe("worktree journal events", () => {
@@ -104,7 +164,10 @@ describe("worktree journal events", () => {
   const originalCwd = process.cwd();
 
   beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "wt-journal-"));
+    resetRecentWorktreeMergeFailuresForTest();
+    // realpathSync to match what `auto-worktree.ts` returns from
+    // `resolveWorktreeProjectRoot` (macOS resolves `/var` → `/private/var`).
+    tmp = realpathSync(mkdtempSync(join(tmpdir(), "wt-journal-")));
   });
   afterEach(() => {
     // Restore cwd before cleanup — on Windows, rmSync fails with EPERM
@@ -114,9 +177,17 @@ describe("worktree journal events", () => {
   });
 
   test("enterMilestone emits worktree-enter on success (new worktree)", () => {
+    initGitRepoIn(tmp, "worktree");
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({ getAutoWorktreePath: () => null });
-    new WorktreeLifecycle(s, deps).enterMilestone("M001", makeNotifyCtx());
+    const result = new WorktreeLifecycle(s, makeDeps()).enterMilestone(
+      "M001",
+      makeNotifyCtx(),
+    );
+    assert.equal(
+      result.ok,
+      true,
+      `enterMilestone failed: ${JSON.stringify(result)}`,
+    );
 
     const entries = readJournalEntries(tmp);
     const enter = entries.find(e => e.eventType === "worktree-enter");
@@ -127,11 +198,19 @@ describe("worktree journal events", () => {
   });
 
   test("enterMilestone emits worktree-enter with created=false for existing worktree", () => {
+    // Pre-create the worktree on disk so the second enter goes through the
+    // existing-worktree branch in `_enterMilestoneCore`.
+    initGitRepoIn(tmp, "worktree");
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: tmp, stdio: "pipe" });
+    execFileSync("git", ["checkout", "main"], { cwd: tmp, stdio: "pipe" });
+    execFileSync(
+      "git",
+      ["worktree", "add", join(tmp, ".gsd", "worktrees", "M001"), "milestone/M001"],
+      { cwd: tmp, stdio: "pipe" },
+    );
+
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({
-      getAutoWorktreePath: () => "/project/.gsd/worktrees/M001",
-    });
-    new WorktreeLifecycle(s, deps).enterMilestone("M001", makeNotifyCtx());
+    new WorktreeLifecycle(s, makeDeps()).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     const enter = entries.find(e => e.eventType === "worktree-enter");
@@ -140,9 +219,9 @@ describe("worktree journal events", () => {
   });
 
   test("enterMilestone emits worktree-skip when isolation disabled", () => {
+    initGitRepoIn(tmp, "none");
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({ shouldUseWorktreeIsolation: () => false, getIsolationMode: () => "none" });
-    new WorktreeLifecycle(s, deps).enterMilestone("M001", makeNotifyCtx());
+    new WorktreeLifecycle(s, makeDeps()).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     const skip = entries.find(e => e.eventType === "worktree-skip");
@@ -152,30 +231,31 @@ describe("worktree journal events", () => {
   });
 
   test("enterMilestone emits worktree-create-failed on error", () => {
+    // Real fixture with isolation:worktree, then delete .git to force the
+    // real createAutoWorktree to throw.
+    initGitRepoIn(tmp, "worktree");
+    rmSync(join(tmp, ".git"), { recursive: true, force: true });
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({
-      getAutoWorktreePath: () => null,
-      createAutoWorktree: () => { throw new Error("disk full"); },
-    });
-    new WorktreeLifecycle(s, deps).enterMilestone("M001", makeNotifyCtx());
+    new WorktreeLifecycle(s, makeDeps()).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     const failed = entries.find(e => e.eventType === "worktree-create-failed");
     assert.ok(failed, "worktree-create-failed event should be emitted");
     assert.equal(failed!.data?.milestoneId, "M001");
-    assert.equal(failed!.data?.error, "disk full");
+    assert.ok(failed!.data?.error, "error message should be present");
     assert.equal(failed!.data?.fallback, "project-root");
   });
 
   test("mergeAndExit emits worktree-merge-start", () => {
-    const s = makeSession({
-      basePath: join(tmp, "worktree"),
-      originalBasePath: tmp,
-    });
-    const deps = makeDeps({
-      isInAutoWorktree: () => true,
-      getIsolationMode: () => "worktree",
-    });
+    initGitRepoIn(tmp, "worktree");
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: tmp, stdio: "pipe" });
+    execFileSync("git", ["checkout", "main"], { cwd: tmp, stdio: "pipe" });
+    const wt = join(tmp, ".gsd", "worktrees", "M001");
+    execFileSync("git", ["worktree", "add", wt, "milestone/M001"], { cwd: tmp, stdio: "pipe" });
+
+    const s = makeSession({ basePath: wt, originalBasePath: tmp });
+    const deps = makeDeps();
+    process.chdir(wt);
     new WorktreeLifecycle(s, deps).exitMilestone(
       "M001",
       { merge: true },
@@ -189,14 +269,41 @@ describe("worktree journal events", () => {
     assert.equal(start!.data?.mode, "worktree");
   });
 
-  test("mergeAndExit emits worktree-merge-failed on error", () => {
-    const s = makeSession({
-      basePath: join(tmp, "worktree"),
-      originalBasePath: tmp,
+  test("exitMilestone propagates codeFilesChanged from merge result", () => {
+    initGitRepoIn(tmp, "worktree");
+    execFileSync("git", ["checkout", "-b", "milestone/M001"], { cwd: tmp, stdio: "pipe" });
+    execFileSync("git", ["checkout", "main"], { cwd: tmp, stdio: "pipe" });
+    const wt = join(tmp, ".gsd", "worktrees", "M001");
+    execFileSync("git", ["worktree", "add", wt, "milestone/M001"], { cwd: tmp, stdio: "pipe" });
+    mkdirSync(join(tmp, ".gsd", "milestones", "M001"), { recursive: true });
+    writeFileSync(
+      join(tmp, ".gsd", "milestones", "M001", "M001-ROADMAP.md"),
+      "# M001\n- [x] S01: Slice one\n",
+    );
+
+    const s = makeSession({ basePath: wt, originalBasePath: tmp });
+    const deps = makeDeps({
+      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    });
+    process.chdir(wt);
+
+    const result = new WorktreeLifecycle(s, deps).exitMilestone(
+      "M001",
+      { merge: true },
+      makeNotifyCtx(),
+    );
+
+    assert.deepEqual(result, {
+      ok: true,
+      merged: true,
+      codeFilesChanged: true,
     });
+  });
+
+  test("mergeAndExit emits worktree-merge-failed on error", () => {
+    const wt = setupMergeWorktree(tmp, "M001");
+    const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      isInAutoWorktree: () => true,
-      getIsolationMode: () => "worktree",
       mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
     });
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal
@@ -218,11 +325,56 @@ describe("worktree journal events", () => {
       );
     }
 
+    new WorktreeLifecycle(s, deps).exitMilestone(
+      "M001",
+      { merge: true },
+      makeNotifyCtx(),
+    );
+
     const entries = readJournalEntries(tmp);
-    const failed = entries.find(e => e.eventType === "worktree-merge-failed");
+    const failures = entries.filter(e => e.eventType === "worktree-merge-failed");
+    const failed = failures[0];
     assert.ok(failed, "worktree-merge-failed event should be emitted");
     assert.equal(failed!.data?.milestoneId, "M001");
     assert.equal(failed!.data?.error, "conflict in main");
+    assert.equal(failures.length, 1, "duplicate merge failures are journaled once");
+  });
+
+  test("merge failure dedupe uses stable conflict category and expires", (t) => {
+    let now = 1_000_000;
+    t.mock.method(Date, "now", () => now);
+    const wt = setupMergeWorktree(tmp, "M001");
+    const s = makeSession({ basePath: wt, originalBasePath: tmp });
+    let attempt = 0;
+    const deps = makeDeps({
+      mergeMilestoneToMain: () => {
+        attempt += 1;
+        throw new MergeConflictError(
+          attempt === 1 ? ["src/a.ts"] : ["src/b.ts", "src/c.ts"],
+          "squash",
+          "milestone/M001",
+          "main",
+        );
+      },
+    });
+    const lifecycle = new WorktreeLifecycle(s, deps);
+
+    lifecycle.exitMilestone("M001", { merge: true }, makeNotifyCtx());
+    lifecycle.exitMilestone("M001", { merge: true }, makeNotifyCtx());
+
+    let failures = readJournalEntries(tmp).filter(e => e.eventType === "worktree-merge-failed");
+    assert.equal(failures.length, 1, "variable conflict filenames should not bypass dedupe");
+    assert.match(
+      String(failures[0]!.data?.error),
+      /src\/a\.ts/,
+      "journal payload keeps the original error message",
+    );
+
+    now += 60_001;
+    lifecycle.exitMilestone("M001", { merge: true }, makeNotifyCtx());
+
+    failures = readJournalEntries(tmp).filter(e => e.eventType === "worktree-merge-failed");
+    assert.equal(failures.length, 2, "same merge failure is journaled again after dedupe expiry");
   });
 
   test("journal entries have valid flowId, seq, and ts fields", () => {