gsd-pi 2.38.0-dev.96dc7fb → 2.38.0-dev.98b44dc

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

@@ -297,116 +297,163 @@ export async function stopAuto(ctx, pi, reason) {
         return;
     const loadedPreferences = loadEffectiveGSDPreferences()?.preferences;
     const reasonSuffix = reason ? ` — ${reason}` : "";
-    clearUnitTimeout();
-    if (lockBase())
-        clearLock(lockBase());
-    if (lockBase())
-        releaseSessionLock(lockBase());
-    clearSkillSnapshot();
-    resetSkillTelemetry();
-    // Remove SIGTERM handler registered at auto-mode start
-    deregisterSigtermHandler();
-    // ── Auto-worktree: exit worktree and reset s.basePath on stop ──
-    if (s.currentMilestoneId) {
-        const notifyCtx = ctx
-            ? { notify: ctx.ui.notify.bind(ctx.ui) }
-            : { notify: () => { } };
-        buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
-            preserveBranch: true,
-        });
-    }
-    // ── DB cleanup: close the SQLite connection ──
-    if (isDbAvailable()) {
+    try {
+        // ── Step 1: Timers and locks ──
         try {
-            const { closeDatabase } = await import("./gsd-db.js");
-            closeDatabase();
+            clearUnitTimeout();
+            if (lockBase())
+                clearLock(lockBase());
+            if (lockBase())
+                releaseSessionLock(lockBase());
         }
         catch (e) {
-            debugLog("db-close-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-locks", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    if (s.originalBasePath) {
-        s.basePath = s.originalBasePath;
+        // ── Step 2: Skill state ──
         try {
-            process.chdir(s.basePath);
+            clearSkillSnapshot();
+            resetSkillTelemetry();
         }
-        catch {
-            /* best-effort */
+        catch (e) {
+            debugLog("stop-cleanup-skills", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    const ledger = getLedger();
-    if (ledger && ledger.units.length > 0) {
-        const totals = getProjectTotals(ledger.units);
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
-    }
-    else {
-        ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
-    }
-    if (s.basePath) {
+        // ── Step 3: SIGTERM handler ──
         try {
-            await rebuildState(s.basePath);
+            deregisterSigtermHandler();
         }
         catch (e) {
-            debugLog("stop-rebuild-state-failed", {
-                error: e instanceof Error ? e.message : String(e),
-            });
+            debugLog("stop-cleanup-sigterm", { error: e instanceof Error ? e.message : String(e) });
         }
-    }
-    clearCmuxSidebar(loadedPreferences);
-    logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
-    if (isDebugEnabled()) {
-        const logPath = writeDebugSummary();
-        if (logPath) {
-            ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+        // ── Step 4: Auto-worktree exit ──
+        try {
+            if (s.currentMilestoneId) {
+                const notifyCtx = ctx
+                    ? { notify: ctx.ui.notify.bind(ctx.ui) }
+                    : { notify: () => { } };
+                buildResolver().exitMilestone(s.currentMilestoneId, notifyCtx, {
+                    preserveBranch: true,
+                });
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-worktree", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 5: DB cleanup ──
+        if (isDbAvailable()) {
+            try {
+                const { closeDatabase } = await import("./gsd-db.js");
+                closeDatabase();
+            }
+            catch (e) {
+                debugLog("db-close-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 6: Restore basePath and chdir ──
+        try {
+            if (s.originalBasePath) {
+                s.basePath = s.originalBasePath;
+                try {
+                    process.chdir(s.basePath);
+                }
+                catch {
+                    /* best-effort */
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-basepath", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 7: Ledger notification ──
+        try {
+            const ledger = getLedger();
+            if (ledger && ledger.units.length > 0) {
+                const totals = getProjectTotals(ledger.units);
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}. Session: ${formatCost(totals.cost)} · ${formatTokenCount(totals.tokens.total)} tokens · ${ledger.units.length} units`, "info");
+            }
+            else {
+                ctx?.ui.notify(`Auto-mode stopped${reasonSuffix}.`, "info");
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-ledger", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 8: Rebuild state ──
+        if (s.basePath) {
+            try {
+                await rebuildState(s.basePath);
+            }
+            catch (e) {
+                debugLog("stop-rebuild-state-failed", {
+                    error: e instanceof Error ? e.message : String(e),
+                });
+            }
+        }
+        // ── Step 9: Cmux sidebar / event log ──
+        try {
+            clearCmuxSidebar(loadedPreferences);
+            logCmuxEvent(loadedPreferences, `Auto-mode stopped${reasonSuffix || ""}.`, reason?.startsWith("Blocked:") ? "warning" : "info");
+        }
+        catch (e) {
+            debugLog("stop-cleanup-cmux", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 10: Debug summary ──
+        try {
+            if (isDebugEnabled()) {
+                const logPath = writeDebugSummary();
+                if (logPath) {
+                    ctx?.ui.notify(`Debug log written → ${logPath}`, "info");
+                }
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-debug", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 11: Reset metrics, routing, hooks ──
+        try {
+            resetMetrics();
+            resetRoutingHistory();
+            resetHookState();
+            if (s.basePath)
+                clearPersistedHookState(s.basePath);
+        }
+        catch (e) {
+            debugLog("stop-cleanup-metrics", { error: e instanceof Error ? e.message : String(e) });
+        }
+        // ── Step 12: Remove paused-session metadata (#1383) ──
+        try {
+            const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
+            if (existsSync(pausedPath))
+                unlinkSync(pausedPath);
+        }
+        catch { /* non-fatal */ }
+        // ── Step 13: Restore original model (before reset clears IDs) ──
+        try {
+            if (pi && ctx && s.originalModelId && s.originalModelProvider) {
+                const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
+                if (original)
+                    await pi.setModel(original);
+            }
+        }
+        catch (e) {
+            debugLog("stop-cleanup-model", { error: e instanceof Error ? e.message : String(e) });
         }
     }
-    resetMetrics();
-    resetRoutingHistory();
-    resetHookState();
-    if (s.basePath)
-        clearPersistedHookState(s.basePath);
-    // Remove paused-session metadata if present (#1383)
-    try {
-        const pausedPath = join(gsdRoot(s.originalBasePath || s.basePath), "runtime", "paused-session.json");
-        if (existsSync(pausedPath))
-            unlinkSync(pausedPath);
-    }
-    catch { /* non-fatal */ }
-    s.active = false;
-    s.paused = false;
-    s.stepMode = false;
-    s.unitDispatchCount.clear();
-    s.unitRecoveryCount.clear();
-    clearInFlightTools();
-    s.lastBudgetAlertLevel = 0;
-    s.lastStateRebuildAt = 0;
-    s.unitLifetimeDispatches.clear();
-    s.currentUnit = null;
-    s.autoModeStartModel = null;
-    s.currentMilestoneId = null;
-    s.originalBasePath = "";
-    s.completedUnits = [];
-    s.pendingQuickTasks = [];
-    clearSliceProgressCache();
-    clearActivityLogState();
-    resetProactiveHealing();
-    s.pendingCrashRecovery = null;
-    s.pendingVerificationRetry = null;
-    s.verificationRetryCount.clear();
-    s.pausedSessionFile = null;
-    ctx?.ui.setStatus("gsd-auto", undefined);
-    ctx?.ui.setWidget("gsd-progress", undefined);
-    ctx?.ui.setFooter(undefined);
-    if (pi && ctx && s.originalModelId && s.originalModelProvider) {
-        const original = ctx.modelRegistry.find(s.originalModelProvider, s.originalModelId);
-        if (original)
-            await pi.setModel(original);
-        s.originalModelId = null;
-        s.originalModelProvider = null;
+    finally {
+        // ── Critical invariants: these MUST execute regardless of errors ──
+        // External cleanup (not covered by session reset)
+        clearInFlightTools();
+        clearSliceProgressCache();
+        clearActivityLogState();
+        resetProactiveHealing();
+        // UI cleanup
+        ctx?.ui.setStatus("gsd-auto", undefined);
+        ctx?.ui.setWidget("gsd-progress", undefined);
+        ctx?.ui.setFooter(undefined);
+        // Reset all session state in one call
+        s.reset();
     }
-    s.cmdCtx = null;
 }
 /**
  * Pause auto-mode without destroying state. Context is preserved.

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

@@ -8,12 +8,13 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Registry I/O ───────────────────────────────────────────────────────────
 function getRegistryPath() {
-    return join(homedir(), ".gsd", "extensions", "registry.json");
+    return join(gsdHome, "extensions", "registry.json");
 }
 function getAgentExtensionsDir() {
-    return join(homedir(), ".gsd", "agent", "extensions");
+    return join(gsdHome, "agent", "extensions");
 }
 function loadRegistry() {
     const filePath = getRegistryPath();

package/dist/resources/extensions/gsd/commands-prefs-wizard.js

@@ -631,7 +631,7 @@ export function serializePreferencesToFrontmatter(prefs) {
         "dynamic_routing", "token_profile", "phases", "parallel",
         "auto_visualize", "auto_report",
         "verification_commands", "verification_auto_fix", "verification_max_retries",
-        "search_provider", "compression_strategy", "context_selection",
+        "search_provider", "context_selection",
     ];
     const seen = new Set();
     for (const key of orderedKeys) {

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

@@ -3,10 +3,12 @@
  *
  * One command, one wizard. Routes to smart entry or status.
  */
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 import { existsSync, readFileSync, readdirSync, unlinkSync } from "node:fs";
 import { homedir } from "node:os";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 import { enableDebug } from "./debug-logger.js";
 import { deriveState } from "./state.js";
 import { GSDDashboardOverlay } from "./dashboard-overlay.js";
@@ -437,7 +439,7 @@ export function registerGSDCommand(pi) {
                 if (parts.length === 3 && ["enable", "disable", "info"].includes(parts[1])) {
                     const idPrefix = parts[2] ?? "";
                     try {
-                        const extDir = join(homedir(), ".gsd", "agent", "extensions");
+                        const extDir = join(gsdHome, "agent", "extensions");
                         const ids = [];
                         for (const entry of readdirSync(extDir, { withFileTypes: true })) {
                             if (!entry.isDirectory())
@@ -528,7 +530,7 @@ export async function handleGSDCommand(args, ctx, pi) {
         return;
     }
     if (trimmed === "widget" || trimmed.startsWith("widget ")) {
-        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("./auto-dashboard.js");
+        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await importExtensionModule(import.meta.url, "./auto-dashboard.js");
         const arg = trimmed.replace(/^widget\s*/, "").trim();
         if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
             setWidgetMode(arg);

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

@@ -8,7 +8,6 @@
  * @see D001 (module location), D002 (200K fallback), D003 (section-boundary truncation)
  */
 import { getCharsPerToken } from "./token-counter.js";
-import { compressToTarget } from "./prompt-compressor.js";
 // ─── Budget ratio constants ──────────────────────────────────────────────────
 // Percentages of total context window allocated to each budget category.
 // These are applied after tokens→chars conversion.
@@ -132,20 +131,13 @@ export function resolveExecutorContextWindow(registry, preferences, sessionConte
     return DEFAULT_CONTEXT_WINDOW;
 }
 /**
- * Smart context reduction: compress first, then truncate if still over budget.
- * Returns the content within budget with maximum information preservation.
+ * Reduce content to fit within budget using section-boundary truncation.
  */
 export function reduceToFit(content, budgetChars) {
     if (!content || content.length <= budgetChars) {
         return { content, droppedSections: 0 };
     }
-    // Step 1: Try compression
-    const compressed = compressToTarget(content, budgetChars);
-    if (compressed.compressedChars <= budgetChars) {
-        return { content: compressed.content, droppedSections: 0 };
-    }
-    // Step 2: Truncate the compressed content at section boundaries
-    return truncateAtSectionBoundary(compressed.content, budgetChars);
+    return truncateAtSectionBoundary(content, budgetChars);
 }
 // ─── Internal helpers ────────────────────────────────────────────────────────
 /**

package/dist/resources/extensions/gsd/detection.js

@@ -9,6 +9,7 @@ import { existsSync, readdirSync, readFileSync, statSync } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { gsdRoot } from "./paths.js";
+const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
 // ─── Project File Markers ───────────────────────────────────────────────────────
 const PROJECT_FILES = [
     "package.json",
@@ -309,7 +310,6 @@ function detectVerificationCommands(basePath, detectedFiles, packageManager) {
  * Check if global GSD setup exists (has ~/.gsd/ with preferences).
  */
 export function hasGlobalSetup() {
-    const gsdHome = join(homedir(), ".gsd");
     return (existsSync(join(gsdHome, "preferences.md")) ||
         existsSync(join(gsdHome, "PREFERENCES.md")));
 }
@@ -318,7 +318,6 @@ export function hasGlobalSetup() {
  * Returns true if ~/.gsd/ doesn't exist or has no preferences or auth.
  */
 export function isFirstEverLaunch() {
-    const gsdHome = join(homedir(), ".gsd");
     if (!existsSync(gsdHome))
         return true;
     // If we have preferences, not first launch

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

@@ -194,8 +194,6 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `search_provider`: `"brave"`, `"tavily"`, `"ollama"`, `"native"`, or `"auto"` — selects the search backend for research phases. `"native"` forces Anthropic's built-in web search only; provider values force that backend and disable native search; `"auto"` uses the default heuristic. Default: `"auto"`.
 
-- `compression_strategy`: `"truncate"` or `"compress"` — controls how context that exceeds the budget is reduced. `"truncate"` (default) drops sections from the end. `"compress"` applies heuristic compression before truncating, preserving more content at the cost of some fidelity. Default: `"truncate"`.
-
 - `context_selection`: `"full"` or `"smart"` — controls how files are inlined into context. `"full"` inlines entire files; `"smart"` uses semantic chunking to include only the most relevant sections. Default is derived from `token_profile`.
 
 - `parallel`: configures parallel orchestration for running multiple slices concurrently. Keys:

package/dist/resources/extensions/gsd/doctor-providers.js

@@ -28,10 +28,12 @@ function modelToProviderId(model) {
         const prefix = model.split("/")[0].toLowerCase();
         // Map known prefixes to registry IDs
         const prefixMap = {
+            "anthropic-vertex": "anthropic-vertex",
             openrouter: "openrouter",
             groq: "groq",
             mistral: "mistral",
             google: "google",
+            "google-vertex": "google-vertex",
             anthropic: "anthropic",
             openai: "openai",
             "github-copilot": "github-copilot",
@@ -67,11 +69,19 @@ function collectConfiguredModelProviders() {
         }
         const modelEntries = typeof models === "object" ? Object.values(models) : [];
         for (const entry of modelEntries) {
-            const modelId = typeof entry === "string" ? entry
-                : typeof entry === "object" && entry !== null && "model" in entry
-                    ? String(entry.model)
-                    : null;
-            if (modelId) {
+            if (typeof entry === "string") {
+                const pid = modelToProviderId(entry);
+                if (pid)
+                    providers.add(pid);
+                continue;
+            }
+            if (typeof entry === "object" && entry !== null && "model" in entry) {
+                const configuredProvider = "provider" in entry ? entry.provider : undefined;
+                if (typeof configuredProvider === "string" && configuredProvider.trim().length > 0) {
+                    providers.add(configuredProvider);
+                    continue;
+                }
+                const modelId = String(entry.model);
                 const pid = modelToProviderId(modelId);
                 if (pid)
                     providers.add(pid);
@@ -88,6 +98,9 @@ function collectConfiguredModelProviders() {
 }
 function resolveKey(providerId) {
     const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
+    if (providerId === "anthropic-vertex" && process.env.ANTHROPIC_VERTEX_PROJECT_ID) {
+        return { found: true, source: "env", backedOff: false };
+    }
     // Check auth.json
     const authPath = getAuthPath();
     if (existsSync(authPath)) {
@@ -138,7 +151,9 @@ function checkLlmProviders() {
     const results = [];
     for (const providerId of required) {
         const info = PROVIDER_REGISTRY.find(p => p.id === providerId);
-        const label = info?.label ?? providerId;
+        const label = providerId === "anthropic-vertex"
+            ? "Anthropic Vertex"
+            : info?.label ?? providerId;
         const lookup = resolveKey(providerId);
         if (!lookup.found) {
             // Check if a cross-provider can serve this provider's models
@@ -157,16 +172,20 @@ function checkLlmProviders() {
                 });
                 continue;
             }
-            const envVar = info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
+            const envVar = providerId === "anthropic-vertex"
+                ? "ANTHROPIC_VERTEX_PROJECT_ID"
+                : info?.envVar ?? `${providerId.toUpperCase()}_API_KEY`;
             results.push({
                 name: providerId,
                 label,
                 category: "llm",
                 status: "error",
-                message: `${label} — no API key found`,
-                detail: info?.hasOAuth
-                    ? `Run /gsd keys to authenticate`
-                    : `Set ${envVar} or run /gsd keys`,
+                message: `${label} — not configured`,
+                detail: providerId === "anthropic-vertex"
+                    ? "Set ANTHROPIC_VERTEX_PROJECT_ID and authenticate with Google ADC"
+                    : info?.hasOAuth
+                        ? `Run /gsd keys to authenticate`
+                        : `Set ${envVar} or run /gsd keys`,
                 required: true,
             });
         }

package/dist/resources/extensions/gsd/doctor.js

@@ -257,10 +257,23 @@ async function markSliceDoneInRoadmap(basePath, milestoneId, sliceId, fixesAppli
         fixesApplied.push(`marked ${sliceId} done in ${roadmapPath}`);
     }
 }
+async function markSliceUndoneInRoadmap(basePath, milestoneId, sliceId, fixesApplied) {
+    const roadmapPath = resolveMilestoneFile(basePath, milestoneId, "ROADMAP");
+    if (!roadmapPath)
+        return;
+    const content = await loadFile(roadmapPath);
+    if (!content)
+        return;
+    const updated = content.replace(new RegExp(`^(\\s*-\\s+)\\[x\\]\\s+\\*\\*${sliceId}:`, "m"), `$1[ ] **${sliceId}:`);
+    if (updated !== content) {
+        await saveFile(roadmapPath, updated);
+        fixesApplied.push(`unmarked ${sliceId} in ${roadmapPath} (premature completion)`);
+    }
+}
 function matchesScope(unitId, scope) {
     if (!scope)
         return true;
-    return unitId === scope || unitId.startsWith(`${scope}/`) || unitId.startsWith(`${scope}`);
+    return unitId === scope || unitId.startsWith(`${scope}/`);
 }
 function auditRequirements(content) {
     if (!content)
@@ -828,6 +841,12 @@ export async function runGSDDoctor(basePath, options) {
                     file: relSliceFile(basePath, milestoneId, slice.id, "SUMMARY"),
                     fixable: true,
                 });
+                if (!allTasksDone) {
+                    dryRunCanFix("slice_checked_missing_summary", `uncheck ${slice.id} in roadmap (tasks incomplete)`);
+                    if (shouldFix("slice_checked_missing_summary")) {
+                        await markSliceUndoneInRoadmap(basePath, milestoneId, slice.id, fixesApplied);
+                    }
+                }
             }
             if (slice.done && !hasSliceUat) {
                 issues.push({

package/dist/resources/extensions/gsd/exit-command.js

@@ -1,9 +1,10 @@
+import { importExtensionModule } from "@gsd/pi-coding-agent";
 export function registerExitCommand(pi, deps = {}) {
     pi.registerCommand("exit", {
         description: "Exit GSD gracefully",
         handler: async (_args, ctx) => {
             // Stop auto-mode first so locks and activity state are cleaned up before shutdown.
-            const stopAuto = deps.stopAuto ?? (await import("./auto.js")).stopAuto;
+            const stopAuto = deps.stopAuto ?? (await importExtensionModule(import.meta.url, "./auto.js")).stopAuto;
             await stopAuto(ctx, pi, "Graceful exit");
             ctx.shutdown();
         },

package/dist/resources/extensions/gsd/export.js

@@ -5,7 +5,7 @@ import { join, basename } from "node:path";
 import { exec } from "node:child_process";
 import { getLedger, getProjectTotals, aggregateByPhase, aggregateBySlice, aggregateByModel, formatCost, formatTokenCount, loadLedgerFromDisk, } from "./metrics.js";
 import { gsdRoot } from "./paths.js";
-import { formatDuration, fileLink } from "../shared/mod.js";
+import { formatDuration, fileLink } from "../shared/format-utils.js";
 import { getErrorMessage } from "./error-utils.js";
 /**
  * Open a file in the user's default browser.

package/dist/resources/extensions/gsd/files.js

@@ -6,8 +6,8 @@ import { promises as fs } from 'node:fs';
 import { resolve } from 'node:path';
 import { atomicWriteAsync } from './atomic-write.js';
 import { resolveMilestoneFile, relMilestoneFile, resolveGsdRootFile } from './paths.js';
-import { findMilestoneIds } from './guided-flow.js';
-import { checkExistingEnvKeys } from '../get-secrets-from-user.js';
+import { findMilestoneIds } from './milestone-ids.js';
+import { checkExistingEnvKeys } from '../env-utils.js';
 import { parseRoadmapSlices } from './roadmap-slices.js';
 import { nativeParseRoadmap, nativeExtractSection, nativeParsePlanFile, nativeParseSummaryFile, NATIVE_UNAVAILABLE } from './native-parser-bridge.js';
 import { debugTime, debugCount } from './debug-logger.js';
@@ -222,13 +222,48 @@ export function formatSecretsManifest(manifest) {
     return lines.join('\n') + '\n';
 }
 // ─── Slice Plan Parser ─────────────────────────────────────────────────────
+function normalizeTaskPlanFrontmatter(frontmatter) {
+    const estimatedStepsRaw = frontmatter.estimated_steps;
+    const estimatedFilesRaw = frontmatter.estimated_files;
+    const skillsUsedRaw = frontmatter.skills_used;
+    const parseOptionalNumber = (value) => {
+        if (typeof value === 'number' && Number.isFinite(value))
+            return value;
+        if (typeof value === 'string' && value.trim()) {
+            const parsed = parseInt(value, 10);
+            if (Number.isFinite(parsed))
+                return parsed;
+        }
+        return undefined;
+    };
+    const estimated_steps = parseOptionalNumber(estimatedStepsRaw);
+    const estimated_files = parseOptionalNumber(estimatedFilesRaw);
+    const skills_used = Array.isArray(skillsUsedRaw)
+        ? skillsUsedRaw.map(v => String(v).trim()).filter(Boolean)
+        : typeof skillsUsedRaw === 'string' && skillsUsedRaw.trim()
+            ? [skillsUsedRaw.trim()]
+            : [];
+    return {
+        ...(estimated_steps !== undefined ? { estimated_steps } : {}),
+        ...(estimated_files !== undefined ? { estimated_files } : {}),
+        skills_used,
+    };
+}
+export function parseTaskPlanFile(content) {
+    const [fmLines] = splitFrontmatter(content);
+    const fm = fmLines ? parseFrontmatterMap(fmLines) : {};
+    return {
+        frontmatter: normalizeTaskPlanFrontmatter(fm),
+    };
+}
 export function parsePlan(content) {
     return cachedParse(content, 'plan', _parsePlanImpl);
 }
 function _parsePlanImpl(content) {
     const stopTimer = debugTime("parse-plan");
+    const [, body] = splitFrontmatter(content);
     // Try native parser first for better performance
-    const nativeResult = nativeParsePlanFile(content);
+    const nativeResult = nativeParsePlanFile(body);
     if (nativeResult) {
         stopTimer({ native: true });
         return {
@@ -249,7 +284,7 @@ function _parsePlanImpl(content) {
             filesLikelyTouched: nativeResult.filesLikelyTouched,
         };
     }
-    const lines = content.split('\n');
+    const lines = body.split('\n');
     const h1 = lines.find(l => l.startsWith('# '));
     let id = '';
     let title = '';
@@ -263,11 +298,11 @@ function _parsePlanImpl(content) {
             title = h1.slice(2).trim();
         }
     }
-    const goal = extractBoldField(content, 'Goal') || '';
-    const demo = extractBoldField(content, 'Demo') || '';
-    const mhSection = extractSection(content, 'Must-Haves');
+    const goal = extractBoldField(body, 'Goal') || '';
+    const demo = extractBoldField(body, 'Demo') || '';
+    const mhSection = extractSection(body, 'Must-Haves');
     const mustHaves = mhSection ? parseBullets(mhSection) : [];
-    const tasksSection = extractSection(content, 'Tasks');
+    const tasksSection = extractSection(body, 'Tasks');
     const tasks = [];
     if (tasksSection) {
         const taskLines = tasksSection.split('\n');
@@ -315,7 +350,7 @@ function _parsePlanImpl(content) {
         if (currentTask)
             tasks.push(currentTask);
     }
-    const filesSection = extractSection(content, 'Files Likely Touched');
+    const filesSection = extractSection(body, 'Files Likely Touched');
     const filesLikelyTouched = filesSection ? parseBullets(filesSection) : [];
     const result = { id, title, goal, demo, mustHaves, tasks, filesLikelyTouched };
     stopTimer({ tasks: tasks.length });
@@ -692,6 +727,10 @@ export function extractUatType(content) {
     const rawValue = modeBullet.slice('UAT mode:'.length).trim().toLowerCase();
     if (rawValue.startsWith('artifact-driven'))
         return 'artifact-driven';
+    if (rawValue.startsWith('browser-executable'))
+        return 'browser-executable';
+    if (rawValue.startsWith('runtime-executable'))
+        return 'runtime-executable';
     if (rawValue.startsWith('live-runtime'))
         return 'live-runtime';
     if (rawValue.startsWith('human-experience'))

package/dist/resources/extensions/gsd/forensics.js

@@ -21,7 +21,7 @@ import { deriveState } from "./state.js";
 import { isAutoActive } from "./auto.js";
 import { loadPrompt } from "./prompt-loader.js";
 import { gsdRoot } from "./paths.js";
-import { formatDuration } from "../shared/mod.js";
+import { formatDuration } from "../shared/format-utils.js";
 import { getAutoWorktreePath } from "./auto-worktree.js";
 // ─── Entry Point ──────────────────────────────────────────────────────────────
 export async function handleForensics(args, ctx, pi) {