@opengsd/gsd-pi 1.4.0-dev.5fc22c6f → 1.4.0-dev.c18009cd

package/src/resources/extensions/gsd/tests/milestone-merge-stash-restore.test.ts

@@ -4,7 +4,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 
-import { _runMilestoneMergeWithStashRestore } from "../auto/closeout.js";
+import {
+  _runMilestoneMergeOnceWithStashRestore,
+  _runMilestoneMergeWithStashRestore,
+} from "../auto/closeout.js";
 import type { IterationContext } from "../auto/types.js";
 import { MergeConflictError } from "../git-service.js";
 import type {
@@ -58,6 +61,30 @@ function buildIc(opts: {
     },
   };
 
+  const plainExitMilestone = (exitOpts: { merge: boolean }) => {
+    log.mergeCalls += 1;
+    if (opts.mergeBehavior === "succeed") {
+      return { ok: true, merged: exitOpts.merge, codeFilesChanged: false } as const;
+    }
+    try {
+      opts.mergeBehavior();
+      return { ok: true, merged: exitOpts.merge, codeFilesChanged: false } as const;
+    } catch (err) {
+      // Mirror Lifecycle's typed-result wrapping of MergeConflictError
+      // and other thrown values per worktree-lifecycle.exitMilestone.
+      const isMergeConflict =
+        err !== null &&
+        typeof err === "object" &&
+        err !== undefined &&
+        (err as { name?: string }).name === "MergeConflictError";
+      return {
+        ok: false,
+        reason: isMergeConflict ? "merge-conflict" : "teardown-failed",
+        cause: err,
+      } as const;
+    }
+  };
+
   const deps = {
     preflightCleanRoot: () => {
       log.preflightCalls += 1;
@@ -76,28 +103,72 @@ function buildIc(opts: {
       },
     },
     lifecycle: {
-      exitMilestone: (_mid: string, exitOpts: { merge: boolean }) => {
-        log.mergeCalls += 1;
-        if (opts.mergeBehavior === "succeed") {
-          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
-        }
-        try {
-          opts.mergeBehavior();
-          return { ok: true, merged: exitOpts.merge, codeFilesChanged: false };
-        } catch (err) {
-          // Mirror Lifecycle's typed-result wrapping of MergeConflictError
-          // and other thrown values per worktree-lifecycle.exitMilestone.
-          const isMergeConflict =
-            err !== null &&
-            typeof err === "object" &&
-            err !== undefined &&
-            (err as { name?: string }).name === "MergeConflictError";
-          return {
-            ok: false,
-            reason: isMergeConflict ? "merge-conflict" : "teardown-failed",
-            cause: err,
-          } as const;
+      exitMilestone: (
+        _mid: string,
+        exitOpts: {
+          merge: boolean;
+          guardedMerge?: {
+            projectRoot: string;
+            preflightCleanRoot: (
+              basePath: string,
+              milestoneId: string,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => PreflightResult;
+            postflightPopStash: (
+              basePath: string,
+              milestoneId: string,
+              stashMarker: string | undefined,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => PostflightResult;
+          };
+        },
+        exitCtx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+      ) => {
+        const notify = exitCtx?.notify ?? (() => {});
+        const guarded = exitOpts.guardedMerge;
+        if (exitOpts.merge && guarded) {
+          const preflight = guarded.preflightCleanRoot(guarded.projectRoot, _mid, notify);
+          if (preflight.blocked) {
+            return {
+              ok: false,
+              reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+                ? "preflight-unmerged-conflicts"
+                : "preflight-dirty-overlap",
+            } as const;
+          }
+
+          const mergeResult = plainExitMilestone({ merge: true });
+          const postflight = preflight.stashPushed
+            ? guarded.postflightPopStash(
+                guarded.projectRoot,
+                _mid,
+                preflight.stashMarker,
+                notify,
+              )
+            : undefined;
+
+          if (!mergeResult.ok) {
+            if (mergeResult.reason === "merge-conflict") {
+              return { ...mergeResult, postflight } as const;
+            }
+            return {
+              ok: false,
+              reason: "merge-failed",
+              cause: mergeResult.cause,
+              postflight,
+            } as const;
+          }
+          if (postflight?.needsManualRecovery) {
+            return {
+              ok: false,
+              reason: "postflight-stash-restore-failed",
+              postflight,
+            } as const;
+          }
+          return mergeResult;
         }
+
+        return plainExitMilestone(exitOpts);
       },
     },
     stopAuto: async (
@@ -155,6 +226,14 @@ const PREFLIGHT_UNMERGED: PreflightResult = {
   summary: "Working tree has unresolved Git conflicts before milestone M002 merge.",
 };
 
+const PREFLIGHT_UNMERGED_EVAL_FAILED: PreflightResult = {
+  stashPushed: false,
+  blocked: true,
+  blockedReason: "unmerged-conflicts-eval-failed",
+  conflictedPaths: ["todo.js"],
+  summary: "Unable to fully evaluate unresolved Git conflicts before milestone M002 merge.",
+};
+
 const POP_OK: PostflightResult = {
   restored: true,
   needsManualRecovery: false,
@@ -344,6 +423,52 @@ test("unmerged conflicts: preflight stops before merge and postflight restore",
   );
 });
 
+test("unmerged conflict evaluation failure stops as preflight-unmerged-conflicts", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: PREFLIGHT_UNMERGED_EVAL_FAILED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+
+  const result = await _runMilestoneMergeWithStashRestore(ic, "M002");
+
+  assert.deepEqual(result, {
+    action: "break",
+    reason: "preflight-unmerged-conflicts",
+  });
+  assert.equal(
+    log.mergeCalls,
+    0,
+    "failed conflict evaluation must not start milestone merge",
+  );
+  assert.equal(log.postflightCalls, 0, "blocked preflight must not attempt stash restore");
+  assert.equal(log.stopAutoCalls.length, 1);
+  assert.match(
+    log.stopAutoCalls[0] ?? "",
+    /Pre-merge unresolved Git conflicts block milestone M002/,
+  );
+});
+
+test("already-merged milestone skips guarded merge to terminate duplicate closeout loops", async () => {
+  const { ic, log } = buildIc({
+    preflightResult: STASH_PUSHED,
+    mergeBehavior: "succeed",
+    postflightResult: POP_OK,
+  });
+  log.milestoneMergedInPhases = true;
+
+  const result = await _runMilestoneMergeOnceWithStashRestore(ic, "M002");
+
+  assert.equal(result, null);
+  assert.equal(log.preflightCalls, 0, "already-merged guard must not re-trigger preflight");
+  assert.equal(log.mergeCalls, 0, "already-merged guard must not re-trigger merge");
+  assert.equal(
+    log.postflightCalls,
+    0,
+    "already-merged guard must not re-trigger stash restore",
+  );
+});
+
 test("merge succeeds but stash pop needs manual recovery -> postflight-stash-restore-failed break", async () => {
   const { ic, log } = buildIc({
     preflightResult: STASH_PUSHED,
@@ -358,6 +483,11 @@ test("merge succeeds but stash pop needs manual recovery -> postflight-stash-res
     reason: "postflight-stash-restore-failed",
   });
   assert.equal(log.postflightCalls, 1);
+  assert.equal(
+    log.milestoneMergedInPhases,
+    true,
+    "successful merge must set the flag before postflight recovery stops auto-mode",
+  );
   assert.equal(log.stopAutoCalls.length, 1);
   assert.match(
     log.stopAutoCalls[0] ?? "",

package/src/resources/extensions/gsd/tests/milestone-merge-transaction.test.ts

@@ -13,7 +13,7 @@ test("runMilestoneMergeTransaction delegates to the supplied merge runner", () =
   const calls: unknown[][] = [];
   const result = runMilestoneMergeTransaction(
     {
-      mergeMilestoneToMain: (basePath, milestoneId, roadmapContent) => {
+      mergeMilestone: (basePath, milestoneId, roadmapContent) => {
         calls.push([basePath, milestoneId, roadmapContent]);
         return { pushed: true, codeFilesChanged: true, commitMessage: "merge M001" };
       },

package/src/resources/extensions/gsd/tests/phases-merge-error-stops-auto.test.ts

@@ -82,13 +82,57 @@ const ic = {
       return { ok: true, needsManualRecovery: false };
     },
     lifecycle: {
-      exitMilestone() {
+      // Mirror WorktreeLifecycle.exitMilestone's guarded-merge branch
+      // (preflight -> inner merge -> postflight). Since #1169 the closeout
+      // routes the guard through the lifecycle verb, so a non-conflict inner
+      // failure ("teardown-failed") is mapped to "merge-failed" here rather
+      // than by the caller.
+      exitMilestone(
+        milestoneId: string,
+        exitOpts: {
+          merge: boolean;
+          guardedMerge?: {
+            projectRoot: string;
+            preflightCleanRoot: (
+              basePath: string,
+              milestoneId: string,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => { blocked?: boolean; blockedReason?: string; stashPushed: boolean; stashMarker?: string };
+            postflightPopStash: (
+              basePath: string,
+              milestoneId: string,
+              stashMarker: string | undefined,
+              notify: (message: string, level: "info" | "warning" | "error") => void,
+            ) => { needsManualRecovery?: boolean };
+          };
+        },
+        exitCtx?: { notify: (message: string, level: "info" | "warning" | "error") => void },
+      ) {
+        const notify = exitCtx?.notify ?? (() => {});
+        const guarded = exitOpts.guardedMerge;
+        if (exitOpts.merge && guarded) {
+          const preflight = guarded.preflightCleanRoot(guarded.projectRoot, milestoneId, notify);
+          if (preflight.blocked) {
+            return {
+              ok: false,
+              reason: preflight.blockedReason?.startsWith("unmerged-conflicts")
+                ? "preflight-unmerged-conflicts"
+                : "preflight-dirty-overlap",
+            };
+          }
+          // Inner merge fails with a non-conflict error. The lifecycle still
+          // runs postflight stash restore on the failed-merge path, then maps
+          // the non-conflict failure to "merge-failed" (a MergeConflictError
+          // would instead map to "merge-conflict").
+          calls.push("merge");
+          const cause = new Error("remote rejected push");
+          if (preflight.stashPushed) {
+            guarded.postflightPopStash(guarded.projectRoot, milestoneId, preflight.stashMarker, notify);
+          }
+          return { ok: false, reason: "merge-failed", cause };
+        }
         calls.push("merge");
-        return {
-          ok: false,
-          reason: "teardown-failed",
-          cause: new Error("remote rejected push"),
-        };
+        return { ok: false, reason: "teardown-failed", cause: new Error("remote rejected push") };
       },
     },
     async stopAuto(_ctx: unknown, _pi: unknown, reason?: string) {

package/src/resources/extensions/gsd/tests/root-write-leak-guard.test.ts

@@ -3,11 +3,11 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { closeSync, ftruncateSync, openSync, statSync, writeFileSync } from "node:fs";
+import { closeSync, ftruncateSync, openSync, statSync } from "node:fs";
 import { join } from "node:path";
 
-import { captureRootDirtySnapshot } from "../root-write-leak-guard.ts";
-import { cleanup, createFile, git, makeTempRepo } from "./test-utils.ts";
+import { captureRootDirtySnapshot, detectRootWriteLeak } from "../root-write-leak-guard.ts";
+import { cleanup, createFile, makeTempRepo } from "./test-utils.ts";
 
 test("captureRootDirtySnapshot ignores unignored GSD root runtime directories", () => {
   const base = makeTempRepo("gsd-root-dirty-runtime-");
@@ -34,11 +34,7 @@ test("captureRootDirtySnapshot does not read dirty files larger than Node's Buff
     const relPath = "large.bin";
     const absPath = join(base, relPath);
 
-    writeFileSync(absPath, "tracked\n", "utf-8");
-    git(base, "add", relPath);
-    git(base, "commit", "-m", "track large fixture");
-
-    const fd = openSync(absPath, "r+");
+    const fd = openSync(absPath, "w");
     try {
       ftruncateSync(fd, 2_200 * 1024 * 1024);
     } finally {
@@ -51,9 +47,35 @@ test("captureRootDirtySnapshot does not read dirty files larger than Node's Buff
     const snapshot = captureRootDirtySnapshot(base);
     const entry = snapshot.get(relPath);
 
-    assert.equal(entry?.status, "M");
+    assert.equal(entry?.status, "??");
     assert.match(entry?.fingerprint ?? "", /^large:\d+:/);
   } finally {
     cleanup(base);
   }
 });
+
+test("detectRootWriteLeak reports changed baseline untracked root files", () => {
+  const base = makeTempRepo("gsd-root-dirty-baseline-");
+  try {
+    const relPath = "notes/todo.md";
+    createFile(base, relPath, "before\n");
+    const before = captureRootDirtySnapshot(base);
+
+    createFile(base, relPath, "after\n");
+    const leak = detectRootWriteLeak({
+      rootPath: base,
+      worktreePath: join(base, ".gsd", "worktrees", "M001"),
+      unitType: "execute-task",
+      unitId: "M001/S01/T01",
+      before,
+    });
+
+    assert.ok(leak, "changed baseline untracked file should be reported as a leak");
+    assert.deepEqual(
+      leak.files.map((file) => file.path),
+      [relPath],
+    );
+  } finally {
+    cleanup(base);
+  }
+});

package/src/resources/extensions/gsd/tests/schedule-wakeup-tool.test.ts

@@ -0,0 +1,167 @@
+// Project/App: gsd-pi
+// File Purpose: Regression tests for ScheduleWakeup tool behavior.
+
+import test, { mock } from "node:test";
+import assert from "node:assert/strict";
+
+import { autoSession } from "../auto-runtime-state.ts";
+import {
+  registerScheduleWakeupTool,
+  _resetInteractiveWakeupsForTest,
+} from "../bootstrap/schedule-wakeup-tool.ts";
+
+test("ScheduleWakeup arms an interactive wakeup when auto-mode is inactive", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: unknown; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const result = await tool.execute(
+      "call-1",
+      {
+        delaySeconds: 1,
+        prompt: "Check the external job and report back.",
+        reason: "poll external job",
+      },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    assert.equal(result.isError, undefined);
+    assert.match(result.content[0].text, /Wakeup scheduled for 1s/);
+    assert.equal(sent.length, 0, "wakeup should not dispatch synchronously");
+
+    mock.timers.tick(999);
+    assert.equal(sent.length, 0, "wakeup should wait for the configured delay");
+
+    mock.timers.tick(1);
+    assert.equal(sent.length, 1);
+    assert.deepEqual(sent[0].options, { triggerTurn: true });
+    assert.deepEqual(sent[0].message, {
+      customType: "gsd-schedule-wakeup",
+      content: "Check the external job and report back.",
+      display: true,
+      details: {
+        delaySeconds: 1,
+        reason: "poll external job",
+      },
+    });
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup re-arm cancels the prior interactive timer instead of stacking", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    const ctx = { cwd: process.cwd() };
+    await tool.execute(
+      "call-1",
+      { delaySeconds: 5, prompt: "stale prompt", reason: "first arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+    await tool.execute(
+      "call-2",
+      { delaySeconds: 5, prompt: "fresh prompt", reason: "re-arm" },
+      undefined,
+      undefined,
+      ctx,
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 1, "re-arming must not stack overlapping wakeups");
+    assert.equal(sent[0].message.content, "fresh prompt");
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});
+
+test("ScheduleWakeup keeps interactive wakeups isolated per session base path", async () => {
+  autoSession.reset();
+  _resetInteractiveWakeupsForTest();
+  mock.timers.enable({ apis: ["setTimeout"] });
+
+  const sent: Array<{ message: any; options: unknown }> = [];
+  let tool: any;
+  const pi = {
+    registerTool(registered: any) {
+      tool = registered;
+    },
+    sendMessage(message: unknown, options: unknown) {
+      sent.push({ message, options } as { message: any; options: unknown });
+    },
+  };
+
+  try {
+    registerScheduleWakeupTool(pi as any);
+    assert.ok(tool, "ScheduleWakeup tool should be registered");
+
+    // Two concurrent interactive sessions (different cwds) arm wakeups. One
+    // session re-arming must not cancel the other session's pending wakeup.
+    await tool.execute(
+      "call-a",
+      { delaySeconds: 5, prompt: "session A", reason: "poll A" },
+      undefined,
+      undefined,
+      { cwd: "/tmp" },
+    );
+    await tool.execute(
+      "call-b",
+      { delaySeconds: 5, prompt: "session B", reason: "poll B" },
+      undefined,
+      undefined,
+      { cwd: process.cwd() },
+    );
+
+    mock.timers.tick(5000);
+
+    assert.equal(sent.length, 2, "distinct sessions must each keep their wakeup");
+    assert.deepEqual(
+      sent.map((s) => s.message.content).sort(),
+      ["session A", "session B"],
+    );
+  } finally {
+    mock.timers.reset();
+    _resetInteractiveWakeupsForTest();
+    autoSession.reset();
+  }
+});

package/src/resources/extensions/gsd/tests/state-corruption-2945.test.ts

@@ -312,7 +312,7 @@ describe("#2945 Bug 3: mergeAndExit must teardown worktree after successful merg
       } as unknown as AutoSession;
 
       const deps = {
-        mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+        mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
         worktreeProjection: new WorktreeStateProjection(),
         gitServiceFactory: () => ({}) as unknown as ReturnType<
           import("../worktree-lifecycle.js").WorktreeLifecycleDeps["gitServiceFactory"]

package/src/resources/extensions/gsd/tests/unit-registry.test.ts

@@ -7,6 +7,8 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
+import { existsSync } from "node:fs";
+import { join } from "node:path";
 
 import {
   KNOWN_UNIT_TYPES,
@@ -15,6 +17,7 @@ import {
   SECTION_CLOSE_GATE_UNIT_TYPES,
   getUnitDescriptor,
   getUnitPhaseChain,
+  getUnitPromptTemplate,
 } from "../unit-registry.ts";
 import {
   AUTO_UNIT_SCOPED_TOOLS,
@@ -96,6 +99,37 @@ const EXPECTED_PHASE_CHAINS: Record<string, string[] | undefined> = {
   "no-such-unit": undefined,
 };
 
+const EXPECTED_DIRECT_PROMPT_TEMPLATES: Record<string, string> = {
+  "research-milestone": "research-milestone",
+  "plan-milestone": "plan-milestone",
+  "validate-milestone": "validate-milestone",
+  "complete-milestone": "complete-milestone",
+  "research-slice": "research-slice",
+  "plan-slice": "plan-slice",
+  "refine-slice": "refine-slice",
+  "replan-slice": "replan-slice",
+  "complete-slice": "complete-slice",
+  "reassess-roadmap": "reassess-roadmap",
+  "execute-task": "execute-task",
+  "reactive-execute": "reactive-execute",
+  "run-uat": "run-uat",
+  "gate-evaluate": "gate-evaluate",
+  "rewrite-docs": "rewrite-docs",
+  "workflow-preferences": "guided-workflow-preferences",
+  "discuss-project": "guided-discuss-project",
+  "discuss-requirements": "guided-discuss-requirements",
+  "research-decision": "guided-research-decision",
+  "research-project": "guided-research-project",
+};
+
+const EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES = [
+  "discuss-milestone",
+  "discuss-slice",
+  "execute-task-simple",
+  "triage-captures",
+  "quick-task",
+];
+
 // ─── Derived-view parity ──────────────────────────────────────────────────
 
 test("KNOWN_UNIT_TYPES derives exactly the pre-registry list, in order", () => {
@@ -134,6 +168,28 @@ test("phaseChainForUnit matches the pre-registry switch for every known input",
   }
 });
 
+test("direct prompt-template associations live on the Unit Registry", () => {
+  for (const [unitType, promptTemplate] of Object.entries(EXPECTED_DIRECT_PROMPT_TEMPLATES)) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      promptTemplate,
+      `prompt template for ${unitType}`,
+    );
+    assert.ok(
+      existsSync(join(process.cwd(), "src/resources/extensions/gsd/prompts", `${promptTemplate}.md`)),
+      `prompt template file must exist for ${unitType}: ${promptTemplate}`,
+    );
+  }
+
+  for (const unitType of EXPECTED_UNDECLARED_PROMPT_TEMPLATE_TYPES) {
+    assert.equal(
+      getUnitPromptTemplate(unitType),
+      undefined,
+      `${unitType} prompt association is conditional or not verified yet`,
+    );
+  }
+});
+
 test("AUTO_UNIT_SCOPED_TOOLS mirrors each contract's allowed tools", () => {
   for (const [unitType, contract] of Object.entries(UNIT_TOOL_CONTRACTS)) {
     assert.deepEqual(AUTO_UNIT_SCOPED_TOOLS[unitType], contract.allowedGsdTools);

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

@@ -107,7 +107,7 @@ function makeDeps(
   // real `getAutoWorktreePath` / `createAutoWorktree` / etc. and the
   // success/existing/failure branches won't fire as expected.
   const deps: LegacyTestDeps = {
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     worktreeProjection: new WorktreeStateProjection(),
     // ADR-016 phase 2 / C4 (#5627): GitServiceImpl constructor → factory.
     gitServiceFactory: () => ({}) as unknown as ReturnType<
@@ -283,7 +283,7 @@ describe("worktree journal events", () => {
 
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+      mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     });
     process.chdir(wt);
 
@@ -304,7 +304,7 @@ describe("worktree journal events", () => {
     const wt = setupMergeWorktree(tmp, "M001");
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     const deps = makeDeps({
-      mergeMilestoneToMain: () => { throw new Error("conflict in main"); },
+      mergeMilestone: () => { throw new Error("conflict in main"); },
     });
     // Since #4380, mergeAndExit re-throws all errors after emitting the journal
     // event and restoring state. Lifecycle now wraps that throw in a typed
@@ -347,7 +347,7 @@ describe("worktree journal events", () => {
     const s = makeSession({ basePath: wt, originalBasePath: tmp });
     let attempt = 0;
     const deps = makeDeps({
-      mergeMilestoneToMain: () => {
+      mergeMilestone: () => {
         attempt += 1;
         throw new MergeConflictError(
           attempt === 1 ? ["src/a.ts"] : ["src/b.ts", "src/c.ts"],

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

@@ -46,7 +46,7 @@ function makeDeps(
 ): LegacyTestDeps & { calls: CallLog[] } {
   const calls: CallLog[] = [];
   // ADR-016 phase 2 / C-track close-out: WorktreeLifecycleDeps is now a
-  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestoneToMain).
+  // 3-field bag (gitServiceFactory, worktreeProjection, mergeMilestone).
   // Tests still pass legacy override hooks via `LegacyTestDeps` — Lifecycle
   // ignores the extras structurally and reads them through the C1-healing
   // primitive-override pattern when stubs are needed.
@@ -73,7 +73,7 @@ function makeDeps(
     },
     autoWorktreeBranch: (mid: string) => `milestone/${mid}`,
     teardownAutoWorktree: () => {},
-    mergeMilestoneToMain: () => ({ pushed: false, codeFilesChanged: true }),
+    mergeMilestone: () => ({ pushed: false, codeFilesChanged: true }),
     ...overrides,
   };
   return deps;