gsd-pi 2.75.0-dev.2203010a0 → 2.75.0-dev.a44b82572

package/src/resources/extensions/gsd/auto-model-selection.ts

@@ -205,7 +205,7 @@ export async function selectAndApplyModel(
           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 (

package/src/resources/extensions/gsd/bootstrap/db-tools.ts

@@ -776,32 +776,26 @@ export function registerDbTools(pi: ExtensionAPI): void {
       };
     }
     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) {
-        return {
-          content: [{ type: "text" as const, text: `Error: Slice ${params.sliceId} not found in milestone ${params.milestoneId}` }],
-          details: { operation: "skip_slice", error: "slice_not_found" } as any,
-        };
-      }
-
-      if (slice.status === "complete" || slice.status === "done") {
-        return {
-          content: [{ type: "text" as const, text: `Error: Slice ${params.sliceId} is already complete — cannot skip.` }],
-          details: { operation: "skip_slice", error: "already_complete" } as any,
-        };
-      }
+      const result = handleSkipSlice({
+        milestoneId: params.milestoneId,
+        sliceId: params.sliceId,
+        reason: params.reason,
+      });
 
-      if (slice.status === "skipped") {
+      if (result.error) {
         return {
-          content: [{ type: "text" as const, text: `Slice ${params.sliceId} is already skipped.` }],
-          details: { operation: "skip_slice", sliceId: params.sliceId, milestoneId: params.milestoneId } as any,
+          content: [{ type: "text" as const, text: `Error: ${result.error}` }],
+          details: {
+            operation: "skip_slice",
+            error: result.error,
+            errorCode: result.errorCode ?? "skip_failed",
+          } as any,
         };
       }
 
-      updateSliceStatus(params.milestoneId, params.sliceId, "skipped");
       invalidateStateCache();
 
       // Rebuild STATE.md so it reflects the skip immediately (#3477).
@@ -814,13 +808,21 @@ export function registerDbTools(pi: ExtensionAPI): void {
         logError("tool", `skip_slice rebuildState failed: ${(err as Error).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" as const, text: `Skipped slice ${params.sliceId} (${params.milestoneId}). Reason: ${params.reason ?? "User-directed skip"}. Auto-mode will advance past this slice.` }],
+        content: [{ type: "text" as const, 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,
         } as any,
       };
     } catch (err) {
@@ -838,12 +840,14 @@ export function registerDbTools(pi: ExtensionAPI): void {
     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/src/resources/extensions/gsd/bootstrap/memory-tools.ts

@@ -0,0 +1,158 @@
+// 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 type { ExtensionAPI } from "@gsd/pi-coding-agent";
+
+import { ensureDbOpen } from "./dynamic-tools.js";
+import {
+  executeGsdGraph,
+  executeMemoryCapture,
+  executeMemoryQuery,
+} from "../tools/memory-tools.js";
+
+export function registerMemoryTools(pi: ExtensionAPI): void {
+  // ─── 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" as const, text: "Error: GSD database is not available. Cannot capture memory." }],
+          details: { operation: "memory_capture", error: "db_unavailable" },
+          isError: true,
+        };
+      }
+      return executeMemoryCapture(params as Parameters<typeof executeMemoryCapture>[0]);
+    },
+  });
+
+  // ─── 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" as const, text: "Error: GSD database is not available. Cannot query memory." }],
+          details: { operation: "memory_query", error: "db_unavailable" },
+          isError: true,
+        };
+      }
+      return executeMemoryQuery(params as Parameters<typeof executeMemoryQuery>[0]);
+    },
+  });
+
+  // ─── 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" as const, text: "Error: GSD database is not available." }],
+          details: { operation: "gsd_graph", error: "db_unavailable" },
+          isError: true,
+        };
+      }
+      return executeGsdGraph(params as Parameters<typeof executeGsdGraph>[0]);
+    },
+  });
+}

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

@@ -9,6 +9,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";
@@ -85,6 +86,7 @@ export function registerGsdExtension(pi: ExtensionAPI): void {
     ["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/src/resources/extensions/gsd/bootstrap/system-context.ts

@@ -113,10 +113,26 @@ export async function buildBeforeAgentStartResult(
 
   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: typeof allRanked = [];
+    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/src/resources/extensions/gsd/commands/handlers/onboarding.ts

@@ -1,17 +1,19 @@
-// 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.
+// 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 type { ExtensionCommandContext } from "@gsd/pi-coding-agent"
-import { AuthStorage } from "@gsd/pi-coding-agent"
-import { homedir } from "node:os"
-import { join } from "node:path"
 import {
   ONBOARDING_STEPS,
   isValidStepId,
-  nearestResumeStep,
   type OnboardingStepId,
 } from "../../setup-catalog.js"
 import {
@@ -20,37 +22,7 @@ import {
   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",
-)
-
-/**
- * Dynamic import shim for the first-run wizard.
- *
- * src/onboarding.ts lives outside the resources rootDir, so a static import
- * pulls it into this tsconfig project and triggers TS6059. We resolve the
- * specifier through a variable + opaque type so TS can't pull the file at
- * compile time; the path resolves correctly at runtime via dist/onboarding.js.
- */
-type FirstRunWizardModule = {
-  runOnboarding: (storage: AuthStorage) => Promise<void>
-  runLlmStep: (...args: unknown[]) => Promise<unknown>
-  runWebSearchStep: (...args: unknown[]) => Promise<unknown>
-  runRemoteQuestionsStep: (...args: unknown[]) => Promise<unknown>
-  runToolKeysStep: (...args: unknown[]) => Promise<unknown>
-}
-async function loadFirstRunWizard(): Promise<FirstRunWizardModule> {
-  const specifier = "../../../../../onboarding.js"
-  return (await import(/* @vite-ignore */ specifier)) as FirstRunWizardModule
-}
-
 interface ParsedArgs {
-  resume: boolean
   reset: boolean
   step: string | null
   stepValid: boolean | null
@@ -58,11 +30,13 @@ interface ParsedArgs {
 
 function parseArgs(raw: string): ParsedArgs {
   const tokens = raw.split(/\s+/).filter(Boolean)
-  const out: ParsedArgs = { resume: false, reset: false, step: null, stepValid: null }
+  const out: ParsedArgs = { 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
+    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) {
@@ -79,52 +53,39 @@ function parseArgs(raw: string): ParsedArgs {
   return out
 }
 
-async function getAuthStorage(): Promise<AuthStorage> {
-  return AuthStorage.create(AUTH_FILE_PATH)
-}
-
-async function runWholeWizard(ctx: ExtensionCommandContext, fromStep?: OnboardingStepId): Promise<void> {
-  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: ExtensionCommandContext, stepId: OnboardingStepId): Promise<void> {
-  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: ExtensionCommandContext, stepId: OnboardingStepId): Promise<void> {
   switch (stepId) {
     case "llm":
-      await ob.runLlmStep(p as any, pc as any, 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 as any, pc as any, 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 as any, pc as any, 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 as any, pc as any, 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
@@ -137,7 +98,6 @@ async function runSingleStep(ctx: ExtensionCommandContext, stepId: OnboardingSte
       return
     }
     case "doctor": {
-      // Best-effort: surface provider doctor results inline
       try {
         const { runProviderDoctor } = await import("../../doctor-providers.js") as any
         if (typeof runProviderDoctor === "function") {
@@ -148,10 +108,9 @@ async function runSingleStep(ctx: ExtensionCommandContext, stepId: OnboardingSte
       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)
@@ -160,6 +119,27 @@ async function runSingleStep(ctx: ExtensionCommandContext, stepId: OnboardingSte
   }
 }
 
+// ─── Setup hub ───────────────────────────────────────────────────────────────
+
+async function renderSetupHub(ctx: ExtensionCommandContext): Promise<void> {
+  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(): string {
   const r = readOnboardingRecord()
   const lines: string[] = ["GSD Onboarding\n"]
@@ -192,38 +172,25 @@ export async function handleOnboarding(rawArgs: string, ctx: ExtensionCommandCon
       ctx.ui.notify(`Unknown step "${args.step}". Valid: ${validIds}`, "warning")
       return
     }
-    await runSingleStep(ctx, args.step as OnboardingStepId)
+    await runStep(ctx, args.step as OnboardingStepId)
     return
   }
 
   if (args.reset) {
     resetOnboarding()
     ctx.ui.notify(
-      "Onboarding reset. Existing API keys/credentials are unchanged — manage them with /gsd keys.",
+      "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 runWholeWizard(ctx)
+    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/src/resources/extensions/gsd/commands/handlers/ops.ts

@@ -251,6 +251,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