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

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

@@ -721,8 +721,6 @@ export async function runGuards(
   // ── Stop/Backtrack directive guard (#3487) ──
   // Check for unexecuted stop or backtrack captures BEFORE dispatching any unit.
   // This ensures user "halt" directives are honored immediately.
-  // IMPORTANT: Fail-closed — any exception during stop handling still breaks the loop
-  // to ensure user halt intent is never silently dropped.
   try {
     const { loadStopCaptures, markCaptureExecuted } = await import("../captures.js");
     const stopCaptures = loadStopCaptures(s.basePath);
@@ -739,10 +737,12 @@ export async function runGuards(
         basename(s.originalBasePath || s.basePath),
       );
 
-      // Pause first — ensures auto-mode stops even if later steps fail
-      await deps.pauseAuto(ctx, pi);
+      // Mark all stop/backtrack captures as executed so they don't re-fire
+      for (const cap of stopCaptures) {
+        markCaptureExecuted(s.basePath, cap.id);
+      }
 
-      // For backtrack captures, write the backtrack trigger after pausing
+      // For backtrack captures, write the backtrack trigger before pausing
       if (isBacktrack) {
         try {
           const { executeBacktrack } = await import("../triage-resolution.js");
@@ -752,19 +752,12 @@ export async function runGuards(
         }
       }
 
-      // Mark captures as executed only after successful pause/transition
-      for (const cap of stopCaptures) {
-        markCaptureExecuted(s.basePath, cap.id);
-      }
-
+      await deps.pauseAuto(ctx, pi);
       debugLog("autoLoop", { phase: "exit", reason: isBacktrack ? "user-backtrack" : "user-stop" });
       return { action: "break", reason: isBacktrack ? "user-backtrack" : "user-stop" };
     }
   } catch (e) {
-    // Fail-closed: if anything in the stop guard throws, break the loop
-    // rather than silently continuing and dropping user halt intent
     debugLog("guards", { phase: "stop-guard-error", error: String(e) });
-    return { action: "break", reason: "stop-guard-error" };
   }
 
   // Budget ceiling guard
@@ -1268,9 +1261,7 @@ export async function runUnitPhase(
         blockers: [],
         nextSteps: [],
       });
-    } catch (err) { /* non-fatal — anchor is advisory */
-      logWarning("engine", `phase anchor failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    } catch { /* non-fatal — anchor is advisory */ }
   }
 
   deps.emitJournalEvent({ ts: new Date().toISOString(), flowId: ic.flowId, seq: ic.nextSeq(), eventType: "unit-end", data: { unitType, unitId, status: unitResult.status, artifactVerified, ...(unitResult.errorContext ? { errorContext: unitResult.errorContext } : {}) }, causedBy: { flowId: ic.flowId, seq: unitStartSeq } });
@@ -1393,4 +1384,3 @@ export async function runFinalize(
 
   return { action: "next", data: undefined as void };
 }
-

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

@@ -31,7 +31,6 @@ import {
   getRtkSessionSavings,
   type RtkSessionSavings,
 } from "../shared/rtk-session-stats.js";
-import { logWarning } from "./workflow-logger.js";
 
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 
@@ -286,9 +285,8 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
             taskDetails = dbTasks.map(t => ({ id: t.id, title: t.title, done: t.status === "complete" || t.status === "done" }));
           }
         }
-      } catch (err) {
+      } catch {
         // Non-fatal — just omit task count
-        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
 
@@ -299,9 +297,8 @@ export function updateSliceProgressCache(base: string, mid: string, activeSid?:
       activeSliceTasks,
       taskDetails,
     };
-  } catch (err) {
+  } catch {
     // Non-fatal — widget just won't show progress bar
-    logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -335,9 +332,8 @@ function refreshLastCommit(basePath: string): void {
       };
     }
     lastCommitFetchedAt = Date.now();
-  } catch (err) {
+  } catch {
     // Non-fatal — just skip last commit display
-    logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -380,9 +376,7 @@ function ensureWidgetModeLoaded(): void {
     if (saved && WIDGET_MODES.includes(saved as WidgetMode)) {
       widgetMode = saved as WidgetMode;
     }
-  } catch (err) { /* non-fatal — use default */
-    logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* non-fatal — use default */ }
 }
 
 /** Persist widget mode to global preferences YAML. */
@@ -401,9 +395,7 @@ function persistWidgetMode(mode: WidgetMode): void {
       content = content.trimEnd() + "\n" + line + "\n";
     }
     writeFileSync(prefsPath, content, "utf-8");
-  } catch (err) { /* non-fatal — mode still set in memory */
-    logWarning("dashboard", `file write failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* non-fatal — mode still set in memory */ }
 }
 
 /** Cycle to the next widget mode. Returns the new mode. */
@@ -466,9 +458,7 @@ export function updateProgressWidget(
 
   // Cache git branch at widget creation time (not per render)
   let cachedBranch: string | null = null;
-  try { cachedBranch = getCurrentBranch(accessors.getBasePath()); } catch (err) { /* not in git repo */
-    logWarning("dashboard", `git branch detection failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  try { cachedBranch = getCurrentBranch(accessors.getBasePath()); } catch { /* not in git repo */ }
 
   // Cache short pwd (last 2 path segments only) + worktree/branch info
   let widgetPwd: string;
@@ -505,8 +495,7 @@ export function updateProgressWidget(
         const sessionId = ctx.sessionManager.getSessionId();
         const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
         cachedRtkLabel = formatRtkSavingsLabel(savings);
-      } catch (err) {
-        logWarning("dashboard", `RTK savings lookup failed: ${err instanceof Error ? (err as Error).message : String(err)}`);
+      } catch {
         cachedRtkLabel = null;
       }
     };
@@ -530,9 +519,7 @@ export function updateProgressWidget(
         }
         refreshRtkLabel();
         cachedLines = undefined;
-      } catch (err) { /* non-fatal */
-        logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
+      } catch { /* non-fatal */ }
     }, 15_000);
 
     return {
@@ -891,4 +878,3 @@ function padToWidth(s: string, colWidth: number): string {
   if (vis >= colWidth) return truncateToWidth(s, colWidth, "…");
   return s + " ".repeat(colWidth - vis);
 }
-

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

@@ -28,7 +28,7 @@ import {
   buildSliceFileName,
 } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import { logWarning, logError } from "./workflow-logger.js";
+import { logError } from "./workflow-logger.js";
 import { join } from "node:path";
 import { hasImplementationArtifacts } from "./auto-recovery.js";
 import {
@@ -712,9 +712,7 @@ export const DISPATCH_RULES: DispatchRule[] = [
             }
           }
         }
-      } catch (err) { /* fall through — don't block on DB errors */
-        logWarning("dispatch", `verification class check failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
+      } catch { /* fall through — don't block on DB errors */ }
 
       return {
         action: "dispatch",
@@ -756,9 +754,8 @@ export async function resolveDispatch(
   try {
     const registry = getRegistry();
     return await registry.evaluateDispatch(ctx);
-  } catch (err) {
+  } catch {
     // Registry not initialized — fall back to inline loop
-    logWarning("dispatch", `registry dispatch failed, falling back to inline rules: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   for (const rule of DISPATCH_RULES) {
@@ -782,4 +779,3 @@ export async function resolveDispatch(
 export function getDispatchRuleNames(): string[] {
   return DISPATCH_RULES.map((r) => r.name);
 }
-

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -9,8 +9,8 @@ import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 import type { GSDPreferences } from "./preferences.js";
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.js";
 import type { ComplexityTier } from "./complexity-classifier.js";
-import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
-import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides } from "./model-router.js";
+import { classifyUnitComplexity, tierLabel, extractTaskMetadata } from "./complexity-classifier.js";
+import { resolveModelForComplexity, escalateTier } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 
@@ -107,65 +107,15 @@ export async function selectAndApplyModel(
           }
         }
 
-        // Load user capability overrides from preferences (D-17: deep-merged with built-in profiles)
-        const capabilityOverrides = loadCapabilityOverrides(
-          (prefs as { modelOverrides?: Record<string, { capabilities?: Record<string, number> }> } | undefined) ?? {},
-        );
-
-        // Fire before_model_select hook (ADR-004, D-03)
-        // Hook can override model selection entirely by returning { modelId }
-        let hookOverride: string | undefined;
-        if (routingConfig.hooks !== false) {
-          const eligible = getEligibleModels(
-            classification.tier,
-            availableModelIds,
-            routingConfig,
-          );
-          const hookResult = await pi.emitBeforeModelSelect({
-            unitType,
-            unitId,
-            classification: {
-              tier: classification.tier,
-              reason: classification.reason,
-              downgraded: classification.downgraded,
-            },
-            taskMetadata: classification.taskMetadata as Record<string, unknown> | undefined,
-            eligibleModels: eligible,
-            phaseConfig: modelConfig ? {
-              primary: modelConfig.primary,
-              fallbacks: modelConfig.fallbacks ?? [],
-            } : undefined,
-          });
-          if (hookResult?.modelId) {
-            hookOverride = hookResult.modelId;
-          }
-        }
+        // Extract task metadata for capability scoring
+        const taskMeta = unitType === "execute-task"
+          ? extractTaskMetadata(unitId, basePath)
+          : undefined;
 
-        let routingResult: ReturnType<typeof resolveModelForComplexity>;
-        if (hookOverride) {
-          // Hook override bypasses capability scoring entirely
-          routingResult = {
-            modelId: hookOverride,
-            fallbacks: [
-              ...(modelConfig?.fallbacks ?? []).filter(f => f !== hookOverride),
-              ...(modelConfig?.primary && modelConfig.primary !== hookOverride ? [modelConfig.primary] : []),
-            ],
-            tier: classification.tier,
-            wasDowngraded: hookOverride !== modelConfig?.primary,
-            reason: `hook override: ${hookOverride}`,
-            selectionMethod: "tier-only",
-          };
-        } else {
-          routingResult = resolveModelForComplexity(
-            classification,
-            modelConfig,
-            routingConfig,
-            availableModelIds,
-            unitType,
-            classification.taskMetadata,
-            capabilityOverrides,
-          );
-        }
+        const routingResult = resolveModelForComplexity(
+          classification, modelConfig, routingConfig, availableModelIds,
+          unitType, taskMeta,
+        );
 
         if (routingResult.wasDowngraded) {
           effectiveModelConfig = {
@@ -173,23 +123,11 @@ export async function selectAndApplyModel(
             fallbacks: routingResult.fallbacks,
           };
           if (verbose) {
-            if (routingResult.selectionMethod === "capability-scored" && routingResult.capabilityScores) {
-              // Verbose scoring breakdown for capability-scored decisions (D-20)
-              const tierLbl = tierLabel(classification.tier);
-              const scores = Object.entries(routingResult.capabilityScores)
-                .sort(([, a], [, b]) => b - a)
-                .map(([id, score]) => `${id}: ${score.toFixed(1)}`)
-                .join(", ");
-              ctx.ui.notify(
-                `Dynamic routing [${tierLbl}]: ${routingResult.modelId} (capability-scored) — ${scores}`,
-                "info",
-              );
-            } else {
-              ctx.ui.notify(
-                `Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${classification.reason})`,
-                "info",
-              );
-            }
+            const method = routingResult.selectionMethod === "capability-scored" ? "capability-scored" : "tier-only";
+            ctx.ui.notify(
+              `Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${method} — ${classification.reason})`,
+              "info",
+            );
           }
         }
         routingTierLabel = ` [${tierLabel(classification.tier)}]`;

package/src/resources/extensions/gsd/auto-post-unit.ts

@@ -279,9 +279,8 @@ export async function postUnitPreVerification(pctx: PostUnitContext, opts?: PreV
                 try {
                   const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
                   ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
-                } catch (err) {
+                } catch {
                   // GitHub sync not available — skip
-                  logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
                 }
 
                 taskContext = {
@@ -559,7 +558,9 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
             } catch (dbErr) {
               // DB unavailable — fail explicitly rather than silently reverting to markdown mutation.
               // Use 'gsd recover' to rebuild DB state from disk if needed.
-              logError("engine", `retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover' to reconcile.`);
+              process.stderr.write(
+                `gsd: retry state-reset failed (DB unavailable): ${(dbErr as Error).message}. Run 'gsd recover' to reconcile.\n`,
+              );
             }
           }
 
@@ -731,4 +732,3 @@ export async function postUnitPostVerification(pctx: PostUnitContext): Promise<"
 
   return "continue";
 }
-

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

@@ -27,7 +27,6 @@ import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary
 import { getPendingGates } from "./gsd-db.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
 import { readPhaseAnchor, formatAnchorForPrompt } from "./phase-anchor.js";
-import { logWarning } from "./workflow-logger.js";
 
 // ─── Preamble Cap ─────────────────────────────────────────────────────────────
 
@@ -50,8 +49,7 @@ function formatExecutorConstraints(): string {
   try {
     const prefs = loadEffectiveGSDPreferences();
     windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
-  } catch (e) {
-    logWarning("prompt", `resolveExecutorContextWindow failed: ${(e as Error).message}`);
+  } catch {
     windowTokens = 200_000; // safe default
   }
   const budgets = computeBudgets(windowTokens);
@@ -200,9 +198,7 @@ export async function inlineDependencySummaries(
       }
       // If slice not found in DB, fall through to file-based parsing
     }
-  } catch (err) {
-    logWarning("prompt", `inlineDependencySummaries DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
 
   // If DB didn't provide depends, fall back to roadmap parsing
   if (!depends) {
@@ -280,8 +276,8 @@ export async function inlineDecisionsFromDb(
         return `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
       }
     }
-  } catch (err) {
-    logWarning("prompt", `inlineDecisionsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
+    // DB not available — fall through to filesystem
   }
   return inlineGsdRootFile(base, "decisions.md", "Decisions");
 }
@@ -307,8 +303,8 @@ export async function inlineRequirementsFromDb(
         return `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
       }
     }
-  } catch (err) {
-    logWarning("prompt", `inlineRequirementsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
+    // DB not available — fall through to filesystem
   }
   return inlineGsdRootFile(base, "requirements.md", "Requirements");
 }
@@ -329,8 +325,8 @@ export async function inlineProjectFromDb(
         return `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
       }
     }
-  } catch (err) {
-    logWarning("prompt", `inlineProjectFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
+    // DB not available — fall through to filesystem
   }
   return inlineGsdRootFile(base, "project.md", "Project");
 }
@@ -490,8 +486,8 @@ export function buildSkillActivationBlock(params: {
       for (const skillName of taskPlan.frontmatter.skills_used) {
         matched.add(normalizeSkillReference(skillName));
       }
-    } catch (err) {
-      logWarning("prompt", `parseTaskPlanFile failed: ${err instanceof Error ? err.message : String(err)}`);
+    } catch {
+      // Non-fatal — malformed task plan should not break prompt construction
     }
   }
 
@@ -740,9 +736,7 @@ export async function checkNeedsReassessment(
         return { sliceId: lastCompleted };
       }
     }
-  } catch (err) {
-    logWarning("prompt", `checkNeedsReassessment DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
 
   // File-based fallback using roadmap checkboxes
   const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -808,9 +802,7 @@ export async function checkNeedsRunUat(
         return { sliceId: sid, uatType };
       }
     }
-  } catch (err) {
-    logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
 
   // File-based fallback using roadmap checkboxes
   if (!prefs?.uat_dispatch) return null;
@@ -1320,9 +1312,7 @@ export async function buildCompleteMilestonePrompt(
     if (isDbAvailable()) {
       sliceIds = getMilestoneSlices(mid).map(s => s.id);
     }
-  } catch (err) {
-    logWarning("prompt", `buildCompleteMilestonePrompt DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
   // File-based fallback: parse roadmap for slice IDs when DB has no data
   if (sliceIds.length === 0 && roadmapPath) {
     const roadmapContent = await loadFile(roadmapPath);
@@ -1403,9 +1393,7 @@ export async function buildValidateMilestonePrompt(
         }
       }
     }
-  } catch (err) {
-    logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
 
   // Inline all slice summaries and UAT results
   let valSliceIds: string[] = [];
@@ -1414,9 +1402,7 @@ export async function buildValidateMilestonePrompt(
     if (isDbAvailable()) {
       valSliceIds = getMilestoneSlices(mid).map(s => s.id);
     }
-  } catch (err) {
-    logWarning("prompt", `buildValidateMilestonePrompt slice IDs lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-  }
+  } catch { /* fall through */ }
   // File-based fallback: parse roadmap for slice IDs when DB has no data
   if (valSliceIds.length === 0 && roadmapPath) {
     const roadmapContent = await loadFile(roadmapPath);
@@ -1555,8 +1541,8 @@ export async function buildReplanSlicePrompt(
         `- **${c.id}**: "${c.text}" — ${c.rationale ?? "no rationale"}`
       ).join("\n");
     }
-  } catch (err) {
-    logWarning("prompt", `loadReplanCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
+    // Non-fatal — captures module may not be available
   }
 
   return loadPrompt("replan-slice", {
@@ -1656,8 +1642,8 @@ export async function buildReassessRoadmapPrompt(
         `- **${c.id}**: "${c.text}" — ${c.rationale ?? "deferred during triage"}`
       ).join("\n");
     }
-  } catch (err) {
-    logWarning("prompt", `loadDeferredCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
+  } catch {
+    // Non-fatal — captures module may not be available
   }
 
   const reassessCommitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
@@ -1873,9 +1859,7 @@ export async function buildRewriteDocsPrompt(
               .filter(t => t.status !== "complete" && t.status !== "done")
               .map(t => ({ id: t.id }));
           }
-        } catch (err) {
-          logWarning("prompt", `buildRewriteDocsPrompt DB task lookup failed: ${err instanceof Error ? err.message : String(err)}`);
-        }
+        } catch { /* fall through */ }
 
         if (!incompleteTasks) {
           // DB unavailable — no task data to inline
@@ -1927,4 +1911,3 @@ export async function buildRewriteDocsPrompt(
     overridesPath: relGsdRootFile("OVERRIDES"),
   });
 }
-

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

@@ -15,7 +15,6 @@ import { parseRoadmap as parseLegacyRoadmap, parsePlan as parseLegacyPlan } from
 import { isDbAvailable, getTask, getSlice, getSliceTasks, updateTaskStatus } from "./gsd-db.js";
 import { isValidationTerminal } from "./state.js";
 import { getErrorMessage } from "./error-utils.js";
-import { logWarning, logError } from "./workflow-logger.js";
 import {
   nativeConflictFiles,
   nativeCommit,
@@ -73,8 +72,7 @@ export function hasImplementationArtifacts(basePath: string): boolean {
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
       });
-    } catch (e) {
-      logWarning("recovery", `git rev-parse check failed: ${(e as Error).message}`);
+    } catch {
       return true;
     }
 
@@ -94,9 +92,8 @@ export function hasImplementationArtifacts(basePath: string): boolean {
     // implementation code (#1703).
     const implFiles = changedFiles.filter(f => !f.startsWith(".gsd/") && !f.startsWith(".gsd\\"));
     return implFiles.length > 0;
-  } catch (e) {
+  } catch {
     // Non-fatal — if git operations fail, don't block the pipeline
-    logWarning("recovery", `implementation artifact check failed: ${(e as Error).message}`);
     return true;
   }
 }
@@ -112,9 +109,8 @@ function detectMainBranch(basePath: string): string {
       encoding: "utf-8",
     });
     if (result.trim()) return "main";
-  } catch (_) {
-    // Expected — main doesn't exist, try master next
-    void _;
+  } catch {
+    // main doesn't exist
   }
   try {
     const result = execFileSync("git", ["rev-parse", "--verify", "master"], {
@@ -123,13 +119,10 @@ function detectMainBranch(basePath: string): string {
       encoding: "utf-8",
     });
     if (result.trim()) return "master";
-  } catch (_) {
-    // Expected — master doesn't exist either
-    void _;
+  } catch {
+    // master doesn't exist either
   }
-  // Neither main nor master found — warn and fall back
-  logWarning("recovery", "neither main nor master branch found, defaulting to main");
-  return "main";
+  return "main"; // default fallback
 }
 
 /**
@@ -151,9 +144,8 @@ function getChangedFilesSinceBranch(basePath: string, targetBranch: string): str
       ).trim();
       return result ? result.split("\n").filter(Boolean) : [];
     }
-  } catch (err) {
+  } catch {
     // merge-base failed — fall back
-    logWarning("recovery", `merge-base detection failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 
   // Fallback: check last 20 commits
@@ -163,8 +155,7 @@ function getChangedFilesSinceBranch(basePath: string, targetBranch: string): str
       { cwd: basePath, stdio: ["ignore", "pipe", "pipe"], encoding: "utf-8" },
     ).trim();
     return result ? [...new Set(result.split("\n").filter(Boolean))] : [];
-  } catch (e) {
-    logWarning("recovery", `git log fallback failed: ${(e as Error).message}`);
+  } catch {
     return [];
   }
 }
@@ -255,9 +246,8 @@ export function verifyExpectedArtifact(
       for (const gid of gateIds) {
         if (pendingIds.has(gid)) return false;
       }
-    } catch (err) {
+    } catch {
       // DB unavailable — treat as verified to avoid blocking
-      logWarning("recovery", `gate-evaluate DB check failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return true;
   }
@@ -345,9 +335,8 @@ export function verifyExpectedArtifact(
             }
           }
         }
-      } catch (err) {
+      } catch {
         // Parse failure — don't block; slice plan may have non-standard format
-        logWarning("recovery", `plan-slice task plan verification failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
   }
@@ -377,8 +366,7 @@ export function verifyExpectedArtifact(
             const roadmap = parseLegacyRoadmap(roadmapContent);
             const slice = roadmap.slices.find((s) => s.id === sid);
             if (slice && !slice.done) return false;
-          } catch (e) {
-            logWarning("recovery", `roadmap parse failed: ${(e as Error).message}`);
+          } catch {
             return false;
           }
         }
@@ -430,9 +418,7 @@ export function writeBlockerPlaceholder(
   if (unitType === "execute-task" && isDbAvailable()) {
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     if (mid && sid && tid) {
-      try { updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString()); } catch (err) { /* non-fatal */
-        logError("recovery", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
-      }
+      try { updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString()); } catch { /* non-fatal */ }
     }
   }
 
@@ -453,23 +439,20 @@ function abortAndResetMerge(
   if (hasMergeHead) {
     try {
       nativeMergeAbort(basePath);
-    } catch (err) {
+    } catch {
       /* best-effort */
-      logWarning("recovery", `git merge-abort failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   } else if (squashMsgPath) {
     try {
       unlinkSync(squashMsgPath);
-    } catch (err) {
+    } catch {
       /* best-effort */
-      logWarning("recovery", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
     }
   }
   try {
     nativeResetHard(basePath);
-  } catch (err) {
+  } catch {
     /* best-effort */
-    logError("recovery", `git reset failed: ${err instanceof Error ? err.message : String(err)}`);
   }
 }
 
@@ -517,8 +500,7 @@ export function reconcileMergeState(
       try {
         nativeCheckoutTheirs(basePath, gsdConflicts);
         nativeAddPaths(basePath, gsdConflicts);
-      } catch (e) {
-        logError("recovery", `auto-resolve .gsd/ conflicts failed: ${(e as Error).message}`);
+      } catch {
         resolved = false;
       }
       if (resolved) {
@@ -531,8 +513,7 @@ export function reconcileMergeState(
             `Auto-resolved ${gsdConflicts.length} .gsd/ state file conflict(s) from prior merge.`,
             "info",
           );
-        } catch (e) {
-          logError("recovery", `auto-commit .gsd/ conflict resolution failed: ${(e as Error).message}`);
+        } catch {
           resolved = false;
         }
       }
@@ -611,4 +592,3 @@ export function buildLoopRemediationSteps(
   }
   return null;
 }
-