gsd-pi 2.59.0 → 2.60.0-dev.2580e65

package/dist/resources/extensions/gsd/commands-codebase.js

@@ -5,26 +5,32 @@
  * Subcommands: generate, update, stats, help
  */
 import { generateCodebaseMap, updateCodebaseMap, writeCodebaseMap, getCodebaseMapStats, readCodebaseMap, } from "./codebase-generator.js";
+import { loadEffectiveGSDPreferences } from "./preferences.js";
 const USAGE = "Usage: /gsd codebase [generate|update|stats]\n\n" +
-    "  generate [--max-files N]  — Generate or regenerate CODEBASE.md\n" +
-    "  update                    — Incremental update (preserves descriptions)\n" +
-    "  stats                     — Show file count, coverage, and generation time\n" +
-    "  help                      — Show this help\n\n" +
-    "With no subcommand, shows stats if a map exists or help if not.";
+    "  generate [--max-files N] [--collapse-threshold N]  — Generate or regenerate CODEBASE.md\n" +
+    "  update [--max-files N] [--collapse-threshold N]    — Incremental update (preserves descriptions)\n" +
+    "  stats                                              — Show file count, coverage, and generation time\n" +
+    "  help                                               — Show this help\n\n" +
+    "With no subcommand, shows stats if a map exists or help if not.\n\n" +
+    "Configure defaults via preferences.md:\n" +
+    "  codebase:\n" +
+    "    exclude_patterns: [\"docs/\", \"fixtures/\"]\n" +
+    "    max_files: 1000\n" +
+    "    collapse_threshold: 15";
 export async function handleCodebase(args, ctx, _pi) {
     const basePath = process.cwd();
     const parts = args.trim().split(/\s+/);
     const sub = parts[0] ?? "";
     switch (sub) {
         case "generate": {
-            const maxFiles = parseMaxFiles(args, ctx);
-            if (maxFiles === false)
+            const options = resolveCodebaseOptions(args, ctx);
+            if (options === false)
                 return; // validation failed, message already shown
             const existing = readCodebaseMap(basePath);
             const existingDescriptions = existing
                 ? (await import("./codebase-generator.js")).parseCodebaseMap(existing)
                 : undefined;
-            const result = generateCodebaseMap(basePath, { maxFiles: maxFiles ?? undefined }, existingDescriptions);
+            const result = generateCodebaseMap(basePath, options, existingDescriptions);
             if (result.fileCount === 0) {
                 ctx.ui.notify("Codebase map generated with 0 files.\n" +
                     "Is this a git repository? Run 'git ls-files' to verify.", "warning");
@@ -42,10 +48,10 @@ export async function handleCodebase(args, ctx, _pi) {
                 ctx.ui.notify("No codebase map found. Run /gsd codebase generate to create one.", "warning");
                 return;
             }
-            const maxFiles = parseMaxFiles(args, ctx);
-            if (maxFiles === false)
+            const options = resolveCodebaseOptions(args, ctx);
+            if (options === false)
                 return;
-            const result = updateCodebaseMap(basePath, { maxFiles: maxFiles ?? undefined });
+            const result = updateCodebaseMap(basePath, options);
             writeCodebaseMap(basePath, result.content);
             ctx.ui.notify(`Codebase map updated: ${result.fileCount} files\n` +
                 `  Added: ${result.added} | Removed: ${result.removed} | Unchanged: ${result.unchanged}` +
@@ -93,19 +99,40 @@ function showStats(basePath, ctx) {
             : `Coverage is complete.`), "info");
 }
 /**
- * Parse and validate --max-files flag.
- * Returns the parsed number, undefined if flag not present, or false if invalid.
+ * Resolve codebase map options by merging preferences with CLI flags.
+ * CLI flags override preferences; preferences override built-in defaults.
+ * Returns false if validation failed (error already shown to user).
  */
-function parseMaxFiles(args, ctx) {
+function resolveCodebaseOptions(args, ctx) {
+    // Load preferences defaults
+    const prefs = loadEffectiveGSDPreferences()?.preferences?.codebase;
+    // Parse CLI flags
     const maxFilesStr = extractFlag(args, "--max-files");
-    if (!maxFilesStr)
-        return undefined;
-    const maxFiles = parseInt(maxFilesStr, 10);
-    if (isNaN(maxFiles) || maxFiles < 1) {
-        ctx.ui.notify("--max-files must be a positive integer (e.g. --max-files 200).", "warning");
-        return false;
+    const collapseStr = extractFlag(args, "--collapse-threshold");
+    // Validate --max-files
+    let maxFiles;
+    if (maxFilesStr) {
+        maxFiles = parseInt(maxFilesStr, 10);
+        if (isNaN(maxFiles) || maxFiles < 1) {
+            ctx.ui.notify("--max-files must be a positive integer (e.g. --max-files 200).", "warning");
+            return false;
+        }
+    }
+    // Validate --collapse-threshold
+    let collapseThreshold;
+    if (collapseStr) {
+        collapseThreshold = parseInt(collapseStr, 10);
+        if (isNaN(collapseThreshold) || collapseThreshold < 1) {
+            ctx.ui.notify("--collapse-threshold must be a positive integer (e.g. --collapse-threshold 15).", "warning");
+            return false;
+        }
     }
-    return maxFiles;
+    return {
+        // CLI flags override preferences
+        maxFiles: maxFiles ?? prefs?.max_files,
+        collapseThreshold: collapseThreshold ?? prefs?.collapse_threshold,
+        excludePatterns: prefs?.exclude_patterns,
+    };
 }
 function extractFlag(args, flag) {
     const escaped = flag.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");

package/dist/resources/extensions/gsd/commands-inspect.js

@@ -6,6 +6,7 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+import { logWarning } from "./workflow-logger.js";
 import { getErrorMessage } from "./error-utils.js";
 export function formatInspectOutput(data) {
     const lines = [];
@@ -71,7 +72,7 @@ export async function handleInspect(ctx) {
         ctx.ui.notify(formatInspectOutput(data), "info");
     }
     catch (err) {
-        process.stderr.write(`gsd-db: /gsd inspect failed: ${getErrorMessage(err)}\n`);
+        logWarning("command", `/gsd inspect failed: ${getErrorMessage(err)}`);
         ctx.ui.notify("Failed to inspect GSD database. Check stderr for details.", "error");
     }
 }

package/dist/resources/extensions/gsd/commands-maintenance.js

@@ -5,12 +5,14 @@
  */
 import { deriveState } from "./state.js";
 import { nativeBranchList, nativeDetectMainBranch, nativeBranchListMerged, nativeBranchDelete, nativeForEachRef, nativeUpdateRef } from "./native-git-bridge.js";
+import { logWarning } from "./workflow-logger.js";
 export async function handleCleanupBranches(ctx, basePath) {
     let branches;
     try {
         branches = nativeBranchList(basePath, "gsd/*");
     }
-    catch {
+    catch (e) {
+        logWarning("command", `branch list failed: ${e.message}`);
         ctx.ui.notify("No GSD branches to clean up.", "info");
         return;
     }
@@ -20,7 +22,8 @@ export async function handleCleanupBranches(ctx, basePath) {
     try {
         merged = nativeBranchListMerged(basePath, mainBranch, "gsd/*");
     }
-    catch {
+    catch (e) {
+        logWarning("command", `merged branch list failed: ${e.message}`);
         merged = [];
     }
     const mergedNonQuick = merged.filter((b) => !b.startsWith("gsd/quick/"));
@@ -30,8 +33,8 @@ export async function handleCleanupBranches(ctx, basePath) {
             nativeBranchDelete(basePath, branch, false);
             deletedMerged++;
         }
-        catch {
-            /* skip branches that cannot be deleted */
+        catch (e) {
+            logWarning("command", `branch delete failed for ${branch}: ${e.message}`);
         }
     }
     // Also delete stale milestone branches for completed milestones when detached
@@ -61,7 +64,9 @@ export async function handleCleanupBranches(ctx, basePath) {
                         nativeBranchDelete(basePath, branch, true);
                         deletedStaleMilestones++;
                     }
-                    catch { /* non-fatal */ }
+                    catch (e) {
+                        logWarning("command", `stale milestone branch delete failed for ${branch}: ${e.message}`);
+                    }
                     continue;
                 }
             }
@@ -73,7 +78,8 @@ export async function handleCleanupBranches(ctx, basePath) {
             try {
                 roadmapContent = await loadFile(roadmapPath);
             }
-            catch {
+            catch (e) {
+                logWarning("command", `loadFile failed for ${roadmapPath}: ${e.message}`);
                 roadmapContent = null;
             }
             if (!roadmapContent)
@@ -84,13 +90,13 @@ export async function handleCleanupBranches(ctx, basePath) {
                 nativeBranchDelete(basePath, branch, true);
                 deletedStaleMilestones++;
             }
-            catch {
-                /* non-fatal */
+            catch (e) {
+                logWarning("command", `milestone branch delete failed for ${branch}: ${e.message}`);
             }
         }
     }
-    catch {
-        /* non-fatal */
+    catch (e) {
+        logWarning("command", `stale milestone cleanup failed: ${e.message}`);
     }
     const summary = [];
     if (deletedMerged > 0) {
@@ -116,7 +122,8 @@ export async function handleCleanupSnapshots(ctx, basePath) {
     try {
         refs = nativeForEachRef(basePath, "refs/gsd/snapshots/");
     }
-    catch {
+    catch (e) {
+        logWarning("command", `snapshot ref list failed: ${e.message}`);
         ctx.ui.notify("No snapshot refs to clean up.", "info");
         return;
     }
@@ -140,8 +147,8 @@ export async function handleCleanupSnapshots(ctx, basePath) {
                 nativeUpdateRef(basePath, old);
                 pruned++;
             }
-            catch {
-                /* skip individual failures */
+            catch (e) {
+                logWarning("command", `snapshot ref update failed for ${old}: ${e.message}`);
             }
         }
     }
@@ -155,7 +162,8 @@ export async function handleCleanupWorktrees(ctx, basePath) {
     try {
         statuses = getAllWorktreeHealth(basePath);
     }
-    catch {
+    catch (e) {
+        logWarning("command", `worktree health inspection failed: ${e.message}`);
         ctx.ui.notify("Failed to inspect worktrees.", "error");
         return;
     }
@@ -185,7 +193,8 @@ export async function handleCleanupWorktrees(ctx, basePath) {
                 lines.push(`  ✓ ${wt.name}  removed (branch ${wt.branch} deleted)`);
                 removed++;
             }
-            catch {
+            catch (e) {
+                logWarning("command", `worktree removal failed for ${wt.name}: ${e.message}`);
                 lines.push(`  ✗ ${wt.name}  failed to remove`);
             }
         }
@@ -228,7 +237,9 @@ export async function handleSkip(unitArg, ctx, basePath) {
             keys = JSON.parse(readFile(completedKeysFile, "utf-8"));
         }
     }
-    catch { /* start fresh */ }
+    catch (e) {
+        logWarning("command", `completed-units.json parse failed: ${e.message}`);
+    }
     // Normalize: accept "execute-task/M001/S01/T03", "M001/S01/T03", or just "T03"
     let skipKey = unitArg;
     if (!skipKey.includes("execute-task") && !skipKey.includes("plan-") && !skipKey.includes("research-") && !skipKey.includes("complete-")) {
@@ -339,7 +350,8 @@ export async function handleCleanupProjects(args, ctx) {
             .filter(e => e.isDirectory())
             .map(e => e.name);
     }
-    catch {
+    catch (e) {
+        logWarning("command", `readdir failed for project-state directory: ${e.message}`);
         ctx.ui.notify(`Failed to read project-state directory at ${projectsDir}.`, "error");
         return;
     }
@@ -413,7 +425,8 @@ export async function handleCleanupProjects(args, ctx) {
                 fsRmSync(pathJoin(projectsDir, e.hash), { recursive: true, force: true });
                 removed++;
             }
-            catch {
+            catch (err) {
+                logWarning("command", `project cleanup rm failed for ${e.hash}: ${err.message}`);
                 failed.push(e.hash);
             }
         }
@@ -479,7 +492,7 @@ export async function handleRecover(ctx, basePath) {
     }
     catch (err) {
         const msg = err instanceof Error ? err.message : String(err);
-        process.stderr.write(`gsd-recover: failed: ${msg}\n`);
+        logWarning("command", `recover failed: ${msg}`);
         ctx.ui.notify(`gsd recover failed: ${msg}`, "error");
     }
 }

package/dist/resources/extensions/gsd/complexity-classifier.js

@@ -38,15 +38,18 @@ const UNIT_TYPE_TIERS = {
 export function classifyUnitComplexity(unitType, unitId, basePath, budgetPct, metadata) {
     // Hook units default to light
     if (unitType.startsWith("hook/")) {
-        const result = { tier: "light", reason: "hook unit", downgraded: false };
+        const result = { 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;
     // 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;
     }
@@ -59,13 +62,14 @@ export function classifyUnitComplexity(unitType, unitId, basePath, budgetPct, me
         }
     }
     // 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 = { tier, reason, downgraded: false };
+    const result = { tier, reason, downgraded: false, taskMetadata: taskMeta };
     return applyBudgetPressure(result, budgetPct);
 }
 /**
@@ -149,7 +153,7 @@ function analyzePlanComplexity(unitId, basePath) {
 /**
  * Extract task metadata from the task plan file on disk.
  */
-function extractTaskMetadata(unitId, basePath) {
+export function extractTaskMetadata(unitId, basePath) {
     const meta = {};
     const { milestone: mid, slice: sid, task: tid } = parseUnitId(unitId);
     if (!mid || !sid || !tid)

package/dist/resources/extensions/gsd/context-masker.js

@@ -0,0 +1,68 @@
+/**
+ * Observation masking for GSD auto-mode sessions.
+ *
+ * Replaces tool result content older than N turns with a placeholder.
+ * Reduces context bloat between compactions with zero LLM overhead.
+ * Preserves message ordering, roles, and all assistant/user messages.
+ *
+ * Operates on the pi-ai Message[] format (post-convertToLlm, pre-provider):
+ *   - toolResult messages: { role: "toolResult", content: TextContent[] }
+ *   - bash results are already converted to: { role: "user", content: [{type:"text",text:"..."}] }
+ *     and start with "Ran `" from bashExecutionToText.
+ */
+const MASK_PLACEHOLDER = "[result masked — within summarized history]";
+const MASK_CONTENT_BLOCK = [{ type: "text", text: MASK_PLACEHOLDER }];
+function findTurnBoundary(messages, keepRecentTurns) {
+    let turnsSeen = 0;
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const m = messages[i];
+        // In the LLM payload, genuine user turns have role "user".
+        // Tool results have role "toolResult" and are excluded by this check.
+        if (m.role === "user") {
+            // Skip bash-result user messages (converted from bashExecution) — these aren't real user turns
+            if (isBashResultUserMessage(m))
+                continue;
+            turnsSeen++;
+            if (turnsSeen >= keepRecentTurns)
+                return i;
+        }
+    }
+    return 0;
+}
+/**
+ * Detect user messages that originated from bashExecution.
+ * After convertToLlm, these are {role: "user", content: [{type:"text", text:"Ran `cmd`\n..."}]}.
+ * The bashExecutionToText format always starts with "Ran `".
+ */
+function isBashResultUserMessage(m) {
+    if (m.role !== "user" || !Array.isArray(m.content))
+        return false;
+    const first = m.content[0];
+    return first && typeof first === "object" && "text" in first &&
+        typeof first.text === "string" && first.text.startsWith("Ran `");
+}
+function isMaskableMessage(m) {
+    // Tool result messages (role: "toolResult" in pi-ai format)
+    if (m.role === "toolResult")
+        return true;
+    // Bash-result user messages (converted from bashExecution by convertToLlm)
+    if (isBashResultUserMessage(m))
+        return true;
+    return false;
+}
+export function createObservationMask(keepRecentTurns = 8) {
+    return (messages) => {
+        const boundary = findTurnBoundary(messages, keepRecentTurns);
+        if (boundary === 0)
+            return messages;
+        return messages.map((m, i) => {
+            if (i >= boundary)
+                return m;
+            if (isMaskableMessage(m)) {
+                // Content may be string or array of content blocks — always replace with array
+                return { ...m, content: MASK_CONTENT_BLOCK };
+            }
+            return m;
+        });
+    };
+}

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

@@ -16,6 +16,7 @@
  * - content-heuristic logs the specific failure (missing file, below minSize, pattern mismatch).
  * - 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 { resolve, sep } from "node:path";
 import { spawnSync } from "node:child_process";
@@ -105,8 +106,8 @@ function handleContentHeuristic(runDir, step, verify) {
                     return "pause";
                 }
             }
-            catch {
-                // Invalid regex at runtime — treat as verification failure
+            catch (e) {
+                logWarning("engine", `content-heuristic regex failed: ${e.message}`);
                 return "pause";
             }
         }

package/dist/resources/extensions/gsd/docs/preferences-reference.md

@@ -189,6 +189,13 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
   - `budget_pressure`: boolean — downgrade model tier when budget is under pressure. Default: `true`.
   - `cross_provider`: boolean — allow routing across different providers. Default: `true`.
   - `hooks`: boolean — enable routing hooks. Default: `true`.
+  - `capability_routing`: boolean — enable capability-profile scoring for model selection within a tier. Requires `enabled: true`. Default: `false`.
+
+- `context_management`: configures context hygiene for auto-mode sessions. Keys:
+  - `observation_masking`: boolean — mask old tool results to reduce context bloat. Default: `true`.
+  - `observation_mask_turns`: number — keep this many recent turns verbatim (1-50). Default: `8`.
+  - `compaction_threshold_percent`: number — trigger compaction at this % of context window (0.5-0.95). Lower values fire compaction earlier, reducing drift. Default: `0.70`.
+  - `tool_result_max_chars`: number — max chars per tool result in GSD sessions (200-10000). Default: `800`.
 
 - `auto_visualize`: boolean — show a visualizer hint after each milestone completion in auto-mode. Default: `false`.
 

package/dist/resources/extensions/gsd/gsd-db.js

@@ -8,7 +8,7 @@ import { createRequire } from "node:module";
 import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 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);
 let providerName = null;
 let providerModule = null;
@@ -710,7 +710,9 @@ export function openDatabase(path) {
                 try {
                     adapter.close();
                 }
-                catch { /* swallow */ }
+                catch (e) {
+                    logWarning("db", `close after VACUUM failed: ${e.message}`);
+                }
                 throw retryErr;
             }
         }
@@ -718,7 +720,9 @@ export function openDatabase(path) {
             try {
                 adapter.close();
             }
-            catch { /* swallow */ }
+            catch (e) {
+                logWarning("db", `close after VACUUM failed: ${e.message}`);
+            }
             throw err;
         }
     }
@@ -730,7 +734,9 @@ export function openDatabase(path) {
         process.on("exit", () => { try {
             closeDatabase();
         }
-        catch { } });
+        catch (e) {
+            logWarning("db", `exit handler close failed: ${e.message}`);
+        } });
     }
     return true;
 }
@@ -739,17 +745,21 @@ export function closeDatabase() {
         try {
             currentDb.exec('PRAGMA wal_checkpoint(TRUNCATE)');
         }
-        catch { /* non-fatal — best effort before close */ }
+        catch (e) {
+            logWarning("db", `WAL checkpoint failed: ${e.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.message}`);
+        }
         try {
             currentDb.close();
         }
-        catch {
-            // swallow close errors
+        catch (e) {
+            logWarning("db", `database close failed: ${e.message}`);
         }
         currentDb = null;
         currentPath = null;
@@ -763,7 +773,9 @@ export function vacuumDatabase() {
     try {
         currentDb.exec('VACUUM');
     }
-    catch { /* non-fatal */ }
+    catch (e) {
+        logWarning("db", `VACUUM failed: ${e.message}`);
+    }
 }
 let _txDepth = 0;
 export function transaction(fn) {
@@ -961,7 +973,9 @@ export function clearArtifacts() {
     try {
         currentDb.exec("DELETE FROM artifacts");
     }
-    catch { /* cache clear is best effort */ }
+    catch (e) {
+        logWarning("db", `clearArtifacts failed: ${e.message}`);
+    }
 }
 export function insertArtifact(a) {
     if (!currentDb)
@@ -1374,11 +1388,11 @@ export function getActiveSliceFromDb(milestoneId) {
     // Uses json_each() to expand the JSON depends array and checks each dep is complete.
     const row = currentDb.prepare(`SELECT s.* FROM slices s
      WHERE s.milestone_id = :mid
-       AND s.status NOT IN ('complete', 'done')
+       AND s.status NOT IN ('complete', 'done', 'skipped')
        AND NOT EXISTS (
          SELECT 1 FROM json_each(s.depends) AS dep
          WHERE dep.value NOT IN (
-           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done')
+           SELECT id FROM slices WHERE milestone_id = :mid AND status IN ('complete', 'done', 'skipped')
          )
        )
      ORDER BY s.sequence, s.id
@@ -1488,7 +1502,9 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
         if (realpathSync(mainDbPath) === realpathSync(worktreeDbPath))
             return zero;
     }
-    catch { /* path resolution failed — fall through to existing checks */ }
+    catch (e) {
+        logWarning("db", `realpathSync failed: ${e.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.
@@ -1610,7 +1626,9 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
                 try {
                     adapter.exec("ROLLBACK");
                 }
-                catch { /* best effort */ }
+                catch (e) {
+                    logWarning("db", `rollback failed: ${e.message}`);
+                }
                 throw txErr;
             }
             return { ...merged, conflicts };
@@ -1619,7 +1637,9 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
             try {
                 adapter.exec("DETACH DATABASE wt");
             }
-            catch { /* best effort */ }
+            catch (e) {
+                logWarning("db", `detach worktree DB failed: ${e.message}`);
+            }
         }
     }
     catch (err) {

package/dist/resources/extensions/gsd/guided-flow.js

@@ -37,6 +37,7 @@ import { selectAndApplyModel } from "./auto-model-selection.js";
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, reserveMilestoneId, claimReservedId, getReservedMilestoneIds, clearReservedMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
 import { getErrorMessage } from "./error-utils.js";
+import { logWarning } from "./workflow-logger.js";
 // ─── ID Generation with Reservation ─────────────────────────────────────────
 /**
  * Generate the next milestone ID, accounting for reserved IDs, and reserve it.
@@ -144,7 +145,9 @@ export function checkAutoStartAfterDiscuss() {
                 }
             }
         }
-        catch { /* non-fatal — PROJECT.md parsing failure shouldn't block auto-start */ }
+        catch (e) {
+            logWarning("guided", `PROJECT.md parsing failed: ${e.message}`);
+        }
     }
     // Gate 4: Discussion manifest process verification (multi-milestone only)
     // The LLM writes DISCUSSION-MANIFEST.json after each Phase 3 gate decision.
@@ -171,7 +174,9 @@ export function checkAutoStartAfterDiscuss() {
                 }
             }
         }
-        catch { /* malformed manifest — warn but don't block */ }
+        catch (e) {
+            logWarning("guided", `discussion manifest verification failed: ${e.message}`);
+        }
     }
     // Draft promotion cleanup: if a CONTEXT-DRAFT.md exists alongside the new
     // CONTEXT.md, delete the draft — it's been consumed by the discussion.
@@ -180,18 +185,21 @@ export function checkAutoStartAfterDiscuss() {
         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.message}`);
+    }
     // Cleanup: remove discussion manifest after auto-start (only needed during discussion)
     try {
         unlinkSync(manifestPath);
     }
-    catch { /* may not exist for single-milestone */ }
+    catch (e) {
+        logWarning("guided", `manifest unlink failed: ${e.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;
@@ -744,8 +752,8 @@ function selfHealRuntimeRecords(basePath, ctx) {
         }
         return { cleared };
     }
-    catch {
-        // Non-fatal — self-heal should never block the wizard
+    catch (e) {
+        logWarning("guided", `self-heal stale runtime records failed: ${e.message}`);
         return { cleared: 0 };
     }
 }
@@ -952,7 +960,9 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                         return;
                     }
                 }
-                catch { /* directory exists but unreadable — fall through to normal flow */ }
+                catch (e) {
+                    logWarning("guided", `directory read failed: ${e.message}`);
+                }
             }
         }
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;

package/dist/resources/extensions/gsd/init-wizard.js

@@ -13,6 +13,7 @@ import { ensureGitignore, untrackRuntimeFiles } from "./gitignore.js";
 import { gsdRoot } from "./paths.js";
 import { assertSafeDirectory } from "./validate-directory.js";
 import { runSkillInstallStep } from "./skill-catalog.js";
+import { generateCodebaseMap, writeCodebaseMap } from "./codebase-generator.js";
 // ─── Defaults ───────────────────────────────────────────────────────────────────
 const DEFAULT_PREFS = {
     mode: "solo",
@@ -189,6 +190,17 @@ export async function showProjectInit(ctx, pi, basePath, detection) {
     // Ensure .gitignore
     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 };
 }