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

package/src/resources/extensions/gsd/auto.ts

@@ -115,7 +115,7 @@ import {
   formatCost,
   formatTokenCount,
 } from "./metrics.js";
-import { setLogBasePath, logWarning, logError } 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";
@@ -316,9 +316,8 @@ export function getAutoDashboardData(): AutoDashboardData {
     if (s.basePath) {
       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,
@@ -566,9 +565,8 @@ function cleanupAfterLoopExit(ctx: ExtensionContext): void {
   try {
     if (lockBase()) clearLock(lockBase());
     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);
@@ -580,9 +578,8 @@ function cleanupAfterLoopExit(ctx: ExtensionContext): void {
     s.basePath = s.originalBasePath;
     try {
       process.chdir(s.basePath);
-    } catch (err) {
+    } catch {
       /* best-effort */
-      logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
   }
 }
@@ -654,9 +651,8 @@ export async function stopAuto(
           } else {
             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) {
@@ -691,9 +687,8 @@ export async function stopAuto(
         s.basePath = s.originalBasePath;
         try {
           process.chdir(s.basePath);
-        } catch (err) {
+        } catch {
           /* best-effort */
-          logWarning("engine", `chdir failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
         }
       }
     } catch (e) {
@@ -765,9 +760,7 @@ export async function stopAuto(
     try {
       const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
       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 {
@@ -801,9 +794,7 @@ export async function stopAuto(
         const { closeBrowser } = await import("../browser-tools/lifecycle.js");
         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();
@@ -861,18 +852,16 @@ export async function pauseAuto(
       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;
   }
@@ -1096,9 +1085,7 @@ export async function startAuto(
           s.originalBasePath = meta.originalBasePath || base;
           s.stepMode = meta.stepMode ?? requestedStepMode;
           s.paused = true;
-          try { unlinkSync(pausedPath); } catch (err) { /* non-fatal */
-            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-          }
+          try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
           ctx.ui.notify(
             `Resuming paused custom workflow${meta.activeRunDir ? ` (${meta.activeRunDir})` : ""}.`,
             "info",
@@ -1109,9 +1096,7 @@ export async function startAuto(
           const summaryFile = resolveMilestoneFile(base, meta.milestoneId, "SUMMARY");
           if (!mDir || summaryFile) {
             // Stale milestone — clean up and fall through to fresh bootstrap
-            try { unlinkSync(pausedPath); } catch (err) { /* non-fatal */
-            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-          }
+            try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
             ctx.ui.notify(
               `Paused milestone ${meta.milestoneId} is ${!mDir ? "missing" : "already complete"}. Starting fresh.`,
               "info",
@@ -1122,9 +1107,7 @@ export async function startAuto(
             s.stepMode = meta.stepMode ?? requestedStepMode;
             s.paused = true;
             // Clean up the persisted file — we're consuming it
-            try { unlinkSync(pausedPath); } catch (err) { /* non-fatal */
-            logWarning("session", `pause file cleanup failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
-          }
+            try { unlinkSync(pausedPath); } catch { /* non-fatal */ }
             ctx.ui.notify(
               `Resuming paused session for ${meta.milestoneId}${meta.worktreePath ? ` (worktree)` : ""}.`,
               "info",
@@ -1132,9 +1115,8 @@ export async function startAuto(
           }
         }
       }
-    } 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" });
     }
   }
 
@@ -1260,9 +1242,8 @@ export async function startAuto(
 
   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");
 
@@ -1434,9 +1415,8 @@ export async function dispatchHookUnit(
     if (match) {
       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 {
       ctx.ui.notify(
@@ -1473,9 +1453,7 @@ export async function dispatchHookUnit(
   ctx.ui.notify(`Running post-unit hook: ${hookName}`, "info");
 
   // Ensure cwd matches basePath before hook dispatch (#1389)
-  try { 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" });
-  }
+  try { if (process.cwd() !== s.basePath) process.chdir(s.basePath); } catch {}
 
   debugLog("dispatchHookUnit", {
     phase: "send-message",
@@ -1497,4 +1475,3 @@ export {
   buildLoopRemediationSteps,
 } from "./auto-recovery.js";
 export { resolveExpectedArtifactPath } from "./auto-artifact-paths.js";
-

package/src/resources/extensions/gsd/bootstrap/agent-end-recovery.ts

@@ -1,6 +1,5 @@
 import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 
-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";
@@ -86,7 +85,7 @@ export async function handleAgentEnd(
       } catch (err) {
         const message = err instanceof Error ? err.message : String(err);
         ctx.ui.notify(`Auto-mode error after empty-content abort: ${message}. Stopping auto-mode.`, "error");
-        try { await pauseAuto(ctx, pi); } catch (e) { logWarning("bootstrap", `pauseAuto failed after empty-content abort: ${(e as Error).message}`); }
+        try { await pauseAuto(ctx, pi); } catch { /* best-effort */ }
       }
       return;
     }
@@ -213,8 +212,8 @@ export async function handleAgentEnd(
     ctx.ui.notify(`Auto-mode error in agent_end handler: ${message}. Stopping auto-mode.`, "error");
     try {
       await pauseAuto(ctx, pi);
-    } catch (e) {
-      logWarning("bootstrap", `pauseAuto failed in agent_end handler: ${(e as Error).message}`);
+    } catch {
+      // best-effort
     }
   }
 }

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

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

package/src/resources/extensions/gsd/bootstrap/dynamic-tools.ts

@@ -5,7 +5,7 @@ import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 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.
@@ -92,7 +92,9 @@ export async function ensureDbOpen(): Promise<boolean> {
             const { migrateFromMarkdown } = await import("../md-importer.js");
             migrateFromMarkdown(basePath);
           } catch (err) {
-            logWarning("bootstrap", `ensureDbOpen auto-migration failed: ${(err as Error).message}`);
+            process.stderr.write(
+              `gsd-db: ensureDbOpen auto-migration failed: ${(err as Error).message}\n`,
+            );
           }
         }
         return opened;
@@ -104,10 +106,20 @@ export async function ensureDbOpen(): Promise<boolean> {
       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 as Error).message ?? String(err)}`);
+    const basePath = process.cwd();
+    const diagnostic = {
+      resolvedPath: resolveProjectRootDbPath(basePath),
+      cwd: basePath,
+      error: (err as Error).message ?? String(err),
+    };
+    process.stderr.write(
+      `gsd-db: ensureDbOpen failed — ${JSON.stringify(diagnostic)}\n`,
+    );
     return false;
   }
 }

package/src/resources/extensions/gsd/bootstrap/journal-tools.ts

@@ -2,7 +2,6 @@ import { Type } from "@sinclair/typebox";
 import type { ExtensionAPI } from "@gsd/pi-coding-agent";
 
 import { queryJournal } from "../journal.js";
-import { logWarning } from "../workflow-logger.js";
 
 export function registerJournalTools(pi: ExtensionAPI): void {
   pi.registerTool({
@@ -52,7 +51,7 @@ export function registerJournalTools(pi: ExtensionAPI): void {
         };
       } 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" as const, text: `Error querying journal: ${msg}` }],
           details: { operation: "journal_query", error: msg } as any,

package/src/resources/extensions/gsd/bootstrap/register-hooks.ts

@@ -322,12 +322,4 @@ export function registerHooks(pi: ExtensionAPI): void {
     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/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -4,7 +4,6 @@ import { join } from "node:path";
 
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 
-import { logWarning } from "../workflow-logger.js";
 import { debugTime } from "../debug-logger.js";
 import { loadPrompt } from "../prompt-loader.js";
 import { readForensicsMarker } from "../forensics.js";
@@ -84,8 +83,8 @@ export async function buildBeforeAgentStartResult(
         memoryBlock = `\n\n${formatted}`;
       }
     }
-  } catch (e) {
-    logWarning("bootstrap", `memory block fetch failed: ${(e as Error).message}`);
+  } catch {
+    // non-fatal
   }
 
   let newSkillsBlock = "";
@@ -112,8 +111,8 @@ export async function buildBeforeAgentStartResult(
           : rawContent;
         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 as Error).message}`);
+    } catch {
+      // skip
     }
   }
 
@@ -159,8 +158,8 @@ export function loadKnowledgeBlock(gsdHomeDir: string, cwd: string): { block: st
         globalSizeKb = Buffer.byteLength(content, "utf-8") / 1024;
         globalKnowledge = content;
       }
-    } catch (e) {
-      logWarning("bootstrap", `global knowledge file read failed: ${(e as Error).message}`);
+    } catch {
+      // skip
     }
   }
 
@@ -171,8 +170,8 @@ export function loadKnowledgeBlock(gsdHomeDir: string, cwd: string): { block: st
     try {
       const content = readFileSync(knowledgePath, "utf-8").trim();
       if (content) projectKnowledge = content;
-    } catch (e) {
-      logWarning("bootstrap", `project knowledge file read failed: ${(e as Error).message}`);
+    } catch {
+      // skip
     }
   }
 
@@ -430,8 +429,8 @@ export function clearForensicsMarker(basePath: string): void {
   if (existsSync(markerPath)) {
     try {
       unlinkSync(markerPath);
-    } catch (e) {
-      logWarning("bootstrap", `unlinkSync forensics marker failed: ${(e as Error).message}`);
+    } catch {
+      // non-fatal
     }
   }
 }

package/src/resources/extensions/gsd/commands/catalog.ts

@@ -229,10 +229,8 @@ const NESTED_COMPLETIONS: CompletionMap = {
   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/src/resources/extensions/gsd/commands-codebase.ts

@@ -14,21 +14,14 @@ import {
   getCodebaseMapStats,
   readCodebaseMap,
 } from "./codebase-generator.js";
-import { loadEffectiveGSDPreferences } from "./preferences.js";
-import type { CodebaseMapOptions } from "./codebase-generator.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: string,
@@ -41,15 +34,15 @@ export async function handleCodebase(
 
   switch (sub) {
     case "generate": {
-      const options = resolveCodebaseOptions(args, ctx);
-      if (options === false) return; // validation failed, message already shown
+      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(
@@ -80,10 +73,10 @@ export async function handleCodebase(
         return;
       }
 
-      const options = resolveCodebaseOptions(args, ctx);
-      if (options === false) return;
+      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(
@@ -148,44 +141,19 @@ function showStats(basePath: string, ctx: ExtensionCommandContext): void {
 }
 
 /**
- * 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: string, ctx: ExtensionCommandContext): CodebaseMapOptions | false {
-  // Load preferences defaults
-  const prefs = loadEffectiveGSDPreferences()?.preferences?.codebase;
-
-  // Parse CLI flags
+function parseMaxFiles(args: string, ctx: ExtensionCommandContext): number | undefined | false {
   const maxFilesStr = extractFlag(args, "--max-files");
-  const collapseStr = extractFlag(args, "--collapse-threshold");
-
-  // Validate --max-files
-  let maxFiles: number | undefined;
-  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;
-    }
-  }
+  if (!maxFilesStr) return undefined;
 
-  // Validate --collapse-threshold
-  let collapseThreshold: number | undefined;
-  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;
-    }
+  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: string, flag: string): string | undefined {

package/src/resources/extensions/gsd/commands-inspect.ts

@@ -8,7 +8,6 @@ import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 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 interface InspectData {
@@ -93,7 +92,7 @@ export async function handleInspect(ctx: ExtensionCommandContext): Promise<void>
 
     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/src/resources/extensions/gsd/commands-maintenance.ts

@@ -7,14 +7,12 @@
 import type { ExtensionCommandContext } from "@gsd/pi-coding-agent";
 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: ExtensionCommandContext, basePath: string): Promise<void> {
   let branches: string[];
   try {
     branches = nativeBranchList(basePath, "gsd/*");
-  } catch (e) {
-    logWarning("command", `branch list failed: ${(e as Error).message}`);
+  } catch {
     ctx.ui.notify("No GSD branches to clean up.", "info");
     return;
   }
@@ -25,8 +23,7 @@ export async function handleCleanupBranches(ctx: ExtensionCommandContext, basePa
   let merged: string[];
   try {
     merged = nativeBranchListMerged(basePath, mainBranch, "gsd/*");
-  } catch (e) {
-    logWarning("command", `merged branch list failed: ${(e as Error).message}`);
+  } catch {
     merged = [];
   }
 
@@ -36,8 +33,8 @@ export async function handleCleanupBranches(ctx: ExtensionCommandContext, basePa
     try {
       nativeBranchDelete(basePath, branch, false);
       deletedMerged++;
-    } catch (e) {
-      logWarning("command", `branch delete failed for ${branch}: ${(e as Error).message}`);
+    } catch {
+      /* skip branches that cannot be deleted */
     }
   }
 
@@ -69,7 +66,7 @@ export async function handleCleanupBranches(ctx: ExtensionCommandContext, basePa
           try {
             nativeBranchDelete(basePath, branch, true);
             deletedStaleMilestones++;
-          } catch (e) { logWarning("command", `stale milestone branch delete failed for ${branch}: ${(e as Error).message}`); }
+          } catch { /* non-fatal */ }
           continue;
         }
       }
@@ -80,8 +77,7 @@ export async function handleCleanupBranches(ctx: ExtensionCommandContext, basePa
       let roadmapContent: string | null = null;
       try {
         roadmapContent = await loadFile(roadmapPath);
-      } catch (e) {
-        logWarning("command", `loadFile failed for ${roadmapPath}: ${(e as Error).message}`);
+      } catch {
         roadmapContent = null;
       }
       if (!roadmapContent) continue;
@@ -89,12 +85,12 @@ export async function handleCleanupBranches(ctx: ExtensionCommandContext, basePa
       try {
         nativeBranchDelete(basePath, branch, true);
         deletedStaleMilestones++;
-      } catch (e) {
-        logWarning("command", `milestone branch delete failed for ${branch}: ${(e as Error).message}`);
+      } catch {
+        /* non-fatal */
       }
     }
-  } catch (e) {
-    logWarning("command", `stale milestone cleanup failed: ${(e as Error).message}`);
+  } catch {
+    /* non-fatal */
   }
 
   const summary: string[] = [];
@@ -126,8 +122,7 @@ export async function handleCleanupSnapshots(ctx: ExtensionCommandContext, baseP
   let refs: string[];
   try {
     refs = nativeForEachRef(basePath, "refs/gsd/snapshots/");
-  } catch (e) {
-    logWarning("command", `snapshot ref list failed: ${(e as Error).message}`);
+  } catch {
     ctx.ui.notify("No snapshot refs to clean up.", "info");
     return;
   }
@@ -152,8 +147,8 @@ export async function handleCleanupSnapshots(ctx: ExtensionCommandContext, baseP
       try {
         nativeUpdateRef(basePath, old);
         pruned++;
-      } catch (e) {
-        logWarning("command", `snapshot ref update failed for ${old}: ${(e as Error).message}`);
+      } catch {
+        /* skip individual failures */
       }
     }
   }
@@ -169,8 +164,7 @@ export async function handleCleanupWorktrees(ctx: ExtensionCommandContext, baseP
   let statuses;
   try {
     statuses = getAllWorktreeHealth(basePath);
-  } catch (e) {
-    logWarning("command", `worktree health inspection failed: ${(e as Error).message}`);
+  } catch {
     ctx.ui.notify("Failed to inspect worktrees.", "error");
     return;
   }
@@ -203,8 +197,7 @@ export async function handleCleanupWorktrees(ctx: ExtensionCommandContext, baseP
         removeWorktree(basePath, wt.name, { deleteBranch: true });
         lines.push(`  ✓ ${wt.name}  removed (branch ${wt.branch} deleted)`);
         removed++;
-      } catch (e) {
-        logWarning("command", `worktree removal failed for ${wt.name}: ${(e as Error).message}`);
+      } catch {
         lines.push(`  ✗ ${wt.name}  failed to remove`);
       }
     }
@@ -253,7 +246,7 @@ export async function handleSkip(unitArg: string, ctx: ExtensionCommandContext,
     if (fileExists(completedKeysFile)) {
       keys = JSON.parse(readFile(completedKeysFile, "utf-8"));
     }
-  } catch (e) { logWarning("command", `completed-units.json parse failed: ${(e as Error).message}`); }
+  } catch { /* start fresh */ }
 
   // Normalize: accept "execute-task/M001/S01/T03", "M001/S01/T03", or just "T03"
   let skipKey = unitArg;
@@ -378,8 +371,7 @@ export async function handleCleanupProjects(args: string, ctx: ExtensionCommandC
     hashList = readdirSync(projectsDir, { withFileTypes: true })
       .filter(e => e.isDirectory())
       .map(e => e.name);
-  } catch (e) {
-    logWarning("command", `readdir failed for project-state directory: ${(e as Error).message}`);
+  } catch {
     ctx.ui.notify(`Failed to read project-state directory at ${projectsDir}.`, "error");
     return;
   }
@@ -462,8 +454,7 @@ export async function handleCleanupProjects(args: string, ctx: ExtensionCommandC
       try {
         fsRmSync(pathJoin(projectsDir, e.hash), { recursive: true, force: true });
         removed++;
-      } catch (err) {
-        logWarning("command", `project cleanup rm failed for ${e.hash}: ${(err as Error).message}`);
+      } catch {
         failed.push(e.hash);
       }
     }
@@ -538,7 +529,7 @@ export async function handleRecover(ctx: ExtensionCommandContext, basePath: stri
     ctx.ui.notify(lines.join("\n"), "success");
   } 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");
   }
 }