@gotgenes/pi-subagents 5.0.0 → 5.2.0

package/src/agent-runner.ts

@@ -68,36 +68,12 @@ function filterActiveTools(
   });
 }
 
-/** Default max turns. undefined = unlimited (no turn limit). */
-let defaultMaxTurns: number | undefined;
-
 /** Normalize max turns. undefined or 0 = unlimited, otherwise minimum 1. */
 export function normalizeMaxTurns(n: number | undefined): number | undefined {
   if (n == null || n === 0) return undefined;
   return Math.max(1, n);
 }
 
-/** Get the default max turns value. undefined = unlimited. */
-export function getDefaultMaxTurns(): number | undefined {
-  return defaultMaxTurns;
-}
-/** Set the default max turns value. undefined or 0 = unlimited, otherwise minimum 1. */
-export function setDefaultMaxTurns(n: number | undefined): void {
-  defaultMaxTurns = normalizeMaxTurns(n);
-}
-
-/** Additional turns allowed after the soft limit steer message. */
-let graceTurns = 5;
-
-/** Get the grace turns value. */
-export function getGraceTurns(): number {
-  return graceTurns;
-}
-/** Set the grace turns value (minimum 1). */
-export function setGraceTurns(n: number): void {
-  graceTurns = Math.max(1, n);
-}
-
 /**
  * Try to find the right model for an agent type.
  * Priority: explicit option > config.model > parent model.
@@ -174,6 +150,17 @@ export interface RunOptions {
     reason: "manual" | "threshold" | "overflow";
     tokensBefore: number;
   }) => void;
+  /**
+   * Default max turns from runtime config. Falls back to the module-scope
+   * `defaultMaxTurns` during the lift-and-shift migration; superseded by
+   * per-call `maxTurns` and per-agent `agentConfig.maxTurns`.
+   */
+  defaultMaxTurns?: number;
+  /**
+   * Grace turns after the soft-limit steer message. Falls back to the
+   * module-scope `graceTurns` during migration.
+   */
+  graceTurns?: number;
 }
 
 export interface RunResult {
@@ -424,7 +411,7 @@ export async function runAgent(
   // Track turns for graceful max_turns enforcement
   let turnCount = 0;
   const maxTurns = normalizeMaxTurns(
-    options.maxTurns ?? agentConfig?.maxTurns ?? defaultMaxTurns,
+    options.maxTurns ?? agentConfig?.maxTurns ?? options.defaultMaxTurns,
   );
   let softLimitReached = false;
   let aborted = false;
@@ -440,7 +427,7 @@ export async function runAgent(
           session.steer(
             "You have reached your turn limit. Wrap up immediately — provide your final answer now.",
           );
-        } else if (softLimitReached && turnCount >= maxTurns + graceTurns) {
+        } else if (softLimitReached && turnCount >= maxTurns + (options.graceTurns ?? 5)) {
           aborted = true;
           session.abort();
         }

package/src/custom-agents.ts

@@ -6,6 +6,7 @@ import { existsSync, readdirSync, readFileSync } from "node:fs";
 import { basename, join } from "node:path";
 import { getAgentDir, parseFrontmatter } from "@earendil-works/pi-coding-agent";
 import { BUILTIN_TOOL_NAMES } from "./agent-types.js";
+import { debugLog } from "./debug.js";
 import type { AgentConfig, MemoryScope, ThinkingLevel } from "./types.js";
 
 /**
@@ -34,7 +35,8 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
   let files: string[];
   try {
     files = readdirSync(dir).filter(f => f.endsWith(".md"));
-  } catch {
+  } catch (err) {
+    debugLog("readdirSync agents dir", err);
     return;
   }
 
@@ -44,7 +46,8 @@ function loadFromDir(dir: string, agents: Map<string, AgentConfig>, source: "pro
     let content: string;
     try {
       content = readFileSync(join(dir, file), "utf-8");
-    } catch {
+    } catch (err) {
+      debugLog("readFileSync agent file", err);
       continue;
     }
 

package/src/debug.ts

@@ -0,0 +1,14 @@
+/**
+ * debug.ts — Debug logging utility for silenced catch blocks.
+ *
+ * Set PI_SUBAGENTS_DEBUG=1 to reveal silent failures in catch blocks
+ * throughout the package. Production behavior is unchanged when unset.
+ */
+
+export function isDebug(): boolean {
+  return process.env.PI_SUBAGENTS_DEBUG === "1";
+}
+
+export function debugLog(context: string, err: unknown): void {
+  if (isDebug()) console.warn(`[pi-subagents:debug] ${context}:`, err);
+}

package/src/env.ts

@@ -3,6 +3,7 @@
  */
 
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
+import { debugLog } from "./debug.js";
 import type { EnvInfo } from "./types.js";
 
 export async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo> {
@@ -12,15 +13,16 @@ export async function detectEnv(pi: ExtensionAPI, cwd: string): Promise<EnvInfo>
   try {
     const result = await pi.exec("git", ["rev-parse", "--is-inside-work-tree"], { cwd, timeout: 5000 });
     isGitRepo = result.code === 0 && result.stdout.trim() === "true";
-  } catch {
-    // Not a git repo or git not installed
+  } catch (err) {
+    debugLog("git rev-parse", err);
   }
 
   if (isGitRepo) {
     try {
       const result = await pi.exec("git", ["branch", "--show-current"], { cwd, timeout: 5000 });
       branch = result.code === 0 ? result.stdout.trim() : "unknown";
-    } catch {
+    } catch (err) {
+      debugLog("git branch", err);
       branch = "unknown";
     }
   }

package/src/index.ts

@@ -13,12 +13,13 @@
 import { join } from "node:path";
 import { defineTool, type ExtensionAPI, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { AgentManager } from "./agent-manager.js";
-import { getAgentConversation, getDefaultMaxTurns, getGraceTurns, setDefaultMaxTurns, setGraceTurns, steerAgent } from "./agent-runner.js";
+import { getAgentConversation, normalizeMaxTurns, steerAgent } from "./agent-runner.js";
 import { getAgentConfig, getAvailableTypes, getDefaultAgentNames, getUserAgentNames, registerAgents, } from "./agent-types.js";
 import { loadCustomAgents } from "./custom-agents.js";
 import { type ModelRegistry, resolveModel } from "./model-resolver.js";
 import { buildEventData, createNotificationSystem } from "./notification.js";
 import { createNotificationRenderer } from "./renderer.js";
+import { createSubagentRuntime } from "./runtime.js";
 import { publishSubagentsService, unpublishSubagentsService } from "./service.js";
 import { createSubagentsService } from "./service-adapter.js";
 import { applyAndEmitLoaded, saveAndEmitChanged } from "./settings.js";
@@ -29,7 +30,6 @@ import { createSteerTool } from "./tools/steer-tool.js";
 import { type NotificationDetails } from "./types.js";
 import { createAgentsMenuHandler } from "./ui/agent-menu.js";
 import {
-  type AgentActivity,
   AgentWidget,
   type UICtx,
 } from "./ui/agent-widget.js";
@@ -47,17 +47,17 @@ export default function (pi: ExtensionAPI) {
   // Initial load
   reloadCustomAgents();
 
-  // ---- Agent activity tracking ----
-  const agentActivity = new Map<string, AgentActivity>();
+  // ---- Runtime: all mutable extension state in one place ----
+  const runtime = createSubagentRuntime();
 
   // ---- Notification system ----
-  // Widget assigned after AgentManager construction; arrow closures capture by reference.
-  let widget: AgentWidget;
+  // runtime.widget is assigned after AgentManager construction; arrow closures
+  // capture `runtime` by reference so they always read the current value.
   const notifications = createNotificationSystem({
     sendMessage: (msg, opts) => pi.sendMessage(msg as any, opts as any),
-    agentActivity,
-    markFinished: (id) => widget.markFinished(id),
-    updateWidget: () => widget.update(),
+    agentActivity: runtime.agentActivity,
+    markFinished: (id) => runtime.widget!.markFinished(id),
+    updateWidget: () => runtime.widget!.update(),
   });
 
   // Background completion: emit lifecycle event and delegate to notification system
@@ -102,21 +102,21 @@ export default function (pi: ExtensionAPI) {
       tokensBefore: info.tokensBefore,
       compactionCount: record.compactionCount,
     });
-  });
+  },
+  () => ({ defaultMaxTurns: runtime.defaultMaxTurns, graceTurns: runtime.graceTurns }));
 
   // Typed service published via Symbol.for() for cross-extension access.
   // Consumers: const { getSubagentsService } = await import("@gotgenes/pi-subagents");
-  let currentCtx: { pi: unknown; ctx: unknown } | undefined;
   const service = createSubagentsService({
     manager,
     resolveModel,
-    getCtx: () => currentCtx,
-    getModelRegistry: () => (currentCtx?.ctx as { modelRegistry?: ModelRegistry } | undefined)?.modelRegistry,
+    getCtx: () => runtime.currentCtx,
+    getModelRegistry: () => (runtime.currentCtx?.ctx as { modelRegistry?: ModelRegistry } | undefined)?.modelRegistry,
   });
   publishSubagentsService(service);
 
   pi.on("session_start", async (_event, ctx) => {
-    currentCtx = { pi, ctx };
+    runtime.currentCtx = { pi, ctx };
     manager.clearCompleted();
   });
 
@@ -128,19 +128,19 @@ export default function (pi: ExtensionAPI) {
   // If the session is going down, there's nothing left to consume agent results.
   pi.on("session_shutdown", async () => {
     unpublishSubagentsService();
-    currentCtx = undefined;
+    runtime.currentCtx = undefined;
     manager.abortAll();
     notifications.dispose();
     manager.dispose();
   });
 
   // Live widget: show running agents above editor
-  widget = new AgentWidget(manager, agentActivity);
+  runtime.widget = new AgentWidget(manager, runtime.agentActivity);
 
   // Grab UI context from first tool execution + clear lingering widget on new turn
   pi.on("tool_execution_start", async (_event, ctx) => {
-    widget.setUICtx(ctx.ui as UICtx);
-    widget.onTurnStart();
+    runtime.widget!.setUICtx(ctx.ui as UICtx);
+    runtime.widget!.onTurnStart();
   });
 
   /** Build the full type list text dynamically from the unified registry. */
@@ -176,8 +176,8 @@ export default function (pi: ExtensionAPI) {
   applyAndEmitLoaded(
     {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
-      setDefaultMaxTurns,
-      setGraceTurns,
+      setDefaultMaxTurns: (n) => { runtime.defaultMaxTurns = normalizeMaxTurns(n); },
+      setGraceTurns: (n) => { runtime.graceTurns = Math.max(1, n); },
     },
     (event, payload) => pi.events.emit(event, payload),
   );
@@ -194,17 +194,18 @@ export default function (pi: ExtensionAPI) {
       listAgents: () => manager.listAgents(),
     },
     widget: {
-      setUICtx: (ctx) => widget.setUICtx(ctx as UICtx),
-      ensureTimer: () => widget.ensureTimer(),
-      update: () => widget.update(),
-      markFinished: (id) => widget.markFinished(id),
+      setUICtx: (ctx) => runtime.widget!.setUICtx(ctx as UICtx),
+      ensureTimer: () => runtime.widget!.ensureTimer(),
+      update: () => runtime.widget!.update(),
+      markFinished: (id) => runtime.widget!.markFinished(id),
     },
-    agentActivity,
+    agentActivity: runtime.agentActivity,
     emitEvent: (name, data) => pi.events.emit(name, data),
     reloadCustomAgents,
     typeListText,
     availableTypesText: getAvailableTypes().join(", "),
     agentDir: getAgentDir(),
+    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
   }) as any));
 
   // ---- get_subagent_result tool ----
@@ -234,7 +235,7 @@ export default function (pi: ExtensionAPI) {
       setMaxConcurrent: (n) => manager.setMaxConcurrent(n),
     },
     reloadCustomAgents,
-    agentActivity,
+    agentActivity: runtime.agentActivity,
     getModelLabel: (type, registry) => {
       const cfg = getAgentConfig(type);
       if (!cfg?.model) return 'inherit';
@@ -246,9 +247,17 @@ export default function (pi: ExtensionAPI) {
     },
     snapshotSettings: () => ({
       maxConcurrent: manager.getMaxConcurrent(),
-      defaultMaxTurns: getDefaultMaxTurns() ?? 0,
-      graceTurns: getGraceTurns(),
+      defaultMaxTurns: runtime.defaultMaxTurns ?? 0,
+      graceTurns: runtime.graceTurns,
     }),
+    getDefaultMaxTurns: () => runtime.defaultMaxTurns,
+    getGraceTurns: () => runtime.graceTurns,
+    setDefaultMaxTurns: (n) => {
+      runtime.defaultMaxTurns = normalizeMaxTurns(n);
+    },
+    setGraceTurns: (n) => {
+      runtime.graceTurns = Math.max(1, n);
+    },
     saveSettings: (settings, successMsg) => saveAndEmitChanged(
       settings,
       successMsg,

package/src/memory.ts

@@ -10,6 +10,7 @@
 import { existsSync, lstatSync, mkdirSync, readFileSync } from "node:fs";
 import { homedir } from "node:os";
 import { join, } from "node:path";
+import { debugLog } from "./debug.js";
 import type { MemoryScope } from "./types.js";
 
 /** Maximum lines to read from MEMORY.md */
@@ -30,7 +31,8 @@ export function isUnsafeName(name: string): boolean {
 export function isSymlink(filePath: string): boolean {
   try {
     return lstatSync(filePath).isSymbolicLink();
-  } catch {
+  } catch (err) {
+    debugLog("lstatSync", err);
     return false;
   }
 }
@@ -44,7 +46,8 @@ export function safeReadFile(filePath: string): string | undefined {
   if (isSymlink(filePath)) return undefined;
   try {
     return readFileSync(filePath, "utf-8");
-  } catch {
+  } catch (err) {
+    debugLog("readFileSync", err);
     return undefined;
   }
 }

package/src/notification.ts

@@ -1,3 +1,4 @@
+import { debugLog } from "./debug.js";
 import type { AgentRecord, NotificationDetails } from "./types.js";
 import type { AgentActivity } from "./ui/agent-widget.js";
 import { getLifetimeTotal, getSessionContextPercent } from "./usage.js";
@@ -142,8 +143,8 @@ export function createNotificationSystem(deps: NotificationDeps): NotificationSy
         pendingNudges.delete(key);
         try {
           send();
-        } catch {
-          /* ignore stale completion side-effect errors */
+        } catch (err) {
+          debugLog("notification render", err);
         }
       }, delay),
     );

package/src/output-file.ts

@@ -9,6 +9,7 @@ import { appendFileSync, chmodSync, mkdirSync, writeFileSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 import type { AgentSession, AgentSessionEvent } from "@earendil-works/pi-coding-agent";
+import { debugLog } from "./debug.js";
 
 /**
  * Encode a cwd path as a filesystem-safe directory name. Handles:
@@ -80,7 +81,9 @@ export function streamToOutputFile(
       };
       try {
         appendFileSync(path, JSON.stringify(entry) + "\n", "utf-8");
-      } catch { /* ignore write errors */ }
+      } catch (err) {
+        debugLog("write JSONL chunk", err);
+      }
       writtenCount++;
     }
   };

package/src/runtime.ts

@@ -0,0 +1,62 @@
+/**
+ * runtime.ts — SubagentRuntime: composition root for all mutable extension state.
+ *
+ * Eliminates module-scope state in agent-runner.ts and closure-scoped state
+ * in index.ts by consolidating them into a single, testable object.
+ * Follows the same pattern as pi-permission-system's ExtensionRuntime.
+ */
+
+import type { AgentActivity, AgentWidget } from "./ui/agent-widget.js";
+
+/**
+ * Narrow config subset read by AgentManager when constructing RunOptions.
+ * Kept separate so callers can satisfy it without depending on the full runtime.
+ */
+export interface RunConfig {
+  readonly defaultMaxTurns: number | undefined;
+  readonly graceTurns: number;
+}
+
+/**
+ * All mutable state owned by the pi-subagents extension.
+ *
+ * Created once inside `piSubagentsExtension()` via `createSubagentRuntime()`.
+ * Tests construct a fresh runtime per test for full isolation.
+ */
+export interface SubagentRuntime {
+  // ── Execution config (was module-scope in agent-runner.ts) ──────────────
+  /** Default max turns for all agents. undefined = unlimited. */
+  defaultMaxTurns: number | undefined;
+  /** Additional turns allowed after the soft-limit steer message. */
+  graceTurns: number;
+
+  // ── Session state (was closure-scoped in index.ts) ───────────────────────
+  /** Active Pi session context — set on session_start, cleared on session_shutdown. */
+  currentCtx: { pi: unknown; ctx: unknown } | undefined;
+  /**
+   * Per-agent live activity state shared across the notification system,
+   * widget, and tool handlers. The Map itself is never replaced.
+   */
+  readonly agentActivity: Map<string, AgentActivity>;
+  /**
+   * Persistent widget reference. Null until constructed after AgentManager.
+   * Notification closures use `runtime.widget!` — safe because agents always
+   * complete after widget construction.
+   */
+  widget: AgentWidget | null;
+}
+
+/**
+ * Create a fully-initialized SubagentRuntime with default values.
+ *
+ * Call once at extension startup; pass the result to factories and handlers.
+ */
+export function createSubagentRuntime(): SubagentRuntime {
+  return {
+    defaultMaxTurns: undefined,
+    graceTurns: 5,
+    currentCtx: undefined,
+    agentActivity: new Map(),
+    widget: null,
+  };
+}

package/src/skill-loader.ts

@@ -23,6 +23,7 @@ import { existsSync, readdirSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { getAgentDir } from "@earendil-works/pi-coding-agent";
+import { debugLog } from "./debug.js";
 import { isSymlink, isUnsafeName, safeReadFile } from "./memory.js";
 
 export interface PreloadedSkill {
@@ -71,7 +72,8 @@ function findSkillDirectory(root: string, name: string): string | undefined {
     let entries: Dirent<string>[];
     try {
       entries = readdirSync(current, { withFileTypes: true });
-    } catch {
+    } catch (err) {
+      debugLog("readdirSync skill root", err);
       continue;
     }
 

package/src/tools/agent-tool.ts

@@ -1,6 +1,6 @@
 import { Text } from "@earendil-works/pi-tui";
 import { Type } from "@sinclair/typebox";
-import { getDefaultMaxTurns, normalizeMaxTurns } from "../agent-runner.js";
+import { normalizeMaxTurns } from "../agent-runner.js";
 import { getAgentConfig, resolveType } from "../agent-types.js";
 import { resolveAgentInvocationConfig } from "../invocation-config.js";
 import { resolveInvocationModel } from "../model-resolver.js";
@@ -146,6 +146,8 @@ export interface AgentToolDeps {
   typeListText: string;
   availableTypesText: string;
   agentDir: string;
+  /** Returns the runtime default max turns (undefined = unlimited). */
+  getDefaultMaxTurns: () => number | undefined;
 }
 
 // ---- Factory ----
@@ -396,7 +398,7 @@ Guidelines:
           ? (model?.name ?? effectiveModelId).replace(/^Claude\s+/i, "").toLowerCase()
           : undefined;
       const effectiveMaxTurns = normalizeMaxTurns(
-        resolvedConfig.maxTurns ?? getDefaultMaxTurns(),
+        resolvedConfig.maxTurns ?? deps.getDefaultMaxTurns(),
       );
       const agentInvocation: AgentInvocation = {
         modelName,

package/src/ui/agent-menu.ts

@@ -1,11 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
-import {
-  getDefaultMaxTurns,
-  getGraceTurns,
-  setDefaultMaxTurns,
-  setGraceTurns,
-} from "../agent-runner.js";
+
 import {
   BUILTIN_TOOL_NAMES,
   getAgentConfig,
@@ -42,6 +37,14 @@ export interface AgentMenuDeps {
   ) => { message: string; level: string };
   emitEvent: (name: string, data: unknown) => void;
   personalAgentsDir: string;
+  /** Returns the runtime default max turns (undefined = unlimited). */
+  getDefaultMaxTurns: () => number | undefined;
+  /** Returns the runtime grace turns value. */
+  getGraceTurns: () => number;
+  /** Updates the runtime default max turns (undefined = unlimited). */
+  setDefaultMaxTurns: (n: number | undefined) => void;
+  /** Updates the runtime grace turns value (minimum 1). */
+  setGraceTurns: (n: number) => void;
 }
 
 // ---- Narrow UI context types ----
@@ -620,8 +623,8 @@ ${systemPrompt}
   async function showSettings(ctx: MenuContext) {
     const choice = await ctx.ui.select("Settings", [
       `Max concurrency (current: ${deps.manager.getMaxConcurrent()})`,
-      `Default max turns (current: ${getDefaultMaxTurns() ?? "unlimited"})`,
-      `Grace turns (current: ${getGraceTurns()})`,
+      `Default max turns (current: ${deps.getDefaultMaxTurns() ?? "unlimited"})`,
+      `Grace turns (current: ${deps.getGraceTurns()})`,
     ]);
     if (!choice) return;
 
@@ -642,15 +645,15 @@ ${systemPrompt}
     } else if (choice.startsWith("Default max turns")) {
       const val = await ctx.ui.input(
         "Default max turns before wrap-up (0 = unlimited)",
-        String(getDefaultMaxTurns() ?? 0),
+        String(deps.getDefaultMaxTurns() ?? 0),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n === 0) {
-          setDefaultMaxTurns(undefined);
+          deps.setDefaultMaxTurns(undefined);
           notifyApplied(ctx, "Default max turns set to unlimited");
         } else if (n >= 1) {
-          setDefaultMaxTurns(n);
+          deps.setDefaultMaxTurns(n);
           notifyApplied(ctx, `Default max turns set to ${n}`);
         } else {
           ctx.ui.notify("Must be 0 (unlimited) or a positive integer.", "warning");
@@ -659,12 +662,12 @@ ${systemPrompt}
     } else if (choice.startsWith("Grace turns")) {
       const val = await ctx.ui.input(
         "Grace turns after wrap-up steer",
-        String(getGraceTurns()),
+        String(deps.getGraceTurns()),
       );
       if (val) {
         const n = parseInt(val, 10);
         if (n >= 1) {
-          setGraceTurns(n);
+          deps.setGraceTurns(n);
           notifyApplied(ctx, `Grace turns set to ${n}`);
         } else {
           ctx.ui.notify("Must be a positive integer.", "warning");

package/src/worktree.ts

@@ -11,6 +11,7 @@ import { randomUUID } from "node:crypto";
 import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
+import { debugLog } from "./debug.js";
 
 export interface WorktreeInfo {
   /** Absolute path to the worktree directory. */
@@ -37,7 +38,8 @@ export function createWorktree(cwd: string, agentId: string): WorktreeInfo | und
   try {
     execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { cwd, stdio: "pipe", timeout: 5000 });
     execFileSync("git", ["rev-parse", "HEAD"], { cwd, stdio: "pipe", timeout: 5000 });
-  } catch {
+  } catch (err) {
+    debugLog("createWorktree git rev-parse", err);
     return undefined;
   }
 
@@ -53,8 +55,8 @@ export function createWorktree(cwd: string, agentId: string): WorktreeInfo | und
       timeout: 30000,
     });
     return { path: worktreePath, branch };
-  } catch {
-    // If worktree creation fails, return undefined (agent runs in normal cwd)
+  } catch (err) {
+    debugLog("git worktree add", err);
     return undefined;
   }
 }
@@ -107,8 +109,8 @@ export function cleanupWorktree(
         stdio: "pipe",
         timeout: 5000,
       });
-    } catch {
-      // Branch already exists — use a unique suffix
+    } catch (err) {
+      debugLog("git branch", err);
       branchName = `${worktree.branch}-${Date.now()}`;
       execFileSync("git", ["branch", branchName], {
         cwd: worktree.path,
@@ -127,9 +129,9 @@ export function cleanupWorktree(
       branch: worktree.branch,
       path: worktree.path,
     };
-  } catch {
-    // Best effort cleanup on error
-    try { removeWorktree(cwd, worktree.path); } catch { /* ignore */ }
+  } catch (err) {
+    debugLog("cleanupWorktree", err);
+    try { removeWorktree(cwd, worktree.path); } catch (removeErr) { debugLog("removeWorktree on cleanup error", removeErr); }
     return { hasChanges: false };
   }
 }
@@ -144,11 +146,11 @@ function removeWorktree(cwd: string, worktreePath: string): void {
       stdio: "pipe",
       timeout: 10000,
     });
-  } catch {
-    // If git worktree remove fails, try pruning
+  } catch (err) {
+    debugLog("git worktree remove", err);
     try {
       execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
-    } catch { /* ignore */ }
+    } catch (pruneErr) { debugLog("git worktree prune", pruneErr); }
   }
 }
 
@@ -158,5 +160,5 @@ function removeWorktree(cwd: string, worktreePath: string): void {
 export function pruneWorktrees(cwd: string): void {
   try {
     execFileSync("git", ["worktree", "prune"], { cwd, stdio: "pipe", timeout: 5000 });
-  } catch { /* ignore */ }
+  } catch (err) { debugLog("pruneWorktrees", err); }
 }