@opengsd/gsd-pi 1.2.0-dev.0b870afa → 1.2.0-dev.23d85b63

package/src/resources/extensions/gsd/tools/exec-tool.ts

@@ -8,10 +8,8 @@ import {
   type ExecSandboxRequest,
   type ExecSandboxResult,
 } from "../exec-sandbox.js";
-import { realpathSync } from "node:fs";
-import path from "node:path";
 import { isContextModeEnabled, type ContextModeConfig } from "../preferences-types.js";
-import { projectRootFromWorktreePath } from "../worktree-root.js";
+import { bashReferencesProjectRootOutsideWorktree } from "../worktree-shell-guard.js";
 import { contextModeDisabledResult, type ToolExecutionResult } from "./context-mode-tool-result.js";
 
 export interface ExecToolParams {
@@ -189,117 +187,6 @@ function isToolExecutionResult(value: unknown): value is ToolExecutionResult {
   return typeof value === "object" && value !== null && Array.isArray((value as { content?: unknown }).content);
 }
 
-function escapeRegExp(value: string): string {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
-function normalizeScanPath(value: string): string {
-  const normalized = value.replace(/\\/g, "/").replace(/\/+$/, "");
-  return normalized.startsWith("/private/var/")
-    ? normalized.slice("/private".length)
-    : normalized;
-}
-
-function parseWorktreeBase(baseDir: string): { originalRoot: string; worktreeRoot: string } | null {
-  const normalizedBase = normalizeScanPath(baseDir);
-  const originalRoot = projectRootFromWorktreePath(normalizedBase);
-  if (!originalRoot) return null;
-  return { originalRoot, worktreeRoot: normalizedBase };
-}
-
-function pathInside(parent: string, target: string): boolean {
-  const parentWithSep = parent.endsWith("/") ? parent : `${parent}/`;
-  return target === parent || target.startsWith(parentWithSep);
-}
-
-function comparablePathVariants(value: string): string[] {
-  const variants = new Set<string>();
-  const normalized = normalizeScanPath(path.resolve(value));
-  variants.add(normalized);
-  try {
-    variants.add(normalizeScanPath(realpathSync(normalized)));
-  } catch {
-    // Nonexistent paths are still compared lexically.
-  }
-  if (normalized.startsWith("/private/var/")) {
-    variants.add(normalized.replace(/^\/private\/var\//, "/var/"));
-  } else if (normalized.startsWith("/var/")) {
-    variants.add(`/private${normalized}`);
-  }
-  return [...variants];
-}
-
-function pathInsideAny(parents: readonly string[], targets: readonly string[]): boolean {
-  return targets.some((target) => parents.some((parent) => pathInside(parent, target)));
-}
-
-function stripWrappingQuotes(value: string): string {
-  const trimmed = value.trim();
-  if (trimmed.length < 2) return trimmed;
-  const first = trimmed[0];
-  const last = trimmed[trimmed.length - 1];
-  if ((first === "'" || first === '"' || first === "`") && last === first) {
-    return trimmed.slice(1, -1).trim();
-  }
-  return trimmed;
-}
-
-function extractPathLikeValues(script: string): string[] {
-  const values: string[] = [];
-  const push = (candidate: string) => {
-    const cleaned = stripWrappingQuotes(candidate).trim();
-    if (!cleaned) return;
-    values.push(cleaned);
-  };
-  const pushQuotedLiterals = (source: string, depth = 0) => {
-    for (const match of source.matchAll(/(["'`])((?:\\.|(?!\1).)*)\1/g)) {
-      push(match[2]);
-      if (depth < 2 && /["'`]/.test(match[2])) {
-        pushQuotedLiterals(match[2], depth + 1);
-      }
-    }
-  };
-
-  for (const match of script.matchAll(/(?:^|[;\n\r]|\&\&|\|\|)\s*cd\s+([^\n\r;|&]+)/g)) {
-    push(match[1]);
-  }
-  for (const match of script.matchAll(/process\.chdir\(\s*([^\n\r;]+?)\s*\)/g)) {
-    push(match[1]);
-    pushQuotedLiterals(match[1]);
-  }
-  pushQuotedLiterals(script);
-  return values;
-}
-
-function resolvesToOriginalRootOutsideWorktree(script: string, baseDir: string): boolean {
-  const parsed = parseWorktreeBase(baseDir);
-  if (!parsed) return false;
-
-  const normalizedWorktree = normalizeScanPath(path.resolve(parsed.worktreeRoot));
-  const normalizedOriginalRoot = normalizeScanPath(path.resolve(parsed.originalRoot));
-  const worktreeRoots = comparablePathVariants(normalizedWorktree);
-  const originalRoots = comparablePathVariants(normalizedOriginalRoot);
-  for (const value of extractPathLikeValues(script)) {
-    const resolved = comparablePathVariants(path.resolve(normalizedWorktree, value));
-    if (pathInsideAny(originalRoots, resolved) && !pathInsideAny(worktreeRoots, resolved)) {
-      return true;
-    }
-  }
-  return false;
-}
-
-function scriptReferencesOriginalRootFromWorktree(script: string, baseDir: string): boolean {
-  const parsed = parseWorktreeBase(baseDir);
-  if (!parsed) return false;
-  const normalizedScript = script.replace(/\\/g, "/");
-  return comparablePathVariants(parsed.originalRoot).some((originalRoot) => {
-    const originalRootPattern = new RegExp(
-      `${escapeRegExp(originalRoot)}(?=$|[\\s'"\\\`;)&|<>]|/(?!\\.gsd(?:-worktrees|/worktrees)(?:/|$)))`,
-    );
-    return originalRootPattern.test(normalizedScript);
-  });
-}
-
 export async function executeGsdExec(
   params: ExecToolParams,
   deps: ExecToolDeps,
@@ -313,10 +200,7 @@ export async function executeGsdExec(
   if (Buffer.byteLength(script, "utf8") > 200_000) {
     return paramError("script exceeds the 200 KB length limit");
   }
-  if (
-    resolvesToOriginalRootOutsideWorktree(script, deps.baseDir)
-    || scriptReferencesOriginalRootFromWorktree(script, deps.baseDir)
-  ) {
+  if (bashReferencesProjectRootOutsideWorktree(script, deps.baseDir)) {
     return paramError(
       "script references the original project root while running inside a milestone worktree; use the active worktree path or relative paths",
     );

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

@@ -1,7 +1,7 @@
 // Project/App: gsd-pi
 // File Purpose: Shared terminal rendering helpers for GSD extension TUI surfaces.
 
-import { truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
+import { style, truncateToWidth, visibleWidth, wrapTextWithAnsi } from "@gsd/pi-tui";
 
 export interface ThemeLike {
   fg(color: string, text: string): string;
@@ -107,21 +107,64 @@ export function renderPanel(
   }
 
   const ruleColor = options.ruleColor ?? "borderAccent";
-  const indent = Math.max(0, options.indent ?? 2);
-  const rule = (text: string) => theme.fg(ruleColor, text);
+  const paddingX = Math.max(0, options.indent ?? 0);
+  const surface = style()
+    .border("open")
+    .title(title, (text) => theme.fg(ruleColor, text))
+    .borderColor((text) => theme.fg(ruleColor, text))
+    .paddingX(paddingX)
+    .bottomRule(true);
 
-  // Header rule: "── <title> ───────"
-  const lead = "── ";
-  const headerUsed = visibleWidth(lead) + visibleWidth(title) + 1;
-  const headerFill = Math.max(0, width - headerUsed);
-  const header = safeLine(rule(lead) + title + " " + rule("─".repeat(headerFill)), width, "");
+  const body = inner.length > 0 ? inner : [""];
+  return surface.render(body, width);
+}
+
+export interface PlainOutcomeLayoutOptions {
+  /** Right side of the header row (e.g. elapsed time). */
+  headerRight?: string;
+  /** Full-width body rows with an optional right column. */
+  splitRows?: Array<{ left: string; right?: string }>;
+  /** Footer hints pinned to the bottom-right (e.g. slash commands). */
+  footerRight?: string;
+}
+
+/**
+ * Plain transcript outcome — matches the GSD chat/tool speaker line (no rule box).
+ * Header: `GSD · <status>` with optional right meta; body copy-clean; optional footer right.
+ */
+export function renderPlainOutcome(
+  theme: ThemeLike,
+  width: number,
+  statusLine: string,
+  bodyLines: string[],
+  options?: PlainOutcomeLayoutOptions,
+): string[] {
+  const headerLeft =
+    theme.fg("accent", theme.bold("GSD")) + theme.fg("dim", " · ") + statusLine;
+  const header = options?.headerRight
+    ? rightAlign(headerLeft, options.headerRight, width)
+    : safeLine(headerLeft, width);
+
+  const out: string[] = [header];
+
+  if (options?.splitRows && options.splitRows.length > 0) {
+    for (const row of options.splitRows) {
+      out.push(row.right ? rightAlign(row.left, row.right, width) : safeLine(row.left, width));
+    }
+  } else {
+    for (const line of bodyLines.filter(Boolean)) {
+      out.push(safeLine(line, width));
+    }
+  }
 
-  // Body lines, indented so no chrome sits on copyable text.
-  const pad = " ".repeat(indent);
-  const contentWidth = Math.max(0, width - indent);
-  const body = inner.map((line) => safeLine(pad + safeLine(line, contentWidth), width, ""));
+  if (options?.footerRight) {
+    out.push(rightAlign("", options.footerRight, width));
+  }
 
-  return [header, "", ...body, rule("─".repeat(width))];
+  if (out.length === 1 && !options?.footerRight) {
+    return [header, ""];
+  }
+  return [...out, ""];
 }
 
 export function renderFrame(

package/src/resources/extensions/gsd/unit-context-composer.ts

@@ -187,7 +187,7 @@ const TOOL_SURFACE_GUIDANCE_BY_UNIT: Record<string, string> = {
   "run-uat":
     "Do not call `gsd_exec`, `Bash`, `Write`, or `Edit` — they are unavailable in this unit. Run every automated check through `gsd_uat_exec` with the appropriate `intent`. For browser UAT modes, use `browser_*` tools when presented; if browser automation fails, record the failure honestly and use `gsd_uat_exec` for the best objective substitute.",
   "complete-slice":
-    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
+    "Run slice-level verification through `gsd_exec` (or MCP-scoped `mcp__…__gsd_exec`), not direct `bash`. Capture learnings through `gsd_capture_thought` (or MCP-scoped `mcp__…__gsd_capture_thought`), not bare `capture_thought`, when workflow MCP tools are presented. Do not call `gsd_uat_result_save` — run-uat owns persisted UAT assessment. On verification failure, do not edit user source files in this unit.",
   "gate-evaluate":
     "Dispatch only **tester** subagents via `subagent`. Persist each gate with `gsd_save_gate_result`. Do not use `ToolSearch` — it is not available.",
   "reactive-execute":

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

@@ -220,15 +220,19 @@ export const UNIT_REGISTRY = {
     phaseChain: ["completion"],
     toolContract: {
       allowedGsdTools: [
+        "gsd_exec",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
         "gsd_decision_save",
+        "gsd_capture_thought",
         "gsd_requirement_update",
         "gsd_summary_save",
         "subagent",
       ],
       requiredWorkflowTools: [
+        "gsd_exec",
+        "gsd_capture_thought",
         "gsd_slice_complete",
         "gsd_task_reopen",
         "gsd_replan_slice",
@@ -254,8 +258,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "execute-task-simple": {
@@ -263,8 +280,21 @@ export const UNIT_REGISTRY = {
     scopeClass: "execute-task",
     phaseChain: ["execution_simple", "execution"],
     toolContract: {
-      allowedGsdTools: ["gsd_task_complete", "gsd_decision_save"],
-      requiredWorkflowTools: ["gsd_task_complete"],
+      allowedGsdTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+        "gsd_decision_save",
+      ],
+      requiredWorkflowTools: [
+        "gsd_task_complete",
+        "gsd_exec",
+        "gsd_exec_search",
+        "gsd_resume",
+        "gsd_capture_thought",
+      ],
     },
   },
   "reactive-execute": {

package/src/resources/extensions/gsd/workflow-logger.ts

@@ -109,6 +109,11 @@ export function setStderrLoggingEnabled(enabled: boolean): boolean {
   return previous;
 }
 
+/** Whether GSD extension diagnostics may write directly to process.stderr. */
+export function isGsdExtensionStderrEnabled(): boolean {
+  return _stderrEnabled;
+}
+
 // ─── Public API ─────────────────────────────────────────────────────────
 
 /**

package/src/resources/extensions/gsd/workflow-mcp-auto-prep.ts

@@ -4,6 +4,7 @@ import {
   type EnsureProjectWorkflowMcpConfigResult,
   ensureProjectWorkflowMcpConfig,
 } from "./mcp-project-config.js";
+import { warmWorkflowMcpProbeInBackground } from "./workflow-mcp-readiness-cache.js";
 import { usesWorkflowMcpTransport } from "./workflow-mcp.js";
 
 interface WorkflowMcpAutoPrepContext {
@@ -75,6 +76,7 @@ export function prepareWorkflowMcpForProject(
     if (result.status !== "unchanged") {
       prepCtx.ui?.notify?.(`GSD MCP Server Prepared at ${result.configPath}`, "info");
     }
+    warmWorkflowMcpProbeInBackground(projectRoot);
     return result;
   } catch (err) {
     prepCtx.ui?.notify?.(

package/src/resources/extensions/gsd/workflow-mcp-readiness-cache.ts

@@ -0,0 +1,150 @@
+// Project/App: gsd-pi
+// File Purpose: Share recent workflow MCP probe results across guided-flow and Claude Code SDK preflight.
+
+import { testMcpServerConnection } from "../mcp-client/manager.js";
+import { mcpToolMatchesBaseName } from "./mcp-tool-name.js";
+import {
+  detectWorkflowMcpLaunchConfig,
+  resolveWorkflowMcpProjectRoot,
+} from "./workflow-mcp.js";
+import { isWorkflowToolSurfaceName } from "./workflow-tool-surface.js";
+
+/** Reuse a recent successful probe instead of spawning another stdio server. */
+export const WORKFLOW_MCP_PROBE_CACHE_TTL_MS = 120_000;
+/** Per-probe connect + tools/list budget (server typically ready in ~1–2s). */
+export const WORKFLOW_MCP_PROBE_TIMEOUT_MS = 5_000;
+
+export interface WorkflowMcpProbeCacheEntry {
+  serverName: string;
+  tools: readonly string[];
+  probedAt: number;
+}
+
+type WorkflowMcpProbeResult = {
+  ok: boolean;
+  tools: readonly string[];
+  serverName?: string;
+  error?: string;
+};
+
+const cacheByProject = new Map<string, WorkflowMcpProbeCacheEntry>();
+const probeInFlightByProject = new Map<string, Promise<WorkflowMcpProbeResult>>();
+let activeWorkflowMcpSdkSessions = 0;
+
+function cacheKey(projectRoot: string): string {
+  return resolveWorkflowMcpProjectRoot(projectRoot);
+}
+
+export function beginWorkflowMcpSdkSession(): void {
+  activeWorkflowMcpSdkSessions++;
+}
+
+export function endWorkflowMcpSdkSession(): void {
+  activeWorkflowMcpSdkSessions = Math.max(0, activeWorkflowMcpSdkSessions - 1);
+}
+
+export function getCachedWorkflowMcpProbe(projectRoot: string): WorkflowMcpProbeCacheEntry | null {
+  const entry = cacheByProject.get(cacheKey(projectRoot));
+  if (!entry) return null;
+  if (Date.now() - entry.probedAt > WORKFLOW_MCP_PROBE_CACHE_TTL_MS) {
+    cacheByProject.delete(cacheKey(projectRoot));
+    return null;
+  }
+  return entry;
+}
+
+export function recordWorkflowMcpProbe(
+  projectRoot: string,
+  serverName: string,
+  tools: readonly string[],
+): void {
+  cacheByProject.set(cacheKey(projectRoot), {
+    serverName,
+    tools: [...tools],
+    probedAt: Date.now(),
+  });
+}
+
+export function clearWorkflowMcpProbeCache(projectRoot?: string): void {
+  if (projectRoot === undefined) {
+    cacheByProject.clear();
+    probeInFlightByProject.clear();
+    activeWorkflowMcpSdkSessions = 0;
+    return;
+  }
+  const key = cacheKey(projectRoot);
+  cacheByProject.delete(key);
+  probeInFlightByProject.delete(key);
+}
+
+export function workflowMcpProbeAdvertisesSurface(tools: readonly string[]): boolean {
+  return tools.some((tool) => isWorkflowToolSurfaceName(tool));
+}
+
+export function cachedWorkflowMcpCoversRequired(
+  projectRoot: string,
+  serverName: string,
+  required: readonly string[],
+): boolean {
+  const entry = getCachedWorkflowMcpProbe(projectRoot);
+  if (!entry || entry.serverName !== serverName) return false;
+  return required.every((tool) =>
+    entry.tools.some((name) => name === tool || mcpToolMatchesBaseName(name, tool)),
+  );
+}
+
+async function runProbeAndCacheWorkflowMcp(
+  projectRoot: string,
+  options: { timeoutMs?: number } = {},
+): Promise<WorkflowMcpProbeResult> {
+  const root = cacheKey(projectRoot);
+  const launch = detectWorkflowMcpLaunchConfig(root);
+  const serverName = launch?.name ?? "gsd-workflow";
+
+  const cached = getCachedWorkflowMcpProbe(projectRoot);
+  if (cached && workflowMcpProbeAdvertisesSurface(cached.tools)) {
+    return { ok: true, tools: cached.tools, serverName: cached.serverName };
+  }
+
+  const result = await testMcpServerConnection(serverName, {
+    projectDir: root,
+    timeoutMs: options.timeoutMs ?? WORKFLOW_MCP_PROBE_TIMEOUT_MS,
+  });
+  if (result.ok && workflowMcpProbeAdvertisesSurface(result.tools)) {
+    recordWorkflowMcpProbe(projectRoot, serverName, result.tools);
+  }
+  return {
+    ok: result.ok,
+    tools: result.tools,
+    serverName,
+    error: result.error,
+  };
+}
+
+export async function probeAndCacheWorkflowMcp(
+  projectRoot: string,
+  options: { timeoutMs?: number } = {},
+): Promise<WorkflowMcpProbeResult> {
+  const key = cacheKey(projectRoot);
+  const inFlight = probeInFlightByProject.get(key);
+  if (inFlight) return inFlight;
+
+  const promise = runProbeAndCacheWorkflowMcp(projectRoot, options).finally(() => {
+    probeInFlightByProject.delete(key);
+  });
+  probeInFlightByProject.set(key, promise);
+  return promise;
+}
+
+/** Fire-and-forget probe so /gsd dispatch often hits a warm cache. */
+export function warmWorkflowMcpProbeInBackground(projectRoot: string): void {
+  if (activeWorkflowMcpSdkSessions > 0) return;
+
+  const key = cacheKey(projectRoot);
+  if (getCachedWorkflowMcpProbe(projectRoot)) return;
+  if (probeInFlightByProject.has(key)) return;
+
+  void probeAndCacheWorkflowMcp(projectRoot).catch(() => {
+    // Background warm is best-effort.
+  });
+}

package/src/resources/extensions/gsd/worktree-manager.ts

@@ -19,7 +19,7 @@
  *   4. remove()  — git worktree remove + branch cleanup
  */
 
-import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync } from "node:fs";
+import { existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, realpathSync, rmSync, statSync } from "node:fs";
 import { execFileSync } from "node:child_process";
 import { join, resolve, sep } from "node:path";
 import { GSDError, GSD_PARSE_ERROR, GSD_STALE_STATE, GSD_LOCK_HELD, GSD_GIT_ERROR, GSD_MERGE_CONFLICT } from "./errors.js";
@@ -49,6 +49,7 @@ import {
   normalizeWorktreePathForCompare,
   resolveWorktreeProjectRoot,
 } from "./worktree-root.js";
+import { MILESTONE_ID_RE } from "./milestone-ids.js";
 import { canonicalWorktreesDir, worktreePathFor, worktreesDirs } from "./worktree-placement.js";
 
 // ─── Types ─────────────────────────────────────────────────────────────────
@@ -197,6 +198,95 @@ function isRegisteredGitWorktreeAtPath(basePath: string, wtPath: string): boolea
   }
 }
 
+/** True when `wtPath` has a git worktree checkout marker (`.git` file with gitdir pointer). */
+export function isLiveGitWorktreeCheckout(wtPath: string): boolean {
+  const gitPath = join(wtPath, ".git");
+  if (!existsSync(gitPath)) return false;
+  try {
+    return lstatSync(gitPath).isFile();
+  } catch {
+    return false;
+  }
+}
+
+/** True when a worktree directory should count toward idle milestone residue detection. */
+export function isMilestoneWorktreeResidueCandidate(basePath: string, wtPath: string): boolean {
+  return isRegisteredGitWorktreeAtPath(basePath, wtPath) || isLiveGitWorktreeCheckout(wtPath);
+}
+
+const EPHEMERAL_GHOST_WORKTREE_ENTRIES = new Set([".bg-shell", ".DS_Store"]);
+
+function isEphemeralGhostWorktreeContents(dirPath: string): boolean {
+  let entries: string[];
+  try {
+    entries = readdirSync(dirPath);
+  } catch {
+    return false;
+  }
+  if (entries.length === 0) return true;
+  for (const entry of entries) {
+    if (EPHEMERAL_GHOST_WORKTREE_ENTRIES.has(entry)) continue;
+    if (entry === ".gsd") {
+      try {
+        const gsdEntries = readdirSync(join(dirPath, ".gsd"));
+        if (gsdEntries.length <= 1 && gsdEntries.every((e) => e === "doctor-history.jsonl")) {
+          continue;
+        }
+      } catch {
+        return false;
+      }
+      continue;
+    }
+    return false;
+  }
+  return true;
+}
+
+/**
+ * Remove milestone worktree directories that are not registered with git and
+ * contain only ephemeral runtime content (e.g. bg-shell manifests recreated
+ * after teardown). Returns removed directory paths.
+ */
+export function pruneEphemeralGhostWorktreeDirectories(basePath: string): string[] {
+  const removed: string[] = [];
+  for (const container of allWorktreesDirs(basePath)) {
+    if (!existsSync(container)) continue;
+    let entries: string[];
+    try {
+      entries = readdirSync(container);
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (!MILESTONE_ID_RE.test(entry)) continue;
+      const fullPath = join(container, entry);
+      try {
+        if (!statSync(fullPath).isDirectory()) continue;
+      } catch {
+        continue;
+      }
+      if (isRegisteredGitWorktreeAtPath(basePath, fullPath)) continue;
+      if (isLiveGitWorktreeCheckout(fullPath)) continue;
+      if (!isEphemeralGhostWorktreeContents(fullPath)) continue;
+      try {
+        rmSync(fullPath, { recursive: true, force: true });
+        logWarning(
+          "reconcile",
+          `Removed ephemeral ghost worktree directory (not registered with git): ${fullPath}`,
+          { worktree: entry },
+        );
+        removed.push(fullPath);
+      } catch (err) {
+        logWarning(
+          "worktree",
+          `ghost worktree directory removal failed for ${fullPath}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+    }
+  }
+  return removed;
+}
+
 function removeStaleWorktreeDirectory(wtPath: string, name: string): void {
   logWarning(
     "reconcile",
@@ -656,7 +746,12 @@ export function removeWorktree(
   const resolvedPathSafe = isInsideWorktreesDir(basePath, resolvedWtPath);
 
   // If we're inside the worktree, move out first — git can't remove an in-use directory
-  const cwd = process.cwd();
+  let cwd: string;
+  try {
+    cwd = process.cwd();
+  } catch {
+    cwd = basePath;
+  }
   const resolvedCwd = existsSync(cwd) ? realpathSync(cwd) : cwd;
   if (resolvedCwd === resolvedWtPath || resolvedCwd.startsWith(resolvedWtPath + sep)) {
     process.chdir(basePath);