gsd-pi 2.80.0 → 2.81.0-dev.3cddbbba2

package/src/resources/extensions/gsd/tests/notification-overlay.test.ts

@@ -1,55 +1,53 @@
-// GSD Extension — Notification Overlay Tests
-// Tests for message wrapping in the notification panel.
-// Mirrors the private wrapText from notification-overlay.ts so its contract
-// can be exercised without exporting internals.
+// Project/App: GSD-2
+// File Purpose: Regression tests for notification overlay wrapping and width-safe rendering.
 
 import { describe, test } from "node:test";
 import assert from "node:assert/strict";
+import { mkdtempSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
 
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { visibleWidth } from "@gsd/pi-tui";
+import { appendNotification, initNotificationStore, _resetNotificationStore } from "../notification-store.ts";
+import { GSDNotificationOverlay, notificationOverlayOptions } from "../notification-overlay.ts";
+import { wrapVisibleText } from "../tui/render-kit.ts";
 
-// ── wrapText logic (mirrors the private function in notification-overlay.ts) ──
+const fakeTheme = {
+  fg: (_color: string, text: string) => text,
+  bold: (text: string) => text,
+};
 
-function wrapText(text: string, maxWidth: number): string[] {
-  if (maxWidth <= 0) return [text];
-  const lines = wrapTextWithAnsi(text, maxWidth);
-  return lines.map((l) =>
-    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
-  );
+function assertLinesFit(lines: string[], width: number): void {
+  for (const line of lines) {
+    assert.ok(
+      visibleWidth(line) <= width,
+      `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} max=${width}: "${line}"`,
+    );
+  }
 }
 
 describe("notification overlay — wrapText", () => {
   test("short text returns single line", () => {
-    const result = wrapText("hello world", 80);
+    const result = wrapVisibleText("hello world", 80);
     assert.deepStrictEqual(result, ["hello world"]);
   });
 
   test("long text wraps at word boundaries without exceeding maxWidth", () => {
     const text = "This is a long notification message that should wrap across multiple lines";
-    const result = wrapText(text, 40);
+    const result = wrapVisibleText(text, 40);
     assert.ok(result.length > 1, `expected multiple lines, got ${result.length}`);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 40,
-        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
-      );
-    }
+    assertLinesFit(result, 40);
   });
 
   test("single word exceeding maxWidth is broken to fit column budget", () => {
-    const result = wrapText("superlongwordthatexceedsmaxwidth", 10);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 10,
-        `line exceeds maxWidth: "${line}" (${visibleWidth(line)})`,
-      );
-    }
+    const result = wrapVisibleText("superlongwordthatexceedsmaxwidth", 10);
+    assertLinesFit(result, 10);
   });
 
   test("preserves all words across wrapped lines", () => {
     const words = ["alpha", "bravo", "charlie", "delta", "echo", "foxtrot"];
     const text = words.join(" ");
-    const result = wrapText(text, 15);
+    const result = wrapVisibleText(text, 15);
     const rejoined = result.join(" ");
     for (const w of words) {
       assert.ok(rejoined.includes(w), `missing word: ${w}`);
@@ -70,23 +68,62 @@ describe("notification overlay — wrapText", () => {
       "(expired — will auto-refresh) ✗ google — not configured " +
       "(aistudio.google.com/apikey) ✗ groq — not configured";
     const maxWidth = 118;
-    const result = wrapText(msg, maxWidth);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= maxWidth,
-        `line exceeds column budget: visibleWidth=${visibleWidth(line)} max=${maxWidth}: "${line}"`,
-      );
-    }
+    const result = wrapVisibleText(msg, maxWidth);
+    assertLinesFit(result, maxWidth);
   });
 
   test("unbreakable long token (URL) is clamped to maxWidth", () => {
     const url = "https://example.com/" + "a".repeat(200);
-    const result = wrapText(url, 40);
-    for (const line of result) {
-      assert.ok(
-        visibleWidth(line) <= 40,
-        `line exceeds maxWidth: visibleWidth=${visibleWidth(line)} line="${line}"`,
-      );
+    const result = wrapVisibleText(url, 40);
+    assertLinesFit(result, 40);
+  });
+
+  test("real overlay render fits common terminal widths", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "gsd-notification-overlay-"));
+    t.after(() => {
+      _resetNotificationStore();
+      rmSync(dir, { recursive: true, force: true });
+    });
+
+    initNotificationStore(dir);
+    appendNotification("A long notification with " + "x".repeat(180), "warning");
+
+    const overlay = new GSDNotificationOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+    t.after(() => overlay.dispose());
+
+    for (const width of [40, 80, 120]) {
+      assertLinesFit(overlay.render(width), width);
+      overlay.invalidate();
     }
   });
+
+  test("rendered height stays within the configured overlay max height", (t) => {
+    const dir = mkdtempSync(join(tmpdir(), "gsd-notification-overlay-height-"));
+    const originalRowsDescriptor = Object.getOwnPropertyDescriptor(process.stdout, "rows");
+    Object.defineProperty(process.stdout, "rows", { value: 40, configurable: true });
+
+    t.after(() => {
+      if (originalRowsDescriptor) {
+        Object.defineProperty(process.stdout, "rows", originalRowsDescriptor);
+      } else {
+        delete (process.stdout as { rows?: number }).rows;
+      }
+      _resetNotificationStore();
+      rmSync(dir, { recursive: true, force: true });
+    });
+
+    initNotificationStore(dir);
+    for (let i = 0; i < 80; i++) {
+      appendNotification(`notification-${i + 1} with enough text to exercise clipping`, "warning");
+    }
+
+    const overlay = new GSDNotificationOverlay({ requestRender() {} }, fakeTheme as any, () => {});
+    t.after(() => overlay.dispose());
+
+    const rendered = overlay.render(100);
+    const maxHeight = Math.floor((40 * 52) / 100);
+    assert.ok(rendered.length <= maxHeight, `expected ${rendered.length} lines to fit maxHeight ${maxHeight}`);
+    assert.ok(rendered.at(-1)?.includes("╯"), "bottom border should remain visible");
+    assert.equal(notificationOverlayOptions().maxHeight, "52%");
+  });
 });

package/src/resources/extensions/gsd/tests/notification-store.test.ts

@@ -19,6 +19,7 @@ import {
   onNotificationStoreChange,
   _resetNotificationStore,
 } from "../notification-store.js";
+import { resolveNotificationStoreBasePath } from "../bootstrap/register-hooks.js";
 
 describe("notification-store", () => {
   let tmp: string;
@@ -243,6 +244,13 @@ describe("notification-store", () => {
     rmSync(tmp2, { recursive: true, force: true });
   });
 
+  test("session notification base resolves auto-worktree paths to project root", () => {
+    const worktreePath = join(tmp, ".gsd", "worktrees", "M001");
+    mkdirSync(worktreePath, { recursive: true });
+
+    assert.equal(resolveNotificationStoreBasePath(worktreePath), tmp);
+  });
+
   test("counters resync from disk after markAllRead", () => {
     initNotificationStore(tmp);
     appendNotification("msg1", "info");

package/src/resources/extensions/gsd/tests/notification-widget.test.ts

@@ -5,7 +5,7 @@ import { join } from "node:path";
 import { tmpdir } from "node:os";
 
 import { initNotificationStore, appendNotification, _resetNotificationStore } from "../notification-store.js";
-import { buildNotificationWidgetLines } from "../notification-widget.js";
+import { buildNotificationWidgetLines, initNotificationWidget, _resetNotificationWidgetForTests } from "../notification-widget.js";
 
 test("buildNotificationWidgetLines shows unread count with shortcut pair", () => {
   const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
@@ -27,3 +27,42 @@ test("buildNotificationWidgetLines shows unread count with shortcut pair", () =>
     rmSync(tmp, { recursive: true, force: true });
   }
 });
+
+test("initNotificationWidget replaces prior interval and store subscription", () => {
+  const tmp = mkdtempSync(join(tmpdir(), "gsd-notification-widget-"));
+  const firstStatuses: Array<string | undefined> = [];
+  const secondStatuses: Array<string | undefined> = [];
+  try {
+    mkdirSync(join(tmp, ".gsd"), { recursive: true });
+    _resetNotificationStore();
+    _resetNotificationWidgetForTests();
+    initNotificationStore(tmp);
+    appendNotification("Need attention", "warning");
+
+    const firstCleanup = initNotificationWidget({
+      hasUI: true,
+      ui: { setStatus: (_key: string, value: string | undefined) => firstStatuses.push(value) },
+    } as any);
+    initNotificationWidget({
+      hasUI: true,
+      ui: { setStatus: (_key: string, value: string | undefined) => secondStatuses.push(value) },
+    } as any);
+
+    const firstCountAfterReplace = firstStatuses.length;
+    firstCleanup();
+    assert.equal(firstStatuses.length, firstCountAfterReplace, "stale cleanup must not clear the replaced status chip");
+
+    appendNotification("Need follow-up", "warning");
+
+    assert.equal(
+      firstStatuses.length,
+      firstCountAfterReplace,
+      "replaced widget must not receive store-change refreshes",
+    );
+    assert.match(secondStatuses.at(-1) ?? "", /2 unread/);
+  } finally {
+    _resetNotificationWidgetForTests();
+    _resetNotificationStore();
+    rmSync(tmp, { recursive: true, force: true });
+  }
+});

package/src/resources/extensions/gsd/tests/notifications-handler.test.ts

@@ -1,3 +1,6 @@
+// Project/App: GSD-2
+// File Purpose: Tests for /gsd notifications command handling and overlay launch behavior.
+
 import test from "node:test";
 import assert from "node:assert/strict";
 import { join } from "node:path";
@@ -58,6 +61,47 @@ test("notifications command falls back to text output when overlay returns undef
   assert.match(notices[0].message, /Recent notifications:/);
 });
 
+test("notifications command opens a compact bounded overlay", async (t) => {
+  const base = makeTempDir("overlay-options");
+  initNotificationStore(base);
+  appendNotification("Build complete", "success");
+
+  t.after(() => {
+    _resetNotificationStore();
+    cleanup(base);
+  });
+
+  const notices: Array<{ message: string; level?: string }> = [];
+  let capturedOptions: any;
+  await handleNotificationsCommand(
+    "",
+    {
+      hasUI: true,
+      ui: {
+        custom: async (_factory: any, options: any) => {
+          capturedOptions = options;
+          return true;
+        },
+        notify: (message: string, level?: string) => {
+          notices.push({ message, level });
+        },
+      },
+    } as any,
+    {} as any,
+  );
+
+  assert.deepEqual(capturedOptions?.overlayOptions, {
+    width: "58%",
+    minWidth: 68,
+    maxHeight: "52%",
+    anchor: "top-center",
+    row: "24%",
+    margin: { top: 2, right: 2, bottom: 6, left: 2 },
+    backdrop: true,
+  });
+  assert.equal(notices.length, 0, "successful overlay should not emit text fallback");
+});
+
 test("notifications tail caps inline output and hints to open overlay", async (t) => {
   const base = makeTempDir("tail-cap");
   initNotificationStore(base);

package/src/resources/extensions/gsd/tests/originalbase-path-comparison.test.ts

@@ -33,12 +33,6 @@ import {
   teardownAutoWorktree,
 } from "../auto-worktree.ts";
 import { normalizeWorktreePathForCompare } from "../worktree-root.ts";
-import {
-  WorktreeResolver,
-  type WorktreeResolverDeps,
-  type NotifyCtx,
-} from "../worktree-resolver.ts";
-import { AutoSession } from "../auto/session.ts";
 
 // ─── Helpers ──────────────────────────────────────────────────────────────────
 
@@ -60,93 +54,6 @@ function createTempRepo(t: { after: (fn: () => void) => void }): string {
   return dir;
 }
 
-function makeSession(overrides?: Partial<{ basePath: string; originalBasePath: string }>): AutoSession {
-  const s = new AutoSession();
-  s.basePath = overrides?.basePath ?? "/project";
-  s.originalBasePath = overrides?.originalBasePath ?? "/project";
-  return s;
-}
-
-interface CallLog { fn: string; args: unknown[] }
-
-function makeDeps(overrides?: Partial<WorktreeResolverDeps>): WorktreeResolverDeps & { calls: CallLog[] } {
-  const calls: CallLog[] = [];
-
-  const deps: WorktreeResolverDeps & { calls: CallLog[] } = {
-    calls,
-    isInAutoWorktree: (basePath: string) => {
-      calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-      return basePath.includes("worktrees");
-    },
-    shouldUseWorktreeIsolation: () => true,
-    getIsolationMode: () => "worktree",
-    mergeMilestoneToMain: (basePath: string, milestoneId: string, roadmapContent: string) => {
-      calls.push({ fn: "mergeMilestoneToMain", args: [basePath, milestoneId, roadmapContent] });
-      return { pushed: false, codeFilesChanged: true };
-    },
-    syncWorktreeStateBack: (mainBasePath: string, worktreePath: string, milestoneId: string) => {
-      calls.push({ fn: "syncWorktreeStateBack", args: [mainBasePath, worktreePath, milestoneId] });
-      return { synced: [] };
-    },
-    teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-      calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-    },
-    createAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "createAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    enterAutoWorktree: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "enterAutoWorktree", args: [basePath, milestoneId] });
-      return `${basePath}/.gsd/worktrees/${milestoneId}`;
-    },
-    getAutoWorktreePath: (basePath: string, milestoneId: string) => {
-      calls.push({ fn: "getAutoWorktreePath", args: [basePath, milestoneId] });
-      return null;
-    },
-    autoCommitCurrentBranch: (basePath: string, reason: string, milestoneId: string) => {
-      calls.push({ fn: "autoCommitCurrentBranch", args: [basePath, reason, milestoneId] });
-    },
-    getCurrentBranch: (basePath: string) => {
-      calls.push({ fn: "getCurrentBranch", args: [basePath] });
-      return "main";
-    },
-    autoWorktreeBranch: (milestoneId: string) => `milestone/${milestoneId}`,
-    resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-      calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-      return null;
-    },
-    readFileSync: (path: string, _enc: string) => {
-      calls.push({ fn: "readFileSync", args: [path] });
-      return "# Roadmap\n";
-    },
-    GitServiceImpl: class {
-      constructor(_basePath: string, _gitConfig: unknown) {}
-    } as unknown as WorktreeResolverDeps["GitServiceImpl"],
-    loadEffectiveGSDPreferences: () => ({ preferences: { git: {} } }),
-    invalidateAllCaches: () => { calls.push({ fn: "invalidateAllCaches", args: [] }); },
-    captureIntegrationBranch: (_basePath: string, _mid: string) => {},
-    enterBranchModeForMilestone: (_basePath: string, _milestoneId: string) => {},
-    ...overrides,
-  };
-
-  if (overrides) {
-    for (const [key, val] of Object.entries(overrides)) {
-      if (key !== "calls") (deps as unknown as Record<string, unknown>)[key] = val;
-    }
-  }
-  return deps;
-}
-
-function makeNotifyCtx(): NotifyCtx & { messages: Array<{ msg: string; level?: string }> } {
-  const messages: Array<{ msg: string; level?: string }> = [];
-  return {
-    messages,
-    notify: (msg: string, level?: "info" | "warning" | "error" | "success") => {
-      messages.push({ msg, level });
-    },
-  };
-}
-
 // ─── Suite 1: getAutoWorktreeOriginalBase() returns realpath-canonical path ──
 
 describe("getAutoWorktreeOriginalBase() is realpath-normalised", () => {
@@ -238,92 +145,15 @@ describe("normalizeWorktreePathForCompare equalises canonical vs non-canonical f
 // resolveMilestoneFile call against the "worktree" path that is actually the
 // same directory). The new code correctly skips the fallback.
 
-describe("WorktreeResolver: roadmap-fallback skipped when basePath is same physical path as originalBase", () => {
-  test("with trailing-slash basePath equal to originalBase: resolveMilestoneFile called once", () => {
-    // originalBase is canonical (as returned by workspace registry)
-    const canonicalBase = "/tmp/m5-test-project";
-    // s.basePath has a trailing slash — same physical dir, non-canonical string
-    const trailingSlashBase = canonicalBase + "/";
-
-    const s = makeSession({
-      basePath: trailingSlashBase,
-      originalBasePath: canonicalBase,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      // isInAutoWorktree: basePath has trailing slash but is NOT a worktree
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return false;
-      },
-      // resolveMilestoneFile always returns null (no roadmap found)
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null;
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-
-    // Override calls ref so we can inspect it directly
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = new WorktreeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    // mergeAndExit → _mergeWorktreeMode
-    // originalBase = s.originalBasePath = canonicalBase
-    // s.basePath = trailingSlashBase — physically same as canonicalBase
-    // Post-fix: isSamePath(trailingSlashBase, canonicalBase) is true
-    //   → roadmap fallback branch is skipped (resolveMilestoneFile called once)
-    // Pre-fix (bug): trailingSlashBase !== canonicalBase → fallback entered
-    //   → resolveMilestoneFile called twice
-
-    resolver.mergeAndExit("M001", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 1,
-      "resolveMilestoneFile must be called exactly once — fallback should be skipped when " +
-      "s.basePath is the same physical path as originalBase (isSamePath fix)");
-  });
-
-  test("with genuinely different basePath (inside worktree): resolveMilestoneFile called twice", () => {
-    // originalBase is the project root
-    const projectRoot = "/tmp/m5-test-project";
-    // s.basePath is inside a worktree — a physically different path
-    const worktreePath = projectRoot + "/.gsd/worktrees/M002";
-
-    const s = makeSession({
-      basePath: worktreePath,
-      originalBasePath: projectRoot,
-    });
-
-    const calls: CallLog[] = [];
-    const deps = makeDeps({
-      isInAutoWorktree: (basePath: string) => {
-        calls.push({ fn: "isInAutoWorktree", args: [basePath] });
-        return basePath.includes("worktrees");
-      },
-      resolveMilestoneFile: (basePath: string, milestoneId: string, fileType: string) => {
-        calls.push({ fn: "resolveMilestoneFile", args: [basePath, milestoneId, fileType] });
-        return null; // no roadmap in either location
-      },
-      teardownAutoWorktree: (basePath: string, milestoneId: string, opts?: { preserveBranch?: boolean }) => {
-        calls.push({ fn: "teardownAutoWorktree", args: [basePath, milestoneId, opts] });
-      },
-    });
-    (deps as unknown as { calls: CallLog[] }).calls = calls;
-
-    const resolver = new WorktreeResolver(s, deps);
-    const ctx = makeNotifyCtx();
-
-    resolver.mergeAndExit("M002", ctx);
-
-    const rmfCalls = calls.filter(c => c.fn === "resolveMilestoneFile");
-    assert.strictEqual(rmfCalls.length, 2,
-      "resolveMilestoneFile must be called twice when basePath is a genuine worktree path " +
-      "(fallback should run for different physical paths)");
-  });
-});
+// ADR-016 phase 2 / C2 + C3 (#5625, #5626): the prior two tests in this
+// suite asserted call counts on `deps.resolveMilestoneFile` /
+// `deps.isInAutoWorktree` / `deps.teardownAutoWorktree` to verify that the
+// roadmap-fallback branch was skipped when basePath was a non-canonical
+// form of originalBase (trailing slash). After C2/C3 those fields are
+// inlined into worktree-lifecycle.ts as direct imports — the mocks no
+// longer fire and the call-count assertions test nothing meaningful. The
+// underlying invariant (isSamePathPhysical normalises trailing slashes,
+// canonical/non-canonical pairs, and case differences) is preserved
+// inside worktree-lifecycle.ts and covered indirectly by the merge-area
+// integration tests, which exercise real worktree merges where the
+// fallback choice matters.

package/src/resources/extensions/gsd/tests/orphan-merge-bootstrap.test.ts

@@ -0,0 +1,144 @@
+// GSD-2 + src/resources/extensions/gsd/tests/orphan-merge-bootstrap.test.ts
+// Regression: bootstrap must actively merge orphan completed-but-unmerged
+// milestones, not just seed `s.currentMilestoneId` (the seed approach was
+// silently overwritten at auto-start.ts:948 — caught in audit of PR #5549).
+//
+// After ADR-016 / slice 7 step E, _mergeOrphanCompletedMilestone 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 { _mergeOrphanCompletedMilestone } from "../auto-start.js";
+import type { WorktreeLifecycle } from "../worktree-lifecycle.js";
+
+interface FakeLifecycleState {
+  mergeCalls: Array<{ milestoneId: string }>;
+  causeOnFail?: unknown;
+}
+
+function fakeLifecycle(state: FakeLifecycleState): WorktreeLifecycle {
+  return {
+    exitMilestone: (milestoneId: string) => {
+      state.mergeCalls.push({ milestoneId });
+      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: orphan merge runs, returns merged:true, emits info notify", () => {
+  const lcState: FakeLifecycleState = { mergeCalls: [] };
+  const uiState: FakeUiState = { notifications: [] };
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.deepEqual(result, { merged: true });
+  assert.deepEqual(lcState.mergeCalls, [{ milestoneId: "M002" }]);
+  assert.equal(uiState.notifications.length, 1);
+  assert.deepEqual(uiState.notifications[0], {
+    message: "Detected unmerged completed milestone M002. Merging now.",
+    level: "info",
+  });
+});
+
+test("regression: failure from exitMilestone (e.g. wrong-branch from PR #5549 commit 5) does not bubble out", () => {
+  // Commit 5 (68ef58a3c) made `_mergeBranchMode` throw on wrong branch
+  // instead of silently returning false. Lifecycle now wraps the throw in
+  // {ok:false, cause}; _mergeOrphanCompletedMilestone must surface that as
+  // a notify, never re-throwing into the slash-command caller.
+  const boom = new Error("dirty working tree blocks checkout");
+  const lcState: FakeLifecycleState = { mergeCalls: [], causeOnFail: boom };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(result.error, boom);
+
+  // First notify announces the merge attempt; second notify reports the failure.
+  assert.equal(uiState.notifications.length, 2);
+  assert.equal(uiState.notifications[0].level, "info");
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(
+    uiState.notifications[1].message,
+    /Could not merge orphan milestone M002/,
+  );
+  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 still captured and notified", () => {
+  // Defensive: non-Error causes (strings, numbers) must not crash the formatter.
+  const lcState: FakeLifecycleState = {
+    mergeCalls: [],
+    // mimic a non-Error cause
+    causeOnFail: "git lock held",
+  };
+  const uiState: FakeUiState = { notifications: [] };
+
+  const result = _mergeOrphanCompletedMilestone(
+    fakeLifecycle(lcState),
+    "M002",
+    fakeUi(uiState),
+  );
+
+  assert.equal(result.merged, false);
+  assert.equal(uiState.notifications[1].level, "warning");
+  assert.match(uiState.notifications[1].message, /git lock held/);
+});
+
+test("the exitMilestone call receives a notify-bound NotifyCtx the lifecycle can invoke", () => {
+  // The lifecycle's NotifyCtx must be wired to ui.notify so user-facing
+  // messages from inside exitMilestone (e.g. "Milestone Mxxx merged") still
+  // reach the UI. Verify by having the fake invoke ctx.notify.
+  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("inner success message", "success");
+      return { ok: true, merged: true, codeFilesChanged: false };
+    },
+  } as unknown as WorktreeLifecycle;
+
+  const result = _mergeOrphanCompletedMilestone(lifecycle, "M002", ui);
+
+  assert.equal(result.merged, true);
+  // 1: outer "Detected unmerged completed milestone..."
+  // 2: inner "inner success message" emitted via the bound ctx.notify
+  assert.equal(uiState.notifications.length, 2);
+  assert.deepEqual(uiState.notifications[1], {
+    message: "inner success message",
+    level: "success",
+  });
+});