gsd-pi 2.81.0 → 2.82.0-dev.c22380fc3

package/src/resources/extensions/gsd/tests/token-tool-gating.test.ts

@@ -124,6 +124,8 @@ test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", ()
     "gsd_milestone_status",
     "gsd_checkpoint_db",
     "gsd_task_complete",
+    "gsd_task_reopen",
+    "gsd_replan_slice",
     "gsd_slice_complete",
     "gsd_complete_slice",
     "memory_query",
@@ -131,6 +133,8 @@ test("buildMinimalAutoGsdToolSet includes closeout tool for complete-slice", ()
   ], "complete-slice");
 
   assert.ok(result.includes("gsd_slice_complete"));
+  assert.ok(result.includes("gsd_task_reopen"));
+  assert.ok(result.includes("gsd_replan_slice"));
   assert.ok(result.includes("subagent"));
   assert.ok(result.includes("capture_thought"));
   assert.ok(!result.includes("gsd_task_complete"));

package/src/resources/extensions/gsd/tests/tui-header-lifecycle.test.ts

@@ -10,8 +10,9 @@ import assert from "node:assert/strict";
 import { mkdirSync, rmSync } from "node:fs";
 import { join } from "node:path";
 import { tmpdir } from "node:os";
+import { visibleWidth } from "@gsd/pi-tui";
 
-import { updateProgressWidget } from "../auto-dashboard.ts";
+import { setCompletionProgressWidget, updateProgressWidget } from "../auto-dashboard.ts";
 import type { GSDState } from "../types.ts";
 
 interface CapturedSetHeader {
@@ -46,6 +47,15 @@ const baseAccessors = {
   getCurrentDispatchedModelId: () => null,
 };
 
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
 // ── Header lifecycle ────────────────────────────────────────────────────
 
 test("updateProgressWidget installs an EMPTY-rendering header (not undefined) — addresses codex P1 finding that setHeader(undefined) restores the built-in logo+instructions header", (t) => {
@@ -208,3 +218,113 @@ test("auto-dashboard widget render output omits Ctrl+N guidance when isStepMode
 
   if (component.dispose) component.dispose();
 });
+
+test("auto-dashboard widget render output fits common terminal widths", (t) => {
+  const dir = makeTempDir("width-safe");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  updateProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    "execute-task",
+    "M001/S01/T01",
+    baseState,
+    { ...baseAccessors, getBasePath: () => dir },
+  );
+
+  assert.ok(widgetFactory);
+
+  const component = widgetFactory!(
+    { requestRender() {} },
+    {
+      fg: (_color: string, text: string) => text,
+      bold: (text: string) => text,
+    },
+  );
+  t.after(() => component.dispose?.());
+
+  for (const width of [40, 80, 120]) {
+    assertLinesFit(component.render(width), width);
+    component.invalidate();
+  }
+
+  if (component.dispose) component.dispose();
+});
+
+test("completion dashboard keeps final milestone roll-up in the progress widget", (t) => {
+  const dir = makeTempDir("completion-widget");
+  mkdirSync(join(dir, ".gsd"), { recursive: true });
+  t.after(() => cleanup(dir));
+
+  let widgetFactory: ((tui: unknown, theme: unknown) => any) | undefined;
+
+  setCompletionProgressWidget(
+    {
+      hasUI: true,
+      ui: {
+        setWidget(_key: string, factory: any) { widgetFactory = factory; },
+        setHeader() {},
+        setStatus() {},
+      },
+    } as any,
+    {
+      milestoneId: "M003",
+      milestoneTitle: "Budget tracking",
+      oneLiner: "Added milestone budget warning output and provider roll-up details.",
+      successCriteriaResults: "Budget warnings appear at the end of milestone completion.",
+      requirementOutcomes: "Users can see what shipped without opening a fresh session.",
+      keyFiles: ["src/resources/extensions/gsd/auto-dashboard.ts", "src/resources/extensions/gsd/auto.ts"],
+      keyDecisions: ["Keep completion closeout in the same TUI surface."],
+      followUps: "None.",
+      reason: "Milestone M003 complete",
+      startedAt: Date.now() - 90_000,
+      totalCost: 21.29,
+      totalTokens: 1_000_000,
+      unitCount: 8,
+      cacheHitRate: 100,
+      contextPercent: 0.9,
+      contextWindow: 1_000_000,
+      completedSlices: 3,
+      totalSlices: 3,
+      basePath: dir,
+    },
+  );
+
+  assert.ok(widgetFactory, "completion widget factory must be installed");
+
+  const fakeTui = { requestRender() {} };
+  const fakeTheme = {
+    fg: (_color: string, text: string) => text,
+    bold: (text: string) => text,
+  };
+  const component = widgetFactory!(fakeTui, fakeTheme);
+  const output = component.render(140).join("\n");
+
+  assert.match(output, /Milestone M003 roll-up/);
+  assert.match(output, /Budget tracking/);
+  assert.match(output, /Outcome/);
+  assert.match(output, /Added milestone budget warning output/);
+  assert.match(output, /What changed/);
+  assert.match(output, /Budget warnings appear/);
+  assert.match(output, /Users can see what shipped/);
+  assert.match(output, /Keep completion closeout/);
+  assert.match(output, /Verification/);
+  assert.match(output, /Files: src\/resources\/extensions\/gsd\/auto-dashboard\.ts/);
+  assert.match(output, /Run totals 3\/3 slices/);
+  assert.match(output, /100% cache hit/);
+  assert.match(output, /\$21\.29/);
+  assert.match(output, /1\.0M tokens/);
+  assert.match(output, /8 units/);
+  assert.doesNotMatch(output, /COMPLETE-MILESTONE/);
+
+  if (component.dispose) component.dispose();
+});

package/src/resources/extensions/gsd/tests/tui-render-kit.test.ts

@@ -0,0 +1,66 @@
+// Project/App: GSD-2
+// File Purpose: Unit tests for shared GSD TUI render helpers.
+
+import { describe, test } from "node:test";
+import assert from "node:assert/strict";
+
+import { visibleWidth } from "@gsd/pi-tui";
+import {
+  padRightVisible,
+  renderFrame,
+  renderKeyHints,
+  renderProgressBar,
+  rightAlign,
+  safeLine,
+  wrapVisibleText,
+  type ThemeLike,
+} from "../tui/render-kit.ts";
+
+const theme: ThemeLike = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
+
+function assertWidth(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds width ${width}: ${visibleWidth(line)} "${line}"`,
+    );
+  }
+}
+
+describe("tui render kit", () => {
+  test("safeLine clamps visible width", () => {
+    assert.equal(visibleWidth(safeLine("abcdef", 4)), 4);
+    assert.equal(safeLine("abcdef", 0), "");
+  });
+
+  test("padRightVisible fills exact visible width", () => {
+    const line = padRightVisible("abc", 8);
+    assert.equal(visibleWidth(line), 8);
+  });
+
+  test("rightAlign keeps output within width", () => {
+    for (const width of [10, 40, 80]) {
+      assertWidth([rightAlign("left side with overflow", "right side", width)], width);
+    }
+  });
+
+  test("wrapVisibleText clamps long words and ansi-aware content", () => {
+    const lines = wrapVisibleText("https://example.com/" + "a".repeat(120), 24);
+    assert.ok(lines.length > 0);
+    assertWidth(lines, 24);
+  });
+
+  test("renderFrame keeps borders and rows within width", () => {
+    for (const width of [3, 40, 80]) {
+      assertWidth(renderFrame(theme, ["row", "long ".repeat(40)], width), width);
+    }
+  });
+
+  test("renderKeyHints and renderProgressBar fit caller budgets", () => {
+    assert.ok(visibleWidth(renderKeyHints(theme, ["↑↓ scroll", "esc close"], 12)) <= 12);
+    assert.equal(visibleWidth(renderProgressBar(theme, 2, 4, 16)), 16);
+  });
+});

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/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",

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

@@ -1,20 +1,57 @@
 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,
   type WorktreeLifecycleDeps,
   type NotifyCtx,
 } from "../worktree-lifecycle.js";
 import { WorktreeStateProjection } from "../worktree-state-projection.js";
+import { type TaskCommitContext } from "../worktree.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 +59,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 +98,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;
@@ -104,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
@@ -114,9 +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 });
-    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 +181,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 +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" });
-    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 +214,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 +252,51 @@ 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"); },
     });
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal