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

package/dist/resources/extensions/ask-user-questions.js

@@ -82,14 +82,11 @@ export default function AskUserQuestions(pi) {
                     return errorResult(`Error: ask_user_questions requires non-empty options for every question (question "${q.id}" has none)`, params.questions);
                 }
             }
-            // Try remote first if configured (works in both interactive and headless modes).
-            // tryRemoteQuestions returns null when no remote channel is configured, so
-            // this is a no-op when the user has not set up Slack/Discord/Telegram.
-            const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
-            const remoteResult = await tryRemoteQuestions(params.questions, signal);
-            if (remoteResult)
-                return { ...remoteResult, details: remoteResult.details };
             if (!ctx.hasUI) {
+                const { tryRemoteQuestions } = await import("./remote-questions/manager.js");
+                const remoteResult = await tryRemoteQuestions(params.questions, signal);
+                if (remoteResult)
+                    return { ...remoteResult, details: remoteResult.details };
                 return errorResult("Error: UI not available (non-interactive mode)", params.questions);
             }
             // Delegate to shared interview UI

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

@@ -495,8 +495,6 @@ export async function runGuards(ic, mid) {
     // ── 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);
@@ -508,9 +506,11 @@ export async function runGuards(ic, mid) {
                 : `Stop directive: ${first.text}`;
             ctx.ui.notify(label, "warning");
             deps.sendDesktopNotification("GSD", label, "warning", "stop-directive", basename(s.originalBasePath || s.basePath));
-            // Pause first — ensures auto-mode stops even if later steps fail
-            await deps.pauseAuto(ctx, pi);
-            // For backtrack captures, write the backtrack trigger after pausing
+            // 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 before pausing
             if (isBacktrack) {
                 try {
                     const { executeBacktrack } = await import("../triage-resolution.js");
@@ -520,19 +520,13 @@ export async function runGuards(ic, mid) {
                     debugLog("guards", { phase: "backtrack-execution-error", error: String(e) });
                 }
             }
-            // 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
     const budgetCeiling = prefs?.budget_ceiling;
@@ -900,9 +894,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 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 } });
     return { action: "next", data: { unitStartedAt: s.currentUnit?.startedAt } };

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

@@ -20,7 +20,6 @@ import { loadEffectiveGSDPreferences, getGlobalGSDPreferencesPath } from "./pref
 import { resolveServiceTierIcon, getEffectiveServiceTier } from "./service-tier.js";
 import { parseUnitId } from "./unit-id.js";
 import { formatRtkSavingsLabel, getRtkSessionSavings, } from "../shared/rtk-session-stats.js";
-import { logWarning } from "./workflow-logger.js";
 // ─── UAT Slice Extraction ─────────────────────────────────────────────────────
 /**
  * Extract the target slice ID from a run-uat unit ID (e.g. "M001/S01" → "S01").
@@ -221,9 +220,8 @@ export function updateSliceProgressCache(base, mid, activeSid) {
                     }
                 }
             }
-            catch (err) {
+            catch {
                 // Non-fatal — just omit task count
-                logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         cachedSliceProgress = {
@@ -234,9 +232,8 @@ export function updateSliceProgressCache(base, mid, activeSid) {
             taskDetails,
         };
     }
-    catch (err) {
+    catch {
         // Non-fatal — widget just won't show progress bar
-        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export function getRoadmapSlicesSync() {
@@ -266,9 +263,8 @@ function refreshLastCommit(basePath) {
         }
         lastCommitFetchedAt = Date.now();
     }
-    catch (err) {
+    catch {
         // Non-fatal — just skip last commit display
-        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 function getLastCommit(basePath) {
@@ -304,9 +300,7 @@ function ensureWidgetModeLoaded() {
             widgetMode = saved;
         }
     }
-    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. */
 function persistWidgetMode(mode) {
@@ -326,9 +320,7 @@ function persistWidgetMode(mode) {
         }
         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. */
 export function cycleWidgetMode() {
@@ -368,9 +360,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     try {
         cachedBranch = getCurrentBranch(accessors.getBasePath());
     }
-    catch (err) { /* not in git repo */
-        logWarning("dashboard", `git branch detection failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    catch { /* not in git repo */ }
     // Cache short pwd (last 2 path segments only) + worktree/branch info
     let widgetPwd;
     {
@@ -404,8 +394,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
                 cachedRtkLabel = formatRtkSavingsLabel(savings);
             }
-            catch (err) {
-                logWarning("dashboard", `RTK savings lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+            catch {
                 cachedRtkLabel = null;
             }
         };
@@ -427,9 +416,7 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 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 {
             render(width) {

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

@@ -13,7 +13,7 @@ import { isDbAvailable, getMilestoneSlices, getPendingGates, markAllGatesOmitted
 import { extractVerdict, isAcceptableUatVerdict } from "./verdict-parser.js";
 import { gsdRoot, resolveMilestoneFile, resolveMilestonePath, resolveSliceFile, resolveTaskFile, relSliceFile, buildMilestoneFileName, } 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 { buildDiscussMilestonePrompt, buildResearchMilestonePrompt, buildPlanMilestonePrompt, buildResearchSlicePrompt, buildPlanSlicePrompt, buildExecuteTaskPrompt, buildCompleteSlicePrompt, buildCompleteMilestonePrompt, buildValidateMilestonePrompt, buildReplanSlicePrompt, buildRunUatPrompt, buildReassessRoadmapPrompt, buildRewriteDocsPrompt, buildReactiveExecutePrompt, buildGateEvaluatePrompt, checkNeedsReassessment, checkNeedsRunUat, } from "./auto-prompts.js";
@@ -564,9 +564,7 @@ export const DISPATCH_RULES = [
                     }
                 }
             }
-            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",
                 unitType: "complete-milestone",
@@ -604,9 +602,8 @@ export async function resolveDispatch(ctx) {
         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) {
         const result = await rule.match(ctx);

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -4,8 +4,8 @@
  * and fallback chains.
  */
 import { resolveModelWithFallbacksForUnit, resolveDynamicRoutingConfig } from "./preferences.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";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
@@ -68,68 +68,19 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                         }
                     }
                 }
-                // Load user capability overrides from preferences (D-17: deep-merged with built-in profiles)
-                const capabilityOverrides = loadCapabilityOverrides(prefs ?? {});
-                // Fire before_model_select hook (ADR-004, D-03)
-                // Hook can override model selection entirely by returning { modelId }
-                let hookOverride;
-                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,
-                        eligibleModels: eligible,
-                        phaseConfig: modelConfig ? {
-                            primary: modelConfig.primary,
-                            fallbacks: modelConfig.fallbacks ?? [],
-                        } : undefined,
-                    });
-                    if (hookResult?.modelId) {
-                        hookOverride = hookResult.modelId;
-                    }
-                }
-                let routingResult;
-                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);
-                }
+                // Extract task metadata for capability scoring
+                const taskMeta = unitType === "execute-task"
+                    ? extractTaskMetadata(unitId, basePath)
+                    : undefined;
+                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, taskMeta);
                 if (routingResult.wasDowngraded) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         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/dist/resources/extensions/gsd/auto-post-unit.js

@@ -208,9 +208,8 @@ export async function postUnitPreVerification(pctx, opts) {
                                     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 = {
                                     taskId: `${sid}/${tid}`,
@@ -449,7 +448,7 @@ export async function postUnitPostVerification(pctx) {
                         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.message}. Run 'gsd recover' to reconcile.`);
+                            process.stderr.write(`gsd: retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.\n`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task

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

@@ -18,7 +18,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 ─────────────────────────────────────────────────────────────
 const MAX_PREAMBLE_CHARS = 30_000;
 function capPreamble(preamble) {
@@ -38,8 +37,7 @@ function formatExecutorConstraints() {
         const prefs = loadEffectiveGSDPreferences();
         windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
     }
-    catch (e) {
-        logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
+    catch {
         windowTokens = 200_000; // safe default
     }
     const budgets = computeBudgets(windowTokens);
@@ -163,9 +161,7 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
             // 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) {
         const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -237,8 +233,8 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
             }
         }
     }
-    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");
 }
@@ -262,8 +258,8 @@ export async function inlineRequirementsFromDb(base, sliceId, level) {
             }
         }
     }
-    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");
 }
@@ -282,8 +278,8 @@ export async function inlineProjectFromDb(base) {
             }
         }
     }
-    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");
 }
@@ -403,8 +399,8 @@ export function buildSkillActivationBlock(params) {
                 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
         }
     }
     const ordered = [...matched]
@@ -623,9 +619,7 @@ export async function checkNeedsReassessment(base, mid, state) {
             }
         }
     }
-    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");
     if (!roadmapPath)
@@ -700,9 +694,7 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
             }
         }
     }
-    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;
@@ -1158,9 +1150,7 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
             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);
@@ -1243,9 +1233,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             }
         }
     }
-    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 = [];
     try {
@@ -1254,9 +1242,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             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);
@@ -1392,8 +1378,8 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
             captureContext = replanCaptures.map(c => `- **${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", {
         workingDirectory: base,
@@ -1482,8 +1468,8 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
             deferredCaptures = deferred.map(c => `- **${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.";
     return loadPrompt("reassess-roadmap", {
@@ -1660,9 +1646,7 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
                             .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
                     incompleteTasks = [];

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

@@ -12,7 +12,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, nativeCheckoutTheirs, nativeAddPaths, nativeMergeAbort, nativeResetHard, } from "./native-git-bridge.js";
 import { resolveSlicePath, resolveSliceFile, resolveTasksDir, resolveTaskFiles, relMilestoneFile, relSliceFile, buildSliceFileName, resolveMilestoneFile, clearPathCache, resolveGsdRootFile, } from "./paths.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync, unlinkSync, } from "node:fs";
@@ -41,8 +40,7 @@ export function hasImplementationArtifacts(basePath) {
                 encoding: "utf-8",
             });
         }
-        catch (e) {
-            logWarning("recovery", `git rev-parse check failed: ${e.message}`);
+        catch {
             return true;
         }
         // Strategy: check `git diff --name-only` against the merge-base with the
@@ -61,9 +59,8 @@ export function hasImplementationArtifacts(basePath) {
         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.message}`);
         return true;
     }
 }
@@ -80,9 +77,8 @@ function detectMainBranch(basePath) {
         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"], {
@@ -93,13 +89,10 @@ function detectMainBranch(basePath) {
         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
 }
 /**
  * Get files changed since the branch diverged from the target branch.
@@ -114,17 +107,15 @@ function getChangedFilesSinceBranch(basePath, targetBranch) {
             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
     try {
         const result = execFileSync("git", ["log", "--name-only", "--pretty=format:", "-20", "HEAD"], { 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.message}`);
+    catch {
         return [];
     }
 }
@@ -207,9 +198,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     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;
     }
@@ -301,9 +291,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     }
                 }
             }
-            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)}`);
             }
         }
     }
@@ -336,8 +325,7 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                         if (slice && !slice.done)
                             return false;
                     }
-                    catch (e) {
-                        logWarning("recovery", `roadmap parse failed: ${e.message}`);
+                    catch {
                         return false;
                     }
                 }
@@ -386,9 +374,7 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
             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)}`);
-            }
+            catch { /* non-fatal */ }
         }
     }
     return diagnoseExpectedArtifact(unitType, unitId, base);
@@ -403,26 +389,23 @@ function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
         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)}`);
     }
 }
 /**
@@ -469,8 +452,7 @@ export function reconcileMergeState(basePath, ctx) {
                 nativeCheckoutTheirs(basePath, gsdConflicts);
                 nativeAddPaths(basePath, gsdConflicts);
             }
-            catch (e) {
-                logError("recovery", `auto-resolve .gsd/ conflicts failed: ${e.message}`);
+            catch {
                 resolved = false;
             }
             if (resolved) {
@@ -478,8 +460,7 @@ export function reconcileMergeState(basePath, ctx) {
                     nativeCommit(basePath, "chore: auto-resolve .gsd/ state file conflicts");
                     ctx.ui.notify(`Auto-resolved ${gsdConflicts.length} .gsd/ state file conflict(s) from prior merge.`, "info");
                 }
-                catch (e) {
-                    logError("recovery", `auto-commit .gsd/ conflict resolution failed: ${e.message}`);
+                catch {
                     resolved = false;
                 }
             }