gsd-pi 2.75.0-dev.2203010a0 → 2.75.0-dev.96d4bb599

package/dist/onboarding.d.ts

@@ -20,6 +20,10 @@ type PicoModule = {
     red: (s: string) => string;
     reset: (s: string) => string;
 };
+interface RunOnboardingOptions {
+    /** Show logo + intro banner. Disable when onboarding is launched inside an active TUI session. */
+    showIntro?: boolean;
+}
 /**
  * Determine if the onboarding wizard should run.
  *
@@ -46,7 +50,7 @@ export declare function shouldRunOnboarding(authStorage: AuthStorage, settingsDe
  * All steps are skippable. All errors are recoverable.
  * Writes status to stderr during execution.
  */
-export declare function runOnboarding(authStorage: AuthStorage): Promise<void>;
+export declare function runOnboarding(authStorage: AuthStorage, opts?: RunOnboardingOptions): Promise<void>;
 export declare function runLlmStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage): Promise<boolean>;
 export declare function runWebSearchStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage, isAnthropicAuth: boolean): Promise<string | null>;
 export declare function runToolKeysStep(p: ClackModule, pc: PicoModule, authStorage: AuthStorage): Promise<number>;

package/dist/onboarding.js

@@ -194,7 +194,7 @@ export function shouldRunOnboarding(authStorage, settingsDefaultProvider) {
  * All steps are skippable. All errors are recoverable.
  * Writes status to stderr during execution.
  */
-export async function runOnboarding(authStorage) {
+export async function runOnboarding(authStorage, opts = {}) {
     let p;
     let pc;
     try {
@@ -207,8 +207,10 @@ export async function runOnboarding(authStorage) {
         return;
     }
     // ── Intro ─────────────────────────────────────────────────────────────────
-    process.stderr.write(renderLogo(pc.cyan));
-    p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
+    if (opts.showIntro !== false) {
+        process.stderr.write(renderLogo(pc.cyan));
+        p.intro(pc.bold('Welcome to GSD — let\'s get you set up'));
+    }
     const completedSteps = [];
     // ── LLM Provider Selection ────────────────────────────────────────────────
     const llmResult = await runStep(p, 'LLM setup failed', () => runLlmStep(p, pc, authStorage), {

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

@@ -150,7 +150,7 @@ sessionModelOverride) {
             const shouldClassify = !isHook || routingConfig.hooks !== false;
             if (shouldClassify) {
                 let classification = classifyUnitComplexity(unitType, unitId, basePath, budgetPct, taskMetadataForPolicy);
-                const availableModelIds = routingEligibleModels.map(m => m.id);
+                const availableModelIds = routingEligibleModels.map(m => `${m.provider}/${m.id}`);
                 // Escalate tier on retry when escalate_on_failure is enabled (default: true)
                 if (retryContext?.isRetry &&
                     retryContext.previousTier &&

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

@@ -708,28 +708,23 @@ export function registerDbTools(pi) {
             };
         }
         try {
-            const { getSlice, updateSliceStatus } = await import("../gsd-db.js");
+            const { handleSkipSlice } = await import("../tools/skip-slice.js");
             const { invalidateStateCache } = await import("../state.js");
-            const slice = getSlice(params.milestoneId, params.sliceId);
-            if (!slice) {
+            const result = handleSkipSlice({
+                milestoneId: params.milestoneId,
+                sliceId: params.sliceId,
+                reason: params.reason,
+            });
+            if (result.error) {
                 return {
-                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} not found in milestone ${params.milestoneId}` }],
-                    details: { operation: "skip_slice", error: "slice_not_found" },
+                    content: [{ type: "text", text: `Error: ${result.error}` }],
+                    details: {
+                        operation: "skip_slice",
+                        error: result.error,
+                        errorCode: result.errorCode ?? "skip_failed",
+                    },
                 };
             }
-            if (slice.status === "complete" || slice.status === "done") {
-                return {
-                    content: [{ type: "text", text: `Error: Slice ${params.sliceId} is already complete — cannot skip.` }],
-                    details: { operation: "skip_slice", error: "already_complete" },
-                };
-            }
-            if (slice.status === "skipped") {
-                return {
-                    content: [{ type: "text", text: `Slice ${params.sliceId} is already skipped.` }],
-                    details: { operation: "skip_slice", sliceId: params.sliceId, milestoneId: params.milestoneId },
-                };
-            }
-            updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
             invalidateStateCache();
             // Rebuild STATE.md so it reflects the skip immediately (#3477).
             // Without this, /gsd auto reads stale STATE.md and resumes the skipped slice.
@@ -741,13 +736,20 @@ export function registerDbTools(pi) {
             catch (err) {
                 logError("tool", `skip_slice rebuildState failed: ${err.message}`, { tool: "gsd_skip_slice" });
             }
+            const suffix = result.wasAlreadySkipped
+                ? result.tasksSkipped > 0
+                    ? ` (already skipped; cascaded ${result.tasksSkipped} leftover task(s) to skipped).`
+                    : " (already skipped; no pending tasks to cascade)."
+                : ` Cascaded ${result.tasksSkipped} task(s) to skipped. Auto-mode will advance past this slice.`;
             return {
-                content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
+                content: [{ type: "text", text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}.${suffix}` }],
                 details: {
                     operation: "skip_slice",
                     sliceId: params.sliceId,
                     milestoneId: params.milestoneId,
                     reason: params.reason,
+                    tasksSkipped: result.tasksSkipped,
+                    wasAlreadySkipped: result.wasAlreadySkipped,
                 },
             };
         }
@@ -764,12 +766,14 @@ export function registerDbTools(pi) {
         name: "gsd_skip_slice",
         label: "Skip Slice",
         description: "Mark a slice as skipped so auto-mode advances past it without executing. " +
+            "Non-closed tasks within the slice are cascaded to skipped so milestone completion is not blocked by leftover pending tasks (#4375). " +
             "The slice data is preserved for reference. The state machine treats skipped slices like completed ones for dependency satisfaction.",
         promptSnippet: "Skip a GSD slice (mark as skipped, auto-mode will advance past it)",
         promptGuidelines: [
             "Use gsd_skip_slice when a slice should be bypassed — descoped, superseded, or no longer relevant.",
             "Cannot skip a slice that is already complete.",
             "Skipped slices satisfy downstream dependencies just like completed slices.",
+            "All pending/active tasks in the slice are cascaded to skipped; completed tasks are never downgraded.",
         ],
         parameters: Type.Object({
             sliceId: Type.String({ description: "Slice ID (e.g. S02)" }),

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

@@ -0,0 +1,128 @@
+// GSD2 — Memory tool registration
+//
+// Exposes the memory-layer tools (capture_thought, memory_query, gsd_graph)
+// to the LLM over MCP. All three degrade gracefully when the GSD database
+// is unavailable.
+import { Type } from "@sinclair/typebox";
+import { ensureDbOpen } from "./dynamic-tools.js";
+import { executeGsdGraph, executeMemoryCapture, executeMemoryQuery, } from "../tools/memory-tools.js";
+export function registerMemoryTools(pi) {
+    // ─── capture_thought ────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "capture_thought",
+        label: "Capture Thought",
+        description: "Record a durable piece of project knowledge (decision, convention, gotcha, pattern, " +
+            "preference, or environment detail) into the GSD memory store. Use sparingly — one memory " +
+            "per genuinely reusable insight, not per task.",
+        promptSnippet: "Capture a durable project insight into the GSD memory store (categories: architecture, convention, gotcha, pattern, preference, environment)",
+        promptGuidelines: [
+            "Use capture_thought for insights that will remain useful across future sessions.",
+            "Do NOT capture one-off bug fixes, temporary state, secrets, or task-specific details.",
+            "Keep content to 1–3 sentences.",
+            "Set confidence: 0.6 tentative, 0.8 solid, 0.95 well-confirmed (default 0.8).",
+        ],
+        parameters: Type.Object({
+            category: Type.Union([
+                Type.Literal("architecture"),
+                Type.Literal("convention"),
+                Type.Literal("gotcha"),
+                Type.Literal("preference"),
+                Type.Literal("environment"),
+                Type.Literal("pattern"),
+            ], { description: "Memory category" }),
+            content: Type.String({ description: "The memory text (1–3 sentences, no secrets)" }),
+            confidence: Type.Optional(Type.Number({ description: "0.1–0.99, default 0.8", minimum: 0.1, maximum: 0.99 })),
+            tags: Type.Optional(Type.Array(Type.String(), { description: "Free-form tags (reserved for future use)" })),
+            scope: Type.Optional(Type.String({ description: "Scope name (reserved for future use; defaults to project)" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot capture memory." }],
+                    details: { operation: "memory_capture", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeMemoryCapture(params);
+        },
+    });
+    // ─── memory_query ───────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "memory_query",
+        label: "Query Memory",
+        description: "Search the GSD memory store for relevant memories. Phase 1 uses keyword matching ranked " +
+            "by confidence and reinforcement; future phases add semantic (embedding) retrieval.",
+        promptSnippet: "Search the GSD memory store by keyword; returns ranked memories with id, category, and content",
+        promptGuidelines: [
+            "Use memory_query when you need durable project context that may not be in the current prompt.",
+            "Provide a short keyword-style query — not a full question.",
+            "Use category to narrow results to gotchas, conventions, architecture notes, etc.",
+        ],
+        parameters: Type.Object({
+            query: Type.String({ description: "Keyword query (2+ char terms)" }),
+            k: Type.Optional(Type.Number({ description: "Max results (default 10, max 50)", minimum: 1, maximum: 50 })),
+            category: Type.Optional(Type.Union([
+                Type.Literal("architecture"),
+                Type.Literal("convention"),
+                Type.Literal("gotcha"),
+                Type.Literal("preference"),
+                Type.Literal("environment"),
+                Type.Literal("pattern"),
+            ], { description: "Restrict results to a single category" })),
+            scope: Type.Optional(Type.String({ description: "Only include memories with this scope (e.g. 'project', 'global')" })),
+            tag: Type.Optional(Type.String({ description: "Only include memories tagged with this value" })),
+            include_superseded: Type.Optional(Type.Boolean({ description: "Include superseded memories (default false)" })),
+            reinforce_hits: Type.Optional(Type.Boolean({ description: "Increment hit_count on returned memories (default false)" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available. Cannot query memory." }],
+                    details: { operation: "memory_query", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeMemoryQuery(params);
+        },
+    });
+    // ─── gsd_graph ──────────────────────────────────────────────────────────
+    pi.registerTool({
+        name: "gsd_graph",
+        label: "GSD Knowledge Graph",
+        description: "Inspect the relationship graph between memories. mode=query walks supersedes edges from a " +
+            "given memoryId; mode=build is a placeholder that future phases will use to rebuild graph " +
+            "edges from milestone LEARNINGS artifacts.",
+        promptSnippet: "Query the memory relationship graph or trigger a rebuild",
+        promptGuidelines: [
+            "Use mode=query with a memoryId when you want to see how a memory relates to others.",
+            "Phase 1 only exposes supersedes edges; additional relation types arrive in later phases.",
+        ],
+        parameters: Type.Object({
+            mode: Type.Union([Type.Literal("build"), Type.Literal("query")], {
+                description: "build = recompute graph (placeholder), query = inspect edges",
+            }),
+            memoryId: Type.Optional(Type.String({ description: "Memory ID (required when mode=query)" })),
+            depth: Type.Optional(Type.Number({ description: "Hops to traverse (0–5, default 1)", minimum: 0, maximum: 5 })),
+            rel: Type.Optional(Type.Union([
+                Type.Literal("related_to"),
+                Type.Literal("depends_on"),
+                Type.Literal("contradicts"),
+                Type.Literal("elaborates"),
+                Type.Literal("supersedes"),
+            ], { description: "Only include edges with this relation type" })),
+        }),
+        async execute(_toolCallId, params, _signal, _onUpdate, _ctx) {
+            const ok = await ensureDbOpen();
+            if (!ok) {
+                return {
+                    content: [{ type: "text", text: "Error: GSD database is not available." }],
+                    details: { operation: "gsd_graph", error: "db_unavailable" },
+                    isError: true,
+                };
+            }
+            return executeGsdGraph(params);
+        },
+    });
+}

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

@@ -5,6 +5,7 @@ import { loadEcosystemExtensions } from "../ecosystem/loader.js";
 import { registerDbTools } from "./db-tools.js";
 import { registerDynamicTools } from "./dynamic-tools.js";
 import { registerJournalTools } from "./journal-tools.js";
+import { registerMemoryTools } from "./memory-tools.js";
 import { registerQueryTools } from "./query-tools.js";
 import { registerHooks } from "./register-hooks.js";
 import { registerShortcuts } from "./register-shortcuts.js";
@@ -74,6 +75,7 @@ export function registerGsdExtension(pi) {
         ["db-tools", () => registerDbTools(pi)],
         ["journal-tools", () => registerJournalTools(pi)],
         ["query-tools", () => registerQueryTools(pi)],
+        ["memory-tools", () => registerMemoryTools(pi)],
         ["shortcuts", () => registerShortcuts(pi)],
         ["hooks", () => registerHooks(pi, ecosystemHandlers)],
         ["ecosystem", () => {

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

@@ -89,10 +89,23 @@ export async function buildBeforeAgentStartResult(event, ctx) {
     }
     let memoryBlock = "";
     try {
-        const { formatMemoriesForPrompt, getActiveMemoriesRanked } = await import("../memory-store.js");
-        const memories = getActiveMemoriesRanked(30);
-        if (memories.length > 0) {
-            const formatted = formatMemoriesForPrompt(memories, 2000);
+        const { formatMemoriesForPrompt, getActiveMemoriesRanked, queryMemoriesRanked } = await import("../memory-store.js");
+        // Always-on "critical" set — small, stable memories that belong in every
+        // turn (gotchas, environment, conventions). Ranked by the existing score.
+        const CRITICAL_CATEGORIES = new Set(["gotcha", "environment", "convention"]);
+        const allRanked = getActiveMemoriesRanked(60);
+        const critical = allRanked.filter((m) => CRITICAL_CATEGORIES.has(m.category)).slice(0, 5);
+        const criticalIds = new Set(critical.map((m) => m.id));
+        // Prompt-relevance set — hybrid FTS5 + (future) semantic retrieval.
+        let relevant = [];
+        const userPrompt = (event.prompt ?? "").trim();
+        if (userPrompt) {
+            const hits = queryMemoriesRanked({ query: userPrompt, k: 10 });
+            relevant = hits.map((h) => h.memory).filter((m) => !criticalIds.has(m.id));
+        }
+        const merged = [...critical, ...relevant];
+        if (merged.length > 0) {
+            const formatted = formatMemoriesForPrompt(merged, 2000);
             if (formatted) {
                 memoryBlock = `\n\n${formatted}`;
             }

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

@@ -1,31 +1,26 @@
-// GSD — /gsd onboarding command handler (re-entry, --resume, --reset, --step)
+// GSD — /gsd onboarding command handler (re-entry hub)
 //
-// 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 { join } from "node:path";
-import { ONBOARDING_STEPS, isValidStepId, nearestResumeStep, } from "../../setup-catalog.js";
+// 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";
-// 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 specifier = "../../../../../onboarding.js";
-    return (await import(/* @vite-ignore */ specifier));
-}
 function parseArgs(raw) {
     const tokens = raw.split(/\s+/).filter(Boolean);
-    const out = { resume: false, reset: false, step: null, stepValid: null };
+    const out = { 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")
+        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) {
@@ -42,46 +37,26 @@ function parseArgs(raw) {
     }
     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);
-}
-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,
-    };
+// ─── 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":
-            await ob.runLlmStep(p, pc, authStorage);
+            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":
-            await ob.runWebSearchStep(p, pc, authStorage, false);
+            ctx.ui.notify("Web search setup: run /gsd keys add and pick a search provider (brave, tavily, etc.).", "info");
             return;
         case "remote":
-            await ob.runRemoteQuestionsStep(p, pc, authStorage);
+            ctx.ui.notify("Remote questions setup: run /gsd remote to configure Discord / Slack / Telegram notifications.", "info");
             return;
         case "tool-keys":
-            await ob.runToolKeysStep(p, pc, authStorage);
+            ctx.ui.notify("Tool keys setup: run /gsd keys add to save API keys for Context7, Jina, Groq voice, etc.", "info");
             return;
         case "model": {
-            // Delegate to /gsd model picker
             const { handleCoreCommand } = await import("./core.js");
             await handleCoreCommand("model", ctx);
             return;
@@ -94,7 +69,6 @@ async function runSingleStep(ctx, stepId) {
             return;
         }
         case "doctor": {
-            // Best-effort: surface provider doctor results inline
             try {
                 const { runProviderDoctor } = await import("../../doctor-providers.js");
                 if (typeof runProviderDoctor === "function") {
@@ -106,10 +80,9 @@ async function runSingleStep(ctx, stepId) {
             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");
+        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);
@@ -117,6 +90,25 @@ async function runSingleStep(ctx, stepId) {
         }
     }
 }
+// ─── 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"];
@@ -149,27 +141,19 @@ export async function handleOnboarding(rawArgs, ctx) {
             ctx.ui.notify(`Unknown step "${args.step}". Valid: ${validIds}`, "warning");
             return;
         }
-        await runSingleStep(ctx, args.step);
+        await runStep(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);
+        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;
     }
-    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.
+    // No flags (or --resume). Show status if complete, then open the hub.
     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);
+    await renderSetupHub(ctx);
 }
 export { renderStatus as renderOnboardingStatus };

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

@@ -248,6 +248,11 @@ Examples:
         await handleExtractLearnings(trimmed.replace(/^extract-learnings\s*/, "").trim(), ctx, pi);
         return true;
     }
+    if (trimmed === "memory" || trimmed.startsWith("memory ") || trimmed === "memory help") {
+        const { handleMemory } = await import("../../commands-memory.js");
+        await handleMemory(trimmed.replace(/^memory\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