gsd-pi 2.38.0-dev.4d4d14a → 2.38.0-dev.5492881

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

@@ -123,12 +123,18 @@ export async function postUnitPreVerification(pctx, opts) {
                 if (report.fixesApplied.length > 0) {
                     ctx.ui.notify(`Post-hook: applied ${report.fixesApplied.length} fix(es).`, "info");
                 }
-                // Proactive health tracking
-                const summary = summarizeDoctorIssues(report.issues);
+                // Proactive health tracking — filter to current milestone to avoid
+                // cross-milestone stale errors inflating the escalation counter
+                const currentMilestoneId = s.currentUnit.id.split("/")[0];
+                const milestoneIssues = currentMilestoneId
+                    ? report.issues.filter(i => i.unitId === currentMilestoneId ||
+                        i.unitId.startsWith(`${currentMilestoneId}/`))
+                    : report.issues;
+                const summary = summarizeDoctorIssues(milestoneIssues);
                 recordHealthSnapshot(summary.errors, summary.warnings, report.fixesApplied.length);
                 // Check if we should escalate to LLM-assisted heal
                 if (summary.errors > 0) {
-                    const unresolvedErrors = report.issues
+                    const unresolvedErrors = milestoneIssues
                         .filter(i => i.severity === "error" && !i.fixable)
                         .map(i => ({ code: i.code, message: i.message, unitId: i.unitId }));
                     const escalation = checkHealEscalation(summary.errors, unresolvedErrors);

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

@@ -11,8 +11,15 @@ import { resolveMilestoneFile, resolveSliceFile, resolveSlicePath, resolveTasksD
 import { resolveSkillDiscoveryMode, resolveInlineLevel, loadEffectiveGSDPreferences } from "./preferences.js";
 import { join } from "node:path";
 import { existsSync } from "node:fs";
-import { computeBudgets, resolveExecutorContextWindow } from "./context-budget.js";
+import { computeBudgets, resolveExecutorContextWindow, truncateAtSectionBoundary } from "./context-budget.js";
 import { formatDecisionsCompact, formatRequirementsCompact } from "./structured-data-formatter.js";
+// ─── Preamble Cap ─────────────────────────────────────────────────────────────
+const MAX_PREAMBLE_CHARS = 30_000;
+function capPreamble(preamble) {
+    if (preamble.length <= MAX_PREAMBLE_CHARS)
+        return preamble;
+    return truncateAtSectionBoundary(preamble, MAX_PREAMBLE_CHARS).content;
+}
 // ─── Executor Constraints ─────────────────────────────────────────────────────
 /**
  * Format executor context constraints for injection into the plan-slice prompt.
@@ -124,7 +131,6 @@ export async function inlineFileSmart(absPath, relPath, label, query, threshold
         return `### ${label}\nSource: \`${relPath}\`\n\n${content.trim()}`;
     }
     // For large files, truncate at section boundary
-    const { truncateAtSectionBoundary } = await import("./context-budget.js");
     const truncated = truncateAtSectionBoundary(content, threshold).content;
     return `### ${label}\nSource: \`${relPath}\`\n\n${truncated}`;
 }
@@ -158,7 +164,6 @@ export async function inlineDependencySummaries(mid, sid, base, budgetChars) {
     }
     const result = sections.join("\n\n");
     if (budgetChars !== undefined && result.length > budgetChars) {
-        const { truncateAtSectionBoundary } = await import("./context-budget.js");
         return truncateAtSectionBoundary(result, budgetChars).content;
     }
     return result;
@@ -525,7 +530,7 @@ export async function buildResearchMilestonePrompt(mid, midTitle, base) {
     if (knowledgeInlineRM)
         inlined.push(knowledgeInlineRM);
     inlined.push(inlineTemplate("research", "Research"));
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relMilestoneFile(base, mid, "RESEARCH");
     return loadPrompt("research-milestone", {
         workingDirectory: base,
@@ -578,7 +583,7 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         inlined.push(inlineTemplate("plan", "Slice Plan"));
         inlined.push(inlineTemplate("task-plan", "Task Plan"));
     }
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relMilestoneFile(base, mid, "ROADMAP");
     const researchOutputPath = join(base, relMilestoneFile(base, mid, "RESEARCH"));
     const secretsOutputPath = join(base, relMilestoneFile(base, mid, "SECRETS"));
@@ -626,7 +631,7 @@ export async function buildResearchSlicePrompt(mid, _midTitle, sid, sTitle, base
     const overridesInline = formatOverridesSection(activeOverrides);
     if (overridesInline)
         inlined.unshift(overridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const outputRelPath = relSliceFile(base, mid, sid, "RESEARCH");
     return loadPrompt("research-slice", {
         workingDirectory: base,
@@ -672,7 +677,7 @@ export async function buildPlanSlicePrompt(mid, _midTitle, sid, sTitle, base, le
     const planOverridesInline = formatOverridesSection(planActiveOverrides);
     if (planOverridesInline)
         inlined.unshift(planOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     // Build executor context constraints from the budget engine
     const executorContextConstraints = formatExecutorConstraints();
     const outputRelPath = relSliceFile(base, mid, sid, "PLAN");
@@ -760,7 +765,6 @@ export async function buildExecuteTaskPrompt(mid, sid, sTitle, tid, tTitle, base
     const carryForwardBudget = Math.floor(budgets.inlineContextBudgetChars * 0.4);
     let finalCarryForward = carryForwardSection;
     if (carryForwardSection.length > carryForwardBudget) {
-        const { truncateAtSectionBoundary } = await import("./context-budget.js");
         finalCarryForward = truncateAtSectionBoundary(carryForwardSection, carryForwardBudget).content;
     }
     return loadPrompt("execute-task", {
@@ -819,7 +823,7 @@ export async function buildCompleteSlicePrompt(mid, _midTitle, sid, sTitle, base
     const completeOverridesInline = formatOverridesSection(completeActiveOverrides);
     if (completeOverridesInline)
         inlined.unshift(completeOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const sliceRel = relSlicePath(base, mid, sid);
     const sliceSummaryPath = join(base, `${sliceRel}/${sid}-SUMMARY.md`);
     const sliceUatPath = join(base, `${sliceRel}/${sid}-UAT.md`);
@@ -875,7 +879,7 @@ export async function buildCompleteMilestonePrompt(mid, midTitle, base, level) {
     if (contextInline)
         inlined.push(contextInline);
     inlined.push(inlineTemplate("milestone-summary", "Milestone Summary"));
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const milestoneSummaryPath = join(base, `${relMilestonePath(base, mid)}/${mid}-SUMMARY.md`);
     return loadPrompt("complete-milestone", {
         workingDirectory: base,
@@ -942,7 +946,7 @@ export async function buildValidateMilestonePrompt(mid, midTitle, base, level) {
     const contextInline = await inlineFileOptional(contextPath, contextRel, "Milestone Context");
     if (contextInline)
         inlined.push(contextInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const validationOutputPath = join(base, `${relMilestonePath(base, mid)}/${mid}-VALIDATION.md`);
     const roadmapOutputPath = `${relMilestonePath(base, mid)}/${mid}-ROADMAP.md`;
     return loadPrompt("validate-milestone", {
@@ -990,7 +994,7 @@ export async function buildReplanSlicePrompt(mid, midTitle, sid, sTitle, base) {
     const replanOverridesInline = formatOverridesSection(replanActiveOverrides);
     if (replanOverridesInline)
         inlined.unshift(replanOverridesInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const replanPath = join(base, `${relSlicePath(base, mid, sid)}/${sid}-REPLAN.md`);
     // Build capture context for replan prompt (captures that triggered this replan)
     let captureContext = "(none)";
@@ -1030,7 +1034,7 @@ export async function buildRunUatPrompt(mid, sliceId, uatPath, uatContent, base)
     const projectInline = await inlineProjectFromDb(base);
     if (projectInline)
         inlined.push(projectInline);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const uatResultPath = join(base, relSliceFile(base, mid, sliceId, "UAT-RESULT"));
     const uatType = extractUatType(uatContent) ?? "human-experience";
     return loadPrompt("run-uat", {
@@ -1066,7 +1070,7 @@ export async function buildReassessRoadmapPrompt(mid, midTitle, completedSliceId
     const knowledgeInlineRA = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
     if (knowledgeInlineRA)
         inlined.push(knowledgeInlineRA);
-    const inlinedContext = `## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`;
+    const inlinedContext = capPreamble(`## Inlined Context (preloaded — do not re-read these files)\n\n${inlined.join("\n\n---\n\n")}`);
     const assessmentPath = join(base, relSliceFile(base, mid, completedSliceId, "ASSESSMENT"));
     // Build deferred captures context for reassess prompt
     let deferredCaptures = "(none)";

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

@@ -15,10 +15,10 @@ import { safeCopy, safeCopyRecursive } from "./safe-fs.js";
 import { gsdRoot } from "./paths.js";
 import { createWorktree, removeWorktree, worktreePath, } from "./worktree-manager.js";
 import { detectWorktreeName, nudgeGitBranchCache, } from "./worktree.js";
-import { MergeConflictError, readIntegrationBranch } from "./git-service.js";
+import { MergeConflictError, readIntegrationBranch, RUNTIME_EXCLUSION_PATHS } from "./git-service.js";
 import { parseRoadmap } from "./files.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
-import { nativeGetCurrentBranch, nativeWorkingTreeStatus, nativeAddAll, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, } from "./native-git-bridge.js";
 // ─── Module State ──────────────────────────────────────────────────────────
 /** Original project root before chdir into auto-worktree. */
 let originalBase = null;
@@ -656,7 +656,7 @@ function autoCommitDirtyState(cwd) {
         const status = nativeWorkingTreeStatus(cwd);
         if (!status)
             return false;
-        nativeAddAll(cwd);
+        nativeAddAllWithExclusions(cwd, RUNTIME_EXCLUSION_PATHS);
         const result = nativeCommit(cwd, "chore: auto-commit before milestone merge");
         return result !== null;
     }

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

@@ -3,6 +3,7 @@
  *
  * 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";
@@ -529,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/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/files.js

@@ -692,6 +692,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/git-service.js

@@ -14,7 +14,7 @@ import { gsdRoot } from "./paths.js";
 import { GIT_NO_PROMPT_ENV } from "./git-constants.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { detectWorktreeName, SLICE_BRANCH_RE, } from "./worktree.js";
-import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAll, nativeResetPaths, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
+import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeBranchExists, nativeHasChanges, nativeAddAllWithExclusions, nativeHasStagedChanges, nativeCommit, nativeRmCached, nativeUpdateRef, } from "./native-git-bridge.js";
 import { GSDError, GSD_MERGE_CONFLICT, GSD_GIT_ERROR } from "./errors.js";
 import { getErrorMessage } from "./error-utils.js";
 export const VALID_BRANCH_NAME = /^[a-zA-Z0-9_\-\/.]+$/;
@@ -261,7 +261,9 @@ export class GitServiceImpl {
             }
             this._runtimeFilesCleanedUp = true;
         }
-        // Stage everything, then unstage excluded paths.
+        // Stage everything using pathspec exclusions so excluded paths are never
+        // hashed by git. The old approach of `git add -A` followed by unstaging
+        // hangs indefinitely on repos with large untracked artifact trees (#1605).
         //
         // Exclude only RUNTIME paths from staging — not the entire .gsd/ directory.
         // When .gsd/milestones/ files are already tracked in the index (projects
@@ -271,15 +273,9 @@ export class GitServiceImpl {
         // the second half of a milestone's artifacts are never committed (#1326).
         //
         // If .gsd/ IS in .gitignore (the default for external state projects),
-        // git add -A already skips it and the reset is a harmless no-op.
-        nativeAddAll(this.basePath);
-        const runtimeExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
-        for (const exclusion of runtimeExclusions) {
-            try {
-                nativeResetPaths(this.basePath, [exclusion]);
-            }
-            catch { /* path not staged — ignore */ }
-        }
+        // git add -A already skips it and the exclusions are harmless no-ops.
+        const allExclusions = [...RUNTIME_EXCLUSION_PATHS, ...extraExclusions];
+        nativeAddAllWithExclusions(this.basePath, allExclusions);
     }
     /** Tracks whether runtime file cleanup has run this session. */
     _runtimeFilesCleanedUp = false;
@@ -440,6 +436,21 @@ export class GitServiceImpl {
         }
     }
 }
+// ─── Draft PR Creation ─────────────────────────────────────────────────────
+/**
+ * Create a draft pull request for a completed milestone using `gh pr create`.
+ * Returns the PR URL on success, or null on failure.
+ * Non-fatal: callers should treat failure as best-effort.
+ */
+export function createDraftPR(basePath, milestoneId, title, body) {
+    try {
+        const result = execSync(`gh pr create --draft --title ${JSON.stringify(title)} --body ${JSON.stringify(body)}`, { cwd: basePath, encoding: "utf8", timeout: 30000, env: GIT_NO_PROMPT_ENV });
+        return result.trim();
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Factory ───────────────────────────────────────────────────────────────
 /** Create a GitServiceImpl with the current effective git preferences. */
 export function createGitService(basePath) {

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

@@ -28,6 +28,7 @@ import { showConfirm } from "../shared/mod.js";
 import { debugLog } from "./debug-logger.js";
 import { findMilestoneIds, nextMilestoneId } from "./milestone-ids.js";
 import { parkMilestone, discardMilestone } from "./milestone-actions.js";
+import { resolveModelWithFallbacksForUnit } from "./preferences-models.js";
 // ─── Re-exports (preserve public API for existing importers) ────────────────
 export { MILESTONE_ID_RE, generateMilestoneSuffix, nextMilestoneId, extractMilestoneSeq, parseMilestoneId, milestoneIdSort, maxMilestoneNum, findMilestoneIds, } from "./milestone-ids.js";
 export { showQueue, handleQueueReorder, showQueueAdd, buildExistingMilestonesContext, } from "./guided-flow-queue.js";
@@ -153,8 +154,32 @@ function parseMilestoneSequenceFromProject(content) {
 /**
  * Read GSD-WORKFLOW.md and dispatch it to the LLM with a contextual note.
  * This is the only way the wizard triggers work — everything else is the LLM's job.
+ *
+ * When a unitType is provided, resolves the user's model preference for that
+ * phase (e.g., models.planning → "plan-milestone") and applies it before
+ * dispatching. This ensures guided-flow dispatches respect the same
+ * per-phase model preferences that auto-mode uses.
  */
-function dispatchWorkflow(pi, note, customType = "gsd-run") {
+async function dispatchWorkflow(pi, note, customType = "gsd-run", ctx, unitType) {
+    // Apply model preference for this unit type (if configured)
+    if (ctx && unitType) {
+        const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+        if (modelConfig) {
+            const availableModels = ctx.modelRegistry.getAvailable();
+            const modelsToTry = [modelConfig.primary, ...modelConfig.fallbacks];
+            for (const modelId of modelsToTry) {
+                // Resolve model from available models (same logic as auto-model-selection)
+                const model = resolveAvailableModel(modelId, availableModels, ctx.model?.provider);
+                if (!model)
+                    continue;
+                const ok = await pi.setModel(model, { persist: false });
+                if (ok) {
+                    debugLog("guided-flow-model-applied", { unitType, model: `${model.provider}/${model.id}` });
+                    break;
+                }
+            }
+        }
+    }
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");
     const workflow = readFileSync(workflowPath, "utf-8");
     pi.sendMessage({
@@ -163,6 +188,31 @@ function dispatchWorkflow(pi, note, customType = "gsd-run") {
         display: false,
     }, { triggerTurn: true });
 }
+/**
+ * Resolve a model ID string to a model object from available models.
+ * Handles "provider/model" and bare ID formats.
+ */
+function resolveAvailableModel(modelId, availableModels, currentProvider) {
+    const slashIdx = modelId.indexOf("/");
+    if (slashIdx !== -1) {
+        const maybeProvider = modelId.substring(0, slashIdx);
+        const id = modelId.substring(slashIdx + 1);
+        const knownProviders = new Set(availableModels.map(m => m.provider.toLowerCase()));
+        if (knownProviders.has(maybeProvider.toLowerCase())) {
+            const match = availableModels.find(m => m.provider.toLowerCase() === maybeProvider.toLowerCase()
+                && m.id.toLowerCase() === id.toLowerCase());
+            if (match)
+                return match;
+        }
+        // Try matching the full string as a model ID (OpenRouter-style)
+        const lower = modelId.toLowerCase();
+        return availableModels.find(m => m.id.toLowerCase() === lower
+            || `${m.provider}/${m.id}`.toLowerCase() === lower);
+    }
+    // Bare ID — prefer current provider, then first available
+    const exactProviderMatch = availableModels.find(m => m.id === modelId && m.provider === currentProvider);
+    return exactProviderMatch ?? availableModels.find(m => m.id === modelId);
+}
 /**
  * Build the discuss-and-plan prompt for a new milestone.
  * Used by all three "new milestone" paths (first ever, no active, all complete).
@@ -244,8 +294,8 @@ export async function showHeadlessMilestoneCreation(ctx, pi, basePath, seedConte
     const prompt = buildHeadlessDiscussPrompt(nextId, seedContext, basePath);
     // Set pending auto start (auto-mode triggers on "Milestone X ready." via checkAutoStartAfterDiscuss)
     pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId };
-    // Dispatch
-    dispatchWorkflow(pi, prompt);
+    // Dispatch — headless milestone creation is a planning activity
+    await dispatchWorkflow(pi, prompt, "gsd-run", ctx, "plan-milestone");
 }
 // ─── Discuss Flow ─────────────────────────────────────────────────────────────
 /**
@@ -381,23 +431,23 @@ export async function showDiscuss(ctx, pi, basePath) {
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
             pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
-            dispatchWorkflow(pi, seed, "gsd-discuss");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
             pendingAutoStart = { ctx, pi, basePath, milestoneId: mid, step: false };
-            dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-            }), "gsd-discuss");
+            }), "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: false };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         return;
     }
@@ -484,7 +534,7 @@ export async function showDiscuss(ctx, pi, basePath) {
                 continue;
         }
         const prompt = await buildDiscussSlicePrompt(mid, chosen.id, chosen.title, basePath, { rediscuss: isRediscuss });
-        dispatchWorkflow(pi, prompt, "gsd-discuss");
+        await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "plan-slice");
         // Wait for the discuss session to finish, then loop back to the picker
         await ctx.waitForIdle();
         invalidateAllCaches();
@@ -611,7 +661,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
         pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-        dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+        await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         return true;
     }
     // "back" or null
@@ -729,7 +779,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         if (isFirst) {
             // First ever — skip wizard, just ask directly
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         else {
             const choice = await showNextAction(ctx, {
@@ -747,7 +797,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             if (choice === "new_milestone") {
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
             }
         }
         return;
@@ -779,7 +829,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -825,23 +875,23 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
                 : basePrompt;
             pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
-            dispatchWorkflow(pi, seed, "gsd-discuss");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
             const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
             pendingAutoStart = { ctx, pi, basePath, milestoneId, step: stepMode };
-            dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+            await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-            }), "gsd-discuss");
+            }), "gsd-discuss", ctx, "plan-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
         }
         return;
     }
@@ -893,24 +943,24 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                     inlineTemplate("secrets-manifest", "Secrets Manifest"),
                 ].join("\n\n---\n\n");
                 const secretsOutputPath = relMilestoneFile(basePath, milestoneId, "SECRETS");
-                dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
+                await dispatchWorkflow(pi, loadPrompt("guided-plan-milestone", {
                     milestoneId, milestoneTitle, secretsOutputPath, inlinedTemplates: planMilestoneTemplates,
-                }));
+                }), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discuss") {
                 const discussMilestoneTemplates = inlineTemplate("context", "Context");
                 const structuredQuestionsAvailable = pi.getActiveTools().includes("ask_user_questions") ? "true" : "false";
-                dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
+                await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                     milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                     commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-                }));
+                }), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneId(milestoneIds, uniqueMilestoneIds);
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath));
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
             }
             else if (choice === "discard_milestone") {
                 const confirmed = await showConfirm(ctx, {
@@ -1021,18 +1071,18 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("plan", "Slice Plan"),
                 inlineTemplate("task-plan", "Task Plan"),
             ].join("\n\n---\n\n");
-            dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
+            await dispatchWorkflow(pi, loadPrompt("guided-plan-slice", {
                 milestoneId, sliceId, sliceTitle, inlinedTemplates: planSliceTemplates,
-            }));
+            }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
-            dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }));
+            await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "research") {
             const researchTemplates = inlineTemplate("research", "Research");
-            dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
+            await dispatchWorkflow(pi, loadPrompt("guided-research-slice", {
                 milestoneId, sliceId, sliceTitle, inlinedTemplates: researchTemplates,
-            }));
+            }), "gsd-run", ctx, "research-slice");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1075,9 +1125,9 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 inlineTemplate("slice-summary", "Slice Summary"),
                 inlineTemplate("uat", "UAT"),
             ].join("\n\n---\n\n");
-            dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
+            await dispatchWorkflow(pi, loadPrompt("guided-complete-slice", {
                 workingDirectory: basePath, milestoneId, sliceId, sliceTitle, inlinedTemplates: completeSliceTemplates,
-            }));
+            }), "gsd-run", ctx, "complete-slice");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -1138,15 +1188,15 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
         }
         if (choice === "execute") {
             if (hasInterrupted) {
-                dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
+                await dispatchWorkflow(pi, loadPrompt("guided-resume-task", {
                     milestoneId, sliceId,
-                }));
+                }), "gsd-run", ctx, "execute-task");
             }
             else {
                 const executeTaskTemplates = inlineTemplate("task-summary", "Task Summary");
-                dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
+                await dispatchWorkflow(pi, loadPrompt("guided-execute-task", {
                     milestoneId, sliceId, taskId, taskTitle, inlinedTemplates: executeTaskTemplates,
-                }));
+                }), "gsd-run", ctx, "execute-task");
             }
         }
         else if (choice === "status") {

package/dist/resources/extensions/gsd/native-git-bridge.js

@@ -518,6 +518,43 @@ export function nativeAddAll(basePath) {
     }
     gitFileExec(basePath, ["add", "-A"]);
 }
+/**
+ * Stage all files with pathspec exclusions (git add -A -- ':!pattern' ...).
+ * Excluded paths are never hashed by git, preventing hangs on large
+ * untracked artifact trees (57GB+, 11K+ files). See #1605.
+ *
+ * Falls back to plain `git add -A` when no exclusions are provided.
+ * Always uses the CLI path (not libgit2) because libgit2's add_all
+ * does not support pathspec exclusion syntax.
+ *
+ * When excluded paths are already covered by .gitignore, git may exit
+ * with code 1 and an "ignored by .gitignore" warning. This is harmless
+ * (the staging succeeds for all non-ignored files) and is suppressed.
+ */
+export function nativeAddAllWithExclusions(basePath, exclusions) {
+    if (exclusions.length === 0) {
+        nativeAddAll(basePath);
+        return;
+    }
+    const pathspecs = exclusions.map(e => `:!${e}`);
+    try {
+        execFileSync("git", ["add", "-A", "--", ...pathspecs], {
+            cwd: basePath,
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf-8",
+            env: GIT_NO_PROMPT_ENV,
+        });
+    }
+    catch (err) {
+        // git exits 1 when pathspec exclusions reference paths already covered
+        // by .gitignore. The staging itself succeeds — only suppress that case.
+        const stderr = err?.stderr ?? "";
+        if (stderr.includes("ignored by one of your .gitignore files")) {
+            return;
+        }
+        throw new GSDError(GSD_GIT_ERROR, `git add -A with exclusions failed in ${basePath}: ${getErrorMessage(err)}`);
+    }
+}
 /**
  * Stage specific files.
  * Native: libgit2 index add.