gsd-pi 2.56.0 → 2.57.0

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/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-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/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/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/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) {

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

@@ -40,16 +40,28 @@ export function resolveModelWithFallbacksForUnit(unitType) {
         case "replan-slice":
             phaseConfig = m.planning;
             break;
+        case "discuss-milestone":
+        case "discuss-slice":
+            phaseConfig = m.discuss ?? m.planning;
+            break;
         case "execute-task":
+        case "reactive-execute":
             phaseConfig = m.execution;
             break;
         case "execute-task-simple":
             phaseConfig = m.execution_simple ?? m.execution;
             break;
         case "complete-slice":
+        case "complete-milestone":
         case "run-uat":
             phaseConfig = m.completion;
             break;
+        case "reassess-roadmap":
+        case "rewrite-docs":
+        case "gate-evaluate":
+        case "validate-milestone":
+            phaseConfig = m.validation ?? m.planning;
+            break;
         default:
             // Subagent unit types (e.g., "subagent", "subagent/scout")
             if (unitType === "subagent" || unitType.startsWith("subagent/")) {

package/dist/resources/extensions/gsd/roadmap-slices.js

@@ -74,6 +74,7 @@ function parseTableSlices(section) {
         // Determine completion status from any cell containing [x], "Done", or "Complete"
         const fullRow = line.toLowerCase();
         const done = /\[x\]/i.test(line) ||
+            /[✅☑✓]/.test(line) ||
             /\bdone\b/.test(fullRow) ||
             /\bcomplete(?:d)?\b/.test(fullRow);
         // Extract risk from any cell containing risk keywords

package/dist/resources/extensions/subagent/agents.js

@@ -4,6 +4,7 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { getAgentDir, parseFrontmatter } from "@gsd/pi-coding-agent";
+const PROJECT_AGENT_DIR_CANDIDATES = [".gsd", ".pi"];
 function loadAgentsFromDir(dir, source) {
     const agents = [];
     if (!fs.existsSync(dir)) {
@@ -60,9 +61,13 @@ function isDirectory(p) {
 function findNearestProjectAgentsDir(cwd) {
     let currentDir = cwd;
     while (true) {
-        const candidate = path.join(currentDir, ".pi", "agents");
-        if (isDirectory(candidate))
-            return candidate;
+        // Prefer the documented project-local location while preserving support
+        // for older workarounds that placed agents under .pi/agents.
+        for (const configDir of PROJECT_AGENT_DIR_CANDIDATES) {
+            const candidate = path.join(currentDir, configDir, "agents");
+            if (isDirectory(candidate))
+                return candidate;
+        }
         const parentDir = path.dirname(currentDir);
         if (parentDir === currentDir)
             return null;

package/dist/web/standalone/.next/BUILD_ID

@@ -1 +1 @@
-ffZReNkOEY2-b8P5TSZWy
+yowc5qPtuKxjOr22KmOAy

package/dist/web/standalone/.next/app-path-routes-manifest.json

@@ -1,34 +1,34 @@
 {
   "/_not-found/page": "/_not-found",
   "/_global-error/page": "/_global-error",
+  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/input/route": "/api/bridge-terminal/input",
   "/api/boot/route": "/api/boot",
-  "/api/bridge-terminal/resize/route": "/api/bridge-terminal/resize",
   "/api/bridge-terminal/stream/route": "/api/bridge-terminal/stream",
+  "/api/cleanup/route": "/api/cleanup",
   "/api/dev-mode/route": "/api/dev-mode",
-  "/api/browse-directories/route": "/api/browse-directories",
   "/api/doctor/route": "/api/doctor",
   "/api/captures/route": "/api/captures",
   "/api/export-data/route": "/api/export-data",
-  "/api/cleanup/route": "/api/cleanup",
+  "/api/browse-directories/route": "/api/browse-directories",
   "/api/forensics/route": "/api/forensics",
+  "/api/git/route": "/api/git",
   "/api/history/route": "/api/history",
   "/api/hooks/route": "/api/hooks",
   "/api/inspect/route": "/api/inspect",
   "/api/knowledge/route": "/api/knowledge",
   "/api/experimental/route": "/api/experimental",
-  "/api/git/route": "/api/git",
   "/api/live-state/route": "/api/live-state",
-  "/api/onboarding/route": "/api/onboarding",
   "/api/preferences/route": "/api/preferences",
-  "/api/projects/route": "/api/projects",
   "/api/recovery/route": "/api/recovery",
+  "/api/onboarding/route": "/api/onboarding",
+  "/api/projects/route": "/api/projects",
   "/api/session/browser/route": "/api/session/browser",
   "/api/session/command/route": "/api/session/command",
   "/api/session/events/route": "/api/session/events",
   "/api/settings-data/route": "/api/settings-data",
-  "/api/session/manage/route": "/api/session/manage",
   "/api/shutdown/route": "/api/shutdown",
+  "/api/session/manage/route": "/api/session/manage",
   "/api/skill-health/route": "/api/skill-health",
   "/api/steer/route": "/api/steer",
   "/api/terminal/input/route": "/api/terminal/input",
@@ -36,9 +36,9 @@
   "/api/terminal/resize/route": "/api/terminal/resize",
   "/api/switch-root/route": "/api/switch-root",
   "/api/terminal/sessions/route": "/api/terminal/sessions",
+  "/api/terminal/stream/route": "/api/terminal/stream",
   "/api/terminal/upload/route": "/api/terminal/upload",
   "/api/undo/route": "/api/undo",
-  "/api/terminal/stream/route": "/api/terminal/stream",
   "/api/visualizer/route": "/api/visualizer",
   "/api/update/route": "/api/update",
   "/api/remote-questions/route": "/api/remote-questions",

package/dist/web/standalone/.next/build-manifest.json

@@ -4,8 +4,8 @@
   ],
   "devFiles": [],
   "lowPriorityFiles": [
-    "static/ffZReNkOEY2-b8P5TSZWy/_buildManifest.js",
-    "static/ffZReNkOEY2-b8P5TSZWy/_ssgManifest.js"
+    "static/yowc5qPtuKxjOr22KmOAy/_buildManifest.js",
+    "static/yowc5qPtuKxjOr22KmOAy/_ssgManifest.js"
   ],
   "rootMainFiles": [
     "static/chunks/webpack-4332cbd5dd1be584.js",