gsd-pi 2.60.0-dev.d9052f5 → 2.61.0-dev.7aed0bf

package/src/resources/extensions/gsd/complexity-classifier.ts

@@ -16,6 +16,7 @@ export interface ClassificationResult {
   tier: ComplexityTier;
   reason: string;
   downgraded: boolean;   // true if budget pressure lowered the tier
+  taskMetadata?: TaskMetadata;
 }
 
 export interface TaskMetadata {
@@ -71,17 +72,20 @@ export function classifyUnitComplexity(
 ): ClassificationResult {
   // Hook units default to light
   if (unitType.startsWith("hook/")) {
-    const result: ClassificationResult = { tier: "light", reason: "hook unit", downgraded: false };
+    const result: ClassificationResult = { tier: "light", reason: "hook unit", downgraded: false, taskMetadata: undefined };
     return applyBudgetPressure(result, budgetPct);
   }
 
   // Start with the default tier for this unit type
   let tier = UNIT_TYPE_TIERS[unitType] ?? "standard";
   let reason = `unit type: ${unitType}`;
+  let taskMeta: TaskMetadata | undefined;
 
   // For execute-task, analyze task metadata for complexity signals
   if (unitType === "execute-task") {
-    const taskAnalysis = analyzeTaskComplexity(unitId, basePath, metadata);
+    // Extract metadata once and reuse throughout to avoid double-extraction
+    taskMeta = metadata ?? extractTaskMetadata(unitId, basePath);
+    const taskAnalysis = analyzeTaskComplexity(unitId, basePath, taskMeta);
     tier = taskAnalysis.tier;
     reason = taskAnalysis.reason;
   }
@@ -96,14 +100,15 @@ export function classifyUnitComplexity(
   }
 
   // Adaptive learning: check if history suggests bumping the tier
-  const tags = metadata?.tags ?? extractTaskMetadata(unitId, basePath).tags;
+  // Use already-extracted taskMeta.tags if available to avoid double-extraction
+  const tags = taskMeta?.tags ?? metadata?.tags;
   const adaptiveAdjustment = getAdaptiveTierAdjustment(unitType, tier, tags);
   if (adaptiveAdjustment && tierOrdinal(adaptiveAdjustment) > tierOrdinal(tier)) {
     reason = `${reason} (adaptive: high failure rate at ${tier})`;
     tier = adaptiveAdjustment;
   }
 
-  const result: ClassificationResult = { tier, reason, downgraded: false };
+  const result: ClassificationResult = { tier, reason, downgraded: false, taskMetadata: taskMeta };
   return applyBudgetPressure(result, budgetPct);
 }
 

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

@@ -17,6 +17,7 @@
  * - The frozen DEFINITION.yaml on disk is the single source of truth for step policies.
  */
 
+import { logWarning } from "./workflow-logger.js";
 import { readFileSync, existsSync, statSync } from "node:fs";
 import { join, resolve, sep } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -130,8 +131,8 @@ function handleContentHeuristic(
         if (!new RegExp(verify.pattern).test(content)) {
           return "pause";
         }
-      } catch {
-        // Invalid regex at runtime — treat as verification failure
+      } catch (e) {
+        logWarning("engine", `content-heuristic regex failed: ${(e as Error).message}`);
         return "pause";
       }
     }

package/src/resources/extensions/gsd/gsd-db.ts

@@ -10,7 +10,7 @@ import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import type { Decision, Requirement, GateRow, GateId, GateScope, GateStatus, GateVerdict } from "./types.js";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
-import { logError } from "./workflow-logger.js";
+import { logError, logWarning } from "./workflow-logger.js";
 
 const _require = createRequire(import.meta.url);
 
@@ -787,11 +787,11 @@ export function openDatabase(path: string): boolean {
         initSchema(adapter, fileBacked);
         process.stderr.write("gsd-db: recovered corrupt database via VACUUM\n");
       } catch (retryErr) {
-        try { adapter.close(); } catch { /* swallow */ }
+        try { adapter.close(); } catch (e) { logWarning("db", `close after VACUUM failed: ${(e as Error).message}`); }
         throw retryErr;
       }
     } else {
-      try { adapter.close(); } catch { /* swallow */ }
+      try { adapter.close(); } catch (e) { logWarning("db", `close after VACUUM failed: ${(e as Error).message}`); }
       throw err;
     }
   }
@@ -802,7 +802,7 @@ export function openDatabase(path: string): boolean {
 
   if (!_exitHandlerRegistered) {
     _exitHandlerRegistered = true;
-    process.on("exit", () => { try { closeDatabase(); } catch {} });
+    process.on("exit", () => { try { closeDatabase(); } catch (e) { logWarning("db", `exit handler close failed: ${(e as Error).message}`); } });
   }
 
   return true;
@@ -812,16 +812,14 @@ export function closeDatabase(): void {
   if (currentDb) {
     try {
       currentDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
-    } catch { /* non-fatal — best effort before close */ }
+    } catch (e) { logWarning("db", `WAL checkpoint failed: ${(e as Error).message}`); }
     try {
       // Incremental vacuum to reclaim space without blocking
       currentDb.exec('PRAGMA incremental_vacuum(64)');
-    } catch { /* non-fatal */ }
+    } catch (e) { logWarning("db", `incremental vacuum failed: ${(e as Error).message}`); }
     try {
       currentDb.close();
-    } catch {
-      // swallow close errors
-    }
+    } catch (e) { logWarning("db", `database close failed: ${(e as Error).message}`); }
     currentDb = null;
     currentPath = null;
     currentPid = 0;
@@ -833,7 +831,7 @@ export function vacuumDatabase(): void {
   if (!currentDb) return;
   try {
     currentDb.exec('VACUUM');
-  } catch { /* non-fatal */ }
+  } catch (e) { logWarning("db", `VACUUM failed: ${(e as Error).message}`); }
 }
 
 let _txDepth = 0;
@@ -1038,7 +1036,7 @@ export function upsertRequirement(r: Requirement): void {
 
 export function clearArtifacts(): void {
   if (!currentDb) return;
-  try { currentDb.exec("DELETE FROM artifacts"); } catch { /* cache clear is best effort */ }
+  try { currentDb.exec("DELETE FROM artifacts"); } catch (e) { logWarning("db", `clearArtifacts failed: ${(e as Error).message}`); }
 }
 
 export function insertArtifact(a: {
@@ -1801,7 +1799,7 @@ export function reconcileWorktreeDb(
   // ATTACHing a WAL-mode DB to itself corrupts the WAL (#2823).
   try {
     if (realpathSync(mainDbPath) === realpathSync(worktreeDbPath)) return zero;
-  } catch { /* path resolution failed — fall through to existing checks */ }
+  } catch (e) { logWarning("db", `realpathSync failed: ${(e as Error).message}`); }
   // Sanitize path: reject any characters that could break ATTACH syntax.
   // ATTACH DATABASE doesn't support parameterized paths in all providers,
   // so we use strict allowlist validation instead.
@@ -1938,12 +1936,12 @@ export function reconcileWorktreeDb(
 
         adapter.exec("COMMIT");
       } catch (txErr) {
-        try { adapter.exec("ROLLBACK"); } catch { /* best effort */ }
+        try { adapter.exec("ROLLBACK"); } catch (e) { logWarning("db", `rollback failed: ${(e as Error).message}`); }
         throw txErr;
       }
       return { ...merged, conflicts };
     } finally {
-      try { adapter.exec("DETACH DATABASE wt"); } catch { /* best effort */ }
+      try { adapter.exec("DETACH DATABASE wt"); } catch (e) { logWarning("db", `detach worktree DB failed: ${(e as Error).message}`); }
     }
   } catch (err) {
     logError("db", "worktree DB reconciliation failed", { error: (err as Error).message });

package/src/resources/extensions/gsd/guided-flow.ts

@@ -52,6 +52,7 @@ export {
   buildExistingMilestonesContext,
 } from "./guided-flow-queue.js";
 import { getErrorMessage } from "./error-utils.js";
+import { logWarning } from "./workflow-logger.js";
 
 // ─── ID Generation with Reservation ─────────────────────────────────────────
 
@@ -180,7 +181,7 @@ export function checkAutoStartAfterDiscuss(): boolean {
           );
         }
       }
-    } catch { /* non-fatal — PROJECT.md parsing failure shouldn't block auto-start */ }
+    } catch (e) { logWarning("guided", `PROJECT.md parsing failed: ${(e as Error).message}`); }
   }
 
   // Gate 4: Discussion manifest process verification (multi-milestone only)
@@ -212,7 +213,7 @@ export function checkAutoStartAfterDiscuss(): boolean {
           );
         }
       }
-    } catch { /* malformed manifest — warn but don't block */ }
+    } catch (e) { logWarning("guided", `discussion manifest verification failed: ${(e as Error).message}`); }
   }
 
   // Draft promotion cleanup: if a CONTEXT-DRAFT.md exists alongside the new
@@ -220,16 +221,16 @@ export function checkAutoStartAfterDiscuss(): boolean {
   try {
     const draftFile = resolveMilestoneFile(basePath, milestoneId, "CONTEXT-DRAFT");
     if (draftFile) unlinkSync(draftFile);
-  } catch { /* non-fatal — stale draft doesn't break anything, CONTEXT.md wins */ }
+  } catch (e) { logWarning("guided", `CONTEXT-DRAFT.md unlink failed: ${(e as Error).message}`); }
 
   // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
-  try { unlinkSync(manifestPath); } catch { /* may not exist for single-milestone */ }
+  try { unlinkSync(manifestPath); } catch (e) { logWarning("guided", `manifest unlink failed: ${(e as Error).message}`); }
 
   pendingAutoStartMap.delete(basePath);
   ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
   startAuto(ctx, pi, basePath, false, { step }).catch((err) => {
     ctx.ui.notify(`Auto-start failed: ${getErrorMessage(err)}`, "error");
-    if (process.env.GSD_DEBUG) console.error('[gsd] auto start error:', err);
+    logWarning("guided", `auto start error: ${getErrorMessage(err)}`);
     debugLog("auto-start-failed", { error: getErrorMessage(err) });
   });
   return true;
@@ -895,8 +896,8 @@ function selfHealRuntimeRecords(basePath: string, ctx: ExtensionContext): { clea
       ctx.ui.notify(`Self-heal: cleared ${cleared} stale runtime record(s) from a previous session.`, "info");
     }
     return { cleared };
-  } catch {
-    // Non-fatal — self-heal should never block the wizard
+  } catch (e) {
+    logWarning("guided", `self-heal stale runtime records failed: ${(e as Error).message}`);
     return { cleared: 0 };
   }
 }
@@ -1142,7 +1143,7 @@ export async function showSmartEntry(
             );
             return;
           }
-        } catch { /* directory exists but unreadable — fall through to normal flow */ }
+        } catch (e) { logWarning("guided", `directory read failed: ${(e as Error).message}`); }
       }
     }
 

package/src/resources/extensions/gsd/init-wizard.ts

@@ -16,6 +16,7 @@ import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import type { ProjectDetection, ProjectSignals } from "./detection.js";
 import { runSkillInstallStep } from "./skill-catalog.js";
+import { generateCodebaseMap, writeCodebaseMap } from "./codebase-generator.js";
 
 // ─── Types ──────────────────────────────────────────────────────────────────────
 
@@ -238,6 +239,17 @@ export async function showProjectInit(
   ensureGitignore(basePath);
   untrackRuntimeFiles(basePath);
 
+  // Auto-generate codebase map for instant agent orientation
+  try {
+    const result = generateCodebaseMap(basePath);
+    if (result.fileCount > 0) {
+      writeCodebaseMap(basePath, result.content);
+      ctx.ui.notify(`Codebase map generated: ${result.fileCount} files`, "info");
+    }
+  } catch {
+    // Non-fatal — codebase map generation failure should never block project init
+  }
+
   ctx.ui.notify("GSD initialized. Starting your first milestone...", "info");
 
   return { completed: true, bootstrapped: true };

package/src/resources/extensions/gsd/markdown-renderer.ts

@@ -9,6 +9,7 @@
 // parseRoadmap(), parsePlan(), parseSummary() in files.ts.
 
 import { readFileSync, existsSync, mkdirSync } from "node:fs";
+import { logWarning } from "./workflow-logger.js";
 import { isClosedStatus } from "./status-guards.js";
 import { join, relative } from "node:path";
 import { createRequire } from "node:module";
@@ -93,9 +94,7 @@ function loadArtifactContent(
   try {
     content = readFileSync(absPath, "utf-8");
   } catch {
-    process.stderr.write(
-      `markdown-renderer: cannot read file from disk: ${absPath}\n`,
-    );
+    logWarning("renderer", `cannot read file from disk: ${absPath}`);
     return null;
   }
 
@@ -111,9 +110,7 @@ function loadArtifactContent(
     });
   } catch {
     // Non-fatal: we have the content, DB storage is best-effort
-    process.stderr.write(
-      `markdown-renderer: warning — failed to store disk fallback in DB: ${artifactPath}\n`,
-    );
+    logWarning("renderer", `failed to store disk fallback in DB: ${artifactPath}`);
   }
 
   return content;
@@ -146,9 +143,7 @@ async function writeAndStore(
     });
   } catch {
     // Non-fatal: file is on disk, DB is best-effort
-    process.stderr.write(
-      `markdown-renderer: warning — failed to update artifact in DB: ${artifactPath}\n`,
-    );
+    logWarning("renderer", `failed to update artifact in DB: ${artifactPath}`);
   }
 
   invalidateCaches();
@@ -806,7 +801,8 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
   try {
     const m = _require("./parsers-legacy.ts");
     parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
-  } catch {
+  } catch (e) {
+    logWarning("renderer", `parsers-legacy.ts require failed, falling back to .js: ${(e as Error).message}`);
     const m = _require("./parsers-legacy.js");
     parseRoadmap = m.parseRoadmap; parsePlan = m.parsePlan;
   }
@@ -841,8 +837,8 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
             });
           }
         }
-      } catch {
-        // Can't parse roadmap — skip silently
+      } catch (e) {
+        logWarning("renderer", `roadmap parse failed: ${(e as Error).message}`);
       }
     }
 
@@ -874,8 +870,8 @@ export function detectStaleRenders(basePath: string): StaleEntry[] {
               });
             }
           }
-        } catch {
-          // Can't parse plan — skip silently
+        } catch (e) {
+          logWarning("renderer", `plan parse failed: ${(e as Error).message}`);
         }
       }
 
@@ -1025,9 +1021,7 @@ export async function repairStaleRenders(basePath: string): Promise<number> {
         }
       }
     } catch (err) {
-      process.stderr.write(
-        `markdown-renderer: repair failed for ${entry.path}: ${(err as Error).message}\n`,
-      );
+      logWarning("renderer", `repair failed for ${entry.path}: ${(err as Error).message}`);
     }
   }
 

package/src/resources/extensions/gsd/md-importer.ts

@@ -31,6 +31,7 @@ import {
 import { findMilestoneIds } from './guided-flow.js';
 import { parseRoadmap, parsePlan } from './parsers-legacy.js';
 import { parseContextDependsOn } from './files.js';
+import { logWarning } from './workflow-logger.js';
 
 // ─── DECISIONS.md Parser ───────────────────────────────────────────────────
 
@@ -712,25 +713,25 @@ export function migrateFromMarkdown(gsdDir: string): {
     try {
       decisions = importDecisions(gsdDir);
     } catch (err) {
-      process.stderr.write(`gsd-migrate: skipping decisions import: ${(err as Error).message}\n`);
+      logWarning("migration", `skipping decisions import: ${(err as Error).message}`);
     }
 
     try {
       requirements = importRequirements(gsdDir);
     } catch (err) {
-      process.stderr.write(`gsd-migrate: skipping requirements import: ${(err as Error).message}\n`);
+      logWarning("migration", `skipping requirements import: ${(err as Error).message}`);
     }
 
     try {
       artifacts = importHierarchyArtifacts(gsdDir);
     } catch (err) {
-      process.stderr.write(`gsd-migrate: skipping artifacts import: ${(err as Error).message}\n`);
+      logWarning("migration", `skipping artifacts import: ${(err as Error).message}`);
     }
 
     try {
       hierarchy = migrateHierarchyToDb(gsdDir);
     } catch (err) {
-      process.stderr.write(`gsd-migrate: skipping hierarchy migration: ${(err as Error).message}\n`);
+      logWarning("migration", `skipping hierarchy migration: ${(err as Error).message}`);
     }
   });
 

package/src/resources/extensions/gsd/milestone-actions.ts

@@ -21,6 +21,7 @@ import {
 import { invalidateAllCaches } from "./cache.js";
 import { loadQueueOrder, saveQueueOrder } from "./queue-order.js";
 import { isDbAvailable, updateMilestoneStatus } from "./gsd-db.js";
+import { logWarning } from "./workflow-logger.js";
 
 // ─── Park ──────────────────────────────────────────────────────────────────
 
@@ -58,7 +59,7 @@ export function parkMilestone(basePath: string, milestoneId: string, reason: str
     try {
       updateMilestoneStatus(milestoneId, "parked");
     } catch (err) {
-      process.stderr.write(`gsd: parkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}\n`);
+      logWarning("engine", `parkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}`);
     }
   }
   invalidateAllCaches();
@@ -84,7 +85,7 @@ export function unparkMilestone(basePath: string, milestoneId: string): boolean
     try {
       updateMilestoneStatus(milestoneId, "active");
     } catch (err) {
-      process.stderr.write(`gsd: unparkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}\n`);
+      logWarning("engine", `unparkMilestone DB sync failed for ${milestoneId}: ${(err as Error).message}`);
     }
   }
   invalidateAllCaches();

package/src/resources/extensions/gsd/milestone-ids.ts

@@ -6,6 +6,7 @@
  */
 
 import { randomInt } from "node:crypto";
+import { logWarning } from "./workflow-logger.js";
 import { readdirSync, existsSync } from "node:fs";
 import { milestonesDir } from "./paths.js";
 import { loadQueueOrder, sortByQueueOrder } from "./queue-order.js";
@@ -128,7 +129,7 @@ export function findMilestoneIds(basePath: string): string[] {
   } catch (err) {
     // Log why milestone scanning failed — silent [] here causes infinite loops (#456)
     if (existsSync(dir)) {
-      console.error(`[gsd] findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
+      logWarning("engine", `findMilestoneIds: .gsd/milestones/ exists but readdirSync failed — ${getErrorMessage(err)}`);
     }
     return [];
   }