gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.2203010a0

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

@@ -45,12 +45,14 @@ import { atomicWriteSync } from "./atomic-write.js";
 import { autoCommitCurrentBranch, captureIntegrationBranch, detectWorktreeName, getCurrentBranch, getMainBranch, setActiveMilestoneId, } from "./worktree.js";
 import { GitServiceImpl } from "./git-service.js";
 import { getPriorSliceCompletionBlocker } from "./dispatch-guard.js";
-import { createAutoWorktree, enterAutoWorktree, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
+import { createAutoWorktree, enterAutoWorktree, enterBranchModeForMilestone, teardownAutoWorktree, isInAutoWorktree, getAutoWorktreePath, mergeMilestoneToMain, autoWorktreeBranch, syncWorktreeStateBack, syncProjectRootToWorktree, checkResourcesStale, escapeStaleWorktree, } from "./auto-worktree.js";
 import { pruneQueueOrder } from "./queue-order.js";
+import { startCommandPolling as _startCommandPolling, isRemoteConfigured } from "../remote-questions/manager.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 { recoverFailedMigration } from "./migrate-external.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";
@@ -64,7 +66,7 @@ import { runPostUnitVerification } from "./auto-verification.js";
 import { autoCommitUnit, postUnitPreVerification, postUnitPostVerification, } from "./auto-post-unit.js";
 import { bootstrapAutoSession, openProjectDbIfPresent } from "./auto-start.js";
 import { initHealthWidget } from "./health-widget.js";
-import { autoLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
+import { runLegacyAutoLoop, runUokKernelLoop, resolveAgentEnd, resolveAgentEndCancelled, _resetPendingResolve, isSessionSwitchInFlight } from "./auto-loop.js";
 import { runAutoLoopWithUok } from "./uok/kernel.js";
 import { resolveUokFlags } from "./uok/flags.js";
 import { WorktreeResolver, } from "./worktree-resolver.js";
@@ -142,6 +144,7 @@ export function startAutoDetached(ctx, pi, base, verboseMode, options) {
         debugLog("auto-start-failed", { error: message });
     });
 }
+/** Returns true if the project is configured for `isolation:worktree` mode. */
 export function shouldUseWorktreeIsolation() {
     const prefs = loadEffectiveGSDPreferences()?.preferences?.git;
     if (prefs?.isolation === "worktree")
@@ -185,6 +188,26 @@ function deregisterSigtermHandler() {
     _deregisterSigtermHandler(s.sigtermHandler);
     s.sigtermHandler = null;
 }
+/**
+ * Wrapper: start background command polling for the configured remote channel
+ * (currently Telegram only). Stores the cleanup function on the session so
+ * every exit path can stop the interval via stopCommandPolling().
+ * No-op when no remote channel is configured.
+ */
+function startAutoCommandPolling(basePath) {
+    if (!isRemoteConfigured())
+        return;
+    // Clear any existing interval before starting a new one (e.g. resume path).
+    stopAutoCommandPolling();
+    s.commandPollingCleanup = _startCommandPolling(basePath);
+}
+/** Wrapper: stop background command polling and clear the stored cleanup. */
+function stopAutoCommandPolling() {
+    if (s.commandPollingCleanup) {
+        s.commandPollingCleanup();
+        s.commandPollingCleanup = null;
+    }
+}
 export function getAutoDashboardData() {
     const ledger = getLedger();
     const totals = ledger ? getProjectTotals(ledger.units) : null;
@@ -248,6 +271,14 @@ export function getActiveRunDir() {
 export function getAutoModeStartModel() {
     return s.autoModeStartModel;
 }
+/**
+ * Update the dashboard-facing dispatched model label.
+ * Used when runtime recovery switches models mid-unit (e.g. provider fallback)
+ * so the AUTO box reflects the active model immediately.
+ */
+export function setCurrentDispatchedModelId(model) {
+    s.currentDispatchedModelId = model ? `${model.provider}/${model.id}` : null;
+}
 // Tool tracking — delegates to auto-tool-tracking.ts
 export function markToolStart(toolCallId, toolName) {
     _markToolStart(toolCallId, s.active, toolName);
@@ -392,6 +423,7 @@ function handleLostSessionLock(ctx, lockStatus) {
     s.paused = false;
     deactivateGSD();
     clearUnitTimeout();
+    stopAutoCommandPolling();
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     deregisterSigtermHandler();
@@ -427,6 +459,7 @@ function cleanupAfterLoopExit(ctx) {
     s.active = false;
     deactivateGSD();
     clearUnitTimeout();
+    stopAutoCommandPolling();
     restoreProjectRootEnv();
     restoreMilestoneLockEnv();
     // Clear crash lock and release session lock so the next `/gsd next` does
@@ -471,6 +504,7 @@ export async function stopAuto(ctx, pi, reason) {
         // ── Step 1: Timers and locks ──
         try {
             clearUnitTimeout();
+            stopAutoCommandPolling();
             if (lockBase())
                 clearLock(lockBase());
             if (lockBase())
@@ -724,6 +758,7 @@ export async function pauseAuto(ctx, _pi, _errorContext) {
     if (!s.active)
         return;
     clearUnitTimeout();
+    stopAutoCommandPolling();
     // Flush queued follow-up messages (#3512).
     // Late async notifications (async_job_result, gsd-auto-wrapup) can trigger
     // extra LLM turns after pause. Flush them the same way run-unit.ts does.
@@ -814,6 +849,7 @@ function buildResolverDeps() {
         teardownAutoWorktree,
         createAutoWorktree,
         enterAutoWorktree,
+        enterBranchModeForMilestone,
         getAutoWorktreePath,
         autoCommitCurrentBranch,
         getCurrentBranch,
@@ -941,6 +977,11 @@ function buildLoopDeps() {
         emitJournalEvent: (entry) => _emitJournalEvent(s.basePath, entry),
     };
 }
+/**
+ * Start auto-mode. Handles both fresh-start and resume paths, sets up session
+ * state, enters the milestone worktree or branch, and dispatches the first unit.
+ * No-ops if auto-mode is already active.
+ */
 export async function startAuto(ctx, pi, base, verboseMode, options) {
     if (s.active) {
         debugLog("startAuto", { phase: "already-active", skipping: true });
@@ -956,6 +997,12 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
     }
     // Escape stale worktree cwd from a previous milestone (#608).
     base = escapeStaleWorktree(base);
+    // Heal .gsd.migrating before any branching — covers both fresh-start and
+    // resume paths (#4416). The matching call in auto-start.ts covers the
+    // bootstrap-only path; this call ensures the resume path is also protected.
+    if (recoverFailedMigration(base)) {
+        ctx.ui.notify("Recovered unfinished migration (.gsd.migrating → .gsd).", "info");
+    }
     const freshStartAssessment = interruptedAssessment
         ?? await assessInterruptedSession(base);
     if (freshStartAssessment.classification === "running") {
@@ -1112,9 +1159,9 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
             const level = to === "red" ? "error" : to === "yellow" ? "warning" : "info";
             ctx.ui.notify(summary, level);
         });
-        // ── Auto-worktree: re-enter worktree on resume ──
+        // ── Auto-worktree / branch-mode: re-enter on resume ──
         if (s.currentMilestoneId &&
-            shouldUseWorktreeIsolation() &&
+            getIsolationMode() !== "none" &&
             s.originalBasePath &&
             !isInAutoWorktree(s.basePath) &&
             !detectWorktreeName(s.basePath) &&
@@ -1179,12 +1226,14 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         writeLock(lockBase(), "resuming", s.currentMilestoneId ?? "unknown");
         logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, s.stepMode ? "Step-mode resumed." : "Auto-mode resumed.", "progress");
         captureProjectRootEnv(s.originalBasePath || s.basePath);
+        startAutoCommandPolling(s.basePath);
         await runAutoLoopWithUok({
             ctx,
             pi,
             s,
             deps: buildLoopDeps(),
-            runLegacyLoop: autoLoop,
+            runKernelLoop: runUokKernelLoop,
+            runLegacyLoop: runLegacyAutoLoop,
         });
         cleanupAfterLoopExit(ctx);
         return;
@@ -1208,35 +1257,18 @@ export async function startAuto(ctx, pi, base, verboseMode, options) {
         logWarning("engine", `cmux sync failed: ${err instanceof Error ? err.message : String(err)}`, { file: "auto.ts" });
     }
     logCmuxEvent(loadEffectiveGSDPreferences()?.preferences, requestedStepMode ? "Step-mode started." : "Auto-mode started.", "progress");
+    startAutoCommandPolling(s.basePath);
     // Dispatch the first unit
     await runAutoLoopWithUok({
         ctx,
         pi,
         s,
         deps: buildLoopDeps(),
-        runLegacyLoop: autoLoop,
+        runKernelLoop: runUokKernelLoop,
+        runLegacyLoop: runLegacyAutoLoop,
     });
     cleanupAfterLoopExit(ctx);
 }
-// ─── Agent End Handler ────────────────────────────────────────────────────────
-/**
- * Deprecated thin wrapper — kept as export for backward compatibility.
- * The actual agent_end processing now happens via resolveAgentEnd() in auto-loop.ts,
- * which is called directly from index.ts. The autoLoop() while loop handles all
- * post-unit processing (verification, hooks, dispatch) that this function used to do.
- *
- * If called by straggler code, it simply resolves the pending promise so the loop
- * can continue.
- */
-export async function handleAgentEnd(ctx, pi) {
-    if (!s.active || !s.cmdCtx) {
-        // Even when inactive, resolve any pending promise so the loop is unblocked.
-        resolveAgentEndCancelled();
-        return;
-    }
-    clearUnitTimeout();
-    resolveAgentEnd({ messages: [] });
-}
 // describeNextUnit is imported from auto-dashboard.ts and re-exported
 export { describeNextUnit } from "./auto-dashboard.js";
 /** Thin wrapper: delegates to auto-dashboard.ts, passing state accessors. */

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

@@ -1,6 +1,6 @@
 import { logWarning } from "../workflow-logger.js";
 import { checkAutoStartAfterDiscuss } from "../guided-flow.js";
-import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto } from "../auto.js";
+import { getAutoDashboardData, getAutoModeStartModel, isAutoActive, pauseAuto, setCurrentDispatchedModelId } from "../auto.js";
 import { getNextFallbackModel, resolveModelWithFallbacksForUnit } from "../preferences.js";
 import { pauseAutoForProviderError } from "../provider-error-pause.js";
 import { isSessionSwitchInFlight, resolveAgentEnd } from "../auto-loop.js";
@@ -106,26 +106,11 @@ export async function handleAgentEnd(pi, event, ctx) {
         const explicitRetryAfterMs = ("retryAfterMs" in lastMsg && typeof lastMsg.retryAfterMs === "number") ? lastMsg.retryAfterMs : undefined;
         // ── 1. Classify using rawErrorMsg to avoid prose false-positives ────
         const cls = classifyError(rawErrorMsg, explicitRetryAfterMs);
-        // ── 1b. Defer to Core RetryHandler for transient errors ─────────────
-        // The Core RetryHandler (agent-session.ts) processes retryable errors
-        // AFTER this extension handler, in the same _processAgentEvent() call.
-        // For transient errors (overloaded, rate limit, server), the Core will
-        // retry in-context — same session, same conversation — which is strictly
-        // better than our Layer 2 pause+resume (which creates a new session).
-        //
-        // If we react here AND the Core also retries, we race: pauseAuto tears
-        // down the session while agent.continue() starts a new turn.
-        //
-        // Solution: Do nothing for transient errors. The Core RetryHandler
-        // runs next in _processAgentEvent and will either:
-        //   a) Retry successfully → new agent_end (success) → we see it next time
-        //   b) Exhaust retries → the agent stays idle, autoLoop's unit timeout
-        //      or stuck detection handles it
-        //
-        // We do NOT call resolveAgentEnd here — that would unblock autoLoop
-        // prematurely while the Core is still retrying in the same session.
-        // We do NOT call pauseAuto — that would tear down the session.
-        if (isTransient(cls)) {
+        // ── 1b. Defer to Core RetryHandler for most transient errors ────────
+        // Core retries transient failures in-session after this handler.
+        // Keep that behavior for non-rate-limit classes to avoid pause/retry races,
+        // but let rate-limit continue into model fallback logic below (#4373).
+        if (isTransient(cls) && cls.kind !== "rate-limit") {
             return;
         }
         // Cap rate-limit backoff for CLI-style providers (openai-codex, google-gemini-cli)
@@ -177,6 +162,7 @@ export async function handleAgentEnd(pi, event, ctx) {
                         if (modelToSet) {
                             const ok = await pi.setModel(modelToSet, { persist: false });
                             if (ok) {
+                                setCurrentDispatchedModelId({ provider: modelToSet.provider, id: modelToSet.id });
                                 ctx.ui.notify(`Model error${errorDetail}. Switched to fallback: ${nextModelId} and resuming.`, "warning");
                                 pi.sendMessage({ customType: "gsd-auto-timeout-recovery", content: "Continue execution.", display: false }, { triggerTurn: true });
                                 return;
@@ -193,6 +179,7 @@ export async function handleAgentEnd(pi, event, ctx) {
                     if (startModel) {
                         const ok = await pi.setModel(startModel, { persist: false });
                         if (ok) {
+                            setCurrentDispatchedModelId({ provider: startModel.provider, id: startModel.id });
                             retryState.networkRetryCount = 0;
                             retryState.currentRetryModelId = undefined;
                             ctx.ui.notify(`Model error${errorDetail}. Restored session model: ${sessionModel.provider}/${sessionModel.id} and resuming.`, "warning");

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

@@ -421,10 +421,14 @@ export function registerDbTools(pi) {
                 depends: Type.Array(Type.String(), { description: "Slice dependency IDs" }),
                 demo: Type.String({ description: "Roadmap demo text / After this" }),
                 goal: Type.String({ description: "Slice goal" }),
-                successCriteria: Type.String({ description: "Slice success criteria block" }),
-                proofLevel: Type.String({ description: "Slice proof level" }),
-                integrationClosure: Type.String({ description: "Slice integration closure" }),
-                observabilityImpact: Type.String({ description: "Slice observability impact" }),
+                // ADR-011: heavy planning fields are optional for sketch slices; required for full slices.
+                successCriteria: Type.Optional(Type.String({ description: "Slice success criteria block (required for full slices; omit for sketches)" })),
+                proofLevel: Type.Optional(Type.String({ description: "Slice proof level (required for full slices; omit for sketches)" })),
+                integrationClosure: Type.Optional(Type.String({ description: "Slice integration closure (required for full slices; omit for sketches)" })),
+                observabilityImpact: Type.Optional(Type.String({ description: "Slice observability impact (required for full slices; omit for sketches)" })),
+                // ADR-011 sketch-then-refine fields.
+                isSketch: Type.Optional(Type.Boolean({ description: "ADR-011: true marks this slice as a sketch awaiting refine-slice expansion" })),
+                sketchScope: Type.Optional(Type.String({ description: "ADR-011: 2–3 sentence scope boundary, required when isSketch=true" })),
             }), { description: "Planned slices for the milestone" }),
             // ── Enrichment metadata (optional — defaults to empty) ────────────
             status: Type.Optional(Type.String({ description: "Milestone status (defaults to active)" })),
@@ -589,6 +593,20 @@ export function registerDbTools(pi) {
             keyFiles: Type.Optional(Type.Array(Type.String(), { description: "List of key files created or modified" })),
             keyDecisions: Type.Optional(Type.Array(Type.String(), { description: "List of key decisions made during this task" })),
             blockerDiscovered: Type.Optional(Type.Boolean({ description: "Whether a plan-invalidating blocker was discovered" })),
+            // ADR-011 Phase 2: mid-execution escalation — agent asks the user to resolve an ambiguity.
+            escalation: Type.Optional(Type.Object({
+                question: Type.String({ description: "The question the user needs to answer — one clear sentence." }),
+                options: Type.Array(Type.Object({
+                    id: Type.String({ description: "Short id (e.g. 'A', 'B') used by /gsd escalate resolve." }),
+                    label: Type.String({ description: "One-line label." }),
+                    tradeoffs: Type.String({ description: "1-2 sentences on the tradeoffs of this option." }),
+                }), { minItems: 2, maxItems: 4, description: "2–4 options the user can choose between." }),
+                recommendation: Type.String({ description: "Option id the executor recommends." }),
+                recommendationRationale: Type.String({ description: "Why the recommendation — 1–2 sentences." }),
+                continueWithDefault: Type.Boolean({
+                    description: "When true, loop continues (artifact logged for later review). When false, auto-mode pauses until the user resolves via /gsd escalate resolve.",
+                }),
+            }, { description: "ADR-011 Phase 2: optional escalation payload. Only honored when phases.mid_execution_escalation is true." })),
             verificationEvidence: Type.Optional(Type.Array(Type.Union([
                 Type.Object({
                     command: Type.String({ description: "Verification command that was run" }),

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

@@ -2,6 +2,7 @@
 import { Type } from "@sinclair/typebox";
 import { ensureDbOpen } from "./dynamic-tools.js";
 import { executeMilestoneStatus } from "../tools/workflow-tool-executors.js";
+import { checkpointDatabase } from "../gsd-db.js";
 export function registerQueryTools(pi) {
     pi.registerTool({
         name: "gsd_milestone_status",
@@ -27,4 +28,32 @@ export function registerQueryTools(pi) {
             return executeMilestoneStatus(params);
         },
     });
+    pi.registerTool({
+        name: "gsd_checkpoint_db",
+        label: "Checkpoint GSD Database",
+        description: "Flush the SQLite WAL (Write-Ahead Log) into the base gsd.db file. " +
+            "Call this before `git add .gsd/gsd.db` to ensure the committed database " +
+            "contains current milestone/slice/task state rather than stale pre-session content. " +
+            "Safe to call at any time while GSD is running.",
+        promptSnippet: "Flush WAL into gsd.db so git add stages current state",
+        promptGuidelines: [
+            "Call gsd_checkpoint_db immediately before staging .gsd/gsd.db with git add.",
+            "Do not use sqlite3 or shell commands to checkpoint — they are blocked. Use this tool instead.",
+        ],
+        parameters: Type.Object({}),
+        async execute(_toolCallId, _params, _signal, _onUpdate, _ctx) {
+            const dbAvailable = await ensureDbOpen();
+            if (!dbAvailable) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot checkpoint." }],
+                    details: { operation: "checkpoint_db", error: "db_unavailable" },
+                };
+            }
+            checkpointDatabase();
+            return {
+                content: [{ type: "text", text: "WAL checkpoint complete. gsd.db is now up to date and safe to stage with git add." }],
+                details: { operation: "checkpoint_db", status: "ok" },
+            };
+        },
+    });
 }

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

@@ -13,6 +13,7 @@ import { loadToolApiKeys } from "../commands-config.js";
 import { loadFile, saveFile, formatContinue } from "../files.js";
 import { deriveState } from "../state.js";
 import { getAutoDashboardData, isAutoActive, isAutoPaused, markToolEnd, markToolStart, recordToolInvocationError } from "../auto.js";
+import { hideFooter } from "../auto-dashboard.js";
 import { isParallelActive, shutdownParallel } from "../parallel-orchestrator.js";
 import { checkToolCallLoop, resetToolCallLoopGuard } from "./tool-call-loop-guard.js";
 import { saveActivityLog } from "../activity-log.js";
@@ -77,6 +78,9 @@ export function registerHooks(pi, ecosystemHandlers) {
             catch { /* non-fatal */ }
         }
         loadToolApiKeys();
+        if (isAutoActive()) {
+            ctx.ui.setFooter(hideFooter);
+        }
     });
     pi.on("session_switch", async (_event, ctx) => {
         initNotificationStore(process.cwd());
@@ -96,6 +100,9 @@ export function registerHooks(pi, ecosystemHandlers) {
             prepareWorkflowMcpForProject(ctx, process.cwd());
         }
         loadToolApiKeys();
+        if (isAutoActive()) {
+            ctx.ui.setFooter(hideFooter);
+        }
     });
     pi.on("before_agent_start", async (event, ctx) => {
         // Wait for ecosystem loader to finish (no-op after first turn).
@@ -292,6 +299,7 @@ export function registerHooks(pi, ecosystemHandlers) {
     pi.on("tool_call", async (event, ctx) => {
         if (!isAutoActive())
             return;
+        markToolStart(event.toolCallId, event.toolName);
         safetyRecordToolCall(event.toolCallId, event.toolName, event.input);
         // Destructive command classification (warn only, never block)
         if (isToolCallEventType("bash", event)) {
@@ -305,6 +313,20 @@ export function registerHooks(pi, ecosystemHandlers) {
         }
     });
     pi.on("tool_result", async (event) => {
+        if (isAutoActive() && typeof event.toolCallId === "string") {
+            markToolEnd(event.toolCallId);
+        }
+        if (isAutoActive() && event.isError && event.toolName.startsWith("gsd_")) {
+            const resultPayload = ("result" in event ? event.result : undefined);
+            const errorText = typeof resultPayload === "string"
+                ? resultPayload
+                : (typeof resultPayload?.content?.[0]?.text === "string"
+                    ? resultPayload.content[0].text
+                    : (typeof event.content === "string"
+                        ? event.content
+                        : String(resultPayload ?? "")));
+            recordToolInvocationError(event.toolName, errorText);
+        }
         if (event.toolName !== "ask_user_questions")
             return;
         const milestoneId = getDiscussionMilestoneId(process.cwd());

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

@@ -4,7 +4,7 @@ import { join } from "node:path";
 import { loadRegistry } from "../workflow-templates.js";
 import { resolveProjectRoot } from "../worktree.js";
 const gsdHome = process.env.GSD_HOME || join(homedir(), ".gsd");
-export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|language";
+export const GSD_COMMAND_DESCRIPTION = "GSD — Get Shit Done: /gsd help|start|templates|next|auto|stop|pause|status|widget|visualize|queue|quick|discuss|capture|triage|dispatch|history|undo|undo-task|reset-slice|rate|skip|export|cleanup|model|mode|prefs|config|keys|hooks|run-hook|skill-health|doctor|debug|logs|forensics|changelog|migrate|remote|steer|knowledge|new-milestone|parallel|cmux|park|unpark|init|setup|onboarding|inspect|extensions|update|fast|mcp|rethink|codebase|notifications|ship|do|session-report|backlog|pr-branch|add-tests|scan|language";
 export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "help", desc: "Categorized command reference with descriptions" },
     { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
@@ -32,7 +32,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "model", desc: "Switch the active session model or open a picker" },
     { cmd: "mode", desc: "Switch workflow mode (solo/team)" },
     { cmd: "prefs", desc: "Manage preferences (model selection, timeouts, etc.)" },
-    { cmd: "config", desc: "Set API keys for external tools" },
+    { cmd: "config", desc: "(deprecated) Set tool API keys — use /gsd keys instead" },
     { cmd: "keys", desc: "API key manager — list, add, remove, test, rotate, doctor" },
     { cmd: "hooks", desc: "Show configured post-unit and pre-dispatch hooks" },
     { cmd: "run-hook", desc: "Manually trigger a specific hook" },
@@ -40,9 +40,11 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "notifications", desc: "View, filter, and clear persistent notification history" },
     { cmd: "doctor", desc: "Runtime health checks with auto-fix" },
     { cmd: "logs", desc: "Browse activity logs, debug logs, and metrics" },
+    { cmd: "debug", desc: "Create and inspect persistent /gsd debug sessions" },
     { cmd: "forensics", desc: "Examine execution logs" },
     { cmd: "init", desc: "Project init wizard — detect, configure, bootstrap .gsd/" },
-    { cmd: "setup", desc: "Global setup status and configuration" },
+    { cmd: "setup", desc: "Configuration hub: status + sub-routes (llm, model, search, remote, keys, prefs, onboarding)" },
+    { cmd: "onboarding", desc: "Re-run the setup wizard  [--resume|--reset|--step <name>]" },
     { cmd: "migrate", desc: "Migrate a v1 .planning directory to .gsd format" },
     { cmd: "remote", desc: "Control remote auto-mode" },
     { cmd: "steer", desc: "Hard-steer plan documents during execution" },
@@ -60,7 +62,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "fast", desc: "Toggle OpenAI service tier (on/off/flex/status)" },
     { cmd: "mcp", desc: "MCP server status, connectivity, and local config bootstrap (status, check, init)" },
     { cmd: "rethink", desc: "Conversational project reorganization — reorder, park, discard, add milestones" },
-    { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, validate, pause, resume)" },
+    { cmd: "workflow", desc: "Custom workflow lifecycle (new, run, list, info, install, uninstall, validate, pause, resume) or run <name> directly" },
     { cmd: "codebase", desc: "Generate, refresh, and inspect the codebase map cache (.gsd/CODEBASE.md)" },
     { cmd: "ship", desc: "Create PR from milestone artifacts and open for review" },
     { cmd: "do", desc: "Route freeform text to the right GSD command" },
@@ -68,6 +70,7 @@ export const TOP_LEVEL_SUBCOMMANDS = [
     { cmd: "backlog", desc: "Manage backlog items (add, promote, remove, list)" },
     { cmd: "pr-branch", desc: "Create clean PR branch filtering .gsd/ commits" },
     { cmd: "add-tests", desc: "Generate tests for completed slices" },
+    { cmd: "scan", desc: "Rapid codebase assessment — lightweight alternative to full map (--focus tech|arch|quality|concerns|tech+arch)" },
     { cmd: "language", desc: "Set or clear the global response language (e.g. /gsd language Chinese)" },
 ];
 const NESTED_COMPLETIONS = {
@@ -100,11 +103,18 @@ const NESTED_COMPLETIONS = {
         { cmd: "watch", desc: "Live TUI dashboard monitoring all workers" },
     ],
     setup: [
-        { cmd: "llm", desc: "Configure LLM provider settings" },
+        { cmd: "llm", desc: "Configure LLM provider & auth" },
+        { cmd: "model", desc: "Pick default model for the active provider" },
         { cmd: "search", desc: "Configure web search provider" },
-        { cmd: "remote", desc: "Configure remote integrations" },
-        { cmd: "keys", desc: "Manage API keys" },
-        { cmd: "prefs", desc: "Configure global preferences" },
+        { cmd: "remote", desc: "Configure remote integrations (Discord/Slack/Telegram)" },
+        { cmd: "keys", desc: "Manage API keys (alias for /gsd keys)" },
+        { cmd: "prefs", desc: "Global preferences wizard (alias for /gsd prefs)" },
+        { cmd: "onboarding", desc: "Run the full onboarding wizard (alias for /gsd onboarding)" },
+    ],
+    onboarding: [
+        { cmd: "--resume", desc: "Resume from the last completed step" },
+        { cmd: "--reset", desc: "Reset onboarding state and start over (does not clear API keys)" },
+        { cmd: "--step", desc: "Run a single step: llm|model|search|remote|tool-keys|prefs|skills|doctor|project" },
     ],
     notifications: [
         { cmd: "clear", desc: "Clear all notifications" },
@@ -116,6 +126,12 @@ const NESTED_COMPLETIONS = {
         { cmd: "tail", desc: "Show last N activity log summaries" },
         { cmd: "clear", desc: "Remove old activity and debug logs" },
     ],
+    debug: [
+        { cmd: "list", desc: "List persisted debug sessions" },
+        { cmd: "status", desc: "Show status for one debug session slug" },
+        { cmd: "continue", desc: "Resume an existing debug session slug" },
+        { cmd: "--diagnose", desc: "Inspect malformed artifacts and session health" },
+    ],
     keys: [
         { cmd: "list", desc: "Show key status dashboard" },
         { cmd: "add", desc: "Add a key for a provider" },
@@ -222,8 +238,11 @@ const NESTED_COMPLETIONS = {
     ],
     workflow: [
         { cmd: "new", desc: "Create a new workflow definition (via skill)" },
-        { cmd: "run", desc: "Create a run and start auto-mode" },
+        { cmd: "run", desc: "Create a YAML run and start auto-mode" },
         { cmd: "list", desc: "List workflow runs" },
+        { cmd: "info", desc: "Show plugin details (source, mode, phases)" },
+        { cmd: "install", desc: "Install a plugin from a URL / gist: / gh:" },
+        { cmd: "uninstall", desc: "Remove an installed plugin" },
         { cmd: "validate", desc: "Validate a workflow definition YAML" },
         { cmd: "pause", desc: "Pause custom workflow auto-mode" },
         { cmd: "resume", desc: "Resume paused custom workflow auto-mode" },
@@ -257,6 +276,13 @@ const NESTED_COMPLETIONS = {
         { cmd: "--dry-run", desc: "Preview what would be filtered" },
         { cmd: "--name", desc: "Custom branch name" },
     ],
+    scan: [
+        { cmd: "--focus tech", desc: "Technology stack and external integrations" },
+        { cmd: "--focus arch", desc: "Architecture patterns and directory structure" },
+        { cmd: "--focus quality", desc: "Coding conventions and testing patterns" },
+        { cmd: "--focus concerns", desc: "Technical debt and risk areas" },
+        { cmd: "--focus tech+arch", desc: "Tech + Architecture (default)" },
+    ],
     language: [
         { cmd: "off", desc: "Clear the language preference (revert to default)" },
         { cmd: "clear", desc: "Alias for off — clear the language preference" },
@@ -377,6 +403,52 @@ export function getGsdArgumentCompletions(prefix) {
         }
         return [];
     }
+    // Completion for `/gsd workflow info <name>` — list all discoverable plugins (project + global).
+    if (command === "workflow" && subcommand === "info" && parts.length <= 3) {
+        const results = [];
+        const seen = new Set();
+        const scanDir = (dir, source) => {
+            if (!existsSync(dir))
+                return;
+            try {
+                for (const f of readdirSync(dir)) {
+                    if (!/\.(ya?ml|md)$/i.test(f))
+                        continue;
+                    const name = f.replace(/\.(ya?ml|md)$/i, "");
+                    if (!name.startsWith(third))
+                        continue;
+                    if (seen.has(name))
+                        continue;
+                    seen.add(name);
+                    results.push({ cmd: name, desc: `Workflow plugin (${source})` });
+                }
+            }
+            catch { /* ignore */ }
+        };
+        try {
+            const base = resolveProjectRoot(process.cwd());
+            scanDir(join(base, ".gsd", "workflows"), "project");
+            scanDir(join(base, ".gsd", "workflow-defs"), "project-legacy");
+            scanDir(join(gsdHome, "workflows"), "global");
+        }
+        catch { /* ignore */ }
+        // Also include bundled template names.
+        try {
+            const registry = loadRegistry();
+            for (const id of Object.keys(registry.templates)) {
+                if (seen.has(id) || !id.startsWith(third))
+                    continue;
+                seen.add(id);
+                results.push({ cmd: id, desc: "Workflow plugin (bundled)" });
+            }
+        }
+        catch { /* ignore */ }
+        return results.map((r) => ({
+            value: `workflow info ${r.cmd}`,
+            label: r.cmd,
+            description: r.desc,
+        }));
+    }
     const nested = NESTED_COMPLETIONS[command];
     if (nested && parts.length <= 2) {
         return filterOptions(subcommand, nested, command);