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

package/src/resources/extensions/gsd/tests/est-annotation-timeout.test.ts

@@ -8,46 +8,7 @@
 
 import test from "node:test";
 import assert from "node:assert/strict";
-import { readFileSync } from "node:fs";
-import { join } from "node:path";
-
-const timersSrcPath = join(import.meta.dirname, "..", "auto-timers.ts");
-const timersSrc = readFileSync(timersSrcPath, "utf-8");
-
-// ─── Source analysis: parseEstimateMinutes exists and is exported ────────────
-
-test("#2243: auto-timers.ts should export parseEstimateMinutes", () => {
-  assert.ok(
-    timersSrc.includes("export function parseEstimateMinutes"),
-    "parseEstimateMinutes should be exported from auto-timers.ts",
-  );
-});
-
-// ─── Inline unit test of parseEstimateMinutes logic ─────────────────────────
-// Since importing the module pulls in heavy deps, test the parsing logic inline.
-
-function parseEstimateMinutes(estimate: string): number | null {
-  if (!estimate || typeof estimate !== "string") return null;
-  const trimmed = estimate.trim();
-  if (!trimmed) return null;
-
-  let totalMinutes = 0;
-  let matched = false;
-
-  const hoursMatch = trimmed.match(/(\d+)\s*h/i);
-  if (hoursMatch) {
-    totalMinutes += Number(hoursMatch[1]) * 60;
-    matched = true;
-  }
-
-  const minutesMatch = trimmed.match(/(\d+)\s*m/i);
-  if (minutesMatch) {
-    totalMinutes += Number(minutesMatch[1]);
-    matched = true;
-  }
-
-  return matched ? totalMinutes : null;
-}
+import { parseEstimateMinutes, resolveUnitSupervisionTimeouts } from "../auto-timers.ts";
 
 test("#2243: parseEstimateMinutes parses '30m' correctly", () => {
   assert.equal(parseEstimateMinutes("30m"), 30);
@@ -73,48 +34,20 @@ test("#2243: parseEstimateMinutes returns null for invalid string", () => {
   assert.equal(parseEstimateMinutes("not a time"), null);
 });
 
-// ─── Source analysis: startUnitSupervision uses task estimates ───────────────
-
-test("#2243: startUnitSupervision should reference task estimates for timeout scaling", () => {
-  const usesEstimate =
-    timersSrc.includes("parseEstimateMinutes") &&
-    timersSrc.includes("estimateMinutes") &&
-    timersSrc.includes("taskEstimate");
-
-  assert.ok(
-    usesEstimate,
-    "startUnitSupervision should use task estimate annotations for timeout scaling",
+test("#2243: estimate scale affects soft and hard timeouts but not idle timeout", () => {
+  const result = resolveUnitSupervisionTimeouts(
+    "execute-task",
+    {
+      soft_timeout_minutes: 10,
+      idle_timeout_minutes: 5,
+      hard_timeout_minutes: 20,
+    },
+    3,
   );
-});
-
-test("#2243: SupervisionContext should accept an optional taskEstimate field", () => {
-  const ctxIdx = timersSrc.indexOf("SupervisionContext");
-  assert.ok(ctxIdx !== -1, "SupervisionContext interface exists");
 
-  const ctxEnd = timersSrc.indexOf("}", ctxIdx);
-  const ctxBlock = timersSrc.slice(ctxIdx, ctxEnd);
-
-  assert.ok(
-    ctxBlock.includes("taskEstimate"),
-    "SupervisionContext should include a taskEstimate field",
-  );
-});
-
-test("#2243: timeouts should be scaled by estimate (timeoutScale in source)", () => {
-  assert.ok(
-    timersSrc.includes("timeoutScale"),
-    "auto-timers.ts should use a timeoutScale factor derived from est: annotations",
-  );
-});
-
-test("#2243: idle timeout should NOT be scaled (idle is idle regardless of estimate)", () => {
-  // Find the idleTimeoutMs line
-  const idleIdx = timersSrc.indexOf("const idleTimeoutMs");
-  assert.ok(idleIdx !== -1, "idleTimeoutMs variable exists");
-  
-  const idleLine = timersSrc.slice(idleIdx, timersSrc.indexOf("\n", idleIdx));
-  assert.ok(
-    !idleLine.includes("timeoutScale"),
-    "idleTimeoutMs should NOT be scaled — idle is idle",
-  );
+  assert.deepEqual(result, {
+    softTimeoutMs: 30 * 60 * 1000,
+    idleTimeoutMs: 5 * 60 * 1000,
+    hardTimeoutMs: 60 * 60 * 1000,
+  });
 });

package/src/resources/extensions/gsd/tests/exec-history.test.ts

@@ -108,6 +108,21 @@ test('executeExecSearch: returns helpful empty-state message when no matches', (
   }
 });
 
+test('executeExecSearch: returns disabled error when context_mode.enabled=false', () => {
+  const base = freshBase();
+  try {
+    writeRun(base, 'should-not-surface', { stdout: 'hidden\n' });
+    const result = executeExecSearch(
+      { query: 'hidden' },
+      { baseDir: base, preferences: { context_mode: { enabled: false } } },
+    );
+    assert.equal(result.isError, true);
+    assert.equal((result.details as { error?: string }).error, 'context_mode_disabled');
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('executeExecSearch: includes stdout_path and preview in details', () => {
   const base = freshBase();
   try {

package/src/resources/extensions/gsd/tests/exec-sandbox.test.ts

@@ -7,6 +7,7 @@ import { join } from 'node:path';
 import { EXEC_DEFAULTS, runExecSandbox, type ExecSandboxOptions } from '../exec-sandbox.ts';
 import { buildExecOptions, executeGsdExec } from '../tools/exec-tool.ts';
 import { isContextModeEnabled } from '../preferences-types.ts';
+import { validatePreferences } from '../preferences-validation.ts';
 
 function freshBase(): string {
   return mkdtempSync(join(tmpdir(), 'gsd-exec-test-'));
@@ -174,6 +175,52 @@ test('executeGsdExec: runs when enabled explicitly set to true', async () => {
   }
 });
 
+test('executeGsdExec: forwards custom exec_env_allowlist from preferences', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      {
+        runtime: 'bash',
+        script: 'printf "allowed=%s blocked=%s\\n" "$GSD_ALLOWED" "$GSD_BLOCKED"',
+      },
+      {
+        baseDir: base,
+        preferences: {
+          context_mode: {
+            enabled: true,
+            exec_env_allowlist: ['GSD_ALLOWED'],
+          },
+        },
+        env: {
+          PATH: '/usr/bin:/bin',
+          HOME: '/tmp',
+          GSD_ALLOWED: 'yes',
+          GSD_BLOCKED: 'no',
+        },
+      },
+    );
+    assert.ok(!result.isError);
+    assert.match(result.content[0].text, /allowed=yes blocked=/);
+    assert.doesNotMatch(result.content[0].text, /blocked=no/);
+  } finally {
+    cleanup(base);
+  }
+});
+
+test('executeGsdExec: enforces per-call timeout override end-to-end', async () => {
+  const base = freshBase();
+  try {
+    const result = await executeGsdExec(
+      { runtime: 'bash', script: 'sleep 2', timeout_ms: 1 },
+      { baseDir: base, preferences: { context_mode: { enabled: true, exec_timeout_ms: 10_000 } } },
+    );
+    assert.equal(result.details.timed_out, true);
+    assert.equal(result.isError, true);
+  } finally {
+    cleanup(base);
+  }
+});
+
 test('executeGsdExec: rejects empty script', async () => {
   const base = freshBase();
   try {
@@ -188,6 +235,24 @@ test('executeGsdExec: rejects empty script', async () => {
   }
 });
 
+test('validatePreferences: rejects invalid context_mode preference values', () => {
+  const result = validatePreferences({
+    context_mode: {
+      enabled: 'false',
+      exec_timeout_ms: 999,
+      exec_stdout_cap_bytes: 1,
+      exec_digest_chars: -1,
+      exec_env_allowlist: ['GOOD_NAME', 'bad-name'],
+    },
+  } as any);
+  assert.ok(result.errors.length > 0);
+  assert.ok(result.errors.includes('context_mode.enabled must be a boolean'));
+  assert.ok(result.errors.includes('context_mode.exec_timeout_ms must be a number between 1000 and 600000'));
+  assert.ok(result.errors.includes('context_mode.exec_stdout_cap_bytes must be a number between 4096 and 16777216'));
+  assert.ok(result.errors.includes('context_mode.exec_digest_chars must be a number between 0 and 4000'));
+  assert.ok(result.errors.includes('context_mode.exec_env_allowlist must be an array of valid env var names'));
+});
+
 test('isContextModeEnabled: defaults to true; only explicit false disables', () => {
   assert.equal(isContextModeEnabled(undefined), true, 'undefined prefs → on');
   assert.equal(isContextModeEnabled(null), true, 'null prefs → on');

package/src/resources/extensions/gsd/tests/execute-task-rendering.test.ts

@@ -39,6 +39,7 @@ test("execute-task prompt renders compact execution and completion gates", async
     taskPlanPath: ".gsd/milestones/M001/slices/S01/tasks/T01-PLAN.md",
     priorTaskLines: "- None",
     skillActivation: "Load relevant skills.",
+    inlinedTemplates: "### Output Template: Task Summary\nSource: `templates/task-summary.md`",
     templatesDir: join(fixtureRoot, "templates"),
     taskSummaryTemplatePath: "C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary.md",
     verificationBudget: "~10K chars",
@@ -46,12 +47,14 @@ test("execute-task prompt renders compact execution and completion gates", async
   });
 
   assert.match(prompt, /You execute\./);
-  assert.match(prompt, /Call `memory_query`/);
+  assert.match(prompt, /Call `memory_query`.*only when no injected memory block exists/s);
   assert.match(prompt, /Before any `Write` that creates an artifact or output file/);
   assert.match(prompt, /Build real behavior/);
   assert.match(prompt, /Background process rule/);
   assert.match(prompt, /blocker_discovered: true/);
-  assert.match(prompt, /C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary\.md/);
+  assert.match(prompt, /Use the inlined Task Summary template below/);
+  assert.match(prompt, /Read `C:\\Users\\Test\\.gsd\\agent\\extensions\\gsd\\templates\\task-summary\.md` only if the inlined template is absent or visibly truncated/);
+  assert.match(prompt, /### Output Template: Task Summary/);
   assert.doesNotMatch(prompt, /\{\{templatesDir\}\}\/task-summary\.md/);
   assert.match(prompt, /Call `gsd_task_complete`/);
   assert.match(prompt, /Do not run git commands/);

package/src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts

@@ -0,0 +1,219 @@
+// GSD-2 + src/resources/extensions/gsd/tests/fast-forward-reused-milestone-branch.test.ts
+// Regression: when createAutoWorktree reuses an existing milestone branch,
+// it must be fast-forwarded onto integration so the next milestone forks
+// from up-to-date code (#5538-followup).
+
+import { describe, test, beforeEach, afterEach } from "node:test";
+import assert from "node:assert/strict";
+import { execFileSync } from "node:child_process";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { basename, join } from "node:path";
+
+import {
+  fastForwardReusedMilestoneBranchIfSafe,
+  _isBranchCheckedOutElsewhere,
+} from "../auto-worktree.js";
+
+const NO_PROMPT_ENV = {
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_AUTHOR_NAME: "test",
+  GIT_AUTHOR_EMAIL: "test@example.com",
+  GIT_COMMITTER_NAME: "test",
+  GIT_COMMITTER_EMAIL: "test@example.com",
+};
+
+function git(cwd: string, ...args: string[]): string {
+  return execFileSync("git", args, {
+    cwd,
+    stdio: ["ignore", "pipe", "pipe"],
+    encoding: "utf-8",
+    env: NO_PROMPT_ENV,
+  });
+}
+
+function rev(cwd: string, ref: string): string {
+  return git(cwd, "rev-parse", ref).trim();
+}
+
+describe("fastForwardReusedMilestoneBranchIfSafe", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "ff-reused-branch-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("fast-forwards a milestone branch that is strictly behind integration (regression: stale base)", () => {
+    // Create milestone/M001 from main's initial commit, then advance main.
+    git(repo, "branch", "milestone/M001");
+    const m001Initial = rev(repo, "milestone/M001");
+
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+    const mainTip = rev(repo, "main");
+
+    assert.notEqual(m001Initial, mainTip, "main must be ahead before the test");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(
+      rev(repo, "milestone/M001"),
+      mainTip,
+      "milestone/M001 must be fast-forwarded to main's tip",
+    );
+  });
+
+  test("does not touch a milestone branch that has its own commits ahead", () => {
+    // Branch from main, add a unique commit, then advance main.
+    git(repo, "checkout", "-q", "-b", "milestone/M001");
+    writeFileSync(join(repo, "milestone-only.txt"), "milestone work\n");
+    git(repo, "add", "milestone-only.txt");
+    git(repo, "commit", "-q", "-m", "M001 work");
+    const milestoneTip = rev(repo, "milestone/M001");
+
+    git(repo, "checkout", "-q", "main");
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(
+      rev(repo, "milestone/M001"),
+      milestoneTip,
+      "diverged milestone branch must NOT be touched (would lose work)",
+    );
+  });
+
+  test("is a no-op when milestone branch is already up-to-date with main", () => {
+    git(repo, "branch", "milestone/M001");
+    const before = rev(repo, "milestone/M001");
+
+    fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+    assert.equal(rev(repo, "milestone/M001"), before, "ref must not move");
+  });
+
+  test("does nothing when the milestone branch does not exist", () => {
+    // Should silently return — no error, no side effects.
+    assert.doesNotThrow(() =>
+      fastForwardReusedMilestoneBranchIfSafe(repo, "M999", "milestone/M999"),
+    );
+  });
+
+  test("does nothing in a non-git directory", () => {
+    const nonRepo = mkdtempSync(join(tmpdir(), "ff-not-a-repo-"));
+    try {
+      assert.doesNotThrow(() =>
+        fastForwardReusedMilestoneBranchIfSafe(nonRepo, "M001", "milestone/M001"),
+      );
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+
+  test("skips fast-forward when branch is checked out in another worktree (peer-review regression)", () => {
+    // Codex peer review caught: `nativeUpdateRef` succeeds even when the
+    // branch is checked out in a linked worktree, leaving that worktree's
+    // HEAD inconsistent with its index/work tree. The fix calls
+    // `nativeWorktreeList` first and skips the FF if any worktree owns the
+    // target branch. This test sets up the exact scenario.
+    git(repo, "branch", "milestone/M001");
+    const m001Initial = rev(repo, "milestone/M001");
+
+    // Add a linked worktree that checks out milestone/M001.
+    const wtPath = join(repo, "..", `${basename(repo)}-wt`);
+    git(repo, "worktree", "add", wtPath, "milestone/M001");
+
+    // Advance main so a fast-forward would otherwise apply.
+    writeFileSync(join(repo, "seed.txt"), "advanced\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "main moved forward");
+
+    try {
+      fastForwardReusedMilestoneBranchIfSafe(repo, "M001", "milestone/M001");
+
+      assert.equal(
+        rev(repo, "milestone/M001"),
+        m001Initial,
+        "milestone/M001 must NOT move while a linked worktree has it checked out",
+      );
+    } finally {
+      git(repo, "worktree", "remove", "--force", wtPath);
+      rmSync(wtPath, { recursive: true, force: true });
+    }
+  });
+});
+
+describe("_isBranchCheckedOutElsewhere", () => {
+  let repo: string;
+
+  beforeEach(() => {
+    repo = mkdtempSync(join(tmpdir(), "is-checked-out-"));
+    git(repo, "init", "-q", "-b", "main");
+    git(repo, "config", "user.email", "test@example.com");
+    git(repo, "config", "user.name", "test");
+    writeFileSync(join(repo, "seed.txt"), "seed\n");
+    git(repo, "add", "seed.txt");
+    git(repo, "commit", "-q", "-m", "initial");
+  });
+
+  afterEach(() => {
+    rmSync(repo, { recursive: true, force: true });
+  });
+
+  test("returns true when branch is checked out in a linked worktree", () => {
+    git(repo, "branch", "milestone/M001");
+    const wtPath = join(repo, "..", `${basename(repo)}-wt`);
+    git(repo, "worktree", "add", wtPath, "milestone/M001");
+    try {
+      assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M001"), true);
+    } finally {
+      git(repo, "worktree", "remove", "--force", wtPath);
+      rmSync(wtPath, { recursive: true, force: true });
+    }
+  });
+
+  test("returns true when branch is checked out in the main worktree itself", () => {
+    // The default checkout. `git worktree list --porcelain` reports the
+    // primary worktree too, so a branch checked out there counts as
+    // "checked out elsewhere" relative to a fresh ref update intent.
+    git(repo, "checkout", "-q", "-b", "milestone/M002");
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M002"), true);
+  });
+
+  test("returns false when branch exists but is not checked out anywhere", () => {
+    git(repo, "branch", "milestone/M003");
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M003"), false);
+  });
+
+  test("returns false for an unknown branch in a clean repo", () => {
+    assert.equal(_isBranchCheckedOutElsewhere(repo, "milestone/M999"), false);
+  });
+
+  test("returns false on a non-git directory (empty worktree list)", () => {
+    // nativeWorktreeList does not throw on a non-repo — it returns []. The
+    // parent function `fastForwardReusedMilestoneBranchIfSafe` never reaches
+    // this code path on a non-repo because `nativeBranchExists` short-circuits
+    // earlier. Documenting actual behavior so future readers don't expect a
+    // fail-safe `true` here.
+    const nonRepo = mkdtempSync(join(tmpdir(), "is-checked-out-not-repo-"));
+    try {
+      assert.equal(_isBranchCheckedOutElsewhere(nonRepo, "milestone/M001"), false);
+    } finally {
+      rmSync(nonRepo, { recursive: true, force: true });
+    }
+  });
+});

package/src/resources/extensions/gsd/tests/finalize-survivor-branch.test.ts

@@ -0,0 +1,151 @@
+// GSD-2 + src/resources/extensions/gsd/tests/finalize-survivor-branch.test.ts
+// Regression: an error from `_mergeBranchMode` (made fail-loud in commit
+// 68ef58a3c) must be caught at the survivor-finalize call site so bootstrap
+// surfaces an error notify instead of an unhandled exception propagating to
+// the slash-command caller (#5549 post-merge audit, R2).
+//
+// After ADR-016 / slice 7 step E, _finalizeSurvivorBranch takes a
+// WorktreeLifecycle and inspects the typed ExitResult instead of catching a
+// throw — the fakeLifecycle below returns {ok:false, cause} to model the
+// previous throw shape.
+
+import test from "node:test";
+import assert from "node:assert/strict";
+
+import { _finalizeSurvivorBranch } from "../auto-start.js";
+import type { WorktreeLifecycle } from "../worktree-lifecycle.js";
+
+interface FakeLifecycleState {
+  mergeCalls: Array<{ milestoneId: string }>;
+  causeOnFail?: unknown;
+  innerNotify?: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+}
+
+function fakeLifecycle(state: FakeLifecycleState): WorktreeLifecycle {
+  return {
+    exitMilestone: (
+      milestoneId: string,
+      _opts: { merge: boolean },
+      ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void },
+    ) => {
+      state.mergeCalls.push({ milestoneId });
+      if (state.innerNotify) state.innerNotify = ctx.notify;
+      if (state.causeOnFail !== undefined) {
+        return { ok: false, reason: "teardown-failed", cause: state.causeOnFail };
+      }
+      return { ok: true, merged: true, codeFilesChanged: false };
+    },
+  } as unknown as WorktreeLifecycle;
+}
+
+interface FakeUiState {
+  notifications: Array<{ message: string; level: string }>;
+}
+
+function fakeUi(state: FakeUiState): {
+  notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void;
+} {
+  return {
+    notify: (message: string, level?: "info" | "warning" | "error" | "success") => {
+      state.notifications.push({ message, level: level ?? "info" });
+    },
+  };
+}
+
+test("happy path: survivor merge runs, returns merged:true, info notify announces the merge", () => {
+  const lcState: FakeLifecycleState = { mergeCalls: [] };
+  const uiState: FakeUiState = { notifications: [] };
+  const result = _finalizeSurvivorBranch(
+    fakeLifecycle(lcState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.deepEqual(result, { merged: true });
+  assert.deepEqual(lcState.mergeCalls, [{ milestoneId: "M001" }]);
+  assert.equal(uiState.notifications.length, 1);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.match(
+    uiState.notifications[0].message,
+    /Milestone M001 is complete but branch\/worktree was not finalized/,
+  );
+});
+
+test("regression: failure from exitMilestone (e.g. wrong-branch) is surfaced as error notify", () => {
+  // Pre-PR-5549 commit 5: `_mergeBranchMode` returned false silently.
+  // Post-commit 5: it throws (caught by Lifecycle and returned as
+  // {ok:false}). Without this fix, an uncaught failure at auto-start.ts
+  // line ~810 would bubble through bootstrapAutoSession to startAutoDetached's
+  // top-level .catch as an unhandled-exception log — observable as a stack
+  // trace instead of a clean failure notification.
+  const boom = new Error("dirty working tree blocks checkout");
+  const lcState: FakeLifecycleState = { mergeCalls: [], causeOnFail: boom };
+  const uiState: FakeUiState = { notifications: [] };
+
+  // Must not throw.
+  const result = _finalizeSurvivorBranch(
+    fakeLifecycle(lcState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, boom);
+
+  // Two notifies: info (announce) + error (the failure detail).
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.equal(uiState.notifications[1].level, "error");
+  assert.match(
+    uiState.notifications[1].message,
+    /Survivor-branch finalization for M001 failed/,
+  );
+  assert.match(uiState.notifications[1].message, /dirty working tree blocks checkout/);
+  assert.match(uiState.notifications[1].message, /Resolve manually/);
+});
+
+test("non-Error failure causes are stringified into the user-facing message", () => {
+  const lcState: FakeLifecycleState = {
+    mergeCalls: [],
+    causeOnFail: "git lock contention",
+  };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _finalizeSurvivorBranch(
+    fakeLifecycle(lcState),
+    "M001",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(uiState.notifications[1].level, "error");
+  assert.match(uiState.notifications[1].message, /git lock contention/);
+});
+
+test("inner notifications from exitMilestone's NotifyCtx reach the same UI", () => {
+  // The Lifecycle's NotifyCtx must be wired to ui.notify so messages emitted
+  // inside exitMilestone (e.g. "Milestone Mxxx merged. Pushed to remote.")
+  // appear in the same UI stream as the outer notifies.
+  const uiState: FakeUiState = { notifications: [] };
+  const ui = fakeUi(uiState);
+
+  const lifecycle = {
+    exitMilestone: (
+      _milestoneId: string,
+      _opts: { merge: boolean },
+      ctx: { notify: (msg: string, level?: "info" | "warning" | "error" | "success") => void },
+    ) => {
+      ctx.notify("Milestone M001 merged.", "success");
+      return { ok: true, merged: true, codeFilesChanged: false };
+    },
+  } as unknown as WorktreeLifecycle;
+
+  const result = _finalizeSurvivorBranch(lifecycle, "M001", ui);
+
+  assert.equal(result.merged, true);
+  // 1: outer announce
+  // 2: inner success
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[1].level, "success");
+  assert.equal(uiState.notifications[1].message, "Milestone M001 merged.");
+});

package/src/resources/extensions/gsd/tests/flat-rate-routing-guard.test.ts

@@ -6,14 +6,11 @@
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
-import { mkdtempSync, mkdirSync, writeFileSync, readFileSync, rmSync } from "node:fs";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
 import { tmpdir } from "node:os";
-import { dirname, join } from "node:path";
-import { fileURLToPath } from "node:url";
+import { join } from "node:path";
 import { buildFlatRateContext, isFlatRateProvider, resolvePreferredModelConfig } from "../auto-model-selection.ts";
 
-const __dirname_4386 = dirname(fileURLToPath(import.meta.url));
-
 describe("flat-rate provider routing guard (#3453)", () => {
 
   test("isFlatRateProvider returns true for github-copilot", () => {
@@ -306,18 +303,3 @@ describe("flat-rate routing opt-in (#4386)", () => {
     );
   });
 });
-
-// ─── Banner transparency: auto-start respects the opt-in (#4386) ────────────
-
-describe("auto-start banner respects allow_flat_rate_providers (#4386)", () => {
-  test("banner expression gates flat-rate disable on allow_flat_rate_providers", () => {
-    const src = readFileSync(
-      join(__dirname_4386, "..", "auto-start.ts"),
-      "utf-8",
-    );
-    assert.ok(
-      src.includes("routingConfig.allow_flat_rate_providers"),
-      "auto-start banner must read allow_flat_rate_providers so the banner reflects the opt-in",
-    );
-  });
-});