gsd-pi 2.60.0-dev.d9052f5 → 2.61.0

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

@@ -82,11 +82,14 @@ 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,6 +495,8 @@ 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);
@@ -506,11 +508,9 @@ 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));
-            // 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
+            // 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
             if (isBacktrack) {
                 try {
                     const { executeBacktrack } = await import("../triage-resolution.js");
@@ -520,13 +520,19 @@ export async function runGuards(ic, mid) {
                     debugLog("guards", { phase: "backtrack-execution-error", error: String(e) });
                 }
             }
-            await deps.pauseAuto(ctx, pi);
+            // Mark captures as executed only after successful pause/transition
+            for (const cap of stopCaptures) {
+                markCaptureExecuted(s.basePath, cap.id);
+            }
             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;
@@ -894,7 +900,9 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
                 nextSteps: [],
             });
         }
-        catch { /* non-fatal — anchor is advisory */ }
+        catch (err) { /* non-fatal — anchor is advisory */
+            logWarning("engine", `phase anchor failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
     }
     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,6 +20,7 @@ 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").
@@ -220,8 +221,9 @@ export function updateSliceProgressCache(base, mid, activeSid) {
                     }
                 }
             }
-            catch {
+            catch (err) {
                 // Non-fatal — just omit task count
+                logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         cachedSliceProgress = {
@@ -232,8 +234,9 @@ export function updateSliceProgressCache(base, mid, activeSid) {
             taskDetails,
         };
     }
-    catch {
+    catch (err) {
         // Non-fatal — widget just won't show progress bar
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 export function getRoadmapSlicesSync() {
@@ -263,8 +266,9 @@ function refreshLastCommit(basePath) {
         }
         lastCommitFetchedAt = Date.now();
     }
-    catch {
+    catch (err) {
         // Non-fatal — just skip last commit display
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 function getLastCommit(basePath) {
@@ -300,7 +304,9 @@ function ensureWidgetModeLoaded() {
             widgetMode = saved;
         }
     }
-    catch { /* non-fatal — use default */ }
+    catch (err) { /* non-fatal — use default */
+        logWarning("dashboard", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 /** Persist widget mode to global preferences YAML. */
 function persistWidgetMode(mode) {
@@ -320,7 +326,9 @@ function persistWidgetMode(mode) {
         }
         writeFileSync(prefsPath, content, "utf-8");
     }
-    catch { /* non-fatal — mode still set in memory */ }
+    catch (err) { /* non-fatal — mode still set in memory */
+        logWarning("dashboard", `file write failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
 }
 /** Cycle to the next widget mode. Returns the new mode. */
 export function cycleWidgetMode() {
@@ -360,7 +368,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
     try {
         cachedBranch = getCurrentBranch(accessors.getBasePath());
     }
-    catch { /* not in git repo */ }
+    catch (err) { /* not in git repo */
+        logWarning("dashboard", `git branch detection failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // Cache short pwd (last 2 path segments only) + worktree/branch info
     let widgetPwd;
     {
@@ -394,7 +404,8 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 const savings = sessionId ? getRtkSessionSavings(accessors.getBasePath(), sessionId) : null;
                 cachedRtkLabel = formatRtkSavingsLabel(savings);
             }
-            catch {
+            catch (err) {
+                logWarning("dashboard", `RTK savings lookup failed: ${err instanceof Error ? err.message : String(err)}`);
                 cachedRtkLabel = null;
             }
         };
@@ -416,7 +427,9 @@ export function updateProgressWidget(ctx, unitType, unitId, state, accessors, ti
                 refreshRtkLabel();
                 cachedLines = undefined;
             }
-            catch { /* non-fatal */ }
+            catch (err) { /* non-fatal */
+                logWarning("dashboard", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }, 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 { logError } from "./workflow-logger.js";
+import { logWarning, 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,7 +564,9 @@ export const DISPATCH_RULES = [
                     }
                 }
             }
-            catch { /* fall through — don't block on DB errors */ }
+            catch (err) { /* fall through — don't block on DB errors */
+                logWarning("dispatch", `verification class check failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
             return {
                 action: "dispatch",
                 unitType: "complete-milestone",
@@ -602,8 +604,9 @@ export async function resolveDispatch(ctx) {
         const registry = getRegistry();
         return await registry.evaluateDispatch(ctx);
     }
-    catch {
+    catch (err) {
         // 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, extractTaskMetadata } from "./complexity-classifier.js";
-import { resolveModelForComplexity, escalateTier } from "./model-router.js";
+import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
+import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
@@ -68,19 +68,68 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
                         }
                     }
                 }
-                // Extract task metadata for capability scoring
-                const taskMeta = unitType === "execute-task"
-                    ? extractTaskMetadata(unitId, basePath)
-                    : undefined;
-                const routingResult = resolveModelForComplexity(classification, modelConfig, routingConfig, availableModelIds, unitType, taskMeta);
+                // 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);
+                }
                 if (routingResult.wasDowngraded) {
                     effectiveModelConfig = {
                         primary: routingResult.modelId,
                         fallbacks: routingResult.fallbacks,
                     };
                     if (verbose) {
-                        const method = routingResult.selectionMethod === "capability-scored" ? "capability-scored" : "tier-only";
-                        ctx.ui.notify(`Dynamic routing [${tierLabel(classification.tier)}]: ${routingResult.modelId} (${method} — ${classification.reason})`, "info");
+                        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");
+                        }
                     }
                 }
                 routingTierLabel = ` [${tierLabel(classification.tier)}]`;

package/dist/resources/extensions/gsd/auto-post-unit.js

@@ -208,8 +208,9 @@ export async function postUnitPreVerification(pctx, opts) {
                                     const { getTaskIssueNumberForCommit } = await import("../github-sync/sync.js");
                                     ghIssueNumber = getTaskIssueNumberForCommit(s.basePath, mid, sid, tid) ?? undefined;
                                 }
-                                catch {
+                                catch (err) {
                                     // GitHub sync not available — skip
+                                    logWarning("engine", `GitHub issue lookup failed: ${err instanceof Error ? err.message : String(err)}`);
                                 }
                                 taskContext = {
                                     taskId: `${sid}/${tid}`,
@@ -448,7 +449,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.
-                            process.stderr.write(`gsd: retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.\n`);
+                            logError("engine", `retry state-reset failed (DB unavailable): ${dbErr.message}. Run 'gsd recover' to reconcile.`);
                         }
                     }
                     // 2. Delete SUMMARY.md for the task

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

@@ -18,6 +18,7 @@ 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) {
@@ -37,7 +38,8 @@ function formatExecutorConstraints() {
         const prefs = loadEffectiveGSDPreferences();
         windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
     }
-    catch {
+    catch (e) {
+        logWarning("prompt", `resolveExecutorContextWindow failed: ${e.message}`);
         windowTokens = 200_000; // safe default
     }
     const budgets = computeBudgets(windowTokens);
@@ -161,7 +163,9 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
             // If slice not found in DB, fall through to file-based parsing
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `inlineDependencySummaries DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // If DB didn't provide depends, fall back to roadmap parsing
     if (!depends) {
         const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
@@ -233,8 +237,8 @@ export async function inlineDecisionsFromDb(base, milestoneId, scope, level) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineDecisionsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "decisions.md", "Decisions");
 }
@@ -258,8 +262,8 @@ export async function inlineRequirementsFromDb(base, sliceId, level) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineRequirementsFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "requirements.md", "Requirements");
 }
@@ -278,8 +282,8 @@ export async function inlineProjectFromDb(base) {
             }
         }
     }
-    catch {
-        // DB not available — fall through to filesystem
+    catch (err) {
+        logWarning("prompt", `inlineProjectFromDb failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return inlineGsdRootFile(base, "project.md", "Project");
 }
@@ -399,8 +403,8 @@ export function buildSkillActivationBlock(params) {
                 matched.add(normalizeSkillReference(skillName));
             }
         }
-        catch {
-            // Non-fatal — malformed task plan should not break prompt construction
+        catch (err) {
+            logWarning("prompt", `parseTaskPlanFile failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     const ordered = [...matched]
@@ -619,7 +623,9 @@ export async function checkNeedsReassessment(base, mid, state) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `checkNeedsReassessment DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback using roadmap checkboxes
     const roadmapPath = resolveMilestoneFile(base, mid, "ROADMAP");
     if (!roadmapPath)
@@ -694,7 +700,9 @@ export async function checkNeedsRunUat(base, mid, state, prefs) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `checkNeedsRunUat DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback using roadmap checkboxes
     if (!prefs?.uat_dispatch)
         return null;
@@ -1150,7 +1158,9 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
             sliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildCompleteMilestonePrompt DB lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback: parse roadmap for slice IDs when DB has no data
     if (sliceIds.length === 0 && roadmapPath) {
         const roadmapContent = await loadFile(roadmapPath);
@@ -1233,7 +1243,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             }
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt verification classes lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // Inline all slice summaries and UAT results
     let valSliceIds = [];
     try {
@@ -1242,7 +1254,9 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
             valSliceIds = getMilestoneSlices(mid).map(s => s.id);
         }
     }
-    catch { /* fall through */ }
+    catch (err) {
+        logWarning("prompt", `buildValidateMilestonePrompt slice IDs lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
     // File-based fallback: parse roadmap for slice IDs when DB has no data
     if (valSliceIds.length === 0 && roadmapPath) {
         const roadmapContent = await loadFile(roadmapPath);
@@ -1378,8 +1392,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 {
-        // Non-fatal — captures module may not be available
+    catch (err) {
+        logWarning("prompt", `loadReplanCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     return loadPrompt("replan-slice", {
         workingDirectory: base,
@@ -1468,8 +1482,8 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
             deferredCaptures = deferred.map(c => `- **${c.id}**: "${c.text}" — ${c.rationale ?? "deferred during triage"}`).join("\n");
         }
     }
-    catch {
-        // Non-fatal — captures module may not be available
+    catch (err) {
+        logWarning("prompt", `loadDeferredCaptures failed: ${err instanceof Error ? err.message : String(err)}`);
     }
     const reassessCommitInstruction = "Do not commit — .gsd/ planning docs are managed externally and not tracked in git.";
     return loadPrompt("reassess-roadmap", {
@@ -1646,7 +1660,9 @@ export async function buildRewriteDocsPrompt(mid, midTitle, activeSlice, base, o
                             .map(t => ({ id: t.id }));
                     }
                 }
-                catch { /* fall through */ }
+                catch (err) {
+                    logWarning("prompt", `buildRewriteDocsPrompt DB task lookup failed: ${err instanceof Error ? err.message : String(err)}`);
+                }
                 if (!incompleteTasks) {
                     // DB unavailable — no task data to inline
                     incompleteTasks = [];

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

@@ -12,6 +12,7 @@ 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";
@@ -40,7 +41,8 @@ export function hasImplementationArtifacts(basePath) {
                 encoding: "utf-8",
             });
         }
-        catch {
+        catch (e) {
+            logWarning("recovery", `git rev-parse check failed: ${e.message}`);
             return true;
         }
         // Strategy: check `git diff --name-only` against the merge-base with the
@@ -59,8 +61,9 @@ export function hasImplementationArtifacts(basePath) {
         const implFiles = changedFiles.filter(f => !f.startsWith(".gsd/") && !f.startsWith(".gsd\\"));
         return implFiles.length > 0;
     }
-    catch {
+    catch (e) {
         // Non-fatal — if git operations fail, don't block the pipeline
+        logWarning("recovery", `implementation artifact check failed: ${e.message}`);
         return true;
     }
 }
@@ -77,8 +80,9 @@ function detectMainBranch(basePath) {
         if (result.trim())
             return "main";
     }
-    catch {
-        // main doesn't exist
+    catch (_) {
+        // Expected — main doesn't exist, try master next
+        void _;
     }
     try {
         const result = execFileSync("git", ["rev-parse", "--verify", "master"], {
@@ -89,10 +93,13 @@ function detectMainBranch(basePath) {
         if (result.trim())
             return "master";
     }
-    catch {
-        // master doesn't exist either
+    catch (_) {
+        // Expected — master doesn't exist either
+        void _;
     }
-    return "main"; // default fallback
+    // Neither main nor master found — warn and fall back
+    logWarning("recovery", "neither main nor master branch found, defaulting to main");
+    return "main";
 }
 /**
  * Get files changed since the branch diverged from the target branch.
@@ -107,15 +114,17 @@ function getChangedFilesSinceBranch(basePath, targetBranch) {
             return result ? result.split("\n").filter(Boolean) : [];
         }
     }
-    catch {
+    catch (err) {
         // 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 {
+    catch (e) {
+        logWarning("recovery", `git log fallback failed: ${e.message}`);
         return [];
     }
 }
@@ -198,8 +207,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     return false;
             }
         }
-        catch {
+        catch (err) {
             // DB unavailable — treat as verified to avoid blocking
+            logWarning("recovery", `gate-evaluate DB check failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         return true;
     }
@@ -291,8 +301,9 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                     }
                 }
             }
-            catch {
+            catch (err) {
                 // 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)}`);
             }
         }
     }
@@ -325,7 +336,8 @@ export function verifyExpectedArtifact(unitType, unitId, base) {
                         if (slice && !slice.done)
                             return false;
                     }
-                    catch {
+                    catch (e) {
+                        logWarning("recovery", `roadmap parse failed: ${e.message}`);
                         return false;
                     }
                 }
@@ -374,7 +386,9 @@ export function writeBlockerPlaceholder(unitType, unitId, base, reason) {
             try {
                 updateTaskStatus(mid, sid, tid, "complete", new Date().toISOString());
             }
-            catch { /* non-fatal */ }
+            catch (err) { /* non-fatal */
+                logError("recovery", `DB status update failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }
     return diagnoseExpectedArtifact(unitType, unitId, base);
@@ -389,23 +403,26 @@ function abortAndResetMerge(basePath, hasMergeHead, squashMsgPath) {
         try {
             nativeMergeAbort(basePath);
         }
-        catch {
+        catch (err) {
             /* best-effort */
+            logWarning("recovery", `git merge-abort failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     else if (squashMsgPath) {
         try {
             unlinkSync(squashMsgPath);
         }
-        catch {
+        catch (err) {
             /* best-effort */
+            logWarning("recovery", `file unlink failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     try {
         nativeResetHard(basePath);
     }
-    catch {
+    catch (err) {
         /* best-effort */
+        logError("recovery", `git reset failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /**
@@ -452,7 +469,8 @@ export function reconcileMergeState(basePath, ctx) {
                 nativeCheckoutTheirs(basePath, gsdConflicts);
                 nativeAddPaths(basePath, gsdConflicts);
             }
-            catch {
+            catch (e) {
+                logError("recovery", `auto-resolve .gsd/ conflicts failed: ${e.message}`);
                 resolved = false;
             }
             if (resolved) {
@@ -460,7 +478,8 @@ 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 {
+                catch (e) {
+                    logError("recovery", `auto-commit .gsd/ conflict resolution failed: ${e.message}`);
                     resolved = false;
                 }
             }