gsd-pi 2.71.0-dev.06b86c6 → 2.71.0-dev.7a61d89

package/src/resources/extensions/gsd/auto.ts

@@ -165,6 +165,7 @@ 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, type JournalEntry } from "./journal.js";
 import {
@@ -272,6 +273,53 @@ function restoreProjectRootEnv(): void {
   s.projectRootEnvCaptured = false;
 }
 
+function captureMilestoneLockEnv(milestoneId: string | null): void {
+  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(): void {
+  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: ExtensionCommandContext,
+  pi: ExtensionAPI,
+  base: string,
+  verboseMode: boolean,
+  options?: {
+    step?: boolean;
+    interrupted?: InterruptedSessionAssessment;
+    milestoneLock?: string | null;
+  },
+): void {
+  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(): boolean {
   const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
   if (prefs?.isolation === "worktree") return true;
@@ -549,11 +597,13 @@ function buildSnapshotOpts(
   _unitType: string,
   _unitId: string,
 ): {
+  autoSessionKey?: string;
   continueHereFired?: boolean;
   promptCharCount?: number;
   baselineCharCount?: number;
 } & Record<string, unknown> {
   return {
+    ...(s.autoStartTime > 0 ? { autoSessionKey: String(s.autoStartTime) } : {}),
     promptCharCount: s.lastPromptCharCount,
     baselineCharCount: s.lastBaselineCharCount,
     ...(s.currentUnitRouting ?? {}),
@@ -574,6 +624,7 @@ function handleLostSessionLock(
   s.paused = false;
   clearUnitTimeout();
   restoreProjectRootEnv();
+  restoreMilestoneLockEnv();
   deregisterSigtermHandler();
   clearCmuxSidebar(loadEffectiveGSDPreferences()?.preferences);
   const base = lockBase();
@@ -610,6 +661,7 @@ function cleanupAfterLoopExit(ctx: ExtensionContext): void {
   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"
@@ -880,6 +932,7 @@ export async function stopAuto(
     ctx?.ui.setWidget("gsd-progress", undefined);
     ctx?.ui.setFooter(undefined);
     restoreProjectRootEnv();
+    restoreMilestoneLockEnv();
 
     // Reset all session state in one call
     s.reset();
@@ -933,6 +986,7 @@ export async function pauseAuto(
       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 });
@@ -971,6 +1025,7 @@ export async function pauseAuto(
   s.active = false;
   s.paused = true;
   restoreProjectRootEnv();
+  restoreMilestoneLockEnv();
   s.pendingVerificationRetry = null;
   s.verificationRetryCount.clear();
   ctx?.ui.setStatus("gsd-auto", "paused");
@@ -1154,6 +1209,7 @@ export async function startAuto(
   options?: {
     step?: boolean;
     interrupted?: InterruptedSessionAssessment;
+    milestoneLock?: string | null;
   },
 ): Promise<void> {
   if (s.active) {
@@ -1163,6 +1219,12 @@ export async function startAuto(
 
   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);
@@ -1194,6 +1256,7 @@ export async function startAuto(
         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); } catch (e) { logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" }); }
         ctx.ui.notify(
@@ -1228,6 +1291,7 @@ export async function startAuto(
             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); } catch (e) { logWarning("session", `pause file cleanup failed: ${e instanceof Error ? e.message : String(e)}`, { file: "auto.ts" }); }
             ctx.ui.notify(
@@ -1247,6 +1311,10 @@ export async function startAuto(
     if (!s.autoStartTime || s.autoStartTime <= 0) s.autoStartTime = Date.now();
   }
 
+  if (s.sessionMilestoneLock) {
+    captureMilestoneLockEnv(s.sessionMilestoneLock);
+  }
+
   if (!s.paused) {
     s.stepMode = requestedStepMode;
   }

package/src/resources/extensions/gsd/bootstrap/register-shortcuts.ts

@@ -1,79 +1,101 @@
 import { existsSync } from "node:fs";
 import { join } from "node:path";
 
-import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import type { ExtensionAPI, ExtensionContext } from "@gsd/pi-coding-agent";
 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: ExtensionAPI): void {
-  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<boolean>(
-        (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",
+  } as const;
+
+  const openDashboardOverlay = async (ctx: ExtensionContext) => {
+    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<boolean>(
+      (tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done(true)),
+      {
+        overlay: true,
+        overlayOptions,
+      },
+    );
+  };
+
+  const openNotificationsOverlay = async (ctx: ExtensionContext) => {
+    await ctx.ui.custom<boolean>(
+      (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: ExtensionContext) => {
+    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<boolean>(
+      (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<boolean>(
-        (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<boolean>(
-        (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/src/resources/extensions/gsd/commands/handlers/auto.ts

@@ -4,7 +4,7 @@ import { existsSync, readFileSync } from "node:fs";
 import { resolve } from "node:path";
 
 import { enableDebug } from "../../debug-logger.js";
-import { getAutoDashboardData, isAutoActive, isAutoPaused, pauseAuto, startAuto, stopAuto, stopAutoRemote } from "../../auto.js";
+import { getAutoDashboardData, 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";
@@ -42,26 +42,6 @@ export function parseMilestoneTarget(input: string): { milestoneId: string | nul
   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: string, fn: () => Promise<void>): Promise<void> {
-  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: string, ctx: ExtensionCommandContext, pi: ExtensionAPI): Promise<boolean> {
   if (trimmed === "next" || trimmed.startsWith("next ")) {
     if (trimmed.includes("--dry-run")) {
@@ -84,13 +64,10 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
       }
     }
 
-    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;
   }
 
@@ -128,13 +105,11 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
       const { showHeadlessMilestoneCreation } = await import("../../guided-flow.js");
       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;
   }
@@ -175,10 +150,9 @@ export async function handleAutoCommand(trimmed: string, ctx: ExtensionCommandCo
 
   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/src/resources/extensions/gsd/commands/handlers/core.ts

@@ -9,10 +9,43 @@ import { runEnvironmentChecks } from "../../doctor-environment.js";
 import { deriveState } from "../../state.js";
 import { handleCmux } from "../../commands-cmux.js";
 import { projectRoot } from "../context.js";
-import { formatShortcut } from "../../files.js";
+import { formattedShortcutPair } from "../../shortcut-defs.js";
 
-export function showHelp(ctx: ExtensionCommandContext): void {
-  const lines = [
+export function showHelp(ctx: ExtensionCommandContext, args = ""): void {
+  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.)",
@@ -26,12 +59,13 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  /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",
@@ -71,7 +105,8 @@ export function showHelp(ctx: ExtensionCommandContext): void {
     "  /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: ExtensionCommandContext): Promise<void> {
@@ -92,9 +127,9 @@ export async function handleStatus(ctx: ExtensionCommandContext): Promise<void>
     {
       overlay: true,
       overlayOptions: {
-        width: "70%",
-        minWidth: 60,
-        maxHeight: "90%",
+        width: "90%",
+        minWidth: 80,
+        maxHeight: "92%",
         anchor: "center",
       },
     },
@@ -309,8 +344,8 @@ export async function handleCoreCommand(
   ctx: ExtensionCommandContext,
   pi?: ExtensionAPI,
 ): Promise<boolean> {
-  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") {

package/src/resources/extensions/gsd/commands/handlers/notifications-handler.ts

@@ -13,6 +13,8 @@ import {
 } from "../../notification-store.js";
 import { GSDNotificationOverlay } from "../../notification-overlay.js";
 
+const MAX_INLINE_ENTRIES = 40;
+
 function severityIcon(severity: NotifySeverity): string {
   switch (severity) {
     case "error": return "✗";
@@ -54,8 +56,9 @@ export async function handleNotificationsCommand(
   if (args === "tail" || args.startsWith("tail ")) {
     const countStr = args.replace(/^tail\s*/, "").trim();
     const count = countStr ? parseInt(countStr, 10) : 20;
-    const n = isNaN(count) || count < 1 ? 20 : Math.min(count, 100);
-    const entries = readNotifications().slice(0, n);
+    const all = readNotifications();
+    const n = isNaN(count) || count < 1 ? 20 : Math.min(count, MAX_INLINE_ENTRIES);
+    const entries = all.slice(0, n);
 
     if (entries.length === 0) {
       ctx.ui.notify("No notifications.", "info");
@@ -65,7 +68,10 @@ export async function handleNotificationsCommand(
     const lines = entries.map((e) =>
       `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`,
     );
-    ctx.ui.notify(`Last ${entries.length} notification(s):\n${lines.join("\n")}`, "info");
+    const suffix = all.length > entries.length
+      ? `\n... and ${all.length - entries.length} more (open /gsd notifications to browse all)`
+      : "";
+    ctx.ui.notify(`Last ${entries.length} notification(s):\n${lines.join("\n")}${suffix}`, "info");
     return true;
   }
 
@@ -86,7 +92,9 @@ export async function handleNotificationsCommand(
     const lines = entries.slice(0, 20).map((e) =>
       `${severityIcon(e.severity)} [${formatTimestamp(e.ts)}] ${e.message}`,
     );
-    const suffix = entries.length > 20 ? `\n... and ${entries.length - 20} more` : "";
+    const suffix = entries.length > 20
+      ? `\n... and ${entries.length - 20} more (open /gsd notifications to browse all)`
+      : "";
     ctx.ui.notify(`${severity} notifications (${entries.length}):\n${lines.join("\n")}${suffix}`, "info");
     return true;
   }
@@ -96,8 +104,8 @@ export async function handleNotificationsCommand(
     // Try overlay first (TUI mode)
     if (ctx.hasUI) {
       try {
-        await ctx.ui.custom<void>(
-          (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done()),
+        const result = await ctx.ui.custom<boolean>(
+          (tui, theme, _kb, done) => new GSDNotificationOverlay(tui, theme, () => done(true)),
           {
             overlay: true,
             overlayOptions: {
@@ -109,7 +117,9 @@ export async function handleNotificationsCommand(
             },
           },
         );
-        return true;
+        if (result !== undefined) {
+          return true;
+        }
       } catch {
         // Fall through to text output if overlay fails
       }

package/src/resources/extensions/gsd/commands/handlers/workflow.ts

@@ -18,7 +18,7 @@ import { createRun, listRuns } from "../../run-manager.js";
 import {
   setActiveEngineId,
   setActiveRunDir,
-  startAuto,
+  startAutoDetached,
   pauseAuto,
   isAutoActive,
   getActiveEngineId,
@@ -77,7 +77,7 @@ async function handleCustomWorkflow(
       setActiveEngineId("custom");
       setActiveRunDir(runDir);
       ctx.ui.notify(`Created workflow run: ${defName}\nRun dir: ${runDir}`, "info");
-      await startAuto(ctx, pi, base, false);
+      startAutoDetached(ctx, pi, base, false);
     } catch (err) {
       // Clean up engine state so a failed workflow run doesn't pollute the next /gsd auto
       setActiveEngineId(null);
@@ -157,13 +157,8 @@ async function handleCustomWorkflow(
       ctx.ui.notify("No custom workflow to resume. Use /gsd auto for dev workflow.", "warning");
       return true;
     }
-    try {
-      await startAuto(ctx, pi, projectRoot(), false);
-      ctx.ui.notify("Custom workflow resumed.", "info");
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      ctx.ui.notify(`Failed to resume workflow: ${msg}`, "error");
-    }
+    startAutoDetached(ctx, pi, projectRoot(), false);
+    ctx.ui.notify("Custom workflow resumed.", "info");
     return true;
   }
 
@@ -278,4 +273,3 @@ export function getNextMilestoneId(basePath: string): string {
   const uniqueIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
   return nextMilestoneId(milestoneIds, uniqueIds);
 }
-

package/src/resources/extensions/gsd/dashboard-overlay.ts

@@ -3,7 +3,8 @@
  *
  * Full-screen overlay showing auto-mode progress: milestone/slice/task
  * breakdown, current unit, completed units, timing, and activity log.
- * Toggled with Ctrl+Alt+G (⌃⌥G on macOS) or opened from /gsd status.
+ * Toggled with Ctrl+Alt+G (⌃⌥G on macOS), Ctrl+Shift+G fallback,
+ * or opened from /gsd status.
  */
 
 import type { Theme } from "@gsd/pi-coding-agent";
@@ -26,6 +27,7 @@ import { formatDuration, padRight, joinColumns, centerLine, fitColumns, STATUS_G
 import { estimateTimeRemaining } from "./auto-dashboard.js";
 import { computeProgressScore, formatProgressLine } from "./progress-score.js";
 import { runEnvironmentChecks, type EnvironmentCheckResult } from "./doctor-environment.js";
+import { formattedShortcutPair } from "./shortcut-defs.js";
 
 function unitLabel(type: string): string {
   switch (type) {
@@ -203,7 +205,12 @@ export class GSDDashboardOverlay {
   }
 
   handleInput(data: string): void {
-    if (matchesKey(data, Key.escape) || matchesKey(data, Key.ctrl("c")) || matchesKey(data, Key.ctrlAlt("g"))) {
+    if (
+      matchesKey(data, Key.escape) ||
+      matchesKey(data, Key.ctrl("c")) ||
+      matchesKey(data, Key.ctrlAlt("g")) ||
+      matchesKey(data, Key.ctrlShift("g"))
+    ) {
       this.dispose();
       this.onClose();
       return;
@@ -587,7 +594,7 @@ export class GSDDashboardOverlay {
 
     lines.push(blank());
     lines.push(hr());
-    lines.push(centered(th.fg("dim", "↑↓ scroll · g/G top/end · esc close")));
+    lines.push(centered(th.fg("dim", `↑↓ scroll · g/G top/end · Esc/${formattedShortcutPair("dashboard")} close`)));
 
     return lines;
   }