gsd-pi 2.38.0-dev.bc2e21e → 2.38.0-dev.d533afb

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);
@@ -138,7 +148,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 +169,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/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_\-\/.]+$/;
@@ -36,12 +36,19 @@ export function buildTaskCommitMessage(ctx) {
         : description;
     const subject = `${type}(${scope}): ${truncated}`;
     // Build body with key files if available
+    const bodyParts = [];
     if (ctx.keyFiles && ctx.keyFiles.length > 0) {
         const fileLines = ctx.keyFiles
             .slice(0, 8) // cap at 8 files to keep commit concise
             .map(f => `- ${f}`)
             .join("\n");
-        return `${subject}\n\n${fileLines}`;
+        bodyParts.push(fileLines);
+    }
+    if (ctx.issueNumber) {
+        bodyParts.push(`Resolves #${ctx.issueNumber}`);
+    }
+    if (bodyParts.length > 0) {
+        return `${subject}\n\n${bodyParts.join("\n\n")}`;
     }
     return subject;
 }
@@ -254,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
@@ -264,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;

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/index.js

@@ -66,6 +66,24 @@ function warnDeprecatedAgentInstructions() {
 }
 // ── Depth verification state ──────────────────────────────────────────────
 let depthVerificationDone = false;
+// ── DB lazy-open helper ───────────────────────────────────────────────────
+// In manual sessions (no auto-mode), the DB is never opened by bootstrapAutoSession.
+// This helper ensures the DB is lazily opened on first tool call that needs it.
+async function ensureDbOpen() {
+    try {
+        const db = await import("./gsd-db.js");
+        if (db.isDbAvailable())
+            return true;
+        const dbPath = join(process.cwd(), ".gsd", "gsd.db");
+        if (existsSync(dbPath)) {
+            return db.openDatabase(dbPath);
+        }
+        return false;
+    }
+    catch {
+        return false;
+    }
+}
 // ── Queue phase tracking ──────────────────────────────────────────────────
 // When true, the LLM is in a queue flow writing CONTEXT.md files.
 // The write-gate applies during queue flows just like discussion flows.
@@ -228,13 +246,8 @@ export default function (pi) {
             when_context: Type.Optional(Type.String({ description: "When/context for the decision (e.g. milestone ID)" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            // Check DB availability
-            let dbAvailable = false;
-            try {
-                const db = await import("./gsd-db.js");
-                dbAvailable = db.isDbAvailable();
-            }
-            catch { /* dynamic import failed */ }
+            // Ensure DB is open (lazy-open on first tool call in manual sessions)
+            const dbAvailable = await ensureDbOpen();
             if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot save decision." }],
@@ -290,12 +303,7 @@ export default function (pi) {
             supporting_slices: Type.Optional(Type.String({ description: "Supporting slices" })),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            let dbAvailable = false;
-            try {
-                const db = await import("./gsd-db.js");
-                dbAvailable = db.isDbAvailable();
-            }
-            catch { /* dynamic import failed */ }
+            const dbAvailable = await ensureDbOpen();
             if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot update requirement." }],
@@ -365,12 +373,7 @@ export default function (pi) {
             content: Type.String({ description: "The full markdown content of the artifact" }),
         }),
         async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
-            let dbAvailable = false;
-            try {
-                const db = await import("./gsd-db.js");
-                dbAvailable = db.isDbAvailable();
-            }
-            catch { /* dynamic import failed */ }
+            const dbAvailable = await ensureDbOpen();
             if (!dbAvailable) {
                 return {
                     content: [{ type: "text", text: "Error: GSD database is not available. Cannot save artifact." }],

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.

package/dist/resources/extensions/gsd/preferences-models.js

@@ -260,18 +260,6 @@ export function resolveInlineLevel() {
         case "quality": return "full";
     }
 }
-/**
- * Resolve the compression strategy from the active token profile.
- * budget/balanced -> "compress", quality -> "truncate".
- * Explicit preference always wins.
- */
-export function resolveCompressionStrategy() {
-    const prefs = loadEffectiveGSDPreferences();
-    if (prefs?.preferences.compression_strategy)
-        return prefs.preferences.compression_strategy;
-    const profile = resolveEffectiveProfile();
-    return profile === "quality" ? "truncate" : "compress";
-}
 /**
  * Resolve the context selection mode from the active token profile.
  * budget -> "smart", balanced/quality -> "full".

package/dist/resources/extensions/gsd/preferences-types.js

@@ -62,10 +62,10 @@ export const KNOWN_PREFERENCE_KEYS = new Set([
     "verification_auto_fix",
     "verification_max_retries",
     "search_provider",
-    "compression_strategy",
     "context_selection",
     "widget_mode",
     "reactive_execution",
+    "github",
 ]);
 /** Canonical list of all dispatch unit types. */
 export const KNOWN_UNIT_TYPES = [