gsd-pi 2.60.0 → 2.61.0-dev.7aed0bf

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

@@ -27,6 +27,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 ─────────────────────────────────────────────────────────────
 
@@ -49,7 +50,8 @@ function formatExecutorConstraints(): string {
   try {
     const prefs = loadEffectiveGSDPreferences();
     windowTokens = resolveExecutorContextWindow(undefined, prefs?.preferences);
-  } catch {
+  } catch (e) {
+    logWarning("prompt", `resolveExecutorContextWindow failed: ${(e as Error).message}`);
     windowTokens = 200_000; // safe default
   }
   const budgets = computeBudgets(windowTokens);
@@ -198,7 +200,9 @@ export async function inlineDependencySummaries(
       }
       // 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) {
@@ -276,8 +280,8 @@ export async function inlineDecisionsFromDb(
         return `### Decisions\nSource: \`.gsd/DECISIONS.md\`\n\n${formatted}`;
       }
     }
-  } 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");
 }
@@ -303,8 +307,8 @@ export async function inlineRequirementsFromDb(
         return `### Requirements\nSource: \`.gsd/REQUIREMENTS.md\`\n\n${formatted}`;
       }
     }
-  } 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");
 }
@@ -325,8 +329,8 @@ export async function inlineProjectFromDb(
         return `### Project\nSource: \`.gsd/PROJECT.md\`\n\n${content}`;
       }
     }
-  } 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");
 }
@@ -486,8 +490,8 @@ export function buildSkillActivationBlock(params: {
       for (const skillName of taskPlan.frontmatter.skills_used) {
         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)}`);
     }
   }
 
@@ -736,7 +740,9 @@ export async function checkNeedsReassessment(
         return { sliceId: lastCompleted };
       }
     }
-  } 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");
@@ -802,7 +808,9 @@ export async function checkNeedsRunUat(
         return { sliceId: sid, uatType };
       }
     }
-  } 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;
@@ -1312,7 +1320,9 @@ export async function buildCompleteMilestonePrompt(
     if (isDbAvailable()) {
       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);
@@ -1393,7 +1403,9 @@ export async function buildValidateMilestonePrompt(
         }
       }
     }
-  } 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: string[] = [];
@@ -1402,7 +1414,9 @@ export async function buildValidateMilestonePrompt(
     if (isDbAvailable()) {
       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);
@@ -1541,8 +1555,8 @@ export async function buildReplanSlicePrompt(
         `- **${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", {
@@ -1642,8 +1656,8 @@ export async function buildReassessRoadmapPrompt(
         `- **${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.";
@@ -1859,7 +1873,9 @@ export async function buildRewriteDocsPrompt(
               .filter(t => t.status !== "complete" && t.status !== "done")
               .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
@@ -1911,3 +1927,4 @@ export async function buildRewriteDocsPrompt(
     overridesPath: relGsdRootFile("OVERRIDES"),
   });
 }
+

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

@@ -15,6 +15,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,
@@ -72,7 +73,8 @@ export function hasImplementationArtifacts(basePath: string): boolean {
         stdio: ["ignore", "pipe", "pipe"],
         encoding: "utf-8",
       });
-    } catch {
+    } catch (e) {
+      logWarning("recovery", `git rev-parse check failed: ${(e as Error).message}`);
       return true;
     }
 
@@ -92,8 +94,9 @@ 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 {
+  } catch (e) {
     // Non-fatal — if git operations fail, don't block the pipeline
+    logWarning("recovery", `implementation artifact check failed: ${(e as Error).message}`);
     return true;
   }
 }
@@ -109,8 +112,9 @@ function detectMainBranch(basePath: string): string {
       encoding: "utf-8",
     });
     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"], {
@@ -119,10 +123,13 @@ function detectMainBranch(basePath: string): string {
       encoding: "utf-8",
     });
     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";
 }
 
 /**
@@ -144,8 +151,9 @@ function getChangedFilesSinceBranch(basePath: string, targetBranch: string): str
       ).trim();
       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
@@ -155,7 +163,8 @@ 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 {
+  } catch (e) {
+    logWarning("recovery", `git log fallback failed: ${(e as Error).message}`);
     return [];
   }
 }
@@ -246,8 +255,9 @@ export function verifyExpectedArtifact(
       for (const gid of gateIds) {
         if (pendingIds.has(gid)) 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;
   }
@@ -335,8 +345,9 @@ export function verifyExpectedArtifact(
             }
           }
         }
-      } 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)}`);
       }
     }
   }
@@ -366,7 +377,8 @@ export function verifyExpectedArtifact(
             const roadmap = parseLegacyRoadmap(roadmapContent);
             const slice = roadmap.slices.find((s) => s.id === sid);
             if (slice && !slice.done) return false;
-          } catch {
+          } catch (e) {
+            logWarning("recovery", `roadmap parse failed: ${(e as Error).message}`);
             return false;
           }
         }
@@ -418,7 +430,9 @@ 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 { /* non-fatal */ }
+      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)}`);
+      }
     }
   }
 
@@ -439,20 +453,23 @@ function abortAndResetMerge(
   if (hasMergeHead) {
     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)}`);
   }
 }
 
@@ -500,7 +517,8 @@ export function reconcileMergeState(
       try {
         nativeCheckoutTheirs(basePath, gsdConflicts);
         nativeAddPaths(basePath, gsdConflicts);
-      } catch {
+      } catch (e) {
+        logError("recovery", `auto-resolve .gsd/ conflicts failed: ${(e as Error).message}`);
         resolved = false;
       }
       if (resolved) {
@@ -513,7 +531,8 @@ export function reconcileMergeState(
             `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 as Error).message}`);
           resolved = false;
         }
       }
@@ -592,3 +611,4 @@ export function buildLoopRemediationSteps(
   }
   return null;
 }
+

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

@@ -66,6 +66,7 @@ import {
   isDebugEnabled,
   getDebugLogPath,
 } from "./debug-logger.js";
+import { logWarning, logError } from "./workflow-logger.js";
 import { parseUnitId } from "./unit-id.js";
 import type { AutoSession } from "./auto/session.js";
 import {
@@ -112,8 +113,9 @@ async function openProjectDbIfPresent(basePath: string): Promise<void> {
   try {
     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)}`);
   }
 }
 
@@ -213,8 +215,9 @@ export async function bootstrapAutoSession(
       try {
         nativeAddAll(base);
         nativeCommit(base, "chore: init gsd");
-      } catch {
+      } catch (err) {
         /* nothing to commit */
+        logWarning("engine", `mkdir failed: ${err instanceof Error ? err.message : String(err)}`);
       }
     }
 
@@ -575,9 +578,7 @@ export async function bootstrapAutoSession(
           migrateFromMarkdown(s.basePath);
         }
       } catch (err) {
-        process.stderr.write(
-          `gsd-migrate: auto-migration failed: ${(err as Error).message}\n`,
-        );
+        logError("engine", `auto-migration failed: ${(err as Error).message}`);
       }
     }
     if (existsSync(gsdDbPath) && !isDbAvailable()) {
@@ -585,9 +586,7 @@ export async function bootstrapAutoSession(
         const { openDatabase: openDb } = await import("./gsd-db.js");
         openDb(gsdDbPath);
       } catch (err) {
-        process.stderr.write(
-          `gsd-db: failed to open existing database: ${(err as Error).message}\n`,
-        );
+        logError("engine", `failed to open existing database: ${(err as Error).message}`);
       }
     }
 
@@ -724,8 +723,9 @@ export async function bootstrapAutoSession(
           }
         }
       }
-    } catch {
+    } catch (err) {
       /* non-fatal */
+      logWarning("engine", `preflight validation failed: ${err instanceof Error ? err.message : String(err)}`);
     }
 
     return true;
@@ -735,3 +735,4 @@ export async function bootstrapAutoSession(
     throw err;
   }
 }
+

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

@@ -24,6 +24,7 @@ import { saveActivityLog } from "./activity-log.js";
 import { recoverTimedOutUnit, type RecoveryContext } from "./auto-timeout-recovery.js";
 import { resolveAgentEndCancelled } from "./auto/resolve.js";
 import type { AutoSession } from "./auto/session.js";
+import { logWarning, logError } from "./workflow-logger.js";
 
 export interface SupervisionContext {
   s: AutoSession;
@@ -99,8 +100,9 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
           }
         }
       }
-    } 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;
@@ -214,12 +216,14 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
       await pauseAuto(ctx, pi);
     } 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);
 
@@ -248,12 +252,14 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
       await pauseAuto(ctx, pi);
     } 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);
 
@@ -311,3 +317,4 @@ export function startUnitSupervision(sctx: SupervisionContext): void {
     }
   }, 15_000);
 }
+

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

@@ -7,6 +7,7 @@
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { snapshotUnitMetrics } from "./metrics.js";
 import { saveActivityLog } from "./activity-log.js";
+import { logWarning } from "./workflow-logger.js";
 
 export interface CloseoutOptions {
   promptCharCount?: number;
@@ -38,11 +39,14 @@ export async function closeoutUnit(
       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 as Error).message}`);
         });
       }
-    } catch { /* non-fatal */ }
+    } catch (err) { /* non-fatal */
+      logWarning("engine", `operation failed: ${err instanceof Error ? err.message : String(err)}`);
+    }
   }
 
   return activityFile ?? undefined;
 }
+

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

@@ -22,6 +22,7 @@ import {
   runDependencyAudit,
 } from "./verification-gate.js";
 import { writeVerificationJSON } from "./verification-evidence.js";
+import { logWarning } from "./workflow-logger.js";
 import type { AutoSession } from "./auto/session.js";
 import { join } from "node:path";
 
@@ -159,9 +160,7 @@ export async function runPostUnitVerification(
           }
         }
       } catch (evidenceErr) {
-        process.stderr.write(
-          `verification-evidence: write error — ${(evidenceErr as Error).message}\n`,
-        );
+        logWarning("engine", `verification-evidence write error: ${(evidenceErr as Error).message}`);
       }
     }
 
@@ -217,9 +216,7 @@ export async function runPostUnitVerification(
     }
   } catch (err) {
     // Gate errors are non-fatal
-    process.stderr.write(
-      `verification-gate: error — ${(err as Error).message}\n`,
-    );
+    logWarning("engine", `verification-gate error: ${(err as Error).message}`);
     return "continue";
   }
 }