gsd-pi 2.60.0-dev.2580e65 → 2.60.0-dev.d9052f5

package/dist/resources/extensions/gsd/auto.js

@@ -34,7 +34,7 @@ import { clearSkillSnapshot } from "./skill-discovery.js";
 import { captureAvailableSkills, resetSkillTelemetry, } from "./skill-telemetry.js";
 import { getRtkSessionSavings } from "../shared/rtk-session-stats.js";
 import { initMetrics, resetMetrics, getLedger, getProjectTotals, formatCost, formatTokenCount, } from "./metrics.js";
-import { setLogBasePath, logWarning } from "./workflow-logger.js";
+import { setLogBasePath } from "./workflow-logger.js";
 import { join } from "node:path";
 import { readFileSync, existsSync, mkdirSync, writeFileSync, unlinkSync } from "node:fs";
 import { atomicWriteSync } from "./atomic-write.js";
@@ -137,9 +137,8 @@ export function getAutoDashboardData() {
             pendingCaptureCount = countPendingCaptures(s.basePath);
         }
     }
-    catch (err) {
+    catch {
         // Non-fatal — captures module may not be loaded
-        logWarning("engine", `capture count failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     return {
         active: s.active,
@@ -341,9 +340,8 @@ function cleanupAfterLoopExit(ctx) {
         if (lockBase())
             releaseSessionLock(lockBase());
     }
-    catch (err) {
+    catch {
         /* best-effort — mirror stopAuto cleanup */
-        logWarning("session", `lock cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     ctx.ui.setStatus("gsd-auto", undefined);
     ctx.ui.setWidget("gsd-progress", undefined);
@@ -354,9 +352,8 @@ function cleanupAfterLoopExit(ctx) {
         try {
             process.chdir(s.basePath);
         }
-        catch (err) {
+        catch {
             /* best-effort */
-            logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
 }
@@ -418,9 +415,8 @@ export async function stopAuto(ctx, pi, reason) {
                         milestoneComplete = true;
                     }
                 }
-                catch (err) {
+                catch {
                     // Non-fatal — fall through to preserveBranch path
-                    logWarning("engine", `milestone summary check failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
                 if (milestoneComplete) {
                     // Milestone is complete — merge worktree branch back to main
@@ -456,9 +452,8 @@ export async function stopAuto(ctx, pi, reason) {
                 try {
                     process.chdir(s.basePath);
                 }
-                catch (err) {
+                catch {
                     /* best-effort */
-                    logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
                 }
             }
         }
@@ -527,9 +522,7 @@ export async function stopAuto(ctx, pi, reason) {
             if (existsSync(pausedPath))
                 unlinkSync(pausedPath);
         }
-        catch (err) { /* non-fatal */
-            logWarning("engine", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-        }
+        catch { /* non-fatal */ }
         // ── Step 13: Restore original model (before reset clears IDs) ──
         try {
             if (pi && ctx && s.originalModelId && s.originalModelProvider) {
@@ -563,9 +556,7 @@ export async function stopAuto(ctx, pi, reason) {
                 await closeBrowser();
             }
         }
-        catch (err) { /* non-fatal: browser-tools may not be loaded */
-            logWarning("engine", `browser teardown failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-        }
+        catch { /* non-fatal: browser-tools may not be loaded */ }
         // External cleanup (not covered by session reset)
         clearInFlightTools();
         clearSliceProgressCache();
@@ -611,18 +602,16 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
         mkdirSync(runtimeDir, { recursive: true });
         writeFileSync(join(runtimeDir, "paused-session.json"), JSON.stringify(pausedMeta, null, 2), "utf-8");
     }
-    catch (err) {
+    catch {
         // Non-fatal — resume will still work via full bootstrap, just without worktree context
-        logWarning("engine", `paused-session file write failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     // Close out the current unit so its runtime record doesn't stay at "dispatched"
     if (s.currentUnit && ctx) {
         try {
             await closeoutUnit(ctx, s.basePath, s.currentUnit.type, s.currentUnit.id, s.currentUnit.startedAt);
         }
-        catch (err) {
+        catch {
             // Non-fatal — best-effort closeout on pause
-            logWarning("engine", `unit closeout on pause failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
         s.currentUnit = null;
     }
@@ -809,9 +798,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                     try {
                         unlinkSync(pausedPath);
                     }
-                    catch (err) { /* non-fatal */
-                        logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                    }
+                    catch { /* non-fatal */ }
                     ctx.ui.notify(`Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`, "info");
                 }
                 else if (meta.milestoneId) {
@@ -823,9 +810,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch (err) { /* non-fatal */
-                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                        }
+                        catch { /* non-fatal */ }
                         ctx.ui.notify(`Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`, "info");
                     }
                     else {
@@ -837,17 +822,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         try {
                             unlinkSync(pausedPath);
                         }
-                        catch (err) { /* non-fatal */
-                            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-                        }
+                        catch { /* non-fatal */ }
                         ctx.ui.notify(`Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`, "info");
                     }
                 }
             }
         }
-        catch (err) {
+        catch {
             // Malformed or missing — proceed with fresh bootstrap
-            logWarning("session", `paused-session restore failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
     }
     if (s.paused) {
@@ -935,9 +917,8 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     try {
         syncCmuxSidebar(loadEffectiveGSDPreferences()?.preferences, await deriveState(s.basePath));
     }
-    catch (err) {
+    catch {
         // Best-effort only — sidebar sync must never block auto-mode startup
-        logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
     // Dispatch the first unit
@@ -1062,9 +1043,8 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
             try {
                 await pi.setModel(match);
             }
-            catch (err) {
+            catch {
                 /* non-fatal */
-                logWarning("dispatch", `hook model set failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
             }
         }
         else {
@@ -1092,9 +1072,7 @@ export async function dispatchHookUnit(ctx, pi, hookName, triggerUnitType, trigg
         if (process.cwd() !== s.basePath)
             process.chdir(s.basePath);
     }
-    catch (err) {
-        logWarning("engine", `chdir failed before hook dispatch: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-    }
+    catch { }
     debugLog("dispatchHookUnit", {
         phase: "send-message",
         promptLength: hookPrompt.length,

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -1,4 +1,3 @@
-import { logWarning } from "../workflow-logger.js";
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
 import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
@@ -69,9 +68,7 @@ export async function handleAgentEnd(pi, event, ctx) {
                 try {
                     await pauseAuto(ctx, pi);
                 }
-                catch (e) {
-                    logWarning("bootstrap", `pauseAuto failed after empty-content abort: ${e.message}`);
-                }
+                catch { /* best-effort */ }
             }
             return;
         }
@@ -187,8 +184,8 @@ export async function handleAgentEnd(pi, event, ctx) {
         try {
             await pauseAuto(ctx, pi);
         }
-        catch (e) {
-            logWarning("bootstrap", `pauseAuto failed in agent_end handler: ${e.message}`);
+        catch {
+            // best-effort
         }
     }
 }

package/dist/resources/extensions/gsd/bootstrap/db-tools.js

@@ -403,8 +403,8 @@ export function registerDbTools(pi) {
             const { insertMilestone } = await import("../gsd-db.js");
             insertMilestone({ id: milestoneId, status: "queued" });
         }
-        catch (e) {
-            logError("tool", `insertMilestone failed for ${milestoneId}: ${e.message}`);
+        catch {
+            // Non-fatal — the safety-net in deriveStateFromDb will catch this
         }
     }
     const milestoneGenerateIdTool = {

package/dist/resources/extensions/gsd/bootstrap/dynamic-tools.js

@@ -2,7 +2,7 @@ import { existsSync } from "node:fs";
 import { join, sep } from "node:path";
 import { createBashTool, createEditTool, createReadTool, createWriteTool } from "@gsd/pi-coding-agent";
 import { DEFAULT_BASH_TIMEOUT_SECS } from "../constants.js";
-import { setLogBasePath, logWarning } from "../workflow-logger.js";
+import { setLogBasePath } from "../workflow-logger.js";
 /**
  * Resolve the correct DB path for the current working directory.
  * If `basePath` is inside a `.gsd/worktrees/<MID>/` directory, returns
@@ -82,7 +82,7 @@ export async function ensureDbOpen() {
                         migrateFromMarkdown(basePath);
                     }
                     catch (err) {
-                        logWarning("bootstrap", `ensureDbOpen auto-migration failed: ${err.message}`);
+                        process.stderr.write(`gsd-db: ensureDbOpen auto-migration failed: ${err.message}\n`);
                     }
                 }
                 return opened;
@@ -93,11 +93,17 @@ export async function ensureDbOpen() {
                 setLogBasePath(projectRoot);
             return opened;
         }
-        logWarning("bootstrap", "ensureDbOpen failed — no .gsd directory found");
+        process.stderr.write(`gsd-db: ensureDbOpen failed — no .gsd directory found (resolvedPath=${resolveProjectRootDbPath(basePath)}, cwd=${basePath})\n`);
         return false;
     }
     catch (err) {
-        logWarning("bootstrap", `ensureDbOpen failed: ${err.message ?? String(err)}`);
+        const basePath = process.cwd();
+        const diagnostic = {
+            resolvedPath: resolveProjectRootDbPath(basePath),
+            cwd: basePath,
+            error: err.message ?? String(err),
+        };
+        process.stderr.write(`gsd-db: ensureDbOpen failed — ${JSON.stringify(diagnostic)}\n`);
         return false;
     }
 }

package/dist/resources/extensions/gsd/bootstrap/journal-tools.js

@@ -1,6 +1,5 @@
 import { Type } from "@sinclair/typebox";
 import { queryJournal } from "../journal.js";
-import { logWarning } from "../workflow-logger.js";
 export function registerJournalTools(pi) {
     pi.registerTool({
         name: "gsd_journal_query",
@@ -52,7 +51,7 @@ export function registerJournalTools(pi) {
             }
             catch (err) {
                 const msg = err instanceof Error ? err.message : String(err);
-                logWarning("tool", `gsd_journal_query tool failed: ${msg}`);
+                process.stderr.write(`gsd-journal: gsd_journal_query tool failed: ${msg}\n`);
                 return {
                     content: [{ type: "text", text: `Error querying journal: ${msg}` }],
                     details: { operation: "journal_query", error: msg },

package/dist/resources/extensions/gsd/bootstrap/register-hooks.js

@@ -303,11 +303,4 @@ export function registerHooks(pi) {
         payload.service_tier = tier;
         return payload;
     });
-    // Capability-aware model routing hook (ADR-004)
-    // Extensions can override model selection by returning { modelId: "..." }
-    // Return undefined to let the built-in capability scoring proceed.
-    pi.on("before_model_select", async (_event) => {
-        // Default: no override — let capability scoring handle selection
-        return undefined;
-    });
 }

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -1,7 +1,6 @@
 import { existsSync, readFileSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
-import { logWarning } from "../workflow-logger.js";
 import { debugTime } from "../debug-logger.js";
 import { loadPrompt } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
@@ -62,8 +61,8 @@ export async function buildBeforeAgentStartResult(event, ctx) {
             }
         }
     }
-    catch (e) {
-        logWarning("bootstrap", `memory block fetch failed: ${e.message}`);
+    catch {
+        // non-fatal
     }
     let newSkillsBlock = "";
     if (hasSkillSnapshot()) {
@@ -89,8 +88,8 @@ export async function buildBeforeAgentStartResult(event, ctx) {
                 codebaseBlock = `\n\n[PROJECT CODEBASE — File structure and descriptions (generated ${generatedAt}, may be stale — run /gsd codebase update to refresh)]\n\n${content}`;
             }
         }
-        catch (e) {
-            logWarning("bootstrap", `CODEBASE file read failed: ${e.message}`);
+        catch {
+            // skip
         }
     }
     warnDeprecatedAgentInstructions();
@@ -129,8 +128,8 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
                 globalKnowledge = content;
             }
         }
-        catch (e) {
-            logWarning("bootstrap", `global knowledge file read failed: ${e.message}`);
+        catch {
+            // skip
         }
     }
     // 2. Project knowledge (.gsd/KNOWLEDGE.md) — project-specific
@@ -142,8 +141,8 @@ export function loadKnowledgeBlock(gsdHomeDir, cwd) {
             if (content)
                 projectKnowledge = content;
         }
-        catch (e) {
-            logWarning("bootstrap", `project knowledge file read failed: ${e.message}`);
+        catch {
+            // skip
         }
     }
     if (!globalKnowledge && !projectKnowledge) {
@@ -382,8 +381,8 @@ export function clearForensicsMarker(basePath) {
         try {
             unlinkSync(markerPath);
         }
-        catch (e) {
-            logWarning("bootstrap", `unlinkSync forensics marker failed: ${e.message}`);
+        catch {
+            // non-fatal
         }
     }
 }

package/dist/resources/extensions/gsd/commands/catalog.js

@@ -216,10 +216,8 @@ const NESTED_COMPLETIONS = {
     codebase: [
         { cmd: "generate", desc: "Generate or regenerate CODEBASE.md" },
         { cmd: "generate --max-files", desc: "Generate with custom file limit (default: 500)" },
-        { cmd: "generate --collapse-threshold", desc: "Generate with custom collapse threshold (default: 20)" },
         { cmd: "update", desc: "Incremental update (preserves descriptions)" },
         { cmd: "update --max-files", desc: "Update with custom file limit" },
-        { cmd: "update --collapse-threshold", desc: "Update with custom collapse threshold" },
         { cmd: "stats", desc: "Show file count, description coverage, and generation time" },
         { cmd: "help", desc: "Show usage and available subcommands" },
     ],

package/dist/resources/extensions/gsd/commands-codebase.js

@@ -5,32 +5,26 @@
  * Subcommands: generate, update, stats, help
  */
 import { generateCodebaseMap, updateCodebaseMap, writeCodebaseMap, getCodebaseMapStats, readCodebaseMap, } from "./codebase-generator.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
 const USAGE = "Usage: /gsd codebase [generate|update|stats]\n\n" +
-    "  generate [--max-files N] [--collapse-threshold N]  — Generate or regenerate CODEBASE.md\n" +
-    "  update [--max-files N] [--collapse-threshold N]    — Incremental update (preserves descriptions)\n" +
-    "  stats                                              — Show file count, coverage, and generation time\n" +
-    "  help                                               — Show this help\n\n" +
-    "With no subcommand, shows stats if a map exists or help if not.\n\n" +
-    "Configure defaults via preferences.md:\n" +
-    "  codebase:\n" +
-    "    exclude_patterns: [\"docs/\", \"fixtures/\"]\n" +
-    "    max_files: 1000\n" +
-    "    collapse_threshold: 15";
+    "  generate [--max-files N]  — Generate or regenerate CODEBASE.md\n" +
+    "  update                    — Incremental update (preserves descriptions)\n" +
+    "  stats                     — Show file count, coverage, and generation time\n" +
+    "  help                      — Show this help\n\n" +
+    "With no subcommand, shows stats if a map exists or help if not.";
 export async function handleCodebase(args, ctx, _pi) {
     const basePath = process.cwd();
     const parts = args.trim().split(/\s+/);
     const sub = parts[0] ?? "";
     switch (sub) {
         case "generate": {
-            const options = resolveCodebaseOptions(args, ctx);
-            if (options === false)
+            const maxFiles = parseMaxFiles(args, ctx);
+            if (maxFiles === false)
                 return; // validation failed, message already shown
             const existing = readCodebaseMap(basePath);
             const existingDescriptions = existing
                 ? (await import("./codebase-generator.js")).parseCodebaseMap(existing)
                 : undefined;
-            const result = generateCodebaseMap(basePath, options, existingDescriptions);
+            const result = generateCodebaseMap(basePath, { maxFiles: maxFiles ?? undefined }, existingDescriptions);
             if (result.fileCount === 0) {
                 ctx.ui.notify("Codebase map generated with 0 files.\n" +
                     "Is this a git repository? Run 'git ls-files' to verify.", "warning");
@@ -48,10 +42,10 @@ export async function handleCodebase(args, ctx, _pi) {
                 ctx.ui.notify("No codebase map found. Run /gsd codebase generate to create one.", "warning");
                 return;
             }
-            const options = resolveCodebaseOptions(args, ctx);
-            if (options === false)
+            const maxFiles = parseMaxFiles(args, ctx);
+            if (maxFiles === false)
                 return;
-            const result = updateCodebaseMap(basePath, options);
+            const result = updateCodebaseMap(basePath, { maxFiles: maxFiles ?? undefined });
             writeCodebaseMap(basePath, result.content);
             ctx.ui.notify(`Codebase map updated: ${result.fileCount} files\n` +
                 `  Added: ${result.added} | Removed: ${result.removed} | Unchanged: ${result.unchanged}` +
@@ -99,40 +93,19 @@ function showStats(basePath, ctx) {
             : `Coverage is complete.`), "info");
 }
 /**
- * Resolve codebase map options by merging preferences with CLI flags.
- * CLI flags override preferences; preferences override built-in defaults.
- * Returns false if validation failed (error already shown to user).
+ * Parse and validate --max-files flag.
+ * Returns the parsed number, undefined if flag not present, or false if invalid.
  */
-function resolveCodebaseOptions(args, ctx) {
-    // Load preferences defaults
-    const prefs = loadEffectiveGSDPreferences()?.preferences?.codebase;
-    // Parse CLI flags
+function parseMaxFiles(args, ctx) {
     const maxFilesStr = extractFlag(args, "--max-files");
-    const collapseStr = extractFlag(args, "--collapse-threshold");
-    // Validate --max-files
-    let maxFiles;
-    if (maxFilesStr) {
-        maxFiles = parseInt(maxFilesStr, 10);
-        if (isNaN(maxFiles) || maxFiles < 1) {
-            ctx.ui.notify("--max-files must be a positive integer (e.g. --max-files 200).", "warning");
-            return false;
-        }
-    }
-    // Validate --collapse-threshold
-    let collapseThreshold;
-    if (collapseStr) {
-        collapseThreshold = parseInt(collapseStr, 10);
-        if (isNaN(collapseThreshold) || collapseThreshold < 1) {
-            ctx.ui.notify("--collapse-threshold must be a positive integer (e.g. --collapse-threshold 15).", "warning");
-            return false;
-        }
+    if (!maxFilesStr)
+        return undefined;
+    const maxFiles = parseInt(maxFilesStr, 10);
+    if (isNaN(maxFiles) || maxFiles < 1) {
+        ctx.ui.notify("--max-files must be a positive integer (e.g. --max-files 200).", "warning");
+        return false;
     }
-    return {
-        // CLI flags override preferences
-        maxFiles: maxFiles ?? prefs?.max_files,
-        collapseThreshold: collapseThreshold ?? prefs?.collapse_threshold,
-        excludePatterns: prefs?.exclude_patterns,
-    };
+    return maxFiles;
 }
 function extractFlag(args, flag) {
     const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/resources/extensions/gsd/commands-inspect.js

@@ -6,7 +6,6 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
-import { logWarning } from "./workflow-logger.js";
 import { getErrorMessage } from "./error-utils.js";
 export function formatInspectOutput(data) {
     const lines = [];
@@ -72,7 +71,7 @@ export async function handleInspect(ctx) {
         ctx.ui.notify(formatInspectOutput(data), "info");
     }
     catch (err) {
-        logWarning("command", `/gsd inspect failed: ${getErrorMessage(err)}`);
+        process.stderr.write(`gsd-db: /gsd inspect failed: ${getErrorMessage(err)}\n`);
         ctx.ui.notify("Failed to inspect GSD database. Check stderr for details.", "error");
     }
 }

package/dist/resources/extensions/gsd/commands-maintenance.js

@@ -5,14 +5,12 @@
  */
 import { deriveState } from "./state.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
-import { logWarning } from "./workflow-logger.js";
 export async function handleCleanupBranches(ctx, basePath) {
     let branches;
     try {
         branches = nativeBranchList(basePath, "gsd/*");
     }
-    catch (e) {
-        logWarning("command", `branch list failed: ${e.message}`);
+    catch {
         ctx.ui.notify("No GSD branches to clean up.", "info");
         return;
     }
@@ -22,8 +20,7 @@ export async function handleCleanupBranches(ctx, basePath) {
     try {
         merged = nativeBranchListMerged(basePath, mainBranch, "gsd/*");
     }
-    catch (e) {
-        logWarning("command", `merged branch list failed: ${e.message}`);
+    catch {
         merged = [];
     }
     const mergedNonQuick = merged.filter((b) => !b.startsWith("gsd/quick/"));
@@ -33,8 +30,8 @@ export async function handleCleanupBranches(ctx, basePath) {
             nativeBranchDelete(basePath, branch, false);
             deletedMerged++;
         }
-        catch (e) {
-            logWarning("command", `branch delete failed for ${branch}: ${e.message}`);
+        catch {
+            /* skip branches that cannot be deleted */
         }
     }
     // Also delete stale milestone branches for completed milestones when detached
@@ -64,9 +61,7 @@ export async function handleCleanupBranches(ctx, basePath) {
                         nativeBranchDelete(basePath, branch, true);
                         deletedStaleMilestones++;
                     }
-                    catch (e) {
-                        logWarning("command", `stale milestone branch delete failed for ${branch}: ${e.message}`);
-                    }
+                    catch { /* non-fatal */ }
                     continue;
                 }
             }
@@ -78,8 +73,7 @@ export async function handleCleanupBranches(ctx, basePath) {
             try {
                 roadmapContent = await loadFile(roadmapPath);
             }
-            catch (e) {
-                logWarning("command", `loadFile failed for ${roadmapPath}: ${e.message}`);
+            catch {
                 roadmapContent = null;
             }
             if (!roadmapContent)
@@ -90,13 +84,13 @@ export async function handleCleanupBranches(ctx, basePath) {
                 nativeBranchDelete(basePath, branch, true);
                 deletedStaleMilestones++;
             }
-            catch (e) {
-                logWarning("command", `milestone branch delete failed for ${branch}: ${e.message}`);
+            catch {
+                /* non-fatal */
             }
         }
     }
-    catch (e) {
-        logWarning("command", `stale milestone cleanup failed: ${e.message}`);
+    catch {
+        /* non-fatal */
     }
     const summary = [];
     if (deletedMerged > 0) {
@@ -122,8 +116,7 @@ export async function handleCleanupSnapshots(ctx, basePath) {
     try {
         refs = nativeForEachRef(basePath, "refs/gsd/snapshots/");
     }
-    catch (e) {
-        logWarning("command", `snapshot ref list failed: ${e.message}`);
+    catch {
         ctx.ui.notify("No snapshot refs to clean up.", "info");
         return;
     }
@@ -147,8 +140,8 @@ export async function handleCleanupSnapshots(ctx, basePath) {
                 nativeUpdateRef(basePath, old);
                 pruned++;
             }
-            catch (e) {
-                logWarning("command", `snapshot ref update failed for ${old}: ${e.message}`);
+            catch {
+                /* skip individual failures */
             }
         }
     }
@@ -162,8 +155,7 @@ export async function handleCleanupWorktrees(ctx, basePath) {
     try {
         statuses = getAllWorktreeHealth(basePath);
     }
-    catch (e) {
-        logWarning("command", `worktree health inspection failed: ${e.message}`);
+    catch {
         ctx.ui.notify("Failed to inspect worktrees.", "error");
         return;
     }
@@ -193,8 +185,7 @@ export async function handleCleanupWorktrees(ctx, basePath) {
                 lines.push(`  ✓ ${wt.name}  removed (branch ${wt.branch} deleted)`);
                 removed++;
             }
-            catch (e) {
-                logWarning("command", `worktree removal failed for ${wt.name}: ${e.message}`);
+            catch {
                 lines.push(`  ✗ ${wt.name}  failed to remove`);
             }
         }
@@ -237,9 +228,7 @@ export async function handleSkip(unitArg, ctx, basePath) {
             keys = JSON.parse(readFile(completedKeysFile, "utf-8"));
         }
     }
-    catch (e) {
-        logWarning("command", `completed-units.json parse failed: ${e.message}`);
-    }
+    catch { /* start fresh */ }
     // Normalize: accept "execute-task/M001/S01/T03", "M001/S01/T03", or just "T03"
     let skipKey = unitArg;
     if (!skipKey.includes("execute-task") && !skipKey.includes("plan-") && !skipKey.includes("research-") && !skipKey.includes("complete-")) {
@@ -350,8 +339,7 @@ export async function handleCleanupProjects(args, ctx) {
             .filter(e => e.isDirectory())
             .map(e => e.name);
     }
-    catch (e) {
-        logWarning("command", `readdir failed for project-state directory: ${e.message}`);
+    catch {
         ctx.ui.notify(`Failed to read project-state directory at ${projectsDir}.`, "error");
         return;
     }
@@ -425,8 +413,7 @@ export async function handleCleanupProjects(args, ctx) {
                 fsRmSync(pathJoin(projectsDir, e.hash), { recursive: true, force: true });
                 removed++;
             }
-            catch (err) {
-                logWarning("command", `project cleanup rm failed for ${e.hash}: ${err.message}`);
+            catch {
                 failed.push(e.hash);
             }
         }
@@ -492,7 +479,7 @@ export async function handleRecover(ctx, basePath) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        logWarning("command", `recover failed: ${msg}`);
+        process.stderr.write(`gsd-recover: failed: ${msg}\n`);
         ctx.ui.notify(`gsd recover failed: ${msg}`, "error");
     }
 }