gsd-pi 2.59.0 → 2.60.0-dev.2580e65

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;
                 }
             }

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

@@ -33,6 +33,7 @@ import { snapshotSkills } from "./skill-discovery.js";
 import { isDbAvailable, getMilestone } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { parseUnitId } from "./unit-id.js";
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync, } from "node:fs";
 import { join } from "node:path";
@@ -63,8 +64,9 @@ async function openProjectDbIfPresent(basePath) {
         const { openDatabase } = await import("./gsd-db.js");
         openDatabase(gsdDbPath);
     }
-    catch {
+    catch (err) {
         /* non-fatal — DB lifecycle block below will retry */
+        logWarning("engine", `DB open failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 }
 /** Guard: tracks consecutive bootstrap attempts that found phase === "complete".
@@ -140,8 +142,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 nativeAddAll(base);
                 nativeCommit(base, "chore: init gsd");
             }
-            catch {
+            catch (err) {
                 /* nothing to commit */
+                logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
             }
         }
         // Initialize GitServiceImpl
@@ -418,7 +421,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 }
             }
             catch (err) {
-                process.stderr.write(`gsd-migrate: auto-migration failed: ${err.message}\n`);
+                logError("engine", `auto-migration failed: ${err.message}`);
             }
         }
         if (existsSync(gsdDbPath) && !isDbAvailable()) {
@@ -427,7 +430,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 openDb(gsdDbPath);
             }
             catch (err) {
-                process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
+                logError("engine", `failed to open existing database: ${err.message}`);
             }
         }
         // Gate: abort bootstrap if the DB file exists but the provider is
@@ -531,8 +534,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 }
             }
         }
-        catch {
+        catch (err) {
             /* non-fatal */
+            logWarning("engine", `preflight validation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
         return true;
     }

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

@@ -15,6 +15,7 @@ import { closeoutUnit } from "./auto-unit-closeout.js";
 import { saveActivityLog } from "./activity-log.js";
 import { recoverTimedOutUnit } from "./auto-timeout-recovery.js";
 import { resolveAgentEndCancelled } from "./auto/resolve.js";
+import { logWarning, logError } from "./workflow-logger.js";
 /**
  * Set up all four supervision timers for the current unit:
  * 1. Soft timeout warning (wrapup)
@@ -70,8 +71,9 @@ export function startUnitSupervision(sctx) {
                 }
             }
         }
-        catch {
+        catch (err) {
             // Non-fatal — fall through with no estimate
+            logWarning("timer", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
         }
     }
     const estimateMinutes = taskEstimate ? parseEstimateMinutes(taskEstimate) : null;
@@ -175,13 +177,15 @@ export function startUnitSupervision(sctx) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.error(`[idle-watchdog] Unhandled error: ${message}`);
+            logError("timer", `[idle-watchdog] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
             resolveAgentEndCancelled({ message: `Idle watchdog error: ${message}`, category: "idle", isTransient: true });
             try {
                 ctx.ui.notify(`Idle watchdog error: ${message}`, "warning");
             }
-            catch { /* best effort */ }
+            catch (err) { /* best effort */
+                logWarning("timer", `notification failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }, 15000);
     // ── 3. Hard timeout ──
@@ -208,13 +212,15 @@ export function startUnitSupervision(sctx) {
         }
         catch (err) {
             const message = err instanceof Error ? err.message : String(err);
-            console.error(`[hard-timeout] Unhandled error: ${message}`);
+            logError("timer", `[hard-timeout] Unhandled error: ${message}`);
             // Unblock any pending unit promise so the auto-loop is not orphaned.
             resolveAgentEndCancelled({ message: `Hard timeout error: ${message}`, category: "timeout", isTransient: true });
             try {
                 ctx.ui.notify(`Hard timeout error: ${message}`, "warning");
             }
-            catch { /* best effort */ }
+            catch (err) { /* best effort */
+                logWarning("timer", `notification failed: ${err instanceof Error ? err.message : String(err)}`);
+            }
         }
     }, hardTimeoutMs);
     // ── 4. Context-pressure continue-here monitor ──

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

@@ -5,6 +5,7 @@
  */
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";
+import { logWarning } from "./workflow-logger.js";
 /**
  * Snapshot metrics, save activity log, and fire-and-forget memory extraction
  * for a completed unit. Returns the activity log file path (if any).
@@ -19,12 +20,13 @@ export async function closeoutUnit(ctx, basePath, unitType, unitId, startedAt, o
             const llmCallFn = buildMemoryLLMCall(ctx);
             if (llmCallFn) {
                 extractMemoriesFromUnit(activityFile, unitType, unitId, llmCallFn).catch((err) => {
-                    if (process.env.GSD_DEBUG)
-                        console.error(`[gsd] memory extraction failed for ${unitType}/${unitId}:`, err);
+                    logWarning("engine", `memory extraction failed for ${unitType}/${unitId}: ${err.message}`);
                 });
             }
         }
-        catch { /* non-fatal */ }
+        catch (err) { /* non-fatal */
+            logWarning("engine", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+        }
     }
     return activityFile ?? undefined;
 }

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

@@ -15,6 +15,7 @@ import { isDbAvailable, getTask } from "./gsd-db.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { runVerificationGate, formatFailureContext, captureRuntimeErrors, runDependencyAudit, } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
+import { logWarning } from "./workflow-logger.js";
 import { join } from "node:path";
 function isInfraVerificationFailure(stderr) {
     return /\b(ENOENT|ENOTFOUND|ETIMEDOUT|ECONNRESET|EAI_AGAIN|spawn\s+\S+\s+ENOENT|command not found)\b/i.test(stderr);
@@ -113,7 +114,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
                 }
             }
             catch (evidenceErr) {
-                process.stderr.write(`verification-evidence: write error — ${evidenceErr.message}\n`);
+                logWarning("engine", `verification-evidence write error: ${evidenceErr.message}`);
             }
         }
         const advisoryFailure = !result.passed &&
@@ -157,7 +158,7 @@ export async function runPostUnitVerification(vctx, pauseAuto) {
     }
     catch (err) {
         // Gate errors are non-fatal
-        process.stderr.write(`verification-gate: error — ${err.message}\n`);
+        logWarning("engine", `verification-gate error: ${err.message}`);
         return "continue";
     }
 }