gsd-pi 2.56.0-dev.b753b00 → 2.57.0-dev.75d5ac5

package/dist/headless-events.d.ts

@@ -14,6 +14,8 @@ export declare const EXIT_CANCELLED = 11;
  * Map a headless session status string to its standardized exit code.
  *
  *   success   → 0
+ *   complete  → 0
+ *   completed → 0
  *   error     → 1
  *   timeout   → 1
  *   blocked   → 10

package/dist/headless-events.js

@@ -17,6 +17,8 @@ export const EXIT_CANCELLED = 11;
  * Map a headless session status string to its standardized exit code.
  *
  *   success   → 0
+ *   complete  → 0
+ *   completed → 0
  *   error     → 1
  *   timeout   → 1
  *   blocked   → 10
@@ -28,6 +30,7 @@ export function mapStatusToExitCode(status) {
     switch (status) {
         case 'success':
         case 'complete':
+        case 'completed':
             return EXIT_SUCCESS;
         case 'error':
         case 'timeout':

package/dist/headless.js

@@ -55,12 +55,11 @@ export function parseHeadlessArgs(argv) {
         commandArgs: [],
     };
     const args = argv.slice(2);
-    let positionalStarted = false;
     for (let i = 0; i < args.length; i++) {
         const arg = args[i];
         if (arg === 'headless')
             continue;
-        if (!positionalStarted && arg.startsWith('--')) {
+        if (arg.startsWith('--')) {
             if (arg === '--timeout' && i + 1 < args.length) {
                 options.timeout = parseInt(args[++i], 10);
                 if (Number.isNaN(options.timeout) || options.timeout < 0) {
@@ -137,8 +136,7 @@ export function parseHeadlessArgs(argv) {
                 options.bare = true;
             }
         }
-        else if (!positionalStarted) {
-            positionalStarted = true;
+        else if (options.command === 'auto') {
             options.command = arg;
         }
         else {
@@ -186,6 +184,7 @@ async function runHeadlessOnce(options, restartCount) {
     // per-unit timeout via auto-supervisor. Disable the overall timeout unless the
     // user explicitly set --timeout.
     const isAutoMode = options.command === 'auto';
+    const isMultiTurnCommand = options.command === 'auto' || options.command === 'next';
     if (isAutoMode && options.timeout === 300_000) {
         options.timeout = 0;
     }
@@ -473,7 +472,9 @@ async function runHeadlessOnce(options, restartCount) {
                 process.stderr.write(line + '\n');
         }
         // Handle execution_complete (v2 structured completion)
-        if (eventObj.type === 'execution_complete' && !completed) {
+        // Skip for multi-turn commands (auto, next) — their completion is detected via
+        // isTerminalNotification("Auto-mode stopped..."/"Step-mode stopped..."), not per-turn events
+        if (eventObj.type === 'execution_complete' && !completed && !isMultiTurnCommand) {
             completed = true;
             const status = String(eventObj.status ?? 'success');
             exitCode = mapStatusToExitCode(status);

package/dist/resources/extensions/gsd/auto/infra-errors.js

@@ -41,5 +41,9 @@ export function isInfrastructureError(err) {
         if (msg.includes(code))
             return code;
     }
+    // SQLite WAL corruption is not transient — retrying burns LLM budget
+    // for guaranteed failures (#2823).
+    if (msg.includes("database disk image is malformed"))
+        return "SQLITE_CORRUPT";
     return null;
 }

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

@@ -713,6 +713,8 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
     const modelResult = await deps.selectAndApplyModel(ctx, pi, unitType, unitId, s.basePath, prefs, s.verbose, s.autoModeStartModel, sidecarItem ? undefined : { isRetry, previousTier });
     s.currentUnitRouting =
         modelResult.routing;
+    s.currentUnitModel =
+        modelResult.appliedModel;
     // Apply sidecar/pre-dispatch hook model override (takes priority over standard model selection)
     const hookModelOverride = sidecarItem?.model ?? iterData.hookModelOverride;
     if (hookModelOverride) {
@@ -721,6 +723,7 @@ export async function runUnitPhase(ic, iterData, loopState, sidecarItem) {
         if (match) {
             const ok = await pi.setModel(match, { persist: false });
             if (ok) {
+                s.currentUnitModel = match;
                 ctx.ui.notify(`Hook model override: ${match.provider}/${match.id}`, "info");
             }
             else {

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

@@ -52,6 +52,12 @@ export async function runUnit(ctx, pi, s, unitType, unitId, prompt) {
     if (!s.active) {
         return { status: "cancelled" };
     }
+    if (s.currentUnitModel && typeof pi.setModel === "function") {
+        const restored = await pi.setModel(s.currentUnitModel, { persist: false });
+        if (!restored) {
+            ctx.ui.notify(`Failed to restore ${s.currentUnitModel.provider}/${s.currentUnitModel.id} after session creation. Using session default.`, "warning");
+        }
+    }
     // ── Create the agent_end promise (per-unit one-shot) ──
     // This happens after newSession completes so session-switch agent_end events
     // from the previous session cannot resolve the new unit.

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

@@ -49,6 +49,7 @@ export class AutoSession {
     currentMilestoneId = null;
     // ── Model state ──────────────────────────────────────────────────────────
     autoModeStartModel = null;
+    currentUnitModel = null;
     originalModelId = null;
     originalModelProvider = null;
     lastBudgetAlertLevel = 0;
@@ -130,6 +131,7 @@ export class AutoSession {
         this.currentMilestoneId = null;
         // Model
         this.autoModeStartModel = null;
+        this.currentUnitModel = null;
         this.originalModelId = null;
         this.originalModelProvider = null;
         this.lastBudgetAlertLevel = 0;

package/dist/resources/extensions/gsd/auto-artifact-paths.js

@@ -16,6 +16,10 @@ export function resolveExpectedArtifactPath(unitType, unitId, base) {
             const dir = resolveMilestonePath(base, mid);
             return dir ? join(dir, buildMilestoneFileName(mid, "CONTEXT")) : null;
         }
+        case "discuss-slice": {
+            const dir = resolveSlicePath(base, mid, sid);
+            return dir ? join(dir, buildSliceFileName(sid, "CONTEXT")) : null;
+        }
         case "research-milestone": {
             const dir = resolveMilestonePath(base, mid);
             return dir ? join(dir, buildMilestoneFileName(mid, "RESEARCH")) : null;
@@ -79,6 +83,8 @@ export function diagnoseExpectedArtifact(unitType, unitId, base) {
     switch (unitType) {
         case "discuss-milestone":
             return `${relMilestoneFile(base, mid, "CONTEXT")} (milestone context from discussion)`;
+        case "discuss-slice":
+            return `${relSliceFile(base, mid, sid, "CONTEXT")} (slice context from discussion)`;
         case "research-milestone":
             return `${relMilestoneFile(base, mid, "RESEARCH")} (milestone research)`;
         case "plan-milestone":

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

@@ -36,7 +36,8 @@ export function unitVerb(unitType) {
     if (unitType.startsWith("hook/"))
         return `hook: ${unitType.slice(5)}`;
     switch (unitType) {
-        case "discuss-milestone": return "discussing";
+        case "discuss-milestone":
+        case "discuss-slice": return "discussing";
         case "research-milestone":
         case "research-slice": return "researching";
         case "plan-milestone":
@@ -55,7 +56,8 @@ export function unitPhaseLabel(unitType) {
     if (unitType.startsWith("hook/"))
         return "HOOK";
     switch (unitType) {
-        case "discuss-milestone": return "DISCUSS";
+        case "discuss-milestone":
+        case "discuss-slice": return "DISCUSS";
         case "research-milestone": return "RESEARCH";
         case "research-slice": return "RESEARCH";
         case "plan-milestone": return "PLAN";
@@ -81,6 +83,7 @@ function peekNext(unitType, state) {
         return `continue ${sid}`;
     switch (unitType) {
         case "discuss-milestone": return "research or plan milestone";
+        case "discuss-slice": return "plan slice";
         case "research-milestone": return "plan milestone roadmap";
         case "plan-milestone": return "plan or execute first slice";
         case "research-slice": return `plan ${sid}`;

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

@@ -531,11 +531,11 @@ export const DISPATCH_RULES = [
                         if (validationPath) {
                             const validationContent = await loadFile(validationPath);
                             if (validationContent) {
-                                // Accept either the structured template format (table with MET/N/A)
+                                // Accept either the structured template format (table with MET/N/A/SATISFIED)
                                 // or prose evidence patterns the validation agent may emit.
                                 const structuredMatch = validationContent.includes("Operational") &&
-                                    (validationContent.includes("MET") || validationContent.includes("N/A"));
-                                const proseMatch = /[Oo]perational[\s:][^\n]*(?:pass|verified|confirmed|met|complete|true|yes|addressed|covered|n\/a|not\s+applicable)/i.test(validationContent);
+                                    (validationContent.includes("MET") || validationContent.includes("N/A") || validationContent.includes("SATISFIED"));
+                                const proseMatch = /[Oo]perational[\s\S]{0,500}?(?:✅|pass|verified|confirmed|met|complete|true|yes|addressed|covered|satisfied|partially|n\/a|not[\s-]+applicable)/i.test(validationContent);
                                 const hasOperationalCheck = structuredMatch || proseMatch;
                                 if (!hasOperationalCheck) {
                                     return {

package/dist/resources/extensions/gsd/auto-model-selection.js

@@ -34,6 +34,7 @@ export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
 export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext) {
     const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
     let routing = null;
+    let appliedModel = null;
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();
         // ─── Dynamic Model Routing ─────────────────────────────────────────
@@ -99,6 +100,7 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
             }
             const ok = await pi.setModel(model, { persist: false });
             if (ok) {
+                appliedModel = model;
                 const fallbackNote = modelId === effectiveModelConfig.primary
                     ? ""
                     : ` (fallback from ${effectiveModelConfig.primary})`;
@@ -127,12 +129,18 @@ export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, p
             const ok = await pi.setModel(startModel, { persist: false });
             if (!ok) {
                 const byId = availableModels.find(m => m.id === autoModeStartModel.id);
-                if (byId)
-                    await pi.setModel(byId, { persist: false });
+                if (byId) {
+                    const fallbackOk = await pi.setModel(byId, { persist: false });
+                    if (fallbackOk)
+                        appliedModel = byId;
+                }
+            }
+            else {
+                appliedModel = startModel;
             }
         }
     }
-    return { routing };
+    return { routing, appliedModel };
 }
 /**
  * Resolve a model ID string to a model object from the available models list.

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

@@ -46,7 +46,7 @@ function enqueueSidecar(s, ctx, entry, debugExtra, notification) {
  *  Auto-commit is skipped for these — their state files are picked up by the
  *  next actual task commit via `smartStage()`. */
 const LIFECYCLE_ONLY_UNITS = new Set([
-    "research-milestone", "discuss-milestone", "plan-milestone",
+    "research-milestone", "discuss-milestone", "discuss-slice", "plan-milestone",
     "validate-milestone", "research-slice", "plan-slice",
     "replan-slice", "complete-slice", "run-uat",
     "reassess-roadmap", "rewrite-docs",

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

@@ -30,8 +30,9 @@ import { initRoutingHistory } from "./routing-history.js";
 import { restoreHookState, resetHookState } from "./post-unit-hooks.js";
 import { resetProactiveHealing, setLevelChangeCallback } from "./doctor-proactive.js";
 import { snapshotSkills } from "./skill-discovery.js";
-import { isDbAvailable, getMilestone } from "./gsd-db.js";
+import { isDbAvailable, getMilestone, openDatabase } from "./gsd-db.js";
 import { hideFooter } from "./auto-dashboard.js";
+import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { debugLog, enableDebug, isDebugEnabled, getDebugLogPath, } from "./debug-logger.js";
 import { parseUnitId } from "./unit-id.js";
 import { setLogBasePath } from "./workflow-logger.js";
@@ -52,6 +53,17 @@ import { sep as pathSep } from "node:path";
  *  cycles indefinitely when the discuss workflow doesn't produce a milestone. */
 let _consecutiveCompleteBootstraps = 0;
 const MAX_CONSECUTIVE_COMPLETE_BOOTSTRAPS = 2;
+async function openProjectDbIfPresent(basePath) {
+    const gsdDbPath = resolveProjectRootDbPath(basePath);
+    if (!existsSync(gsdDbPath) || isDbAvailable())
+        return;
+    try {
+        openDatabase(gsdDbPath);
+    }
+    catch (err) {
+        process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);
+    }
+}
 export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, requestedStepMode, deps) {
     const { shouldUseWorktreeIsolation, registerSigtermHandler, lockBase, buildResolver, } = deps;
     const lockResult = acquireSessionLock(base);
@@ -166,6 +178,9 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             });
             ctx.ui.notify(`Debug logging enabled → ${getDebugLogPath()}`, "info");
         }
+        // Open the project DB before the first derive so resume uses DB truth
+        // immediately on cold starts instead of falling back to markdown (#2841).
+        await openProjectDbIfPresent(base);
         // Invalidate caches before initial state derivation
         invalidateAllCaches();
         // Clean stale runtime unit files for completed milestones (#887)
@@ -377,15 +392,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
             }
         }
         // ── DB lifecycle ──
-        const gsdDbPath = join(s.basePath, ".gsd", "gsd.db");
+        const gsdDbPath = resolveProjectRootDbPath(s.basePath);
         const gsdDirPath = join(s.basePath, ".gsd");
         if (existsSync(gsdDirPath) && !existsSync(gsdDbPath)) {
             const hasDecisions = existsSync(join(gsdDirPath, "DECISIONS.md"));
             const hasRequirements = existsSync(join(gsdDirPath, "REQUIREMENTS.md"));
             const hasMilestones = existsSync(join(gsdDirPath, "milestones"));
             try {
-                const { openDatabase: openDb } = await import("./gsd-db.js");
-                openDb(gsdDbPath);
+                openDatabase(gsdDbPath);
                 if (hasDecisions || hasRequirements || hasMilestones) {
                     const { migrateFromMarkdown } = await import("./md-importer.js");
                     migrateFromMarkdown(s.basePath);
@@ -397,8 +411,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         }
         if (existsSync(gsdDbPath) && !isDbAvailable()) {
             try {
-                const { openDatabase: openDb } = await import("./gsd-db.js");
-                openDb(gsdDbPath);
+                openDatabase(gsdDbPath);
             }
             catch (err) {
                 process.stderr.write(`gsd-db: failed to open existing database: ${err.message}\n`);

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

@@ -1060,12 +1060,17 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     const milestoneBranch = autoWorktreeBranch(milestoneId);
     // 1. Auto-commit dirty state in worktree before leaving
     autoCommitDirtyState(worktreeCwd);
-    // Reconcile worktree DB into main DB before leaving worktree context
+    // Reconcile worktree DB into main DB before leaving worktree context.
+    // Skip when both paths resolve to the same physical file (shared WAL /
+    // symlink layout) — ATTACHing a WAL-mode file to itself corrupts the
+    // database (#2823).
     if (isDbAvailable()) {
         try {
             const worktreeDbPath = join(worktreeCwd, ".gsd", "gsd.db");
             const mainDbPath = join(originalBasePath_, ".gsd", "gsd.db");
-            reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+            if (!isSamePath(worktreeDbPath, mainDbPath)) {
+                reconcileWorktreeDb(mainDbPath, worktreeDbPath);
+            }
         }
         catch {
             /* non-fatal */

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

@@ -774,6 +774,10 @@ function buildLoopDeps() {
     };
 }
 export async function startAuto(ctx, pi, base, verboseMode, options) {
+    if (s.active) {
+        debugLog("startAuto", { phase: "already-active", skipping: true });
+        return;
+    }
     const requestedStepMode = options?.step ?? false;
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);

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

@@ -872,7 +872,7 @@ export function registerDbTools(pi) {
         promptSnippet: "Validate a GSD milestone (DB write + VALIDATION.md render)",
         promptGuidelines: [
             "Use gsd_validate_milestone when all slices are done and the milestone needs validation before completion.",
-            "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verdictRationale, remediationPlan (optional).",
+            "Parameters: milestoneId, verdict, remediationRound, successCriteriaChecklist, sliceDeliveryAudit, crossSliceIntegration, requirementCoverage, verificationClasses (optional), verdictRationale, remediationPlan (optional).",
             "If verdict is 'needs-remediation', also provide remediationPlan and use gsd_reassess_roadmap to add remediation slices to the roadmap.",
             "On success, returns validationPath where VALIDATION.md was written.",
         ],
@@ -884,6 +884,7 @@ export function registerDbTools(pi) {
             sliceDeliveryAudit: Type.String({ description: "Markdown table auditing each slice's claimed vs delivered output" }),
             crossSliceIntegration: Type.String({ description: "Markdown describing any cross-slice boundary mismatches" }),
             requirementCoverage: Type.String({ description: "Markdown describing any unaddressed requirements" }),
+            verificationClasses: Type.Optional(Type.String({ description: "Markdown describing verification class compliance and gaps" })),
             verdictRationale: Type.String({ description: "Why this verdict was chosen" }),
             remediationPlan: Type.Optional(Type.String({ description: "Remediation plan (required if verdict is needs-remediation)" })),
         }),

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

@@ -13,6 +13,7 @@ const UNIT_TYPE_TIERS = {
     "run-uat": "light",
     // Tier 2 — Standard: research, routine planning, discussion
     "discuss-milestone": "standard",
+    "discuss-slice": "standard",
     "research-milestone": "standard",
     "research-slice": "standard",
     "plan-milestone": "standard",

package/dist/resources/extensions/gsd/dashboard-overlay.js

@@ -21,6 +21,8 @@ import { computeProgressScore } from "./progress-score.js";
 import { runEnvironmentChecks } from "./doctor-environment.js";
 function unitLabel(type) {
     switch (type) {
+        case "discuss-milestone":
+        case "discuss-slice": return "Discuss";
         case "research-milestone": return "Research";
         case "plan-milestone": return "Plan";
         case "research-slice": return "Research";

package/dist/resources/extensions/gsd/dispatch-guard.js

@@ -18,9 +18,19 @@ export function getPriorSliceCompletionBlocker(base, _mainBranch, unitType, unit
     const { milestone: targetMid, slice: targetSid } = parseUnitId(unitId);
     if (!targetMid || !targetSid)
         return null;
+    // Parallel worker isolation: when GSD_MILESTONE_LOCK is set, this worker
+    // is scoped to a single milestone. Skip the cross-milestone dependency
+    // check — other milestones are being handled by their own workers.
+    // Without this, the dispatch guard sees incomplete slices in M010/M011
+    // (cloned into the worktree DB) and blocks M012 from ever starting. #2797
+    const milestoneLock = process.env.GSD_MILESTONE_LOCK;
     // Use findMilestoneIds to respect custom queue order.
     // Only check milestones that come BEFORE the target in queue order.
-    const allIds = findMilestoneIds(base);
+    // When locked to a specific milestone, only check that milestone's
+    // intra-slice dependencies — skip all cross-milestone checks.
+    const allIds = milestoneLock && targetMid === milestoneLock
+        ? [targetMid]
+        : findMilestoneIds(base);
     const targetIdx = allIds.indexOf(targetMid);
     if (targetIdx < 0)
         return null;

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

@@ -102,12 +102,14 @@ Setting `prefer_skills: []` does **not** disable skill discovery — it just mea
 
 - `custom_instructions`: extra durable instructions related to skill use. For operational project knowledge (recurring rules, gotchas, patterns), use `.gsd/KNOWLEDGE.md` instead — it's injected into every agent prompt automatically and agents can append to it during execution.
 
-- `models`: per-stage model selection for auto-mode. Keys: `research`, `planning`, `execution`, `execution_simple`, `completion`, `subagent`. Values can be:
+- `models`: per-stage model selection (applies to both auto-mode and guided-flow dispatches). Keys: `research`, `planning`, `discuss`, `execution`, `execution_simple`, `completion`, `validation`, `subagent`. Values can be:
   - Simple string: `"claude-sonnet-4-6"` — single model, no fallbacks
   - Provider-qualified string: `"bedrock/claude-sonnet-4-6"` — targets a specific provider when the same model ID exists across multiple providers
   - Object with fallbacks: `{ model: "claude-opus-4-6", fallbacks: ["glm-5", "minimax-m2.5"] }` — tries fallbacks in order if primary fails
   - Object with provider: `{ model: "claude-opus-4-6", provider: "bedrock" }` — explicit provider targeting in object format
-  - Omit a key to use whatever model is currently active. Fallbacks are tried when model switching fails (provider unavailable, rate limited, etc.).
+  - Omit a key to use whatever model is currently active (except `discuss` and `validation` which fall back to `planning` when unset). Fallbacks are tried when model switching fails (provider unavailable, rate limited, etc.).
+  - `discuss` — used for milestone/slice discussion (interactive context gathering). Falls back to `planning` if unset.
+  - `validation` — used for gate evaluation, roadmap reassessment, milestone validation, and doc rewrites. Falls back to `planning` if unset.
 
 - `skill_staleness_days`: number — skills unused for this many days get deprioritized during discovery. Set to `0` to disable staleness tracking. Default: `60`.
 

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

@@ -5,7 +5,7 @@
 // Exposes a unified sync API for decisions and requirements storage.
 // Schema is initialized on first open with WAL mode for file-backed DBs.
 import { createRequire } from "node:module";
-import { existsSync, copyFileSync, mkdirSync } from "node:fs";
+import { existsSync, copyFileSync, mkdirSync, realpathSync } from "node:fs";
 import { dirname } from "node:path";
 import { GSDError, GSD_STALE_STATE } from "./errors.js";
 const _require = createRequire(import.meta.url);
@@ -1455,6 +1455,13 @@ export function reconcileWorktreeDb(mainDbPath, worktreeDbPath) {
     const zero = { decisions: 0, requirements: 0, artifacts: 0, milestones: 0, slices: 0, tasks: 0, memories: 0, verification_evidence: 0, conflicts: [] };
     if (!existsSync(worktreeDbPath))
         return zero;
+    // Guard: bail when both paths resolve to the same physical file.
+    // ATTACHing a WAL-mode DB to itself corrupts the WAL (#2823).
+    try {
+        if (realpathSync(mainDbPath) === realpathSync(worktreeDbPath))
+            return zero;
+    }
+    catch { /* path resolution failed — fall through to existing checks */ }
     // Sanitize path: reject any characters that could break ATTACH syntax.
     // ATTACH DATABASE doesn't support parameterized paths in all providers,
     // so we use strict allowlist validation instead.

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

@@ -143,6 +143,7 @@ export function checkAutoStartAfterDiscuss() {
     }
     catch { /* may not exist for single-milestone */ }
     pendingAutoStart = null;
+    ctx.ui.notify(`Milestone ${milestoneId} ready.`, "info");
     startAuto(ctx, pi, basePath, false, { step }).catch((err) => {
         ctx.ui.notify(`Auto-start failed: ${getErrorMessage(err)}`, "error");
         if (process.env.GSD_DEBUG)
@@ -171,7 +172,7 @@ function parseMilestoneSequenceFromProject(content) {
  * 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
+ * phase (e.g., models.planning → "plan-milestone", models.discuss → "discuss-milestone") and applies it before
  * dispatching. This ensures guided-flow dispatches respect the same
  * per-phase model preferences that auto-mode uses.
  */
@@ -460,7 +461,7 @@ 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 };
-            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
@@ -469,14 +470,14 @@ export async function showDiscuss(ctx, pi, basePath) {
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId: mid, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${mid}): milestone context from discuss`),
-            }), "gsd-discuss", ctx, "plan-milestone");
+            }), "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: false };
-            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -590,7 +591,7 @@ export async function showDiscuss(ctx, pi, basePath) {
                 continue;
         }
         const prompt = await buildDiscussSlicePrompt(mid, chosen.id, chosen.title, basePath, { rediscuss: isRediscuss });
-        await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "plan-slice");
+        await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-slice");
         // Wait for the discuss session to finish, then loop back to the picker
         await ctx.waitForIdle();
         invalidateAllCaches();
@@ -651,7 +652,7 @@ async function dispatchDiscussForMilestone(ctx, pi, basePath, mid, milestoneTitl
     const prompt = draftContent
         ? `${basePrompt}\n\n## Prior Discussion (Draft Seed)\n\n${draftContent}`
         : basePrompt;
-    await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "plan-milestone");
+    await dispatchWorkflow(pi, prompt, "gsd-discuss", ctx, "discuss-milestone");
 }
 // ─── Smart Entry Point ────────────────────────────────────────────────────────
 /**
@@ -774,7 +775,7 @@ async function handleMilestoneActions(ctx, pi, basePath, milestoneId, milestoneT
         const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
         const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
         pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-        await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+        await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         return true;
     }
     // "back" or null
@@ -898,7 +899,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 };
-            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");
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New project, milestone ${nextId}. Do NOT read or explore .gsd/ — it's empty scaffolding.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else {
             const choice = await showNextAction(ctx, {
@@ -916,7 +917,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             });
             if (choice === "new_milestone") {
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
         }
         return;
@@ -948,7 +949,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         else if (choice === "status") {
             const { fireStatusViaCommand } = await import("./commands.js");
@@ -994,7 +995,7 @@ 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 };
-            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "plan-milestone");
+            await dispatchWorkflow(pi, seed, "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "discuss_fresh") {
             const discussMilestoneTemplates = inlineTemplate("context", "Context");
@@ -1003,14 +1004,14 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             await dispatchWorkflow(pi, loadPrompt("guided-discuss-milestone", {
                 milestoneId, milestoneTitle, inlinedTemplates: discussMilestoneTemplates, structuredQuestionsAvailable,
                 commitInstruction: buildDocsCommitInstruction(`docs(${milestoneId}): milestone context from discuss`),
-            }), "gsd-discuss", ctx, "plan-milestone");
+            }), "gsd-discuss", ctx, "discuss-milestone");
         }
         else if (choice === "skip_milestone") {
             const milestoneIds = findMilestoneIds(basePath);
             const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
             const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
             pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+            await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
         }
         return;
     }
@@ -1081,14 +1082,14 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
                 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");
+                }), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "skip_milestone") {
                 const milestoneIds = findMilestoneIds(basePath);
                 const uniqueMilestoneIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
                 const nextId = nextMilestoneIdReserved(milestoneIds, uniqueMilestoneIds);
                 pendingAutoStart = { ctx, pi, basePath, milestoneId: nextId, step: stepMode };
-                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "plan-milestone");
+                await dispatchWorkflow(pi, buildDiscussPrompt(nextId, `New milestone ${nextId}.`, basePath), "gsd-run", ctx, "discuss-milestone");
             }
             else if (choice === "discard_milestone") {
                 const confirmed = await showConfirm(ctx, {
@@ -1214,7 +1215,7 @@ export async function showSmartEntry(ctx, pi, basePath, options) {
             }), "gsd-run", ctx, "plan-slice");
         }
         else if (choice === "discuss") {
-            await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }), "gsd-run", ctx, "plan-slice");
+            await dispatchWorkflow(pi, await buildDiscussSlicePrompt(milestoneId, sliceId, sliceTitle, basePath, { rediscuss: hasContext }), "gsd-run", ctx, "discuss-slice");
         }
         else if (choice === "research") {
             const researchTemplates = inlineTemplate("research", "Research");

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

@@ -26,6 +26,9 @@ export function classifyUnitPhase(unitType) {
         case "research-milestone":
         case "research-slice":
             return "research";
+        case "discuss-milestone":
+        case "discuss-slice":
+            return "discussion";
         case "plan-milestone":
         case "plan-slice":
             return "planning";
@@ -183,7 +186,7 @@ export function aggregateByPhase(units) {
         agg.duration += u.finishedAt - u.startedAt;
     }
     // Return in a stable order
-    const order = ["research", "planning", "execution", "completion", "reassessment"];
+    const order = ["research", "discussion", "planning", "execution", "completion", "reassessment"];
     return order.map(p => map.get(p)).filter((a) => !!a);
 }
 export function aggregateBySlice(units) {