gsd-pi 2.75.0 → 2.76.0-dev.b072ebb73

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

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,16 @@ 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
+        await handleScan(trimmed.replace(/^scan\s*/, "").trim(), ctx, pi);
+        return true;
+    }
     return false;
 }

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

@@ -3,7 +3,7 @@ import { join } from "node:path";
 import { parse as parseYaml } from "yaml";
 import { handleQuick } from "../../quick.js";
 import { showDiscuss, showHeadlessMilestoneCreation, showQueue } from "../../guided-flow.js";
-import { handleStart, handleTemplates } from "../../commands-workflow-templates.js";
+import { handleStart, handleTemplates, dispatchMarkdownPhasePlugin } from "../../commands-workflow-templates.js";
 import { gsdRoot } from "../../paths.js";
 import { deriveState } from "../../state.js";
 import { isParked, parkMilestone, unparkMilestone } from "../../milestone-actions.js";
@@ -14,13 +14,24 @@ import { projectRoot } from "../context.js";
 import { createRun, listRuns } from "../../run-manager.js";
 import { setActiveEngineId, setActiveRunDir, startAutoDetached, pauseAuto, isAutoActive, getActiveEngineId, } from "../../auto.js";
 import { validateDefinition } from "../../definition-loader.js";
+import { formatPluginInfo, listPluginsFormatted, resolvePlugin, } from "../../workflow-plugins.js";
+import { dispatchOneshot } from "../../workflow-dispatch.js";
+import { fetchWorkflowSource, globalInstallDir, inferPluginName, installPlugin, previewContent, projectInstallDir, resolveSourceUrl, uninstallPlugin, validateFetchedContent, } from "../../workflow-install.js";
 // ─── Custom Workflow Subcommands ─────────────────────────────────────────
+const RESERVED_SUBCOMMANDS = new Set([
+    "new", "run", "list", "validate", "pause", "resume",
+    "info", "install", "uninstall",
+]);
 const WORKFLOW_USAGE = [
-    "Usage: /gsd workflow <subcommand>",
+    "Usage: /gsd workflow [<name> | <subcommand>]",
     "",
+    "  <name> [args]     — Run a plugin directly (resolves project/global/bundled)",
     "  new               — Create a new workflow definition (via skill)",
-    "  run <name> [k=v]  — Create a run and start auto-mode",
+    "  run <name> [k=v]  — Explicit YAML run (creates a new run dir)",
     "  list [name]       — List workflow runs (optionally filtered by name)",
+    "  info <name>       — Show plugin details (source, mode, phases)",
+    "  install <source>  — Install a plugin from a URL / gist: / gh:",
+    "  uninstall <name>  — Remove an installed plugin",
     "  validate <name>   — Validate a workflow definition YAML",
     "  pause             — Pause custom workflow auto-mode",
     "  resume            — Resume paused custom workflow auto-mode",
@@ -80,25 +91,91 @@ export function parseWorkflowRunArgs(args) {
     }
     return { defName, overrides };
 }
+/**
+ * Parse every token as an optional `k=v` override. Use when the workflow name
+ * is already known (e.g., direct `/gsd workflow <name> ...` dispatch) so the
+ * first token isn't eaten as a def name.
+ */
+export function parseWorkflowOverridesOnly(args) {
+    const parts = splitWorkflowRunArgs(args);
+    const overrides = {};
+    for (const part of parts) {
+        const eqIdx = part.indexOf("=");
+        if (eqIdx > 0) {
+            overrides[part.slice(0, eqIdx)] = part.slice(eqIdx + 1);
+        }
+    }
+    return overrides;
+}
+/**
+ * Dispatch a resolved plugin according to its declared mode.
+ */
+function dispatchPluginByMode(plugin, args, ctx, pi) {
+    switch (plugin.meta.mode) {
+        case "oneshot": {
+            dispatchOneshot(plugin, pi, args.trim());
+            ctx.ui.notify(`Running oneshot workflow: ${plugin.meta.displayName}`, "info");
+            return;
+        }
+        case "yaml-step": {
+            const overrides = parseWorkflowOverridesOnly(args);
+            try {
+                const base = projectRoot();
+                const runDir = createRun(base, plugin.name, Object.keys(overrides).length > 0 ? overrides : undefined);
+                setActiveEngineId("custom");
+                setActiveRunDir(runDir);
+                ctx.ui.notify(`Created workflow run: ${plugin.name}\nRun dir: ${runDir}`, "info");
+                startAutoDetached(ctx, pi, base, false);
+            }
+            catch (err) {
+                setActiveEngineId(null);
+                setActiveRunDir(null);
+                const msg = err instanceof Error ? err.message : String(err);
+                ctx.ui.notify(`Failed to run workflow "${plugin.name}": ${msg}`, "error");
+            }
+            return;
+        }
+        case "markdown-phase": {
+            if (isAutoActive()) {
+                ctx.ui.notify("Cannot start a markdown-phase workflow while auto-mode is running.\n" +
+                    "Run /gsd pause first.", "warning");
+                return;
+            }
+            // Delegate to commands-workflow-templates which handles branch + state file.
+            dispatchMarkdownPhasePlugin(plugin, args.trim(), ctx, pi);
+            return;
+        }
+        case "auto-milestone": {
+            ctx.ui.notify(`'${plugin.name}' runs via the full milestone pipeline.\n` +
+                `Use /gsd auto or /gsd start ${plugin.name}.`, "info");
+            return;
+        }
+    }
+}
 async function handleCustomWorkflow(sub, ctx, pi) {
-    // Bare `/gsd workflow` — show usage
+    // Bare `/gsd workflow` — list plugins
     if (!sub) {
-        ctx.ui.notify(WORKFLOW_USAGE, "info");
+        const base = projectRoot();
+        const listing = listPluginsFormatted(base);
+        ctx.ui.notify(listing, "info");
         return true;
     }
+    // Split into head + rest for subcommand detection.
+    const spaceIdx = sub.indexOf(" ");
+    const head = (spaceIdx === -1 ? sub : sub.slice(0, spaceIdx)).trim();
+    const rest = spaceIdx === -1 ? "" : sub.slice(spaceIdx + 1).trim();
     // ── new ──
-    if (sub === "new") {
+    if (head === "new") {
         ctx.ui.notify("Use the create-workflow skill: /skill create-workflow", "info");
         return true;
     }
     // ── run <name> [param=value ...] ──
-    if (sub === "run" || sub.startsWith("run ")) {
-        const args = sub.slice("run".length).trim();
-        if (!args) {
+    if (head === "run") {
+        if (!rest) {
             ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
             return true;
         }
-        const { defName, overrides } = parseWorkflowRunArgs(args);
+        const { defName, overrides } = parseWorkflowRunArgs(rest);
         try {
             const base = projectRoot();
             const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
@@ -108,7 +185,6 @@ async function handleCustomWorkflow(sub, ctx, pi) {
             startAutoDetached(ctx, pi, base, false);
         }
         catch (err) {
-            // Clean up engine state so a failed workflow run doesn't pollute the next /gsd auto
             setActiveEngineId(null);
             setActiveRunDir(null);
             const msg = err instanceof Error ? err.message : String(err);
@@ -116,11 +192,10 @@ async function handleCustomWorkflow(sub, ctx, pi) {
         }
         return true;
     }
-    // ── list [name] ──
-    if (sub === "list" || sub.startsWith("list ")) {
-        const filterName = sub.slice("list".length).trim() || undefined;
+    // ── list [name] — list YAML runs ──
+    if (head === "list") {
         const base = projectRoot();
-        const runs = listRuns(base, filterName);
+        const runs = listRuns(base, rest || undefined);
         if (runs.length === 0) {
             ctx.ui.notify("No workflow runs found.", "info");
             return true;
@@ -132,38 +207,152 @@ async function handleCustomWorkflow(sub, ctx, pi) {
         ctx.ui.notify(lines.join("\n"), "info");
         return true;
     }
+    // ── info <name> ──
+    if (head === "info") {
+        if (!rest) {
+            ctx.ui.notify("Usage: /gsd workflow info <name>", "warning");
+            return true;
+        }
+        const base = projectRoot();
+        const plugin = resolvePlugin(base, rest);
+        if (!plugin) {
+            ctx.ui.notify(`Plugin not found: ${rest}\nRun /gsd workflow to list plugins.`, "warning");
+            return true;
+        }
+        ctx.ui.notify(formatPluginInfo(plugin), "info");
+        return true;
+    }
+    // ── install <source> [--project] [--name <override>] ──
+    if (head === "install") {
+        if (!rest) {
+            ctx.ui.notify("Usage: /gsd workflow install <source> [--project] [--name <n>]\n\n" +
+                "Sources:\n" +
+                "  https://…/path/workflow.yaml\n" +
+                "  gist:<id>\n" +
+                "  gh:owner/repo/path[@ref]", "warning");
+            return true;
+        }
+        const tokens = rest.split(/\s+/);
+        let source = "";
+        let scope = "global";
+        let nameOverride;
+        for (let i = 0; i < tokens.length; i++) {
+            const t = tokens[i];
+            if (t === "--project")
+                scope = "project";
+            else if (t === "--name")
+                nameOverride = tokens[++i];
+            else if (t && !source)
+                source = t;
+        }
+        const base = projectRoot();
+        try {
+            const url = resolveSourceUrl(source);
+            ctx.ui.notify(`Fetching ${url}…`, "info");
+            const fetched = await fetchWorkflowSource(url);
+            validateFetchedContent(fetched);
+            const name = nameOverride ? nameOverride.trim().toLowerCase() : inferPluginName(fetched);
+            if (!name)
+                throw new Error("Could not infer plugin name. Use --name <n>.");
+            const target = scope === "global"
+                ? { scope: "global", dir: globalInstallDir() }
+                : { scope: "project", dir: projectInstallDir(base) };
+            const preview = previewContent(fetched.content, 20);
+            const summary = [
+                `Install workflow plugin:`,
+                `  Source:    ${fetched.url}`,
+                `  Name:      ${name}`,
+                `  Format:    ${fetched.ext.slice(1)}`,
+                `  Target:    ${join(target.dir, `${name}${fetched.ext}`)}`,
+                `  Scope:     ${target.scope}`,
+                "",
+                `Preview (first 20 lines):`,
+                "  " + preview.split("\n").join("\n  "),
+                "",
+                `Proceeding with install. Run /gsd workflow uninstall ${name} to revert.`,
+            ].join("\n");
+            ctx.ui.notify(summary, "info");
+            const result = installPlugin(target, fetched, name);
+            ctx.ui.notify(`✓ Installed plugin "${result.name}" (${result.ext.slice(1)}) to ${result.path}`, "info");
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            ctx.ui.notify(`Failed to install: ${msg}`, "error");
+        }
+        return true;
+    }
+    // ── uninstall <name> ──
+    if (head === "uninstall") {
+        if (!rest) {
+            ctx.ui.notify("Usage: /gsd workflow uninstall <name>", "warning");
+            return true;
+        }
+        const base = projectRoot();
+        const result = uninstallPlugin(base, rest.trim());
+        if (!result.removed) {
+            ctx.ui.notify(`No installed plugin named "${rest}" found in ${globalInstallDir()} or ${projectInstallDir(base)}.`, "warning");
+            return true;
+        }
+        const warning = result.warnedNotInProvenance
+            ? " (no provenance record — was this hand-authored?)"
+            : "";
+        ctx.ui.notify(`✓ Removed ${result.path}${warning}`, "info");
+        return true;
+    }
     // ── validate <name> ──
-    if (sub === "validate" || sub.startsWith("validate ")) {
-        const defName = sub.slice("validate".length).trim();
-        if (!defName) {
+    if (head === "validate") {
+        if (!rest) {
             ctx.ui.notify("Usage: /gsd workflow validate <name>", "warning");
             return true;
         }
         const base = projectRoot();
-        const defPath = join(base, ".gsd", "workflow-defs", `${defName}.yaml`);
-        if (!existsSync(defPath)) {
-            ctx.ui.notify(`Definition not found: ${defPath}`, "error");
-            return true;
+        const plugin = resolvePlugin(base, rest);
+        let raw;
+        let sourceLabel;
+        if (plugin && plugin.format === "yaml") {
+            try {
+                raw = readFileSync(plugin.path, "utf-8");
+                sourceLabel = plugin.path;
+            }
+            catch (err) {
+                ctx.ui.notify(`Failed to read definition: ${err instanceof Error ? err.message : String(err)}`, "error");
+                return true;
+            }
+        }
+        else {
+            // Legacy fallback path for names that don't resolve via plugins.
+            const defPath = join(base, ".gsd", "workflow-defs", `${rest}.yaml`);
+            if (!existsSync(defPath)) {
+                ctx.ui.notify(`Definition not found: ${defPath}`, "error");
+                return true;
+            }
+            try {
+                raw = readFileSync(defPath, "utf-8");
+                sourceLabel = defPath;
+            }
+            catch (err) {
+                ctx.ui.notify(`Failed to read definition: ${err instanceof Error ? err.message : String(err)}`, "error");
+                return true;
+            }
         }
         try {
-            const raw = readFileSync(defPath, "utf-8");
             const parsed = parseYaml(raw);
             const result = validateDefinition(parsed);
             if (result.valid) {
-                ctx.ui.notify(`✓ "${defName}" is a valid workflow definition.`, "info");
+                ctx.ui.notify(`✓ "${rest}" is a valid workflow definition (${sourceLabel}).`, "info");
             }
             else {
-                ctx.ui.notify(`✗ "${defName}" has errors:\n  - ${result.errors.join("\n  - ")}`, "error");
+                ctx.ui.notify(`✗ "${rest}" has errors:\n  - ${result.errors.join("\n  - ")}`, "error");
             }
         }
         catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
-            ctx.ui.notify(`Failed to validate "${defName}": ${msg}`, "error");
+            ctx.ui.notify(`Failed to validate "${rest}": ${msg}`, "error");
         }
         return true;
     }
     // ── pause ──
-    if (sub === "pause") {
+    if (head === "pause" && !rest) {
         const engineId = getActiveEngineId();
         if (engineId === "dev" || engineId === null) {
             ctx.ui.notify("No custom workflow is running. Use /gsd pause for dev workflow.", "warning");
@@ -178,7 +367,7 @@ async function handleCustomWorkflow(sub, ctx, pi) {
         return true;
     }
     // ── resume ──
-    if (sub === "resume") {
+    if (head === "resume" && !rest) {
         const engineId = getActiveEngineId();
         if (engineId === "dev" || engineId === null) {
             ctx.ui.notify("No custom workflow to resume. Use /gsd auto for dev workflow.", "warning");
@@ -188,8 +377,18 @@ async function handleCustomWorkflow(sub, ctx, pi) {
         ctx.ui.notify("Custom workflow resumed.", "info");
         return true;
     }
+    // ── Direct dispatch: /gsd workflow <name> [args] ──
+    // If the first token isn't a reserved subcommand, resolve it as a plugin.
+    if (!RESERVED_SUBCOMMANDS.has(head)) {
+        const base = projectRoot();
+        const plugin = resolvePlugin(base, head);
+        if (plugin) {
+            dispatchPluginByMode(plugin, rest, ctx, pi);
+            return true;
+        }
+    }
     // Unknown subcommand — show usage
-    ctx.ui.notify(`Unknown workflow subcommand: "${sub}"\n\n${WORKFLOW_USAGE}`, "warning");
+    ctx.ui.notify(`Unknown workflow subcommand or plugin: "${head}"\n\n${WORKFLOW_USAGE}`, "warning");
     return true;
 }
 export async function handleWorkflowCommand(trimmed, ctx, pi) {

package/dist/resources/extensions/gsd/commands-cmux.js

@@ -9,7 +9,7 @@ import { ensurePreferencesFile, serializePreferencesToFrontmatter } from "./comm
  * Returns true if preferences were written, false if skipped.
  */
 export function autoEnableCmuxPreferences() {
-    const path = getProjectGSDPreferencesPath();
+    const path = resolveProjectPreferencesWritePath();
     if (!existsSync(path))
         return false;
     const existing = loadProjectGSDPreferences();
@@ -43,7 +43,7 @@ function extractBodyAfterFrontmatter(content) {
     return after.trim() ? after : null;
 }
 async function writeProjectCmuxPreferences(ctx, updater) {
-    const path = getProjectGSDPreferencesPath();
+    const path = resolveProjectPreferencesWritePath();
     await ensurePreferencesFile(path, ctx, "project");
     const existing = loadProjectGSDPreferences();
     const prefs = existing?.preferences ? { ...existing.preferences } : { version: 1 };
@@ -60,6 +60,9 @@ async function writeProjectCmuxPreferences(ctx, updater) {
     await ctx.waitForIdle();
     await ctx.reload();
 }
+function resolveProjectPreferencesWritePath() {
+    return loadProjectGSDPreferences()?.path ?? getProjectGSDPreferencesPath();
+}
 function formatCmuxStatus() {
     const loaded = loadEffectiveGSDPreferences();
     const detected = detectCmuxEnvironment();

package/dist/resources/extensions/gsd/commands-config.js

@@ -49,7 +49,12 @@ export function getConfigAuthStorage() {
     mkdirSync(dirname(authPath), { recursive: true });
     return AuthStorage.create(authPath);
 }
+let deprecationWarned = false;
 export async function handleConfig(ctx) {
+    if (!deprecationWarned) {
+        ctx.ui.notify("/gsd config is deprecated and will be removed. Use /gsd keys (manages both LLM and tool API keys).", "warning");
+        deprecationWarned = true;
+    }
     const auth = getConfigAuthStorage();
     // Show current status
     const statusLines = ["GSD Tool Configuration\n"];