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

package/src/resources/extensions/gsd/migration-auto-check.ts

@@ -0,0 +1,129 @@
+import { existsSync, readdirSync, readFileSync } from "node:fs";
+
+import { ensureDbOpen } from "./bootstrap/dynamic-tools.js";
+import {
+  clearEngineHierarchy,
+  getAllMilestones,
+  getMilestoneSlices,
+  getSliceTasks,
+  isDbAvailable,
+  transaction,
+} from "./gsd-db.js";
+import { migrateHierarchyToDb } from "./md-importer.js";
+import { parsePlan, parseRoadmap } from "./parsers-legacy.js";
+import {
+  milestonesDir,
+  resolveMilestoneFile,
+  resolveSliceFile,
+} from "./paths.js";
+import { invalidateStateCache } from "./state.js";
+
+export interface HierarchyCounts {
+  milestones: number;
+  slices: number;
+  tasks: number;
+}
+
+export interface MigrationAutoCheckResult {
+  action: "none" | "imported";
+  reason: "no-markdown" | "in-sync" | "db-empty" | "count-mismatch";
+  markdown: HierarchyCounts;
+  beforeDb: HierarchyCounts;
+  afterDb: HierarchyCounts;
+}
+
+function zeroCounts(): HierarchyCounts {
+  return { milestones: 0, slices: 0, tasks: 0 };
+}
+
+function sameCounts(a: HierarchyCounts, b: HierarchyCounts): boolean {
+  return a.milestones === b.milestones && a.slices === b.slices && a.tasks === b.tasks;
+}
+
+export function countMarkdownHierarchy(basePath: string): HierarchyCounts {
+  const root = milestonesDir(basePath);
+  if (!existsSync(root)) return zeroCounts();
+
+  const counts = zeroCounts();
+  for (const entry of readdirSync(root, { withFileTypes: true })) {
+    if (!entry.isDirectory() || !/^M\d+/.test(entry.name)) continue;
+    counts.milestones++;
+
+    const roadmapPath = resolveMilestoneFile(basePath, entry.name, "ROADMAP");
+    if (!roadmapPath || !existsSync(roadmapPath)) continue;
+
+    const roadmap = parseRoadmap(readFileSync(roadmapPath, "utf-8"));
+    counts.slices += roadmap.slices.length;
+
+    for (const slice of roadmap.slices) {
+      const planPath = resolveSliceFile(basePath, entry.name, slice.id, "PLAN");
+      if (!planPath || !existsSync(planPath)) continue;
+      const plan = parsePlan(readFileSync(planPath, "utf-8"));
+      counts.tasks += plan.tasks.length;
+    }
+  }
+
+  return counts;
+}
+
+export function countDbHierarchy(): HierarchyCounts {
+  if (!isDbAvailable()) return zeroCounts();
+  const counts = zeroCounts();
+  const milestones = getAllMilestones();
+  counts.milestones = milestones.length;
+
+  for (const milestone of milestones) {
+    const slices = getMilestoneSlices(milestone.id);
+    counts.slices += slices.length;
+    for (const slice of slices) {
+      counts.tasks += getSliceTasks(milestone.id, slice.id).length;
+    }
+  }
+
+  return counts;
+}
+
+export async function autoImportMarkdownHierarchyIfDbMismatch(
+  basePath: string,
+): Promise<MigrationAutoCheckResult> {
+  const markdown = countMarkdownHierarchy(basePath);
+  if (sameCounts(markdown, zeroCounts())) {
+    return {
+      action: "none",
+      reason: "no-markdown",
+      markdown,
+      beforeDb: zeroCounts(),
+      afterDb: zeroCounts(),
+    };
+  }
+
+  const opened = await ensureDbOpen(basePath);
+  if (!opened || !isDbAvailable()) {
+    throw new Error(`failed to open or create the GSD database at ${basePath}`);
+  }
+
+  const beforeDb = countDbHierarchy();
+  if (sameCounts(markdown, beforeDb)) {
+    return { action: "none", reason: "in-sync", markdown, beforeDb, afterDb: beforeDb };
+  }
+
+  const reason = sameCounts(beforeDb, zeroCounts()) ? "db-empty" : "count-mismatch";
+  const imported = transaction(() => {
+    clearEngineHierarchy();
+    return migrateHierarchyToDb(basePath);
+  });
+  invalidateStateCache();
+
+  const afterDb = {
+    milestones: imported.milestones,
+    slices: imported.slices,
+    tasks: imported.tasks,
+  };
+  if (!sameCounts(markdown, afterDb)) {
+    throw new Error(
+      `migration auto-import verification failed: markdown ${markdown.milestones}M/${markdown.slices}S/${markdown.tasks}T, db ${afterDb.milestones}M/${afterDb.slices}S/${afterDb.tasks}T`,
+    );
+  }
+
+  return { action: "imported", reason, markdown, beforeDb, afterDb };
+}

package/src/resources/extensions/gsd/native-git-bridge.ts

@@ -705,20 +705,21 @@ export function nativeAddTracked(basePath: string): void {
   gitFileExec(basePath, ["add", "-u"]);
 }
 
-function isDotGsdIgnored(basePath: string): boolean {
-  for (const path of [".gsd", ".gsd/"]) {
-    try {
-      execFileSync("git", ["check-ignore", "-q", path], {
-        cwd: basePath,
-        stdio: "pipe",
-        env: GIT_NO_PROMPT_ENV,
-      });
-      return true;
-    } catch {
-      // exit 1 means this form is not ignored; try the next variant
-    }
+export function nativeIsIgnored(basePath: string, path: string): boolean {
+  try {
+    execFileSync("git", ["check-ignore", "-q", "--", path], {
+      cwd: basePath,
+      stdio: "pipe",
+      env: GIT_NO_PROMPT_ENV,
+    });
+    return true;
+  } catch {
+    return false;
   }
-  return false;
+}
+
+function isDotGsdIgnored(basePath: string): boolean {
+  return [".gsd", ".gsd/"].some(path => nativeIsIgnored(basePath, path));
 }
 
 /**
@@ -1183,6 +1184,33 @@ export function nativeRmForce(basePath: string, paths: string[]): void {
   }
 }
 
+function runGitWorktreeAdd(
+  basePath: string,
+  wtPath: string,
+  branch: string,
+  createBranch?: boolean,
+  startPoint?: string,
+): void {
+  if (createBranch) {
+    const branchRef = gitExec(basePath, ["show-ref", "--verify", `refs/heads/${branch}`], true);
+    if (branchRef) {
+      gitExec(basePath, ["worktree", "add", wtPath, branch]);
+      return;
+    }
+    gitExec(basePath, ["worktree", "add", "-b", branch, wtPath, startPoint ?? "HEAD"]);
+  } else {
+    gitExec(basePath, ["worktree", "add", wtPath, branch]);
+  }
+}
+
+export function assertWorktreeMaterialized(wtPath: string): void {
+  if (existsSync(join(wtPath, ".git"))) return;
+  throw new GSDError(
+    GSD_GIT_ERROR,
+    `git worktree add did not materialize a valid worktree at ${wtPath}: missing .git file`,
+  );
+}
+
 /**
  * Add a new git worktree.
  * Native: libgit2 worktree API.
@@ -1198,14 +1226,20 @@ export function nativeWorktreeAdd(
   const native = loadNative();
   if (native) {
     native.gitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
-    return;
+    try {
+      assertWorktreeMaterialized(wtPath);
+      return;
+    } catch {
+      rmSync(wtPath, { recursive: true, force: true });
+      gitExec(basePath, ["worktree", "prune"], true);
+      runGitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
+      assertWorktreeMaterialized(wtPath);
+      return;
+    }
   }
 
-  if (createBranch) {
-    gitExec(basePath, ["worktree", "add", "-b", branch, wtPath, startPoint ?? "HEAD"]);
-  } else {
-    gitExec(basePath, ["worktree", "add", wtPath, branch]);
-  }
+  runGitWorktreeAdd(basePath, wtPath, branch, createBranch, startPoint);
+  assertWorktreeMaterialized(wtPath);
 }
 
 /**

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

@@ -1,9 +1,8 @@
-// GSD Extension — Notification History Overlay
-// Scrollable panel showing all persisted notifications with severity filtering.
-// Toggled with Ctrl+Alt+N (⌃⌥N on macOS), Ctrl+Shift+N fallback, or /gsd notifications.
+// Project/App: GSD-2
+// File Purpose: Notification history overlay with severity filtering and width-safe TUI rendering.
 
 import type { Theme } from "@gsd/pi-coding-agent";
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi, matchesKey, Key } from "@gsd/pi-tui";
+import { truncateToWidth, visibleWidth, matchesKey, Key } from "@gsd/pi-tui";
 
 import {
   readNotifications,
@@ -14,10 +13,32 @@ import {
   type NotifySeverity,
 } from "./notification-store.js";
 import { formattedShortcutPair } from "./shortcut-defs.js";
-import { padRight, joinColumns } from "../shared/mod.js";
-
-type FilterMode = "all" | "error" | "warning" | "info";
-const FILTER_CYCLE: FilterMode[] = ["all", "error", "warning", "info"];
+import {
+  padRightVisible,
+  renderFrame,
+  renderKeyHints,
+  rightAlign,
+  wrapVisibleText,
+} from "./tui/render-kit.js";
+
+type FilterMode = "all" | "error" | "warning" | "success" | "info";
+const FILTER_CYCLE: FilterMode[] = ["all", "error", "warning", "success", "info"];
+const OVERLAY_WIDTH = "58%";
+const OVERLAY_MIN_WIDTH = 68;
+const OVERLAY_MAX_HEIGHT_PERCENT = 52;
+const OVERLAY_MARGIN = { top: 2, right: 2, bottom: 6, left: 2 } as const;
+
+export function notificationOverlayOptions() {
+  return {
+    width: OVERLAY_WIDTH,
+    minWidth: OVERLAY_MIN_WIDTH,
+    maxHeight: `${OVERLAY_MAX_HEIGHT_PERCENT}%`,
+    anchor: "top-center",
+    row: "24%",
+    margin: OVERLAY_MARGIN,
+    backdrop: true,
+  } as const;
+}
 
 function severityIcon(severity: NotifySeverity): string {
   switch (severity) {
@@ -29,17 +50,6 @@ function severityIcon(severity: NotifySeverity): string {
   }
 }
 
-/** Column-aware word wrap using pi-tui's native wrapper (handles unicode/ANSI). */
-function wrapText(text: string, maxWidth: number): string[] {
-  if (maxWidth <= 0) return [text];
-  const lines = wrapTextWithAnsi(text, maxWidth);
-  // Safety clamp: if any line still exceeds maxWidth (e.g. unbreakable long token),
-  // truncate it with an ellipsis so it cannot bleed past the box border.
-  return lines.map((l) =>
-    visibleWidth(l) > maxWidth ? truncateToWidth(l, maxWidth, "…") : l,
-  );
-}
-
 function formatTimestamp(ts: string): string {
   try {
     const d = new Date(ts);
@@ -184,13 +194,19 @@ export class GSDNotificationOverlay {
     }
 
     const content = this.buildContentLines(width);
-    const maxVisibleRows = Math.max(5, process.stdout.rows ? process.stdout.rows - 8 : 24) - 2;
+    const terminalRows = process.stdout.rows || 32;
+    const availableRows = Math.max(1, terminalRows - OVERLAY_MARGIN.top - OVERLAY_MARGIN.bottom);
+    const overlayRows = Math.min(
+      availableRows,
+      Math.max(1, Math.floor((terminalRows * OVERLAY_MAX_HEIGHT_PERCENT) / 100)),
+    );
+    const maxVisibleRows = Math.max(5, overlayRows - 2);
     const visibleContentRows = Math.min(content.length, maxVisibleRows);
     const maxScroll = Math.max(0, content.length - visibleContentRows);
     this.scrollOffset = Math.min(this.scrollOffset, maxScroll);
     const visibleContent = content.slice(this.scrollOffset, this.scrollOffset + visibleContentRows);
 
-    const lines = this.wrapInBox(visibleContent, width);
+    const lines = renderFrame(this.theme, visibleContent, width);
 
     this.cachedWidth = width;
     this.cachedLines = lines;
@@ -227,33 +243,15 @@ export class GSDNotificationOverlay {
     }
   }
 
-  private wrapInBox(inner: string[], width: number): string[] {
-    const th = this.theme;
-    const border = (s: string) => th.fg("borderAccent", s);
-    const innerWidth = width - 4;
-    const lines: string[] = [];
-
-    lines.push(border("╭" + "─".repeat(width - 2) + "╮"));
-    for (const line of inner) {
-      const truncated = truncateToWidth(line, innerWidth);
-      const padWidth = Math.max(0, innerWidth - visibleWidth(truncated));
-      lines.push(border("│") + " " + truncated + " ".repeat(padWidth) + " " + border("│"));
-    }
-    lines.push(border("╰" + "─".repeat(width - 2) + "╯"));
-    return lines;
-  }
-
   private buildContentLines(width: number): string[] {
     const th = this.theme;
-    const shellWidth = width - 4;
-    const contentWidth = Math.min(shellWidth, 128);
-    const sidePad = Math.max(0, Math.floor((shellWidth - contentWidth) / 2));
-    const leftMargin = " ".repeat(sidePad);
+    const shellWidth = Math.max(1, width - 4);
+    const contentWidth = shellWidth;
     const lines: string[] = [];
 
     const row = (content = ""): string => {
       const truncated = truncateToWidth(content, contentWidth);
-      return leftMargin + padRight(truncated, contentWidth);
+      return padRightVisible(truncated, contentWidth);
     };
     const blank = () => row("");
     const hr = () => row(th.fg("dim", "─".repeat(contentWidth)));
@@ -262,9 +260,15 @@ export class GSDNotificationOverlay {
     const title = th.fg("accent", th.bold("Notifications"));
     const filterLabel = this.filter === "all"
       ? th.fg("dim", "all")
-      : th.fg(this.filter === "error" ? "error" : this.filter === "warning" ? "warning" : "dim", this.filter);
+      : th.fg(
+        this.filter === "error" ? "error"
+          : this.filter === "warning" ? "warning"
+            : this.filter === "success" ? "success"
+              : "dim",
+        this.filter,
+      );
     const count = `${this.filteredEntries.length} entries`;
-    lines.push(row(joinColumns(
+    lines.push(row(rightAlign(
       `${title}  ${th.fg("dim", "filter:")} ${filterLabel}`,
       th.fg("dim", count),
       contentWidth,
@@ -273,7 +277,7 @@ export class GSDNotificationOverlay {
 
     // Controls
     const closeShortcut = formattedShortcutPair("notifications");
-    lines.push(row(th.fg("dim", `↑/↓ scroll  f filter  c clear  Esc close  (${closeShortcut})`)));
+    lines.push(row(renderKeyHints(th, ["↑/↓ scroll", "f filter", "c clear", `Esc/${closeShortcut} close`], contentWidth)));
     lines.push(blank());
 
     // Entries
@@ -302,7 +306,7 @@ export class GSDNotificationOverlay {
       const msgMaxWidth = Math.max(10, contentWidth - prefixWidth);
 
       // Wrap long messages onto continuation lines indented to align with message start
-      const msgLines = wrapText(entry.message, msgMaxWidth);
+      const msgLines = wrapVisibleText(entry.message, msgMaxWidth);
       const indent = " ".repeat(prefixWidth);
       for (let i = 0; i < msgLines.length; i++) {
         if (i === 0) {

package/src/resources/extensions/gsd/orphan-stash-audit.ts

@@ -0,0 +1,117 @@
+// GSD-2 + src/resources/extensions/gsd/orphan-stash-audit.ts
+// Startup sweep for orphaned gsd-preflight-stash entries left behind by
+// interrupted milestone merges (#5538-followup).
+
+import { execFileSync } from "node:child_process";
+import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
+
+export interface OrphanPreflightStashAuditResult {
+  applied: Array<{ milestoneId: string; stashRef: string }>;
+  warnings: string[];
+}
+
+/**
+ * Recognize the "already restored" failure mode of `git stash apply`.
+ *
+ * When a preflight stash captured untracked files via `--include-untracked`
+ * and those files are now present in the working tree (e.g. a prior audit
+ * run already applied this stash), `git stash apply` aborts with
+ * `<path> already exists, no checkout` and exits non-zero. That is the
+ * idempotent steady state for this audit, not a recovery failure — treat
+ * it as a no-op so repeated GSD startups stop spamming the user with
+ * warnings about stashes that have already been restored (#5538-followup
+ * peer-review feedback).
+ */
+function _isAlreadyRestoredApplyError(err: unknown): boolean {
+  if (!err || typeof err !== "object") return false;
+  const stderr = (err as { stderr?: unknown }).stderr;
+  const stderrText = typeof stderr === "string" ? stderr : stderr instanceof Uint8Array ? Buffer.from(stderr).toString("utf-8") : "";
+  if (stderrText && /already exists, no checkout/i.test(stderrText)) return true;
+  const message = err instanceof Error ? err.message : String(err);
+  return /already exists, no checkout/i.test(message);
+}
+
+export { _isAlreadyRestoredApplyError };
+
+/**
+ * Audit `git stash list` for orphaned `gsd-preflight-stash:M00x:*` entries.
+ *
+ * The matching merge code in `phases.ts` previously skipped the postflight
+ * pop whenever `mergeAndExit` threw, leaking the user's pre-merge working
+ * tree into the stash list. For every preflight-stash entry whose milestone
+ * is now complete (per the supplied callback), `git stash apply` is invoked —
+ * NOT `pop`. The stash entry stays in the list so the user retains a backup
+ * if the apply produces unexpected merge results. Idempotent across repeated
+ * startup runs.
+ *
+ * Failures are best-effort: a list error (no repo, git unavailable) returns
+ * an empty result. An apply error becomes a warning the user sees alongside
+ * the existing orphan-branch audit messages — startup continues.
+ */
+export function auditOrphanedPreflightStashes(
+  basePath: string,
+  isMilestoneComplete: (milestoneId: string) => boolean,
+): OrphanPreflightStashAuditResult {
+  const result: OrphanPreflightStashAuditResult = { applied: [], warnings: [] };
+
+  let listOutput: string;
+  try {
+    listOutput = execFileSync(
+      "git",
+      ["stash", "list", "--format=%gd%x00%s"],
+      {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+      },
+    );
+  } catch {
+    return result;
+  }
+
+  const MARKER_RE = /\bgsd-preflight-stash:([A-Za-z0-9_-]+):/;
+  for (const line of listOutput.split("\n")) {
+    const sep = line.indexOf("\x00");
+    if (sep < 0) continue;
+    const ref = line.slice(0, sep);
+    const subject = line.slice(sep + 1);
+    if (!ref || !subject) continue;
+
+    const match = MARKER_RE.exec(subject);
+    if (!match) continue;
+    const milestoneId = match[1];
+
+    let complete = false;
+    try {
+      complete = isMilestoneComplete(milestoneId);
+    } catch (err) {
+      result.warnings.push(
+        `Could not determine completion status for ${milestoneId} during preflight-stash audit: ${err instanceof Error ? err.message : String(err)}.`,
+      );
+      continue;
+    }
+    if (!complete) continue;
+
+    try {
+      execFileSync("git", ["stash", "apply", "--quiet", ref], {
+        cwd: basePath,
+        stdio: ["ignore", "pipe", "pipe"],
+        encoding: "utf-8",
+        env: GIT_NO_PROMPT_ENV,
+      });
+      result.applied.push({ milestoneId, stashRef: ref });
+    } catch (err) {
+      // Idempotent steady state: stash was already applied in a prior audit
+      // run; the files exist and `git stash apply` refuses to overwrite.
+      // Skip silently so repeat runs are no-ops.
+      if (_isAlreadyRestoredApplyError(err)) continue;
+      result.warnings.push(
+        `Could not apply orphaned preflight stash ${ref} (milestone ${milestoneId}): ${err instanceof Error ? err.message : String(err)}. ` +
+          `Run \`git stash apply ${ref}\` manually to restore your pre-merge changes.`,
+      );
+    }
+  }
+
+  return result;
+}

package/src/resources/extensions/gsd/parallel-merge.ts

@@ -8,9 +8,13 @@
 import { existsSync, readdirSync } from "node:fs";
 import { join } from "node:path";
 import { spawnSync } from "node:child_process";
-import { loadFile } from "./files.js";
-import { resolveGsdPathContract, resolveMilestoneFile } from "./paths.js";
-import { mergeMilestoneToMain } from "./auto-worktree.js";
+import { resolveGsdPathContract } from "./paths.js";
+import { getAutoWorktreePath } from "./auto-worktree.js";
+import { buildWorktreeLifecycleDeps } from "./auto.js";
+import {
+  mergeMilestoneStandalone,
+  type MergeStandaloneResult,
+} from "./worktree-lifecycle.js";
 import { MergeConflictError } from "./git-service.js";
 import { removeSessionStatus } from "./session-status-io.js";
 import type { WorkerInfo } from "./parallel-orchestrator.js";
@@ -136,44 +140,46 @@ export function determineMergeOrder(
 
 /**
  * Attempt to merge a single milestone's worktree back to main.
- * Wraps mergeMilestoneToMain with error handling for parallel context.
+ *
+ * Routes through `WorktreeLifecycle.mergeMilestoneStandalone` so parallel
+ * callers get the same projection-finalize / roadmap-fallback / secondary-
+ * teardown invariants as the single-loop path. Closes the parallel-merge
+ * bypass that ADR-016 names (issue #5618).
  */
 export async function mergeCompletedMilestone(
   basePath: string,
   milestoneId: string,
 ): Promise<MergeResult> {
-  try {
-    // Load the roadmap content (needed by mergeMilestoneToMain)
-    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
-    if (!roadmapPath) {
-      return {
-        milestoneId,
-        success: false,
-        error: `No roadmap found for ${milestoneId}`,
-      };
-    }
-
-    const roadmapContent = await loadFile(roadmapPath);
-    if (!roadmapContent) {
-      return {
-        milestoneId,
-        success: false,
-        error: `Could not read roadmap for ${milestoneId}`,
-      };
-    }
+  // Resolve the worktree path explicitly; parallel-merge has no AutoSession
+  // to read it from. Only use the worktree path when git actually knows
+  // about it (`getAutoWorktreePath` returns non-null). When the directory
+  // exists on disk but isn't a registered git worktree (e.g. a stale
+  // session-status marker dir), fall back to the project root and let the
+  // standalone's mode detection pick branch-mode or skipped — using the
+  // un-registered dir as `worktreeBasePath` would cause `getCurrentBranch`
+  // to fail with a "Worktree HEAD diverged" error.
+  const registeredWtPath = getAutoWorktreePath(basePath, milestoneId);
+  const worktreeBasePath = registeredWtPath ?? basePath;
 
-    // Attempt the merge
-    const result = mergeMilestoneToMain(basePath, milestoneId, roadmapContent);
-
-    // Clean up parallel session status
-    removeSessionStatus(basePath, milestoneId);
-
-    return {
+  let result: MergeStandaloneResult;
+  try {
+    result = mergeMilestoneStandalone(buildWorktreeLifecycleDeps(), {
+      originalBasePath: basePath,
+      worktreeBasePath,
       milestoneId,
-      success: true,
-      commitMessage: result.commitMessage,
-      pushed: result.pushed,
-    };
+      // Parallel context never runs with degraded isolation — workers only
+      // exist when isolation succeeded. Pass `false` explicitly so the
+      // standalone's degraded-skip branch is not reached.
+      isolationDegraded: false,
+      notify: (msg, level) => {
+        // Surface user-visible messages from the standalone through the
+        // workflow logger so the parallel merge's progress is visible in
+        // the same channel as the rest of the parallel orchestration.
+        if (level === "error" || level === "warning") {
+          logWarning("parallel", `${milestoneId}: ${msg}`);
+        }
+      },
+    });
   } catch (err) {
     if (err instanceof MergeConflictError) {
       return {
@@ -189,6 +195,27 @@ export async function mergeCompletedMilestone(
       error: getErrorMessage(err),
     };
   }
+
+  if (!result.merged) {
+    return {
+      milestoneId,
+      success: false,
+      error:
+        result.mode === "skipped"
+          ? `Merge skipped for ${milestoneId} (mode=none or isolation degraded).`
+          : `No roadmap for ${milestoneId} — milestone branch preserved for manual merge.`,
+    };
+  }
+
+  // Clean up parallel session status — only on a real merge.
+  removeSessionStatus(basePath, milestoneId);
+
+  return {
+    milestoneId,
+    success: true,
+    commitMessage: result.commitMessage,
+    pushed: result.pushed,
+  };
 }
 
 /**