gsd-pi 2.75.0-dev.063e5a3 → 2.75.0-dev.b6ad8c5f7

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,199 @@
+// GSD — /gsd onboarding command handler (re-entry, --resume, --reset, --step)
+//
+// Provides the discoverable re-entry point for the onboarding wizard. The
+// first-run wizard in src/onboarding.ts is hidden behind shouldRunOnboarding;
+// this handler lets users re-launch it on demand.
+import { AuthStorage } from "@gsd/pi-coding-agent";
+import { homedir } from "node:os";
+import { dirname, join, resolve } from "node:path";
+import { pathToFileURL } from "node:url";
+import { ONBOARDING_STEPS, isValidStepId, nearestResumeStep, } from "../../setup-catalog.js";
+import { isOnboardingComplete, readOnboardingRecord, resetOnboarding, } from "../../onboarding-state.js";
+// Inline auth path (mirrors src/app-paths.ts) — keep this module rootDir-clean
+// for the resources tsconfig. Importing from src/ pulls files outside
+// src/resources and breaks the build.
+const AUTH_FILE_PATH = join(process.env.GSD_CODING_AGENT_DIR ||
+    join(process.env.GSD_HOME || join(homedir(), ".gsd"), "agent"), "auth.json");
+async function loadFirstRunWizard() {
+    const candidates = [];
+    // Primary deployed path: loader sets GSD_PKG_ROOT (gsd package root).
+    if (process.env.GSD_PKG_ROOT) {
+        candidates.push(pathToFileURL(join(process.env.GSD_PKG_ROOT, "dist", "onboarding.js")).href);
+    }
+    // Fallback: derive package root from process entry (typically dist/loader.js).
+    // This keeps /gsd onboarding resilient if GSD_PKG_ROOT is absent.
+    const argvEntry = process.argv[1];
+    if (argvEntry) {
+        const pkgRootFromArgv = resolve(dirname(argvEntry), "..");
+        candidates.push(pathToFileURL(join(pkgRootFromArgv, "dist", "onboarding.js")).href);
+    }
+    // Source-tree/dev fallback (works in dist/resources/... and ts test loaders).
+    candidates.push("../../../../../onboarding.js");
+    let lastError = null;
+    for (const specifier of candidates) {
+        try {
+            return (await import(/* @vite-ignore */ specifier));
+        }
+        catch (err) {
+            lastError = err;
+        }
+    }
+    const reason = lastError instanceof Error ? lastError.message : String(lastError);
+    throw new Error(`[gsd] Failed to load onboarding wizard module. Tried: ${candidates.join(", ")}. Last error: ${reason}`);
+}
+function parseArgs(raw) {
+    const tokens = raw.split(/\s+/).filter(Boolean);
+    const out = { resume: false, reset: false, step: null, stepValid: null };
+    for (let i = 0; i < tokens.length; i++) {
+        const t = tokens[i];
+        if (t === "--resume" || t === "resume")
+            out.resume = true;
+        else if (t === "--reset" || t === "reset")
+            out.reset = true;
+        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;
+}
+async function getAuthStorage() {
+    return AuthStorage.create(AUTH_FILE_PATH);
+}
+async function runWholeWizard(ctx, fromStep) {
+    const authStorage = await getAuthStorage();
+    // The first-run wizard ignores the resume hint today — it always walks the
+    // full sequence with skip prompts. We still mark completion at the end and
+    // record the resume hint for next time. This keeps the wizard linear and
+    // simple; per-step jump support comes via --step.
+    if (fromStep) {
+        ctx.ui.notify(`Resuming from step: ${fromStep}. The wizard runs all remaining steps; press skip on any you've already configured.`, "info");
+    }
+    const { runOnboarding } = await loadFirstRunWizard();
+    await runOnboarding(authStorage, { showIntro: false });
+}
+async function runSingleStep(ctx, stepId) {
+    const authStorage = await getAuthStorage();
+    const ob = await loadFirstRunWizard();
+    // Lazy-load clack + chalk via the same path the wizard uses
+    const p = await import("@clack/prompts");
+    const { default: chalk } = await import("chalk");
+    const pc = {
+        cyan: chalk.cyan, green: chalk.green, yellow: chalk.yellow,
+        dim: chalk.dim, bold: chalk.bold, red: chalk.red, reset: chalk.reset,
+    };
+    switch (stepId) {
+        case "llm":
+            await ob.runLlmStep(p, pc, authStorage);
+            return;
+        case "search":
+            await ob.runWebSearchStep(p, pc, authStorage, false);
+            return;
+        case "remote":
+            await ob.runRemoteQuestionsStep(p, pc, authStorage);
+            return;
+        case "tool-keys":
+            await ob.runToolKeysStep(p, pc, authStorage);
+            return;
+        case "model": {
+            // Delegate to /gsd model picker
+            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": {
+            // Best-effort: surface provider doctor results inline
+            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 automatically during /gsd init. Use /gsd init or /skill manage.", "info");
+            return;
+        }
+        case "project": {
+            const { handleCoreCommand } = await import("./core.js");
+            await handleCoreCommand("init", ctx);
+            return;
+        }
+    }
+}
+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 runSingleStep(ctx, args.step);
+        return;
+    }
+    if (args.reset) {
+        resetOnboarding();
+        ctx.ui.notify("Onboarding reset. Existing API keys/credentials are unchanged — manage them with /gsd keys.", "info");
+        await runWholeWizard(ctx);
+        return;
+    }
+    if (args.resume) {
+        const r = readOnboardingRecord();
+        const next = nearestResumeStep(r.lastResumePoint, r.completedSteps);
+        await runWholeWizard(ctx, next);
+        return;
+    }
+    // No flags. If already complete, show status + offer choice.
+    if (isOnboardingComplete()) {
+        ctx.ui.notify(renderStatus(), "info");
+        ctx.ui.notify("Onboarding already complete. Use /gsd onboarding --reset to start over, or --step <name> to redo one section.", "info");
+        return;
+    }
+    await runWholeWizard(ctx);
+}
+export { renderStatus as renderOnboardingStatus };

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

@@ -3,6 +3,7 @@ import { handleConfig } from "../../commands-config.js";
 import { handleDoctor, handleCapture, handleKnowledge, handleRunHook, handleSkillHealth, handleSteer, handleTriage, handleUpdate } from "../../commands-handlers.js";
 import { handleInspect } from "../../commands-inspect.js";
 import { handleLogs } from "../../commands-logs.js";
+import { handleDebug } from "../../commands-debug.js";
 import { handleCleanupBranches, handleCleanupSnapshots, handleSkip, handleCleanupProjects, handleCleanupWorktrees, handleRecover } from "../../commands-maintenance.js";
 import { handleExport } from "../../export.js";
 import { handleHistory } from "../../history.js";
@@ -39,6 +40,10 @@ export async function handleOpsCommand(trimmed, ctx, pi) {
         await handleLogs(trimmed.replace(/^logs\s*/, "").trim(), ctx);
         return true;
     }
+    if (trimmed === "debug" || trimmed.startsWith("debug ")) {
+        await handleDebug(trimmed.replace(/^debug\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "forensics" || trimmed.startsWith("forensics ")) {
         const { handleForensics } = await import("../../forensics.js");
         await handleForensics(trimmed.replace(/^forensics\s*/, "").trim(), ctx, pi);
@@ -183,6 +188,11 @@ Examples:
         await handleNotificationsCommand(trimmed.replace(/^notifications\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "escalate" || trimmed.startsWith("escalate ")) {
+        const { handleEscalateCommand } = await import("./escalate.js");
+        await handleEscalateCommand(trimmed.replace(/^escalate\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     if (trimmed === "inspect") {
         await handleInspect(ctx);
         return true;
@@ -238,5 +248,11 @@ Examples:
         await handleExtractLearnings(trimmed.replace(/^extract-learnings\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "scan" || trimmed.startsWith("scan ")) {
+        const { handleScan } = await import("../../commands-scan.js");
+        // \s* (not \s+) is intentional: handles both /gsd scan (no args) and /gsd scan --focus X
+        await handleScan(trimmed.replace(/^scan\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }