gsd-pi 2.75.0 → 2.76.0-dev.82e249f7b

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);

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

@@ -31,11 +31,17 @@ export function showHelp(ctx, args = "") {
         "  /gsd undo           Revert last completed unit  [--force]",
         "  /gsd rethink        Conversational project reorganization",
         "",
+        "OBSERVABILITY",
+        "  /gsd logs           Browse activity and debug logs",
+        "  /gsd debug          Create/list/continue persistent debug sessions",
+        "",
         "SETUP",
+        "  /gsd onboarding     Re-run setup wizard  [--resume|--reset|--step <name>]",
+        "  /gsd setup          Configuration hub  [llm|model|search|remote|keys|prefs|onboarding]",
         "  /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 prefs          Manage preferences (alias for /gsd setup prefs)",
+        "  /gsd keys           API key manager (LLM + tool keys)",
         "  /gsd doctor         Diagnose and repair .gsd/ state",
         "",
         "Use /gsd help full for the complete command reference.",
@@ -61,6 +67,8 @@ export function showHelp(ctx, args = "") {
         "  /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]  (${formattedShortcutPair("notifications")})`,
+        "  /gsd logs           Browse activity logs, debug logs, and metrics",
+        "  /gsd debug          Create/list/continue persistent debug sessions",
         "",
         "COURSE CORRECTION",
         "  /gsd steer <desc>   Apply user override to active work",
@@ -77,14 +85,15 @@ export function showHelp(ctx, args = "") {
         "  /gsd codebase [generate|update|stats]   Manage the CODEBASE.md cache used in prompt context",
         "",
         "SETUP & CONFIGURATION",
+        "  /gsd onboarding     Re-run setup wizard  [--resume|--reset|--step <name>]",
+        "  /gsd setup          Configuration hub  [llm|model|search|remote|keys|prefs|onboarding]",
         "  /gsd init           Project init wizard — detect, configure, bootstrap .gsd/",
-        "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
         "  /gsd model          Switch active session model  [provider/model|model-id]",
         "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
-        "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
+        "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]  (alias for /gsd setup prefs)",
         "  /gsd cmux           Manage cmux integration  [status|on|off|notifications|sidebar|splits|browser]",
-        "  /gsd config         Set API keys for external tools",
-        "  /gsd keys           API key manager  [list|add|remove|test|rotate|doctor]",
+        "  /gsd keys           API key manager (LLM + tool keys)  [list|add|remove|test|rotate|doctor]",
+        "  /gsd config         (deprecated) Set tool API keys — use /gsd keys instead",
         "  /gsd show-config    Show effective configuration (models, routing, toggles)",
         "  /gsd hooks          Show post-unit hook configuration",
         "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
@@ -149,29 +158,38 @@ export async function handleVisualize(ctx) {
         ctx.ui.notify("Visualizer requires an interactive terminal. Use /gsd status for a text-based overview.", "warning");
     }
 }
-export async function handleSetup(args, ctx) {
+export async function handleSetup(args, ctx, pi) {
     const { detectProjectState, hasGlobalSetup } = await import("../../detection.js");
-    const globalConfigured = hasGlobalSetup();
-    const detection = detectProjectState(projectRoot());
-    const statusLines = ["GSD Setup Status\n"];
-    statusLines.push(`  Global preferences: ${globalConfigured ? "configured" : "not set"}`);
-    statusLines.push(`  Project state: ${detection.state}`);
-    if (detection.projectSignals.primaryLanguage) {
-        statusLines.push(`  Detected: ${detection.projectSignals.primaryLanguage}`);
+    const { isOnboardingComplete, readOnboardingRecord } = await import("../../onboarding-state.js");
+    // Sub-route dispatch — keep redirects but route the canonical work to /gsd
+    // onboarding (single source for wizard steps) and /gsd keys (single source
+    // for credentials).
+    if (args === "onboarding" || args === "wizard") {
+        const { handleOnboarding } = await import("./onboarding.js");
+        await handleOnboarding("", ctx);
+        return;
     }
     if (args === "llm" || args === "auth") {
-        ctx.ui.notify("Use /login to configure LLM authentication.", "info");
+        const { handleOnboarding } = await import("./onboarding.js");
+        await handleOnboarding("--step llm", ctx);
         return;
     }
     if (args === "search") {
-        ctx.ui.notify("Use /search-provider to configure web search.", "info");
+        const { handleOnboarding } = await import("./onboarding.js");
+        await handleOnboarding("--step search", ctx);
         return;
     }
     if (args === "remote") {
-        ctx.ui.notify("Use /gsd remote to configure remote questions.", "info");
+        const { handleOnboarding } = await import("./onboarding.js");
+        await handleOnboarding("--step remote", ctx);
+        return;
+    }
+    if (args === "model") {
+        await handleModel("", ctx, pi);
         return;
     }
     if (args === "keys") {
+        ctx.ui.notify("Tip: /gsd keys is the canonical command for API key management.", "info");
         const { handleKeys } = await import("../../key-manager.js");
         await handleKeys("", ctx);
         return;
@@ -181,13 +199,30 @@ export async function handleSetup(args, ctx) {
         await handlePrefsWizard(ctx, "global");
         return;
     }
+    // Bare /gsd setup — render the hub: status + actions
+    const globalConfigured = hasGlobalSetup();
+    const detection = detectProjectState(projectRoot());
+    const onboardingDone = isOnboardingComplete();
+    const record = readOnboardingRecord();
+    const statusLines = ["GSD Setup\n"];
+    statusLines.push(onboardingDone
+        ? `  Onboarding:         ✓ complete${record.completedAt ? ` (${record.completedAt.slice(0, 10)})` : ""}`
+        : `  Onboarding:         ○ not complete  —  /gsd onboarding to start`);
+    statusLines.push(`  Global preferences: ${globalConfigured ? "configured" : "not set"}`);
+    statusLines.push(`  Project state:      ${detection.state}`);
+    if (detection.projectSignals.primaryLanguage) {
+        statusLines.push(`  Detected:           ${detection.projectSignals.primaryLanguage}`);
+    }
     ctx.ui.notify(statusLines.join("\n"), "info");
-    ctx.ui.notify("Available setup commands:\n" +
-        "  /gsd setup llm     — LLM authentication\n" +
-        "  /gsd setup search  — Web search provider\n" +
-        "  /gsd setup remote  — Remote questions (Discord/Slack/Telegram)\n" +
-        "  /gsd setup keys    — Tool API keys\n" +
-        "  /gsd setup prefs   — Global preferences wizard", "info");
+    ctx.ui.notify("Configuration hub:\n" +
+        "  /gsd setup llm        — LLM provider & auth\n" +
+        "  /gsd setup model      — Default model picker\n" +
+        "  /gsd setup search     — Web search provider\n" +
+        "  /gsd setup remote     — Remote questions (Discord/Slack/Telegram)\n" +
+        "  /gsd setup keys       — API keys (alias for /gsd keys)\n" +
+        "  /gsd setup prefs      — Global preferences (alias for /gsd prefs)\n" +
+        "  /gsd setup onboarding — Full wizard (alias for /gsd onboarding)\n\n" +
+        "Tip: /gsd onboarding --resume to continue an incomplete setup.", "info");
 }
 function sortModelsForSelection(models, currentModel) {
     return [...models].sort((a, b) => {
@@ -364,7 +399,12 @@ export async function handleCoreCommand(trimmed, ctx, pi) {
         return true;
     }
     if (trimmed === "setup" || trimmed.startsWith("setup ")) {
-        await handleSetup(trimmed.replace(/^setup\s*/, "").trim(), ctx);
+        await handleSetup(trimmed.replace(/^setup\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "onboarding" || trimmed.startsWith("onboarding ")) {
+        const { handleOnboarding } = await import("./onboarding.js");
+        await handleOnboarding(trimmed.replace(/^onboarding\s*/, "").trim(), ctx);
         return true;
     }
     return false;

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

@@ -0,0 +1,171 @@
+// GSD Extension — /gsd escalate Command Handler (ADR-011 Phase 2)
+// Surface and resolve mid-execution escalations from the CLI.
+import { projectRoot } from "../context.js";
+import { getActiveMilestoneId } from "../../state.js";
+import { readEscalationArtifact, formatEscalationForDisplay, resolveEscalation, listActionableEscalations, listAllEscalations, } from "../../escalation.js";
+import { saveDecisionToDb } from "../../db-writer.js";
+import { loadEffectiveGSDPreferences } from "../../preferences.js";
+import { invalidateStateCache } from "../../state.js";
+import { emitUokAuditEvent, buildAuditEnvelope } from "../../uok/audit.js";
+function helpMessage() {
+    return [
+        "/gsd escalate — manage mid-execution escalations (ADR-011 Phase 2)",
+        "",
+        "Subcommands:",
+        "  list [--all]           show pending escalations (use --all to include resolved)",
+        "  show <taskId>          print the escalation artifact",
+        "  resolve <taskId> <choice> [rationale...]",
+        "                         resolve an escalation — choice is an option id,",
+        "                         `accept` (use recommendation), or `reject-blocker`",
+        "                         (convert to a blocker and trigger slice replan)",
+        "",
+        "Note: disabling `phases.mid_execution_escalation` does NOT clear pending",
+        "escalations. If you need to drain them, re-enable the flag, resolve via",
+        "`/gsd escalate resolve`, then disable.",
+    ].join("\n");
+}
+function formatListEntries(rows, basePath) {
+    if (rows.length === 0)
+        return "No escalations.";
+    return rows.map((t) => {
+        const art = t.escalation_artifact_path ? readEscalationArtifact(t.escalation_artifact_path) : null;
+        const status = t.escalation_pending ? "PENDING (paused)" : t.escalation_awaiting_review ? "awaiting-review" : "resolved";
+        const question = art?.question ?? "(artifact missing)";
+        return `  ${t.slice_id}/${t.id}  [${status}]  ${question}`;
+    }).join("\n");
+}
+export async function handleEscalateCommand(args, ctx, pi) {
+    void pi;
+    const trimmed = args.trim();
+    if (trimmed === "" || trimmed === "help") {
+        ctx.ui.notify(helpMessage(), "info");
+        return;
+    }
+    const basePath = projectRoot();
+    const prefs = loadEffectiveGSDPreferences()?.preferences;
+    if (prefs?.phases?.mid_execution_escalation !== true) {
+        ctx.ui.notify("Escalation is off. Enable with `phases: { mid_execution_escalation: true }` in your PREFERENCES.md.", "warning");
+        return;
+    }
+    const milestoneId = await getActiveMilestoneId(basePath);
+    if (!milestoneId) {
+        ctx.ui.notify("No active milestone — cannot list escalations.", "warning");
+        return;
+    }
+    // ── list ────────────────────────────────────────────────────────────────
+    if (trimmed === "list" || trimmed === "list --all" || trimmed === "--all") {
+        const includeAll = trimmed.includes("--all");
+        const rows = includeAll ? listAllEscalations(milestoneId) : listActionableEscalations(milestoneId);
+        const body = formatListEntries(rows, basePath);
+        ctx.ui.notify(`${includeAll ? "All escalations" : "Actionable escalations"} for ${milestoneId}:\n${body}`, "info");
+        return;
+    }
+    // Parse a possibly-slice-qualified task id: "Sxx/Tyy" or plain "Tyy".
+    // Returns { sliceId?, taskId }.
+    const parseTaskRef = (ref) => {
+        const slash = ref.indexOf("/");
+        if (slash > 0) {
+            return { sliceId: ref.slice(0, slash), taskId: ref.slice(slash + 1) };
+        }
+        return { taskId: ref };
+    };
+    // Resolve a task ref to a single row, surfacing ambiguity when a bare task
+    // id matches more than one slice.
+    const locateRow = (ref) => {
+        const { sliceId, taskId } = parseTaskRef(ref);
+        const rows = listAllEscalations(milestoneId).filter((t) => t.id === taskId && (sliceId === undefined || t.slice_id === sliceId));
+        if (rows.length === 0)
+            return "not-found";
+        if (rows.length > 1)
+            return "ambiguous";
+        return rows[0];
+    };
+    // ── show <taskRef> ──────────────────────────────────────────────────────
+    if (trimmed.startsWith("show ")) {
+        const ref = trimmed.slice(5).trim();
+        const row = locateRow(ref);
+        if (row === "ambiguous") {
+            ctx.ui.notify(`Task ${ref} matches multiple slices. Use Sxx/Tyy format.`, "warning");
+            return;
+        }
+        if (row === "not-found" || !row.escalation_artifact_path) {
+            ctx.ui.notify(`No escalation found for ${ref} in ${milestoneId}.`, "warning");
+            return;
+        }
+        const art = readEscalationArtifact(row.escalation_artifact_path);
+        if (!art) {
+            ctx.ui.notify(`Escalation artifact at ${row.escalation_artifact_path} is missing or malformed.`, "error");
+            return;
+        }
+        ctx.ui.notify(formatEscalationForDisplay(art), "info");
+        return;
+    }
+    // ── resolve <taskRef> <choice> [rationale...] ───────────────────────────
+    if (trimmed.startsWith("resolve ")) {
+        const parts = trimmed.slice(8).trim().split(/\s+/);
+        const ref = parts[0];
+        const choice = parts[1];
+        const rationale = parts.slice(2).join(" ").trim();
+        if (!ref || !choice) {
+            ctx.ui.notify("Usage: /gsd escalate resolve <taskId|Sxx/Tyy> <choice> [rationale...]", "warning");
+            return;
+        }
+        const row = locateRow(ref);
+        if (row === "ambiguous") {
+            ctx.ui.notify(`Task ${ref} matches multiple slices. Use Sxx/Tyy format.`, "warning");
+            return;
+        }
+        if (row === "not-found") {
+            ctx.ui.notify(`No escalation found for ${ref} in ${milestoneId}.`, "warning");
+            return;
+        }
+        const taskId = row.id;
+        const result = resolveEscalation(basePath, milestoneId, row.slice_id, taskId, choice, rationale);
+        invalidateStateCache();
+        if (result.status !== "resolved" && result.status !== "rejected-to-blocker") {
+            ctx.ui.notify(result.message, result.status === "invalid-choice" ? "warning" : "error");
+            return;
+        }
+        // Persist the user's choice as a decision (only for resolved, not reject-blocker).
+        if (result.status === "resolved") {
+            try {
+                const art = row.escalation_artifact_path ? readEscalationArtifact(row.escalation_artifact_path) : null;
+                const scope = `${milestoneId}/${row.slice_id}/${taskId}`;
+                const decisionText = art?.question ?? `escalation on ${taskId}`;
+                const choiceLabel = choice === "accept"
+                    ? `${art?.recommendation ?? "accepted"} (recommended)`
+                    : (result.chosenOption?.label ?? choice);
+                const { id: decisionId } = await saveDecisionToDb({
+                    scope,
+                    decision: decisionText,
+                    choice: choiceLabel,
+                    rationale: rationale || result.chosenOption?.tradeoffs || "User-resolved escalation.",
+                    made_by: "human",
+                    source: "escalation",
+                    when_context: `ADR-011 escalation resolved ${new Date().toISOString()}`,
+                }, basePath);
+                emitUokAuditEvent(basePath, buildAuditEnvelope({
+                    traceId: `escalation:${milestoneId}:${row.slice_id}:${taskId}`,
+                    category: "gate",
+                    type: "escalation-decision-persisted",
+                    payload: {
+                        milestoneId,
+                        sliceId: row.slice_id,
+                        taskId,
+                        decisionId,
+                        choice,
+                    },
+                }));
+                ctx.ui.notify(`${result.message}\nDecision recorded as ${decisionId}. Run /gsd auto to continue.`, "success");
+            }
+            catch (decErr) {
+                ctx.ui.notify(`${result.message}\nWARN: decision persistence failed: ${decErr.message}`, "warning");
+            }
+            return;
+        }
+        // rejected-to-blocker path
+        ctx.ui.notify(`${result.message} Run /gsd auto to trigger the replan.`, "success");
+        return;
+    }
+    ctx.ui.notify(`Unknown subcommand. ${helpMessage()}`, "warning");
+}

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

@@ -0,0 +1,159 @@
+// GSD — /gsd onboarding command handler (re-entry hub)
+//
+// The first-run wizard in src/onboarding.ts uses @clack/prompts and takes over
+// raw stdin. Running it from inside the pi-coding-agent TUI wedges the TUI
+// (clack leaves stdin paused + cooked, pi-tui's data handler then receives no
+// keypresses). So re-entry cannot replay the clack wizard — instead it routes
+// to a setup hub built from ctx.ui.select, which the TUI owns.
+//
+// Clack-only steps (llm/search/remote/tool-keys via the first-run wizard) are
+// surfaced as notifications pointing the user at the canonical per-step
+// commands (/login, /gsd keys, /gsd remote) that are already ctx.ui-safe.
+import { ONBOARDING_STEPS, isValidStepId, } from "../../setup-catalog.js";
+import { isOnboardingComplete, readOnboardingRecord, resetOnboarding, } from "../../onboarding-state.js";
+function parseArgs(raw) {
+    const tokens = raw.split(/\s+/).filter(Boolean);
+    const out = { reset: false, step: null, stepValid: null };
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--reset" || t === "reset")
+            out.reset = true;
+        else if (t === "--resume" || t === "resume") {
+            // Re-entry no longer replays the wizard; --resume collapses into the hub.
+        }
+        else if (t === "--step" || t === "step") {
+            const next = tokens[i + 1];
+            if (next) {
+                out.step = next;
+                out.stepValid = isValidStepId(next);
+                i++;
+            }
+        }
+        else if (t.startsWith("--step=")) {
+            const v = t.slice(7);
+            out.step = v;
+            out.stepValid = isValidStepId(v);
+        }
+    }
+    return out;
+}
+// ─── Per-step routing ────────────────────────────────────────────────────────
+//
+// Clack-based steps are surfaced as notifications — running them inline from
+// the TUI would wedge stdin (see header comment). Everything else routes to an
+// existing ctx.ui-safe handler.
+async function runStep(ctx, stepId) {
+    switch (stepId) {
+        case "llm":
+            ctx.ui.notify("LLM provider setup: run /login to sign in via OAuth, or /gsd keys add to paste an API key.", "info");
+            return;
+        case "search":
+            ctx.ui.notify("Web search setup: run /gsd keys add and pick a search provider (brave, tavily, etc.).", "info");
+            return;
+        case "remote":
+            ctx.ui.notify("Remote questions setup: run /gsd remote to configure Discord / Slack / Telegram notifications.", "info");
+            return;
+        case "tool-keys":
+            ctx.ui.notify("Tool keys setup: run /gsd keys add to save API keys for Context7, Jina, Groq voice, etc.", "info");
+            return;
+        case "model": {
+            const { handleCoreCommand } = await import("./core.js");
+            await handleCoreCommand("model", ctx);
+            return;
+        }
+        case "prefs": {
+            const { ensurePreferencesFile, handlePrefsWizard } = await import("../../commands-prefs-wizard.js");
+            const { getGlobalGSDPreferencesPath } = await import("../../preferences.js");
+            await ensurePreferencesFile(getGlobalGSDPreferencesPath(), ctx, "global");
+            await handlePrefsWizard(ctx, "global");
+            return;
+        }
+        case "doctor": {
+            try {
+                const { runProviderDoctor } = await import("../../doctor-providers.js");
+                if (typeof runProviderDoctor === "function") {
+                    await runProviderDoctor(ctx);
+                    return;
+                }
+            }
+            catch { /* fall through */ }
+            ctx.ui.notify("Run /gsd doctor to validate your setup.", "info");
+            return;
+        }
+        case "skills":
+            ctx.ui.notify("Skill install runs during /gsd init. Use /gsd init or /skill manage.", "info");
+            return;
+        case "project": {
+            const { handleCoreCommand } = await import("./core.js");
+            await handleCoreCommand("init", ctx);
+            return;
+        }
+    }
+}
+// ─── Setup hub ───────────────────────────────────────────────────────────────
+async function renderSetupHub(ctx) {
+    const record = readOnboardingRecord();
+    const completed = new Set(record.completedSteps);
+    const skipped = new Set(record.skippedSteps);
+    const labels = ONBOARDING_STEPS.map(step => {
+        const mark = completed.has(step.id) ? "✓" : skipped.has(step.id) ? "↷" : "○";
+        const req = step.required ? " (required)" : "";
+        return `${mark} ${step.label}${req} — ${step.hint}`;
+    });
+    const labelToStep = new Map(labels.map((label, i) => [label, ONBOARDING_STEPS[i].id]));
+    const choice = await ctx.ui.select("GSD Setup — pick a step to configure", labels);
+    if (typeof choice !== "string")
+        return;
+    const stepId = labelToStep.get(choice);
+    if (!stepId)
+        return;
+    await runStep(ctx, stepId);
+}
+function renderStatus() {
+    const r = readOnboardingRecord();
+    const lines = ["GSD Onboarding\n"];
+    if (r.completedAt) {
+        lines.push(`  Completed: ${r.completedAt}`);
+    }
+    else {
+        lines.push(`  Status: not complete`);
+    }
+    if (r.lastResumePoint)
+        lines.push(`  Last step: ${r.lastResumePoint}`);
+    lines.push("");
+    lines.push("  Steps:");
+    for (const step of ONBOARDING_STEPS) {
+        const mark = r.completedSteps.includes(step.id)
+            ? "✓"
+            : r.skippedSteps.includes(step.id)
+                ? "↷"
+                : "○";
+        const reqTag = step.required ? " (required)" : "";
+        lines.push(`    ${mark} ${step.id.padEnd(10)} — ${step.label}${reqTag}`);
+    }
+    return lines.join("\n");
+}
+export async function handleOnboarding(rawArgs, ctx) {
+    const args = parseArgs(rawArgs.trim());
+    if (args.step !== null) {
+        if (!args.stepValid) {
+            const validIds = ONBOARDING_STEPS.map(s => s.id).join(", ");
+            ctx.ui.notify(`Unknown step "${args.step}". Valid: ${validIds}`, "warning");
+            return;
+        }
+        await runStep(ctx, args.step);
+        return;
+    }
+    if (args.reset) {
+        resetOnboarding();
+        ctx.ui.notify("Onboarding state cleared. API keys/credentials are unchanged — manage them with /gsd keys. Restart GSD to re-run the first-run wizard, or pick a step below.", "info");
+        await renderSetupHub(ctx);
+        return;
+    }
+    // No flags (or --resume). Show status if complete, then open the hub.
+    if (isOnboardingComplete()) {
+        ctx.ui.notify(renderStatus(), "info");
+    }
+    await renderSetupHub(ctx);
+}
+export { renderStatus as renderOnboardingStatus };