gsd-pi 2.54.0 → 2.56.0-dev.603f970

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

@@ -115,7 +115,7 @@ export const DISPATCH_RULES = [
                 unitType: "run-uat",
                 unitId: `${mid}/${sliceId}`,
                 prompt: await buildRunUatPrompt(mid, sliceId, relSliceFile(basePath, mid, sliceId, "UAT"), uatContent ?? "", basePath),
-                pauseAfterDispatch: uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
+                pauseAfterDispatch: !process.env.GSD_HEADLESS && uatType !== "artifact-driven" && uatType !== "browser-executable" && uatType !== "runtime-executable",
             };
         },
     },

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

@@ -8,6 +8,22 @@ import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
+export function resolvePreferredModelConfig(unitType, autoModeStartModel) {
+    const explicitConfig = resolveModelWithFallbacksForUnit(unitType);
+    if (explicitConfig)
+        return explicitConfig;
+    const routingConfig = resolveDynamicRoutingConfig();
+    if (!routingConfig.enabled || !routingConfig.tier_models)
+        return undefined;
+    const ceilingModel = routingConfig.tier_models.heavy
+        ?? (autoModeStartModel ? `${autoModeStartModel.provider}/${autoModeStartModel.id}` : undefined);
+    if (!ceilingModel)
+        return undefined;
+    return {
+        primary: ceilingModel,
+        fallbacks: [],
+    };
+}
 /**
  * Select and apply the appropriate model for a unit dispatch.
  * Handles: per-unit-type model preferences, dynamic complexity routing,
@@ -16,8 +32,9 @@ import { unitPhaseLabel } from "./auto-dashboard.js";
  * Returns routing metadata for metrics tracking.
  */
 export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext) {
-    const modelConfig = resolveModelWithFallbacksForUnit(unitType);
+    const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel);
     let routing = null;
+    let appliedModel = null;
     if (modelConfig) {
         const availableModels = ctx.modelRegistry.getAvailable();
         // ─── Dynamic Model Routing ─────────────────────────────────────────
@@ -83,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})`;
@@ -111,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-prompts.js

@@ -66,6 +66,10 @@ function buildSourceFilePaths(base, mid, sid) {
     if (existsSync(decisionsPath)) {
         paths.push(`- **Decisions**: \`${relGsdRootFile("DECISIONS")}\``);
     }
+    const queuePath = resolveGsdRootFile(base, "QUEUE");
+    if (existsSync(queuePath)) {
+        paths.push(`- **Queue**: \`${relGsdRootFile("QUEUE")}\``);
+    }
     const contextPath = resolveMilestoneFile(base, mid, "CONTEXT");
     if (contextPath) {
         paths.push(`- **Milestone Context**: \`${relMilestoneFile(base, mid, "CONTEXT")}\``);
@@ -812,6 +816,11 @@ export async function buildPlanMilestonePrompt(mid, midTitle, base, level) {
         if (decisionsInline)
             inlined.push(decisionsInline);
     }
+    const queuePath = resolveGsdRootFile(base, "QUEUE");
+    if (existsSync(queuePath)) {
+        const queueInline = await inlineFileSmart(queuePath, relGsdRootFile("QUEUE"), "Project Queue", `${mid} ${midTitle}`);
+        inlined.push(queueInline);
+    }
     const knowledgeInlinePM = await inlineGsdRootFile(base, "knowledge.md", "Project Knowledge");
     if (knowledgeInlinePM)
         inlined.push(knowledgeInlinePM);

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);
@@ -64,6 +76,14 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         clearLock(base);
         return false;
     }
+    // Capture the user's session model before guided-flow dispatch can apply a
+    // phase-specific planning model for a discuss turn (#2829).
+    const startModelSnapshot = ctx.model
+        ? {
+            provider: ctx.model.provider,
+            id: ctx.model.id,
+        }
+        : null;
     try {
         // Validate GSD_PROJECT_ID early so the user gets immediate feedback
         const customProjectId = process.env.GSD_PROJECT_ID;
@@ -158,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)
@@ -369,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);
@@ -389,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`);
@@ -410,12 +431,11 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
         initMetrics(s.basePath);
         // Initialize routing history
         initRoutingHistory(s.basePath);
-        // Capture session's model at auto-mode start (#650)
-        const currentModel = ctx.model;
-        if (currentModel) {
+        // Restore the model that was active when auto bootstrap began (#650, #2829).
+        if (startModelSnapshot) {
             s.autoModeStartModel = {
-                provider: currentModel.provider,
-                id: currentModel.id,
+                provider: startModelSnapshot.provider,
+                id: startModelSnapshot.id,
             };
         }
         // Snapshot installed skills

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

@@ -22,6 +22,8 @@ import { logWarning } from "./workflow-logger.js";
 import { loadEffectiveGSDPreferences } from "./preferences.js";
 import { nativeGetCurrentBranch, nativeDetectMainBranch, nativeWorkingTreeStatus, nativeAddAllWithExclusions, nativeCommit, nativeCheckoutBranch, nativeMergeSquash, nativeConflictFiles, nativeCheckoutTheirs, nativeAddPaths, nativeRmForce, nativeBranchDelete, nativeBranchExists, nativeDiffNumstat, nativeUpdateRef, nativeIsAncestor, } from "./native-git-bridge.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
+const PROJECT_PREFERENCES_FILE = "PREFERENCES.md";
+const LEGACY_PROJECT_PREFERENCES_FILE = "preferences.md";
 // ─── Shared Constants & Helpers ─────────────────────────────────────────────
 /**
  * Root-level .gsd/ state files synced between worktree and project root.
@@ -37,7 +39,7 @@ const ROOT_STATE_FILES = [
     "QUEUE.md",
     "completed-units.json",
     "metrics.json",
-    // NOTE: preferences.md is intentionally NOT in ROOT_STATE_FILES.
+    // NOTE: project preferences are intentionally NOT in ROOT_STATE_FILES.
     // Forward-sync (main → worktree) is handled explicitly in syncGsdStateToWorktree().
     // Back-sync (worktree → main) must NEVER overwrite the project root's copy
     // because the project root is authoritative for preferences (#2684).
@@ -134,6 +136,11 @@ export function syncProjectRootToWorktree(projectRoot, worktreePath_, milestoneI
         return;
     const prGsd = join(projectRoot, ".gsd");
     const wtGsd = join(worktreePath_, ".gsd");
+    // When .gsd is a symlink to the same external directory in both locations,
+    // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+    // Compare realpaths and skip when they resolve to the same physical path (#2184).
+    if (isSamePath(prGsd, wtGsd))
+        return;
     // Copy milestone directory from project root to worktree — additive only.
     // force:false prevents cpSync from overwriting existing worktree files.
     // Without this, worktree-authoritative files (e.g. VALIDATION.md written
@@ -169,6 +176,11 @@ export function syncStateToProjectRoot(worktreePath_, projectRoot, milestoneId)
         return;
     const wtGsd = join(worktreePath_, ".gsd");
     const prGsd = join(projectRoot, ".gsd");
+    // When .gsd is a symlink to the same external directory in both locations,
+    // cpSync rejects the copy because source === destination (ERR_FS_CP_EINVAL).
+    // Compare realpaths and skip when they resolve to the same physical path (#2184).
+    if (isSamePath(wtGsd, prGsd))
+        return;
     // 1. STATE.md — the quick-glance status used by initial deriveState()
     safeCopy(join(wtGsd, "STATE.md"), join(prGsd, "STATE.md"), { force: true });
     // 2. Milestone directory — ROADMAP, slice PLANs, task summaries
@@ -338,19 +350,26 @@ export function syncGsdStateToWorktree(mainBasePath, worktreePath_) {
             }
         }
     }
-    // Forward-sync preferences.md from project root to worktree (additive only).
-    // NOT in ROOT_STATE_FILES because syncWorktreeStateBack() must never overwrite
-    // the project root's preferences — the project root is authoritative (#2684).
+    // Forward-sync project preferences from project root to worktree (additive only).
+    // Prefer the canonical uppercase file name, but keep the legacy lowercase
+    // fallback so older repos still work on case-sensitive filesystems.
     {
-        const src = join(mainGsd, "preferences.md");
-        const dst = join(wtGsd, "preferences.md");
-        if (existsSync(src) && !existsSync(dst)) {
-            try {
-                cpSync(src, dst);
-                synced.push("preferences.md");
-            }
-            catch {
-                /* non-fatal */
+        const worktreeHasPreferences = existsSync(join(wtGsd, PROJECT_PREFERENCES_FILE))
+            || existsSync(join(wtGsd, LEGACY_PROJECT_PREFERENCES_FILE));
+        if (!worktreeHasPreferences) {
+            for (const file of [PROJECT_PREFERENCES_FILE, LEGACY_PROJECT_PREFERENCES_FILE]) {
+                const src = join(mainGsd, file);
+                const dst = join(wtGsd, file);
+                if (existsSync(src)) {
+                    try {
+                        cpSync(src, dst);
+                        synced.push(file);
+                    }
+                    catch {
+                        /* non-fatal */
+                    }
+                    break;
+                }
             }
         }
     }
@@ -836,10 +855,16 @@ function copyPlanningArtifacts(srcBase, wtPath) {
         "STATE.md",
         "KNOWLEDGE.md",
         "OVERRIDES.md",
-        "preferences.md",
     ]) {
         safeCopy(join(srcGsd, file), join(dstGsd, file), { force: true });
     }
+    // Seed canonical PREFERENCES.md when available; fall back to legacy lowercase.
+    if (existsSync(join(srcGsd, PROJECT_PREFERENCES_FILE))) {
+        safeCopy(join(srcGsd, PROJECT_PREFERENCES_FILE), join(dstGsd, PROJECT_PREFERENCES_FILE), { force: true });
+    }
+    else if (existsSync(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE))) {
+        safeCopy(join(srcGsd, LEGACY_PROJECT_PREFERENCES_FILE), join(dstGsd, LEGACY_PROJECT_PREFERENCES_FILE), { force: true });
+    }
     // Shared WAL (R012): worktrees use the project root's DB directly.
     // No longer copy gsd.db into the worktree — the DB path resolver in
     // ensureDbOpen() detects the worktree location and opens the root DB.

package/dist/resources/extensions/gsd/bootstrap/agent-end-recovery.js

@@ -5,6 +5,7 @@ import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
 import { resolveModelId } from "../auto-model-selection.js";
 import { clearDiscussionFlowState } from "./write-gate.js";
+import { resumeAutoAfterProviderDelay } from "./provider-error-resume.js";
 import { classifyError, createRetryState, resetRetryState, isTransient, } from "../error-classifier.js";
 const retryState = createRetryState();
 const MAX_NETWORK_RETRIES = 2;
@@ -28,7 +29,10 @@ async function pauseTransientWithBackoff(cls, pi, ctx, errorDetail, isRateLimit)
         retryAfterMs,
         resume: allowAutoResume
             ? () => {
-                pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution — provider error recovery delay elapsed.", display: false }, { triggerTurn: true });
+                void resumeAutoAfterProviderDelay(pi, ctx).catch((err) => {
+                    const message = err instanceof Error ? err.message : String(err);
+                    ctx.ui.notify(`Provider error recovery delay elapsed, but auto-mode failed to resume: ${message}`, "error");
+                });
             }
             : undefined,
     });

package/dist/resources/extensions/gsd/bootstrap/provider-error-resume.js

@@ -0,0 +1,18 @@
+import { getAutoDashboardData, startAuto } from "../auto.js";
+const defaultDeps = {
+    getSnapshot: () => getAutoDashboardData(),
+    startAuto,
+};
+export async function resumeAutoAfterProviderDelay(pi, ctx, deps = defaultDeps) {
+    const snapshot = deps.getSnapshot();
+    if (snapshot.active)
+        return "already-active";
+    if (!snapshot.paused)
+        return "not-paused";
+    if (!snapshot.basePath) {
+        ctx.ui.notify("Provider error recovery delay elapsed, but no paused auto-mode base path was available. Leaving auto-mode paused.", "warning");
+        return "missing-base";
+    }
+    await deps.startAuto(ctx, pi, snapshot.basePath, false, { step: snapshot.stepMode });
+    return "resumed";
+}

package/dist/resources/extensions/gsd/bootstrap/register-extension.js

@@ -6,14 +6,27 @@ import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
+export function handleRecoverableExtensionProcessError(err) {
+    if (err.code === "EPIPE") {
+        process.exit(0);
+    }
+    if (err.code === "ENOENT") {
+        const syscall = err.syscall;
+        if (syscall?.startsWith("spawn")) {
+            process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            return true;
+        }
+        if (syscall === "uv_cwd") {
+            process.stderr.write(`[gsd] ENOENT (${syscall}): ${err.message}\n`);
+            return true;
+        }
+    }
+    return false;
+}
 function installEpipeGuard() {
     if (!process.listeners("uncaughtException").some((listener) => listener.name === "_gsdEpipeGuard")) {
         const _gsdEpipeGuard = (err) => {
-            if (err.code === "EPIPE") {
-                process.exit(0);
-            }
-            if (err.code === "ENOENT" && err.syscall?.startsWith("spawn")) {
-                process.stderr.write(`[gsd] spawn ENOENT: ${err.path ?? "unknown"} — command not found\n`);
+            if (handleRecoverableExtensionProcessError(err)) {
                 return;
             }
             throw err;

package/dist/resources/extensions/gsd/bootstrap/register-shortcuts.js

@@ -2,6 +2,7 @@ import { existsSync } from "node:fs";
 import { join } from "node:path";
 import { Key } from "@gsd/pi-tui";
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
+import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
     pi.registerShortcut(Key.ctrlAlt("g"), {
@@ -22,4 +23,23 @@ export function registerShortcuts(pi) {
             });
         },
     });
+    pi.registerShortcut(Key.ctrlAlt("p"), {
+        description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
+        handler: async (ctx) => {
+            const parallelDir = join(process.cwd(), ".gsd", "parallel");
+            if (!existsSync(parallelDir)) {
+                ctx.ui.notify("No parallel workers found. Run /gsd parallel start first.", "info");
+                return;
+            }
+            await ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done()), {
+                overlay: true,
+                overlayOptions: {
+                    width: "90%",
+                    minWidth: 80,
+                    maxHeight: "92%",
+                    anchor: "center",
+                },
+            });
+        },
+    });
 }

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

@@ -47,7 +47,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "inspect", desc: "Show SQLite DB diagnostics" },
     { cmd: "knowledge", desc: "Add persistent project knowledge (rule, pattern, or lesson)" },
     { cmd: "new-milestone", desc: "Create a milestone from a specification document (headless)" },
-    { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge)" },
+    { cmd: "parallel", desc: "Parallel milestone orchestration (start, status, stop, merge, watch)" },
     { cmd: "cmux", desc: "Manage cmux integration (status, sidebar, notifications, splits)" },
     { cmd: "park", desc: "Park a milestone — skip without deleting" },
     { cmd: "unpark", desc: "Reactivate a parked milestone" },
@@ -87,6 +87,7 @@ const NESTED_COMPLETIONS = {
         { cmd: "pause", desc: "Pause a specific worker" },
         { cmd: "resume", desc: "Resume a paused worker" },
         { cmd: "merge", desc: "Merge completed milestone branches" },
+        { cmd: "watch", desc: "Live TUI dashboard monitoring all workers" },
     ],
     setup: [
         { cmd: "llm", desc: "Configure LLM provider settings" },

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

@@ -87,6 +87,20 @@ export async function handleParallelCommand(trimmed, _ctx, pi) {
         emitParallelMessage(pi, formatMergeResults(results));
         return true;
     }
-    emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge]`);
+    if (subcommand === "watch") {
+        const root = projectRoot();
+        const { ParallelMonitorOverlay } = await import("../../parallel-monitor-overlay.js");
+        await _ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(), root), {
+            overlay: true,
+            overlayOptions: {
+                width: "90%",
+                minWidth: 80,
+                maxHeight: "92%",
+                anchor: "center",
+            },
+        });
+        return true;
+    }
+    emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge|watch]`);
     return true;
 }

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/crash-recovery.js

@@ -13,9 +13,9 @@ import { readFileSync, unlinkSync, existsSync } from "node:fs";
 import { join } from "node:path";
 import { gsdRoot } from "./paths.js";
 import { atomicWriteSync } from "./atomic-write.js";
-const LOCK_FILE = "auto.lock";
+import { effectiveLockFile } from "./session-lock.js";
 function lockPath(basePath) {
-    return join(gsdRoot(basePath), LOCK_FILE);
+    return join(gsdRoot(basePath), effectiveLockFile());
 }
 /** Write or update the lock file with current auto-mode state. */
 export function writeLock(basePath, unitType, unitId, sessionFile) {

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`.