gsd-pi 2.80.0-dev.fbe7c8c6f → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/worktree-db-same-file.test.ts

@@ -1,13 +1,4 @@
-/**
- * worktree-db-same-file.test.ts — Regression test for #2823.
- *
- * Verifies that reconcileWorktreeDb() does not ATTACH a WAL-mode DB file
- * to itself when the worktree DB path resolves to the same physical file
- * as the main DB path (shared-WAL / symlink layout).
- *
- * Also verifies that the auto-loop classifies "database disk image is
- * malformed" as an infrastructure error to prevent wasting retries.
- */
+// GSD-2 — Worktree DB same-file reconciliation regression tests.
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
@@ -15,10 +6,8 @@ import {
   existsSync,
   mkdirSync,
   mkdtempSync,
-  readFileSync,
   rmSync,
   symlinkSync,
-  writeFileSync,
 } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
@@ -29,10 +18,11 @@ import {
   reconcileWorktreeDb,
   insertDecision,
 } from "../gsd-db.ts";
+import {
+  _shouldReconcileWorktreeDb,
+} from "../auto-worktree.ts";
 import { isInfrastructureError } from "../auto/infra-errors.ts";
 
-// ─── Fix 1 & 2: reconcileWorktreeDb same-file guard ─────────────────
-
 describe("#2823: reconcileWorktreeDb same-file guard", () => {
   let tmpDir: string;
 
@@ -50,7 +40,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     mkdirSync(mainGsd, { recursive: true });
     const mainDbPath = join(mainGsd, "gsd.db");
 
-    // Create a real DB at mainDbPath
     openDatabase(mainDbPath);
     insertDecision({
       id: "D001",
@@ -64,17 +53,14 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
       superseded_by: null,
     });
 
-    // Create a worktree path that resolves to the same file via symlink
     const wtGsd = join(tmpDir, "worktree", ".gsd");
     mkdirSync(join(tmpDir, "worktree"), { recursive: true });
     symlinkSync(mainGsd, wtGsd, "junction");
     const worktreeDbPath = join(wtGsd, "gsd.db");
 
-    // Both paths exist and resolve to the same physical file
     assert.ok(existsSync(mainDbPath), "main DB exists");
-    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists (via symlink)");
+    assert.ok(existsSync(worktreeDbPath), "worktree DB path exists via symlink");
 
-    // This should NOT attempt ATTACH — should return zero result
     const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
 
     assert.equal(result.decisions, 0, "no decisions reconciled");
@@ -101,7 +87,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
       superseded_by: null,
     });
 
-    // Same exact path — should bail immediately
     const result = reconcileWorktreeDb(dbPath, dbPath);
 
     assert.equal(result.decisions, 0);
@@ -109,7 +94,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
   });
 
   test("still reconciles when paths are genuinely different files", () => {
-    // Main DB
     const mainGsd = join(tmpDir, "main", ".gsd");
     mkdirSync(mainGsd, { recursive: true });
     const mainDbPath = join(mainGsd, "gsd.db");
@@ -128,7 +112,6 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     });
     closeDatabase();
 
-    // Create a separate worktree DB with different data
     const wtGsd = join(tmpDir, "worktree", ".gsd");
     mkdirSync(wtGsd, { recursive: true });
     const worktreeDbPath = join(wtGsd, "gsd.db");
@@ -147,42 +130,36 @@ describe("#2823: reconcileWorktreeDb same-file guard", () => {
     });
     closeDatabase();
 
-    // Re-open main and reconcile — should work normally
     openDatabase(mainDbPath);
     const result = reconcileWorktreeDb(mainDbPath, worktreeDbPath);
 
-    assert.ok(
-      result.decisions > 0,
-      "should reconcile decisions from a genuinely different DB",
-    );
+    assert.ok(result.decisions > 0, "should reconcile decisions from a different DB");
   });
 });
 
-test("merge-time DB reconciliation only runs when legacy worktree DB exists", () => {
-  const src = readFileSync(join(import.meta.dirname, "..", "auto-worktree.ts"), "utf-8");
-  const reconcileIdx = src.indexOf("reconcileWorktreeDb(mainDbPath, worktreeDbPath)");
-  assert.ok(reconcileIdx !== -1, "merge-time reconcile call exists");
-  const guardWindow = src.slice(Math.max(0, reconcileIdx - 240), reconcileIdx);
-
-  assert.ok(
-    guardWindow.includes("existsSync(worktreeDbPath)") && guardWindow.includes("!isSamePath(worktreeDbPath, mainDbPath)"),
-    "merge-time reconcile requires a real legacy worktree DB and distinct DB paths",
+test("merge-time DB reconciliation requires an existing distinct worktree DB", () => {
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => true, () => false),
+    true,
+  );
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => false, () => false),
+    false,
+  );
+  assert.equal(
+    _shouldReconcileWorktreeDb("worktree.db", "main.db", () => true, () => true),
+    false,
   );
 });
 
-// ─── Fix 3: infrastructure error classification ─────────────────────
-
 describe("#2823: malformed DB classified as infrastructure error", () => {
   test("database disk image is malformed is detected as infra error", () => {
-    const err = new Error("database disk image is malformed");
-    const code = isInfrastructureError(err);
-    assert.ok(code !== null, "should be classified as infrastructure error");
+    const code = isInfrastructureError(new Error("database disk image is malformed"));
     assert.equal(code, "SQLITE_CORRUPT");
   });
 
   test("other SQLite errors are not falsely classified", () => {
-    const err = new Error("SQLITE_BUSY: database is locked");
-    const code = isInfrastructureError(err);
-    assert.equal(code, null, "SQLITE_BUSY should not be infra error (it's transient)");
+    const code = isInfrastructureError(new Error("SQLITE_BUSY: database is locked"));
+    assert.equal(code, null);
   });
 });

package/src/resources/extensions/gsd/tests/worktree-expected-warnings.test.ts

@@ -1,38 +1,39 @@
-/**
- * worktree-expected-warnings.test.ts — #3665
- *
- * Verify that auto-worktree.ts and worktree-manager.ts suppress expected
- * ENOENT and EISDIR conditions instead of logging misleading warnings.
- */
+// GSD-2 — Expected worktree condition warning suppression tests.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join, dirname } from "node:path";
-import { fileURLToPath } from "node:url";
+import { mkdtempSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { join, resolve } from "node:path";
+import { tmpdir } from "node:os";
 
-const __dirname = dirname(fileURLToPath(import.meta.url));
-const autoWorktreeFile = join(__dirname, "..", "auto-worktree.ts");
-const worktreeManagerFile = join(__dirname, "..", "worktree-manager.ts");
+import { _isExpectedWorktreeUnlinkError } from "../auto-worktree.ts";
+import { resolveGitDir } from "../worktree-manager.ts";
 
 describe("worktree expected-condition warning suppression (#3665)", () => {
-  const autoSource = readFileSync(autoWorktreeFile, "utf-8");
-
-  test("auto-worktree.ts checks for ENOENT before logging unlink warning", () => {
-    assert.match(autoSource, /code\s*!==\s*["']ENOENT["']/);
-  });
-
-  test("auto-worktree.ts checks for EISDIR before logging unlink warning", () => {
-    assert.match(autoSource, /code\s*!==\s*["']EISDIR["']/);
+  test("known unlink races are classified as expected", () => {
+    assert.equal(_isExpectedWorktreeUnlinkError("ENOENT"), true);
+    assert.equal(_isExpectedWorktreeUnlinkError("EISDIR"), true);
+    assert.equal(_isExpectedWorktreeUnlinkError("EACCES"), false);
   });
 
-  test("auto-worktree.ts references issue #3597", () => {
-    assert.match(autoSource, /#3597/);
+  test("resolveGitDir returns .git directory without reading it as a file", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-resolve-gitdir-"));
+    try {
+      mkdirSync(join(base, ".git"), { recursive: true });
+      assert.equal(resolveGitDir(base), join(base, ".git"));
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 
-  const managerSource = readFileSync(worktreeManagerFile, "utf-8");
-
-  test("worktree-manager.ts checks isDirectory() before reading .git file", () => {
-    assert.match(managerSource, /lstatSync\(gitPath\)\.isDirectory\(\)/);
+  test("resolveGitDir resolves worktree .git file targets", () => {
+    const base = mkdtempSync(join(tmpdir(), "gsd-resolve-worktree-gitdir-"));
+    try {
+      mkdirSync(join(base, ".gitdir"), { recursive: true });
+      writeFileSync(join(base, ".git"), "gitdir: .gitdir\n");
+      assert.equal(resolveGitDir(base), resolve(base, ".gitdir"));
+    } finally {
+      rmSync(base, { recursive: true, force: true });
+    }
   });
 });

package/src/resources/extensions/gsd/tests/worktree-health-dispatch.test.ts

@@ -9,12 +9,13 @@
 
 import { describe, test, beforeEach, afterEach } from "node:test";
 import assert from "node:assert/strict";
-import { existsSync, mkdtempSync, mkdirSync, readFileSync, writeFileSync, rmSync, readdirSync } from "node:fs";
+import { existsSync, mkdtempSync, mkdirSync, writeFileSync, rmSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
 import { execSync } from "node:child_process";
 
 import { PROJECT_FILES, classifyProject } from "../detection.js";
+import { _shouldProceedWithInvalidRepoClassificationForTest } from "../auto/phases.ts";
 
 // ─── Helpers ─────────────────────────────────────────────────────────────────
 
@@ -86,19 +87,19 @@ test("PROJECT_FILES is exported and contains expected multi-ecosystem entries",
   assert.ok(PROJECT_FILES.includes("Package.swift"), "includes Swift marker");
 });
 
-test("runUnitPhase fails closed when classification returns invalid-repo", () => {
-  const source = readFileSync(join(process.cwd(), "src/resources/extensions/gsd/auto/phases.ts"), "utf-8");
-  const invalidRepoBranch = source.slice(
-    source.indexOf('projectClassification.kind === "invalid-repo"'),
-    source.indexOf('projectClassification.kind === "greenfield"'),
+test("invalid-repo classification only proceeds when the git marker was already confirmed", () => {
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", true),
+    true,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("missing .git", false),
+    false,
+  );
+  assert.equal(
+    _shouldProceedWithInvalidRepoClassificationForTest("permission denied", true),
+    false,
   );
-
-  assert.match(invalidRepoBranch, /projectClassification\.reason === "missing \.git" && hasGit/);
-  assert.match(invalidRepoBranch, /project classification could not confirm \.git/);
-  assert.match(invalidRepoBranch, /ctx\.ui\.notify\(msg,\s*"error"\)/);
-  assert.match(invalidRepoBranch, /await deps\.stopAuto\(ctx,\s*pi,\s*msg\)/);
-  assert.match(invalidRepoBranch, /return \{ action: "break", reason: "worktree-invalid" \}/);
-  assert.match(invalidRepoBranch, /classified as invalid-repo/);
 });
 
 describe("health check with git repo", () => {

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

@@ -1,13 +1,86 @@
 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 {
-  WorktreeResolver,
-  type WorktreeResolverDeps,
+  WorktreeLifecycle,
+  type WorktreeLifecycleDeps,
   type NotifyCtx,
-} from "../worktree-resolver.js";
+} from "../worktree-lifecycle.js";
+import { WorktreeStateProjection } from "../worktree-state-projection.js";
+import { type TaskCommitContext } from "../worktree.js";
+
+// 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,
+    worktreePath: string,
+    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";
 
@@ -23,33 +96,21 @@ function makeSession(
 }
 
 function makeDeps(
-  overrides?: Partial<WorktreeResolverDeps>,
-): WorktreeResolverDeps {
-  const deps: WorktreeResolverDeps = {
-    isInAutoWorktree: () => false,
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
+  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 = {
     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",
-    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 WorktreeResolverDeps["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;
@@ -87,7 +148,9 @@ describe("worktree journal events", () => {
   const originalCwd = process.cwd();
 
   beforeEach(() => {
-    tmp = mkdtempSync(join(tmpdir(), "wt-journal-"));
+    // 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
@@ -97,11 +160,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 });
-    const resolver = new WorktreeResolver(s, deps);
-
-    resolver.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");
@@ -112,13 +181,19 @@ describe("worktree journal events", () => {
   });
 
   test("enterMilestone emits worktree-enter with created=false for existing worktree", () => {
-    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
-    const deps = makeDeps({
-      getAutoWorktreePath: () => "/project/.gsd/worktrees/M001",
-    });
-    const resolver = new WorktreeResolver(s, deps);
+    // 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" },
+    );
 
-    resolver.enterMilestone("M001", makeNotifyCtx());
+    const s = makeSession({ basePath: tmp, originalBasePath: tmp });
+    new WorktreeLifecycle(s, makeDeps()).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     const enter = entries.find(e => e.eventType === "worktree-enter");
@@ -127,11 +202,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" });
-    const resolver = new WorktreeResolver(s, deps);
-
-    resolver.enterMilestone("M001", makeNotifyCtx());
+    new WorktreeLifecycle(s, makeDeps()).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     const skip = entries.find(e => e.eventType === "worktree-skip");
@@ -141,35 +214,36 @@ 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"); },
-    });
-    const resolver = new WorktreeResolver(s, deps);
-
-    resolver.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",
-    });
-    const resolver = new WorktreeResolver(s, deps);
+    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" });
 
-    resolver.mergeAndExit("M001", makeNotifyCtx());
+    const s = makeSession({ basePath: wt, originalBasePath: tmp });
+    const deps = makeDeps();
+    process.chdir(wt);
+    new WorktreeLifecycle(s, deps).exitMilestone(
+      "M001",
+      { merge: true },
+      makeNotifyCtx(),
+    );
 
     const entries = readJournalEntries(tmp);
     const start = entries.find(e => e.eventType === "worktree-merge-start");
@@ -178,24 +252,71 @@ 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", () => {
+    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({
-      isInAutoWorktree: () => true,
-      getIsolationMode: () => "worktree",
       mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
     });
-    const resolver = new WorktreeResolver(s, deps);
-
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal
-    // event and restoring state — callers must handle the throw.
-    assert.throws(
-      () => resolver.mergeAndExit("M001", makeNotifyCtx()),
-      /conflict in main/,
+    // event and restoring state. Lifecycle now wraps that throw in a typed
+    // ExitResult — failure surfaces as ok:false / cause.
+    const result = new WorktreeLifecycle(s, deps).exitMilestone(
+      "M001",
+      { merge: true },
+      makeNotifyCtx(),
     );
+    assert.equal(result.ok, false);
+    if (!result.ok) {
+      assert.equal(result.reason, "teardown-failed");
+      assert.match(
+        result.cause instanceof Error
+          ? result.cause.message
+          : String(result.cause),
+        /conflict in main/,
+      );
+    }
 
     const entries = readJournalEntries(tmp);
     const failed = entries.find(e => e.eventType === "worktree-merge-failed");
@@ -207,9 +328,7 @@ describe("worktree journal events", () => {
   test("journal entries have valid flowId, seq, and ts fields", () => {
     const s = makeSession({ basePath: tmp, originalBasePath: tmp });
     const deps = makeDeps({ shouldUseWorktreeIsolation: () => false });
-    const resolver = new WorktreeResolver(s, deps);
-
-    resolver.enterMilestone("M001", makeNotifyCtx());
+    new WorktreeLifecycle(s, deps).enterMilestone("M001", makeNotifyCtx());
 
     const entries = readJournalEntries(tmp);
     assert.ok(entries.length > 0, "at least one entry should exist");