gsd-pi 2.71.0-dev.977c553 → 2.71.0-dev.e17e0ce

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

@@ -8,6 +8,7 @@ import { classifyUnitComplexity, tierLabel } from "./complexity-classifier.js";
 import { resolveModelForComplexity, escalateTier, getEligibleModels, loadCapabilityOverrides, adjustToolSet } from "./model-router.js";
 import { getLedger, getProjectTotals } from "./metrics.js";
 import { unitPhaseLabel } from "./auto-dashboard.js";
+import { getSessionModelOverride } from "./session-model-override.js";
 export function resolvePreferredModelConfig(unitType, autoModeStartModel, 
 /** When false, only return explicit per-phase model configs — do not
  *  synthesize a routing ceiling from dynamic_routing.tier_models (#3962). */
@@ -44,8 +45,15 @@ isAutoMode = true) {
 export async function selectAndApplyModel(ctx, pi, unitType, unitId, basePath, prefs, verbose, autoModeStartModel, retryContext, 
 /** When false (interactive/guided-flow), skip dynamic routing and use the session model.
  *  Dynamic routing only applies in auto-mode where cost optimization is expected. (#3962) */
-isAutoMode = true) {
-    const modelConfig = resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
+isAutoMode = true, 
+/** Explicit /gsd model pin captured at bootstrap for long-running auto loops. */
+sessionModelOverride) {
+    const effectiveSessionModelOverride = sessionModelOverride === undefined
+        ? getSessionModelOverride(ctx.sessionManager.getSessionId())
+        : (sessionModelOverride ?? undefined);
+    const modelConfig = effectiveSessionModelOverride
+        ? undefined
+        : resolvePreferredModelConfig(unitType, autoModeStartModel, isAutoMode);
     let routing = null;
     let appliedModel = null;
     if (modelConfig) {

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

@@ -39,6 +39,7 @@ import { join } from "node:path";
 import { sep as pathSep } from "node:path";
 import { resolveProjectRootDbPath } from "./bootstrap/dynamic-tools.js";
 import { resolveDefaultSessionModel, resolveDynamicRoutingConfig } from "./preferences-models.js";
+import { getSessionModelOverride } from "./session-model-override.js";
 /**
  * Bootstrap a fresh auto-mode session. Handles everything from git init
  * through secrets collection, returning when ready for the first
@@ -187,12 +188,17 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
     // Capture the user's session model before guided-flow dispatch can apply a
     // phase-specific planning model for a discuss turn (#2829).
     //
-    // GSD PREFERENCES.md takes priority over the session model from settings.json
-    // (#3517).  The session model (ctx.model) comes from findInitialModel() which
-    // reads defaultProvider/defaultModel from ~/.gsd/agent/settings.json.  When
-    // the user has explicit model preferences in PREFERENCES.md, those should win.
+    // Precedence:
+    // 1) Explicit session override via /gsd model (this session)
+    // 2) GSD model preferences from PREFERENCES.md
+    // 3) Current session model from settings/session restore
+    //
+    // This preserves #3517 defaults while honoring explicit runtime model
+    // selection for subsequent /gsd runs in the same session.
+    const manualSessionOverride = getSessionModelOverride(ctx.sessionManager.getSessionId());
     const preferredModel = resolveDefaultSessionModel(ctx.model?.provider);
-    const startModelSnapshot = preferredModel
+    const startModelSnapshot = manualSessionOverride
+        ?? preferredModel
         ?? (ctx.model
             ? { provider: ctx.model.provider, id: ctx.model.id }
             : null);
@@ -523,7 +529,7 @@ 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"));
@@ -571,6 +577,7 @@ export async function bootstrapAutoSession(s, ctx, pi, base, verboseMode, reques
                 id: startModelSnapshot.id,
             };
         }
+        s.manualSessionModelOverride = manualSessionOverride ?? null;
         // Apply worker model override from parallel orchestrator (#worker-model).
         // GSD_WORKER_MODEL is injected by the coordinator when parallel.worker_model
         // is configured, so parallel milestone workers use a cheaper model than the

package/dist/resources/extensions/gsd/auto-tool-tracking.js

@@ -82,7 +82,7 @@ export function clearInFlightTools() {
  * handler. When these errors occur, retrying the same unit will produce the same
  * failure, so the retry loop must be broken.
  */
-const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}' in JSON|Unexpected end of JSON|Unexpected token.*in JSON/i;
+const TOOL_INVOCATION_ERROR_RE = /Validation failed for tool|Expected ',' or '\}'(?: after property value)?(?: in JSON)?|Unexpected end of JSON|Unexpected token.*in JSON/i;
 /**
  * Returns true if the error message indicates a tool invocation failure due to
  * malformed/truncated arguments (as opposed to a normal tool execution error).

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

@@ -1795,7 +1795,7 @@ export function mergeMilestoneToMain(originalBasePath_, milestoneId, roadmapCont
     // 12. Remove worktree directory first (must happen before branch deletion)
     try {
         removeWorktree(originalBasePath_, milestoneId, {
-            branch: null,
+            branch: milestoneBranch,
             deleteBranch: false,
         });
     }

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

@@ -49,6 +49,7 @@ import { pruneQueueOrder } from "./queue-order.js";
 import { debugLog, isDebugEnabled, writeDebugSummary } from "./debug-logger.js";
 import { reconcileMergeState, } from "./auto-recovery.js";
 import { resolveDispatch, DISPATCH_RULES } from "./auto-dispatch.js";
+import { getErrorMessage } from "./error-utils.js";
 import { initRegistry, convertDispatchRules } from "./rule-registry.js";
 import { emitJournalEvent as _emitJournalEvent } from "./journal.js";
 import { updateProgressWidget as _updateProgressWidget, updateSliceProgressCache, clearSliceProgressCache, hideFooter, } from "./auto-dashboard.js";
@@ -103,6 +104,40 @@ function restoreProjectRootEnv() {
     s.hadProjectRootEnv = false;
     s.projectRootEnvCaptured = false;
 }
+function captureMilestoneLockEnv(milestoneId) {
+    if (!s.milestoneLockEnvCaptured) {
+        s.hadMilestoneLockEnv = Object.prototype.hasOwnProperty.call(process.env, "GSD_MILESTONE_LOCK");
+        s.previousMilestoneLockEnv = process.env.GSD_MILESTONE_LOCK ?? null;
+        s.milestoneLockEnvCaptured = true;
+    }
+    if (milestoneId) {
+        process.env.GSD_MILESTONE_LOCK = milestoneId;
+    }
+    else {
+        delete process.env.GSD_MILESTONE_LOCK;
+    }
+}
+function restoreMilestoneLockEnv() {
+    if (!s.milestoneLockEnvCaptured)
+        return;
+    if (s.hadMilestoneLockEnv && s.previousMilestoneLockEnv !== null) {
+        process.env.GSD_MILESTONE_LOCK = s.previousMilestoneLockEnv;
+    }
+    else {
+        delete process.env.GSD_MILESTONE_LOCK;
+    }
+    s.previousMilestoneLockEnv = null;
+    s.hadMilestoneLockEnv = false;
+    s.milestoneLockEnvCaptured = false;
+}
+export function startAutoDetached(ctx, pi, base, verboseMode, options) {
+    void startAuto(ctx, pi, base, verboseMode, options).catch((err) => {
+        const message = getErrorMessage(err);
+        ctx.ui.notify(`Auto-start failed: ${message}`, "error");
+        logWarning("engine", `auto start error: ${message}`, { file: "auto.ts" });
+        debugLog("auto-start-failed", { error: message });
+    });
+}
 export function shouldUseWorktreeIsolation() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
     if (prefs?.isolation === "worktree")
@@ -324,6 +359,7 @@ function clearUnitTimeout() {
 /** Build snapshot metric opts. */
 function buildSnapshotOpts(_unitType, _unitId) {
     return {
+        ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
         promptCharCount: s.lastPromptCharCount,
         baselineCharCount: s.lastBaselineCharCount,
         ...(s.currentUnitRouting ?? {}),
@@ -340,6 +376,7 @@ function handleLostSessionLock(ctx, lockStatus) {
     s.paused = false;
     clearUnitTimeout();
     restoreProjectRootEnv();
+    restoreMilestoneLockEnv();
     deregisterSigtermHandler();
     clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
     const base = lockBase();
@@ -371,6 +408,7 @@ function cleanupAfterLoopExit(ctx) {
     s.active = false;
     clearUnitTimeout();
     restoreProjectRootEnv();
+    restoreMilestoneLockEnv();
     // Clear crash lock and release session lock so the next `/gsd next` does
     // not see a stale lock with the current PID and treat it as a "remote"
     // session (which would cause it to SIGTERM itself). (#2730)
@@ -628,6 +666,7 @@ export async function stopAuto(ctx, pi, reason) {
         ctx?.ui.setWidget("gsd-progress", undefined);
         ctx?.ui.setFooter(undefined);
         restoreProjectRootEnv();
+        restoreMilestoneLockEnv();
         // Reset all session state in one call
         s.reset();
     }
@@ -673,6 +712,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
             activeEngineId: s.activeEngineId,
             activeRunDir: s.activeRunDir,
             autoStartTime: s.autoStartTime,
+            milestoneLock: s.sessionMilestoneLock ?? undefined,
         };
         const runtimeDir = join(gsdRoot(s.originalBasePath || s.basePath), "runtime");
         mkdirSync(runtimeDir, { recursive: true });
@@ -704,6 +744,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     s.active = false;
     s.paused = true;
     restoreProjectRootEnv();
+    restoreMilestoneLockEnv();
     s.pendingVerificationRetry = null;
     s.verificationRetryCount.clear();
     ctx?.ui.setStatus("gsd-auto", "paused");
@@ -859,6 +900,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     }
     const requestedStepMode = options?.step ?? false;
     const interruptedAssessment = options?.interrupted ?? null;
+    if (options?.milestoneLock !== undefined) {
+        s.sessionMilestoneLock = options.milestoneLock ?? null;
+    }
+    if (s.sessionMilestoneLock) {
+        captureMilestoneLockEnv(s.sessionMilestoneLock);
+    }
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);
     const freshStartAssessment = interruptedAssessment
@@ -883,6 +930,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                 s.originalBasePath = meta.originalBasePath || base;
                 s.stepMode = meta.stepMode ?? requestedStepMode;
                 s.autoStartTime = meta.autoStartTime || Date.now();
+                s.sessionMilestoneLock = meta.milestoneLock ?? null;
                 s.paused = true;
                 try {
                     unlinkSync(pausedPath);
@@ -918,6 +966,7 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
                         s.pausedUnitType = meta.unitType ?? null;
                         s.pausedUnitId = meta.unitId ?? null;
                         s.autoStartTime = meta.autoStartTime || Date.now();
+                        s.sessionMilestoneLock = meta.milestoneLock ?? null;
                         s.paused = true;
                         try {
                             unlinkSync(pausedPath);
@@ -946,6 +995,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         if (!s.autoStartTime || s.autoStartTime <= 0)
             s.autoStartTime = Date.now();
     }
+    if (s.sessionMilestoneLock) {
+        captureMilestoneLockEnv(s.sessionMilestoneLock);
+    }
     if (!s.paused) {
         s.stepMode = requestedStepMode;
     }

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

@@ -111,6 +111,8 @@ export function registerHooks(pi) {
             return { cancel: true };
         }
         const basePath = process.cwd();
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        await ensureDbOpen();
         const state = await deriveState(basePath);
         if (!state.activeMilestone || !state.activeSlice || !state.activeTask)
             return;

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

@@ -4,61 +4,76 @@ import { Key } from "@gsd/pi-tui";
 import { GSDDashboardOverlay } from "../dashboard-overlay.js";
 import { GSDNotificationOverlay } from "../notification-overlay.js";
 import { ParallelMonitorOverlay } from "../parallel-monitor-overlay.js";
+import { GSD_SHORTCUTS } from "../shortcut-defs.js";
 import { projectRoot } from "../commands/context.js";
 import { shortcutDesc } from "../../shared/mod.js";
 export function registerShortcuts(pi) {
-    pi.registerShortcut(Key.ctrlAlt("g"), {
-        description: shortcutDesc("Open GSD dashboard", "/gsd status"),
-        handler: async (ctx) => {
-            const basePath = projectRoot();
-            if (!existsSync(join(basePath, ".gsd"))) {
-                ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
-                return;
-            }
-            await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
-                overlay: true,
-                overlayOptions: {
-                    width: "90%",
-                    minWidth: 80,
-                    maxHeight: "92%",
-                    anchor: "center",
-                },
-            });
-        },
+    const overlayOptions = {
+        width: "90%",
+        minWidth: 80,
+        maxHeight: "92%",
+        anchor: "center",
+    };
+    const openDashboardOverlay = async (ctx) => {
+        const basePath = projectRoot();
+        if (!existsSync(join(basePath, ".gsd"))) {
+            ctx.ui.notify("No .gsd/ directory found. Run /gsd to start.", "info");
+            return;
+        }
+        await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
+            overlay: true,
+            overlayOptions,
+        });
+    };
+    const openNotificationsOverlay = async (ctx) => {
+        await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)), {
+            overlay: true,
+            overlayOptions: {
+                width: "80%",
+                minWidth: 60,
+                maxHeight: "88%",
+                anchor: "center",
+                backdrop: true,
+            },
+        });
+    };
+    const openParallelOverlay = async (ctx) => {
+        const basePath = projectRoot();
+        const parallelDir = join(basePath, ".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(true), basePath), {
+            overlay: true,
+            overlayOptions,
+        });
+    };
+    pi.registerShortcut(Key.ctrlAlt(GSD_SHORTCUTS.dashboard.key), {
+        description: shortcutDesc(GSD_SHORTCUTS.dashboard.action, GSD_SHORTCUTS.dashboard.command),
+        handler: openDashboardOverlay,
     });
-    pi.registerShortcut(Key.ctrlAlt("n"), {
-        description: shortcutDesc("Open notification history", "/gsd notifications"),
-        handler: async (ctx) => {
-            await ctx.ui.custom((tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)), {
-                overlay: true,
-                overlayOptions: {
-                    width: "80%",
-                    minWidth: 60,
-                    maxHeight: "88%",
-                    anchor: "center",
-                    backdrop: true,
-                },
-            });
-        },
+    // Fallback for terminals where Ctrl+Alt letter chords are not forwarded reliably.
+    pi.registerShortcut(Key.ctrlShift(GSD_SHORTCUTS.dashboard.key), {
+        description: shortcutDesc(`${GSD_SHORTCUTS.dashboard.action} (fallback)`, GSD_SHORTCUTS.dashboard.command),
+        handler: openDashboardOverlay,
     });
-    pi.registerShortcut(Key.ctrlAlt("p"), {
-        description: shortcutDesc("Open parallel worker monitor", "/gsd parallel watch"),
-        handler: async (ctx) => {
-            const basePath = projectRoot();
-            const parallelDir = join(basePath, ".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(true)), {
-                overlay: true,
-                overlayOptions: {
-                    width: "90%",
-                    minWidth: 80,
-                    maxHeight: "92%",
-                    anchor: "center",
-                },
-            });
-        },
+    pi.registerShortcut(Key.ctrlAlt(GSD_SHORTCUTS.notifications.key), {
+        description: shortcutDesc(GSD_SHORTCUTS.notifications.action, GSD_SHORTCUTS.notifications.command),
+        handler: openNotificationsOverlay,
+    });
+    // Fallback for terminals where Ctrl+Alt letter chords are not forwarded reliably.
+    pi.registerShortcut(Key.ctrlShift(GSD_SHORTCUTS.notifications.key), {
+        description: shortcutDesc(`${GSD_SHORTCUTS.notifications.action} (fallback)`, GSD_SHORTCUTS.notifications.command),
+        handler: openNotificationsOverlay,
+    });
+    pi.registerShortcut(Key.ctrlAlt(GSD_SHORTCUTS.parallel.key), {
+        description: shortcutDesc(GSD_SHORTCUTS.parallel.action, GSD_SHORTCUTS.parallel.command),
+        handler: openParallelOverlay,
+    });
+    // Fallback for terminals where Ctrl+Alt letter chords are not forwarded reliably.
+    pi.registerShortcut(Key.ctrlShift(GSD_SHORTCUTS.parallel.key), {
+        description: shortcutDesc(`${GSD_SHORTCUTS.parallel.action} (fallback)`, GSD_SHORTCUTS.parallel.command),
+        handler: openParallelOverlay,
     });
 }

package/dist/resources/extensions/gsd/bootstrap/system-context.js

@@ -257,6 +257,10 @@ function buildWorktreeContextBlock() {
  */
 const RESUME_INTENT_PATTERNS = /^(continue|resume|ok|go|go ahead|proceed|keep going|carry on|next|yes|yeah|yep|sure|do it|let's go|pick up where you left off)$/;
 async function buildGuidedExecuteContextInjection(prompt, basePath) {
+    const ensureStateDbOpen = async () => {
+        const { ensureDbOpen } = await import("./dynamic-tools.js");
+        await ensureDbOpen();
+    };
     const executeMatch = prompt.match(/Execute the next task:\s+(T\d+)\s+\("([^"]+)"\)\s+in slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (executeMatch) {
         const [, taskId, taskTitle, sliceId, milestoneId] = executeMatch;
@@ -265,6 +269,7 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
     const resumeMatch = prompt.match(/Resume interrupted work\.[\s\S]*?slice\s+(S\d+)\s+of milestone\s+(M\d+(?:-[a-z0-9]{6})?)/i);
     if (resumeMatch) {
         const [, sliceId, milestoneId] = resumeMatch;
+        await ensureStateDbOpen();
         const state = await deriveState(basePath);
         if (state.activeMilestone?.id === milestoneId && state.activeSlice?.id === sliceId && state.activeTask) {
             return buildTaskExecutionContextInjection(basePath, milestoneId, sliceId, state.activeTask.id, state.activeTask.title);
@@ -279,6 +284,7 @@ async function buildGuidedExecuteContextInjection(prompt, basePath) {
     // replanning, gate evaluation, or other non-execution phases.
     const trimmed = prompt.trim().toLowerCase().replace(/[.!?,]+$/g, "");
     if (RESUME_INTENT_PATTERNS.test(trimmed)) {
+        await ensureStateDbOpen();
         const state = await deriveState(basePath);
         if (state.phase === "executing" && state.activeTask && state.activeMilestone && state.activeSlice) {
             return buildTaskExecutionContextInjection(basePath, state.activeMilestone.id, state.activeSlice.id, state.activeTask.id, state.activeTask.title);

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

@@ -1,8 +1,18 @@
 import { checkRemoteAutoSession, isAutoActive, isAutoPaused, stopAutoRemote } from "../auto.js";
-import { assertSafeDirectory } from "../validate-directory.js";
+import { validateDirectory } from "../validate-directory.js";
 import { resolveProjectRoot } from "../worktree.js";
 import { showNextAction } from "../../shared/tui.js";
 import { handleStatus } from "./handlers/core.js";
+/**
+ * Typed error for when GSD is run outside a valid project directory.
+ * Command handlers catch this to show a friendly message instead of a raw exception.
+ */
+export class GSDNoProjectError extends Error {
+    constructor(reason) {
+        super(reason);
+        this.name = "GSDNoProjectError";
+    }
+}
 export function projectRoot() {
     let cwd;
     try {
@@ -13,11 +23,10 @@ export function projectRoot() {
         cwd = process.env.HOME ?? "/";
     }
     const root = resolveProjectRoot(cwd);
-    if (root !== cwd) {
-        assertSafeDirectory(cwd);
-    }
-    else {
-        assertSafeDirectory(root);
+    const pathToCheck = root !== cwd ? cwd : root;
+    const result = validateDirectory(pathToCheck);
+    if (result.severity === "blocked") {
+        throw new GSDNoProjectError(result.reason ?? "GSD must be run inside a project directory.");
     }
     return root;
 }

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

@@ -1,3 +1,4 @@
+import { GSDNoProjectError } from "./context.js";
 import { handleAutoCommand } from "./handlers/auto.js";
 import { handleCoreCommand } from "./handlers/core.js";
 import { handleOpsCommand } from "./handlers/ops.js";
@@ -12,10 +13,19 @@ export async function handleGSDCommand(args, ctx, pi) {
         () => handleWorkflowCommand(trimmed, ctx, pi),
         () => handleOpsCommand(trimmed, ctx, pi),
     ];
-    for (const handler of handlers) {
-        if (await handler()) {
+    try {
+        for (const handler of handlers) {
+            if (await handler()) {
+                return;
+            }
+        }
+    }
+    catch (err) {
+        if (err instanceof GSDNoProjectError) {
+            ctx.ui.notify(`${err.message} \`cd\` into a project directory first.`, "warning");
             return;
         }
+        throw err;
     }
     ctx.ui.notify(`Unknown: /gsd ${trimmed}. Run /gsd help for available commands.`, "warning");
 }

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

@@ -1,7 +1,7 @@
 import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 import { enableDebug } from "../../debug-logger.js";
-import { isAutoActive, isAutoPaused, pauseAuto, startAuto, stopAuto, stopAutoRemote } from "../../auto.js";
+import { isAutoActive, isAutoPaused, pauseAuto, startAutoDetached, stopAuto, stopAutoRemote } from "../../auto.js";
 import { handleRate } from "../../commands-rate.js";
 import { guardRemoteSession, projectRoot } from "../context.js";
 import { findMilestoneIds } from "../../milestone-id-utils.js";
@@ -36,27 +36,6 @@ export function parseMilestoneTarget(input) {
     const rest = input.replace(match[0], "").replace(/\s+/g, " ").trim();
     return { milestoneId: match[1], rest };
 }
-/**
- * Set GSD_MILESTONE_LOCK to target a specific milestone, then run `fn`.
- * Clears the env var when `fn` resolves or rejects, so the lock does not
- * leak into subsequent commands in the same process.
- */
-async function withMilestoneLock(milestoneId, fn) {
-    const previous = process.env.GSD_MILESTONE_LOCK;
-    process.env.GSD_MILESTONE_LOCK = milestoneId;
-    try {
-        await fn();
-    }
-    finally {
-        // Restore previous value (undefined → delete, else restore).
-        if (previous === undefined) {
-            delete process.env.GSD_MILESTONE_LOCK;
-        }
-        else {
-            process.env.GSD_MILESTONE_LOCK = previous;
-        }
-    }
-}
 export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "next" || trimmed.startsWith("next ")) {
         if (trimmed.includes("--dry-run")) {
@@ -79,12 +58,10 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
                 return true;
             }
         }
-        if (milestoneId) {
-            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode, { step: true }));
-        }
-        else {
-            await startAuto(ctx, pi, projectRoot(), verboseMode, { step: true });
-        }
+        startAutoDetached(ctx, pi, projectRoot(), verboseMode, {
+            step: true,
+            milestoneLock: milestoneId,
+        });
         return true;
     }
     if (trimmed === "auto" || trimmed.startsWith("auto ")) {
@@ -122,12 +99,12 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
             await showHeadlessMilestoneCreation(ctx, pi, projectRoot(), seedContent);
         }
         else if (milestoneId) {
-            // Target a specific milestone — use GSD_MILESTONE_LOCK so state
-            // derivation only sees this milestone (#2521).
-            await withMilestoneLock(milestoneId, () => startAuto(ctx, pi, projectRoot(), verboseMode));
+            startAutoDetached(ctx, pi, projectRoot(), verboseMode, {
+                milestoneLock: milestoneId,
+            });
         }
         else {
-            await startAuto(ctx, pi, projectRoot(), verboseMode);
+            startAutoDetached(ctx, pi, projectRoot(), verboseMode);
         }
         return true;
     }
@@ -168,7 +145,7 @@ export async function handleAutoCommand(trimmed, ctx, pi) {
     if (trimmed === "") {
         if (!(await guardRemoteSession(ctx, pi)))
             return true;
-        await startAuto(ctx, pi, projectRoot(), false, { step: true });
+        startAutoDetached(ctx, pi, projectRoot(), false, { step: true });
         return true;
     }
     return false;

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

@@ -4,10 +4,43 @@ import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard
 import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
+import { setSessionModelOverride } from "../../session-model-override.js";
 import { projectRoot } from "../context.js";
-import { formatShortcut } from "../../files.js";
-export function showHelp(ctx) {
-    const lines = [
+import { formattedShortcutPair } from "../../shortcut-defs.js";
+export function showHelp(ctx, args = "") {
+    const summaryLines = [
+        "GSD — Get Shit Done\n",
+        "QUICK START",
+        "  /gsd start <tpl>   Start a workflow template",
+        "  /gsd               Run next unit (same as /gsd next)",
+        "  /gsd auto          Run all queued units continuously",
+        "  /gsd pause         Pause auto-mode",
+        "  /gsd stop          Stop auto-mode gracefully",
+        "",
+        "VISIBILITY",
+        `  /gsd status         Dashboard  (${formattedShortcutPair("dashboard")})`,
+        `  /gsd parallel watch Parallel monitor  (${formattedShortcutPair("parallel")})`,
+        `  /gsd notifications  Notification history  (${formattedShortcutPair("notifications")})`,
+        "  /gsd visualize      Interactive 10-tab TUI",
+        "  /gsd queue          Show queued/dispatched units",
+        "",
+        "COURSE CORRECTION",
+        "  /gsd steer <desc>   Apply user override to active work",
+        "  /gsd capture <text> Quick-capture a thought to CAPTURES.md",
+        "  /gsd triage         Classify and route pending captures",
+        "  /gsd undo           Revert last completed unit  [--force]",
+        "  /gsd rethink        Conversational project reorganization",
+        "",
+        "SETUP",
+        "  /gsd init           Project init wizard",
+        "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
+        "  /gsd model          Switch active session model",
+        "  /gsd prefs          Manage preferences",
+        "  /gsd doctor         Diagnose and repair .gsd/ state",
+        "",
+        "Use /gsd help full for the complete command reference.",
+    ];
+    const fullLines = [
         "GSD — Get Shit Done\n",
         "WORKFLOW",
         "  /gsd start <tpl>   Start a workflow template (bugfix, spike, feature, hotfix, etc.)",
@@ -21,12 +54,13 @@ export function showHelp(ctx) {
         "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
         "",
         "VISIBILITY",
-        `  /gsd status         Show progress dashboard  (${formatShortcut("Ctrl+Alt+G")})`,
+        `  /gsd status         Show progress dashboard  (${formattedShortcutPair("dashboard")})`,
+        `  /gsd parallel watch Open parallel worker monitor  (${formattedShortcutPair("parallel")})`,
         "  /gsd visualize      Interactive 10-tab TUI (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)",
         "  /gsd queue          Show queued/dispatched units and execution order",
         "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
         "  /gsd changelog      Show categorized release notes  [version]",
-        `  /gsd notifications  View persistent notification history  [clear|tail|filter]  (${formatShortcut("Ctrl+Alt+N")})`,
+        `  /gsd notifications  View persistent notification history  [clear|tail|filter]  (${formattedShortcutPair("notifications")})`,
         "",
         "COURSE CORRECTION",
         "  /gsd steer <desc>   Apply user override to active work",
@@ -66,7 +100,8 @@ export function showHelp(ctx) {
         "  /gsd inspect        Show SQLite DB diagnostics (schema, row counts, recent entries)",
         "  /gsd update         Update GSD to the latest version via npm",
     ];
-    ctx.ui.notify(lines.join("\n"), "info");
+    const full = ["full", "--full", "all"].includes(args.trim().toLowerCase());
+    ctx.ui.notify((full ? fullLines : summaryLines).join("\n"), "info");
 }
 export async function handleStatus(ctx) {
     const basePath = projectRoot();
@@ -82,9 +117,9 @@ export async function handleStatus(ctx) {
     const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)), {
         overlay: true,
         overlayOptions: {
-            width: "70%",
-            minWidth: 60,
-            maxHeight: "90%",
+            width: "90%",
+            minWidth: 80,
+            maxHeight: "92%",
             anchor: "center",
         },
     });
@@ -251,11 +286,21 @@ async function handleModel(trimmedArgs, ctx, pi) {
         ctx.ui.notify(`No API key for ${targetModel.provider}/${targetModel.id}`, "warning");
         return;
     }
+    // /gsd model is an explicit per-session pin for GSD dispatches.
+    // This is captured at auto bootstrap so it survives internal session
+    // switches during /gsd auto and /gsd next runs.
+    const sessionId = ctx.sessionManager?.getSessionId?.();
+    if (sessionId) {
+        setSessionModelOverride(sessionId, {
+            provider: targetModel.provider,
+            id: targetModel.id,
+        });
+    }
     ctx.ui.notify(`Model: ${targetModel.provider}/${targetModel.id}`, "info");
 }
 export async function handleCoreCommand(trimmed, ctx, pi) {
-    if (trimmed === "help" || trimmed === "h" || trimmed === "?") {
-        showHelp(ctx);
+    if (trimmed === "help" || trimmed === "h" || trimmed === "?" || trimmed.startsWith("help ")) {
+        showHelp(ctx, trimmed.startsWith("help ") ? trimmed.slice(5).trim() : "");
         return true;
     }
     if (trimmed === "status") {