gsd-pi 2.39.0 → 2.40.0-dev.4a93031

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

@@ -0,0 +1,246 @@
+import { computeProgressScore, formatProgressLine } from "../../progress-score.js";
+import { getGlobalGSDPreferencesPath, getProjectGSDPreferencesPath } from "../../preferences.js";
+import { ensurePreferencesFile, handlePrefs, handlePrefsMode, handlePrefsWizard } from "../../commands-prefs-wizard.js";
+import { runEnvironmentChecks } from "../../doctor-environment.js";
+import { deriveState } from "../../state.js";
+import { handleCmux } from "../../commands-cmux.js";
+import { projectRoot } from "../context.js";
+export function showHelp(ctx) {
+    const lines = [
+        "GSD — Get Shit Done\n",
+        "WORKFLOW",
+        "  /gsd start <tpl>   Start a workflow template (bugfix, spike, feature, hotfix, etc.)",
+        "  /gsd templates     List available workflow templates  [info <name>]",
+        "  /gsd               Run next unit in step mode (same as /gsd next)",
+        "  /gsd next           Execute next task, then pause  [--dry-run] [--verbose]",
+        "  /gsd auto           Run all queued units continuously  [--verbose]",
+        "  /gsd stop           Stop auto-mode gracefully",
+        "  /gsd pause          Pause auto-mode (preserves state, /gsd auto to resume)",
+        "  /gsd discuss        Start guided milestone/slice discussion",
+        "  /gsd new-milestone  Create milestone from headless context (used by gsd headless)",
+        "",
+        "VISIBILITY",
+        "  /gsd status         Show progress dashboard  (Ctrl+Alt+G)",
+        "  /gsd visualize      Interactive 10-tab TUI (progress, timeline, deps, metrics, health, agent, changes, knowledge, captures, export)",
+        "  /gsd queue          Show queued/dispatched units and execution order",
+        "  /gsd history        View execution history  [--cost] [--phase] [--model] [N]",
+        "  /gsd changelog      Show categorized release notes  [version]",
+        "",
+        "COURSE CORRECTION",
+        "  /gsd steer <desc>   Apply user override to active work",
+        "  /gsd capture <text> Quick-capture a thought to CAPTURES.md",
+        "  /gsd triage         Classify and route pending captures",
+        "  /gsd skip <unit>    Prevent a unit from auto-mode dispatch",
+        "  /gsd undo           Revert last completed unit  [--force]",
+        "  /gsd park [id]      Park a milestone — skip without deleting  [reason]",
+        "  /gsd unpark [id]    Reactivate a parked milestone",
+        "",
+        "PROJECT KNOWLEDGE",
+        "  /gsd knowledge <type> <text>   Add rule, pattern, or lesson to KNOWLEDGE.md",
+        "",
+        "SETUP & CONFIGURATION",
+        "  /gsd init           Project init wizard — detect, configure, bootstrap .gsd/",
+        "  /gsd setup          Global setup status  [llm|search|remote|keys|prefs]",
+        "  /gsd mode           Set workflow mode (solo/team)  [global|project]",
+        "  /gsd prefs          Manage preferences  [global|project|status|wizard|setup|import-claude]",
+        "  /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 hooks          Show post-unit hook configuration",
+        "  /gsd extensions     Manage extensions  [list|enable|disable|info]",
+        "",
+        "MAINTENANCE",
+        "  /gsd doctor         Diagnose and repair .gsd/ state  [audit|fix|heal] [scope]",
+        "  /gsd export         Export milestone/slice results  [--json|--markdown|--html] [--all]",
+        "  /gsd cleanup        Remove merged branches or snapshots  [branches|snapshots]",
+        "  /gsd migrate        Migrate .planning/ (v1) to .gsd/ (v2) format",
+        "  /gsd remote         Control remote auto-mode  [slack|discord|status|disconnect]",
+        "  /gsd inspect        Show SQLite DB diagnostics (schema, row counts, recent entries)",
+        "  /gsd update         Update GSD to the latest version via npm",
+    ];
+    ctx.ui.notify(lines.join("\n"), "info");
+}
+export async function handleStatus(ctx) {
+    const basePath = projectRoot();
+    const state = await deriveState(basePath);
+    if (state.registry.length === 0) {
+        ctx.ui.notify("No GSD milestones found. Run /gsd to start.", "info");
+        return;
+    }
+    const { GSDDashboardOverlay } = await import("../../dashboard-overlay.js");
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDDashboardOverlay(tui, theme, () => done()), {
+        overlay: true,
+        overlayOptions: {
+            width: "70%",
+            minWidth: 60,
+            maxHeight: "90%",
+            anchor: "center",
+        },
+    });
+    if (result === undefined) {
+        ctx.ui.notify(formatTextStatus(state), "info");
+    }
+}
+export async function fireStatusViaCommand(ctx) {
+    await handleStatus(ctx);
+}
+export async function handleVisualize(ctx) {
+    if (!ctx.hasUI) {
+        ctx.ui.notify("Visualizer requires an interactive terminal.", "warning");
+        return;
+    }
+    const { GSDVisualizerOverlay } = await import("../../visualizer-overlay.js");
+    const result = await ctx.ui.custom((tui, theme, _kb, done) => new GSDVisualizerOverlay(tui, theme, () => done()), {
+        overlay: true,
+        overlayOptions: {
+            width: "80%",
+            minWidth: 80,
+            maxHeight: "90%",
+            anchor: "center",
+        },
+    });
+    if (result === undefined) {
+        ctx.ui.notify("Visualizer requires an interactive terminal. Use /gsd status for a text-based overview.", "warning");
+    }
+}
+export async function handleSetup(args, ctx) {
+    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}`);
+    }
+    if (args === "llm" || args === "auth") {
+        ctx.ui.notify("Use /login to configure LLM authentication.", "info");
+        return;
+    }
+    if (args === "search") {
+        ctx.ui.notify("Use /search-provider to configure web search.", "info");
+        return;
+    }
+    if (args === "remote") {
+        ctx.ui.notify("Use /gsd remote to configure remote questions.", "info");
+        return;
+    }
+    if (args === "keys") {
+        const { handleKeys } = await import("../../key-manager.js");
+        await handleKeys("", ctx);
+        return;
+    }
+    if (args === "prefs") {
+        await ensurePreferencesFile(getGlobalGSDPreferencesPath(), ctx, "global");
+        await handlePrefsWizard(ctx, "global");
+        return;
+    }
+    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");
+}
+export async function handleCoreCommand(trimmed, ctx) {
+    if (trimmed === "help" || trimmed === "h" || trimmed === "?") {
+        showHelp(ctx);
+        return true;
+    }
+    if (trimmed === "status") {
+        await handleStatus(ctx);
+        return true;
+    }
+    if (trimmed === "visualize") {
+        await handleVisualize(ctx);
+        return true;
+    }
+    if (trimmed === "widget" || trimmed.startsWith("widget ")) {
+        const { cycleWidgetMode, setWidgetMode, getWidgetMode } = await import("../../auto-dashboard.js");
+        const arg = trimmed.replace(/^widget\s*/, "").trim();
+        if (arg === "full" || arg === "small" || arg === "min" || arg === "off") {
+            setWidgetMode(arg);
+        }
+        else {
+            cycleWidgetMode();
+        }
+        ctx.ui.notify(`Widget: ${getWidgetMode()}`, "info");
+        return true;
+    }
+    if (trimmed === "mode" || trimmed.startsWith("mode ")) {
+        const modeArgs = trimmed.replace(/^mode\s*/, "").trim();
+        const scope = modeArgs === "project" ? "project" : "global";
+        const path = scope === "project" ? getProjectGSDPreferencesPath() : getGlobalGSDPreferencesPath();
+        await ensurePreferencesFile(path, ctx, scope);
+        await handlePrefsMode(ctx, scope);
+        return true;
+    }
+    if (trimmed === "prefs" || trimmed.startsWith("prefs ")) {
+        await handlePrefs(trimmed.replace(/^prefs\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "cmux" || trimmed.startsWith("cmux ")) {
+        await handleCmux(trimmed.replace(/^cmux\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "setup" || trimmed.startsWith("setup ")) {
+        await handleSetup(trimmed.replace(/^setup\s*/, "").trim(), ctx);
+        return true;
+    }
+    return false;
+}
+export function formatTextStatus(state) {
+    const lines = ["GSD Status\n"];
+    lines.push(formatProgressLine(computeProgressScore()));
+    lines.push("");
+    lines.push(`Phase: ${state.phase}`);
+    if (state.activeMilestone) {
+        lines.push(`Active milestone: ${state.activeMilestone.id} — ${state.activeMilestone.title}`);
+    }
+    if (state.activeSlice) {
+        lines.push(`Active slice: ${state.activeSlice.id} — ${state.activeSlice.title}`);
+    }
+    if (state.activeTask) {
+        lines.push(`Active task: ${state.activeTask.id} — ${state.activeTask.title}`);
+    }
+    if (state.progress) {
+        const { milestones, slices, tasks } = state.progress;
+        const parts = [`milestones ${milestones.done}/${milestones.total}`];
+        if (slices)
+            parts.push(`slices ${slices.done}/${slices.total}`);
+        if (tasks)
+            parts.push(`tasks ${tasks.done}/${tasks.total}`);
+        lines.push(`Progress: ${parts.join(", ")}`);
+    }
+    if (state.nextAction) {
+        lines.push(`Next: ${state.nextAction}`);
+    }
+    if (state.blockers.length > 0) {
+        lines.push(`Blockers: ${state.blockers.join("; ")}`);
+    }
+    if (state.registry.length > 0) {
+        lines.push("");
+        lines.push("Milestones:");
+        for (const milestone of state.registry) {
+            const icon = milestone.status === "complete"
+                ? "✓"
+                : milestone.status === "active"
+                    ? "▶"
+                    : milestone.status === "parked"
+                        ? "⏸"
+                        : "○";
+            lines.push(`  ${icon} ${milestone.id}: ${milestone.title} (${milestone.status})`);
+        }
+    }
+    const envResults = runEnvironmentChecks(projectRoot());
+    const envIssues = envResults.filter((result) => result.status !== "ok");
+    if (envIssues.length > 0) {
+        lines.push("");
+        lines.push("Environment:");
+        for (const issue of envIssues) {
+            lines.push(`  ${issue.status === "error" ? "✗" : "⚠"} ${issue.message}`);
+        }
+    }
+    return lines.join("\n");
+}

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

@@ -0,0 +1,166 @@
+import { dispatchDirectPhase } from "../../auto-direct-dispatch.js";
+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 { handleCleanupBranches, handleCleanupSnapshots, handleSkip } from "../../commands-maintenance.js";
+import { handleExport } from "../../export.js";
+import { handleHistory } from "../../history.js";
+import { handleUndo } from "../../undo.js";
+import { handleRemote } from "../../../remote-questions/mod.js";
+import { projectRoot } from "../context.js";
+export async function handleOpsCommand(trimmed, ctx, pi) {
+    if (trimmed === "init") {
+        const { detectProjectState } = await import("../../detection.js");
+        const { handleReinit, showProjectInit } = await import("../../init-wizard.js");
+        const basePath = projectRoot();
+        const detection = detectProjectState(basePath);
+        if (detection.state === "v2-gsd" || detection.state === "v2-gsd-empty") {
+            await handleReinit(ctx, detection);
+        }
+        else {
+            await showProjectInit(ctx, pi, basePath, detection);
+        }
+        return true;
+    }
+    if (trimmed === "keys" || trimmed.startsWith("keys ")) {
+        const { handleKeys } = await import("../../key-manager.js");
+        await handleKeys(trimmed.replace(/^keys\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "doctor" || trimmed.startsWith("doctor ")) {
+        await handleDoctor(trimmed.replace(/^doctor\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "logs" || trimmed.startsWith("logs ")) {
+        await handleLogs(trimmed.replace(/^logs\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "forensics" || trimmed.startsWith("forensics ")) {
+        const { handleForensics } = await import("../../forensics.js");
+        await handleForensics(trimmed.replace(/^forensics\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "changelog" || trimmed.startsWith("changelog ")) {
+        const { handleChangelog } = await import("../../changelog.js");
+        await handleChangelog(trimmed.replace(/^changelog\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "history" || trimmed.startsWith("history ")) {
+        await handleHistory(trimmed.replace(/^history\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
+    if (trimmed === "undo" || trimmed.startsWith("undo ")) {
+        await handleUndo(trimmed.replace(/^undo\s*/, "").trim(), ctx, pi, projectRoot());
+        return true;
+    }
+    if (trimmed.startsWith("skip ")) {
+        await handleSkip(trimmed.replace(/^skip\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
+    if (trimmed === "export" || trimmed.startsWith("export ")) {
+        await handleExport(trimmed.replace(/^export\s*/, "").trim(), ctx, projectRoot());
+        return true;
+    }
+    if (trimmed === "cleanup") {
+        await handleCleanupBranches(ctx, projectRoot());
+        await handleCleanupSnapshots(ctx, projectRoot());
+        return true;
+    }
+    if (trimmed === "cleanup branches") {
+        await handleCleanupBranches(ctx, projectRoot());
+        return true;
+    }
+    if (trimmed === "cleanup snapshots") {
+        await handleCleanupSnapshots(ctx, projectRoot());
+        return true;
+    }
+    if (trimmed.startsWith("capture ") || trimmed === "capture") {
+        await handleCapture(trimmed.replace(/^capture\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "triage") {
+        await handleTriage(ctx, pi, process.cwd());
+        return true;
+    }
+    if (trimmed === "config") {
+        await handleConfig(ctx);
+        return true;
+    }
+    if (trimmed === "hooks") {
+        const { formatHookStatus } = await import("../../post-unit-hooks.js");
+        ctx.ui.notify(formatHookStatus(), "info");
+        return true;
+    }
+    if (trimmed === "skill-health" || trimmed.startsWith("skill-health ")) {
+        await handleSkillHealth(trimmed.replace(/^skill-health\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed.startsWith("run-hook ")) {
+        await handleRunHook(trimmed.replace(/^run-hook\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "run-hook") {
+        ctx.ui.notify(`Usage: /gsd run-hook <hook-name> <unit-type> <unit-id>
+
+Unit types:
+  execute-task   - Task execution (unit-id: M001/S01/T01)
+  plan-slice     - Slice planning (unit-id: M001/S01)
+  research-milestone - Milestone research (unit-id: M001)
+  complete-slice - Slice completion (unit-id: M001/S01)
+  complete-milestone - Milestone completion (unit-id: M001)
+
+Examples:
+  /gsd run-hook code-review execute-task M001/S01/T01
+  /gsd run-hook lint-check plan-slice M001/S01`, "warning");
+        return true;
+    }
+    if (trimmed.startsWith("steer ")) {
+        await handleSteer(trimmed.replace(/^steer\s+/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "steer") {
+        ctx.ui.notify("Usage: /gsd steer <description of change>. Example: /gsd steer Use Postgres instead of SQLite", "warning");
+        return true;
+    }
+    if (trimmed.startsWith("knowledge ")) {
+        await handleKnowledge(trimmed.replace(/^knowledge\s+/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "knowledge") {
+        ctx.ui.notify("Usage: /gsd knowledge <rule|pattern|lesson> <description>. Example: /gsd knowledge rule Use real DB for integration tests", "warning");
+        return true;
+    }
+    if (trimmed === "migrate" || trimmed.startsWith("migrate ")) {
+        const { handleMigrate } = await import("../../migrate/command.js");
+        await handleMigrate(trimmed.replace(/^migrate\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "remote" || trimmed.startsWith("remote ")) {
+        await handleRemote(trimmed.replace(/^remote\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "dispatch" || trimmed.startsWith("dispatch ")) {
+        const phase = trimmed.replace(/^dispatch\s*/, "").trim();
+        if (!phase) {
+            ctx.ui.notify("Usage: /gsd dispatch <phase>  (research|plan|execute|complete|reassess|uat|replan)", "warning");
+            return true;
+        }
+        await dispatchDirectPhase(ctx, pi, phase, projectRoot());
+        return true;
+    }
+    if (trimmed === "inspect") {
+        await handleInspect(ctx);
+        return true;
+    }
+    if (trimmed === "update") {
+        await handleUpdate(ctx);
+        return true;
+    }
+    if (trimmed === "extensions" || trimmed.startsWith("extensions ")) {
+        const { handleExtensions } = await import("../../commands-extensions.js");
+        await handleExtensions(trimmed.replace(/^extensions\s*/, "").trim(), ctx);
+        return true;
+    }
+    return false;
+}

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

@@ -0,0 +1,94 @@
+import { getOrchestratorState, getWorkerStatuses, isParallelActive, pauseWorker, prepareParallelStart, resumeWorker, startParallel, stopParallel, } from "../../parallel-orchestrator.js";
+import { formatEligibilityReport } from "../../parallel-eligibility.js";
+import { formatMergeResults, mergeAllCompleted, mergeCompletedMilestone } from "../../parallel-merge.js";
+import { loadEffectiveGSDPreferences, resolveParallelConfig } from "../../preferences.js";
+import { projectRoot } from "../context.js";
+export async function handleParallelCommand(trimmed, _ctx, pi) {
+    if (!trimmed.startsWith("parallel"))
+        return false;
+    const parallelArgs = trimmed.slice("parallel".length).trim();
+    const [subcommand = "", ...restParts] = parallelArgs.split(/\s+/);
+    const rest = restParts.join(" ");
+    if (subcommand === "start" || subcommand === "") {
+        const loaded = loadEffectiveGSDPreferences();
+        const config = resolveParallelConfig(loaded?.preferences);
+        if (!config.enabled) {
+            pi.sendMessage({
+                customType: "gsd-parallel",
+                content: "Parallel mode is not enabled. Set `parallel.enabled: true` in your preferences.",
+                display: false,
+            });
+            return true;
+        }
+        const candidates = await prepareParallelStart(projectRoot(), loaded?.preferences);
+        const report = formatEligibilityReport(candidates);
+        if (candidates.eligible.length === 0) {
+            pi.sendMessage({ customType: "gsd-parallel", content: `${report}\n\nNo milestones are eligible for parallel execution.`, display: false });
+            return true;
+        }
+        const result = await startParallel(projectRoot(), candidates.eligible.map((candidate) => candidate.milestoneId), loaded?.preferences);
+        const lines = ["Parallel orchestration started.", `Workers: ${result.started.join(", ")}`];
+        if (result.errors.length > 0) {
+            lines.push(`Errors: ${result.errors.map((entry) => `${entry.mid}: ${entry.error}`).join("; ")}`);
+        }
+        pi.sendMessage({ customType: "gsd-parallel", content: `${report}\n\n${lines.join("\n")}`, display: false });
+        return true;
+    }
+    if (subcommand === "status") {
+        if (!isParallelActive()) {
+            pi.sendMessage({ customType: "gsd-parallel", content: "No parallel orchestration is currently active.", display: false });
+            return true;
+        }
+        const workers = getWorkerStatuses();
+        const lines = ["# Parallel Workers\n"];
+        for (const worker of workers) {
+            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — ${worker.completedUnits} units — $${worker.cost.toFixed(2)}`);
+        }
+        const state = getOrchestratorState();
+        if (state) {
+            lines.push(`\nTotal cost: $${state.totalCost.toFixed(2)}`);
+        }
+        pi.sendMessage({ customType: "gsd-parallel", content: lines.join("\n"), display: false });
+        return true;
+    }
+    if (subcommand === "stop") {
+        const milestoneId = rest.trim() || undefined;
+        await stopParallel(projectRoot(), milestoneId);
+        pi.sendMessage({ customType: "gsd-parallel", content: milestoneId ? `Stopped worker for ${milestoneId}.` : "All parallel workers stopped.", display: false });
+        return true;
+    }
+    if (subcommand === "pause") {
+        const milestoneId = rest.trim() || undefined;
+        pauseWorker(projectRoot(), milestoneId);
+        pi.sendMessage({ customType: "gsd-parallel", content: milestoneId ? `Paused worker for ${milestoneId}.` : "All parallel workers paused.", display: false });
+        return true;
+    }
+    if (subcommand === "resume") {
+        const milestoneId = rest.trim() || undefined;
+        resumeWorker(projectRoot(), milestoneId);
+        pi.sendMessage({ customType: "gsd-parallel", content: milestoneId ? `Resumed worker for ${milestoneId}.` : "All parallel workers resumed.", display: false });
+        return true;
+    }
+    if (subcommand === "merge") {
+        const milestoneId = rest.trim() || undefined;
+        if (milestoneId) {
+            const result = await mergeCompletedMilestone(projectRoot(), milestoneId);
+            pi.sendMessage({ customType: "gsd-parallel", content: formatMergeResults([result]), display: false });
+            return true;
+        }
+        const workers = getWorkerStatuses();
+        if (workers.length === 0) {
+            pi.sendMessage({ customType: "gsd-parallel", content: "No parallel workers to merge.", display: false });
+            return true;
+        }
+        const results = await mergeAllCompleted(projectRoot(), workers);
+        pi.sendMessage({ customType: "gsd-parallel", content: formatMergeResults(results), display: false });
+        return true;
+    }
+    pi.sendMessage({
+        customType: "gsd-parallel",
+        content: `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge]`,
+        display: false,
+    });
+    return true;
+}

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

@@ -0,0 +1,102 @@
+import { existsSync, readFileSync, unlinkSync } from "node:fs";
+import { join } from "node:path";
+import { handleQuick } from "../../quick.js";
+import { showDiscuss, showHeadlessMilestoneCreation, showQueue } from "../../guided-flow.js";
+import { handleStart, handleTemplates } from "../../commands-workflow-templates.js";
+import { gsdRoot } from "../../paths.js";
+import { deriveState } from "../../state.js";
+import { isParked, parkMilestone, unparkMilestone } from "../../milestone-actions.js";
+import { loadEffectiveGSDPreferences } from "../../preferences.js";
+import { nextMilestoneId } from "../../milestone-ids.js";
+import { findMilestoneIds } from "../../guided-flow.js";
+import { projectRoot } from "../context.js";
+export async function handleWorkflowCommand(trimmed, ctx, pi) {
+    if (trimmed === "queue") {
+        await showQueue(ctx, pi, projectRoot());
+        return true;
+    }
+    if (trimmed === "discuss") {
+        await showDiscuss(ctx, pi, projectRoot());
+        return true;
+    }
+    if (trimmed === "quick" || trimmed.startsWith("quick ")) {
+        await handleQuick(trimmed.replace(/^quick\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "new-milestone") {
+        const basePath = projectRoot();
+        const headlessContextPath = join(gsdRoot(basePath), "runtime", "headless-context.md");
+        if (existsSync(headlessContextPath)) {
+            const seedContext = readFileSync(headlessContextPath, "utf-8");
+            try {
+                unlinkSync(headlessContextPath);
+            }
+            catch { /* non-fatal */ }
+            await showHeadlessMilestoneCreation(ctx, pi, basePath, seedContext);
+        }
+        else {
+            const { showSmartEntry } = await import("../../guided-flow.js");
+            await showSmartEntry(ctx, pi, basePath);
+        }
+        return true;
+    }
+    if (trimmed === "start" || trimmed.startsWith("start ")) {
+        await handleStart(trimmed.replace(/^start\s*/, "").trim(), ctx, pi);
+        return true;
+    }
+    if (trimmed === "templates" || trimmed.startsWith("templates ")) {
+        await handleTemplates(trimmed.replace(/^templates\s*/, "").trim(), ctx);
+        return true;
+    }
+    if (trimmed === "park" || trimmed.startsWith("park ")) {
+        const basePath = projectRoot();
+        const arg = trimmed.replace(/^park\s*/, "").trim();
+        let targetId = arg;
+        if (!targetId) {
+            const state = await deriveState(basePath);
+            if (!state.activeMilestone) {
+                ctx.ui.notify("No active milestone to park.", "warning");
+                return true;
+            }
+            targetId = state.activeMilestone.id;
+        }
+        if (isParked(basePath, targetId)) {
+            ctx.ui.notify(`${targetId} is already parked. Use /gsd unpark ${targetId} to reactivate.`, "info");
+            return true;
+        }
+        const reasonParts = arg.replace(targetId, "").trim().replace(/^["']|["']$/g, "");
+        const reason = reasonParts || "Parked via /gsd park";
+        const success = parkMilestone(basePath, targetId, reason);
+        ctx.ui.notify(success ? `Parked ${targetId}. Run /gsd unpark ${targetId} to reactivate.` : `Could not park ${targetId} — milestone not found.`, success ? "info" : "warning");
+        return true;
+    }
+    if (trimmed === "unpark" || trimmed.startsWith("unpark ")) {
+        const basePath = projectRoot();
+        const arg = trimmed.replace(/^unpark\s*/, "").trim();
+        let targetId = arg;
+        if (!targetId) {
+            const state = await deriveState(basePath);
+            const parkedEntries = state.registry.filter((entry) => entry.status === "parked");
+            if (parkedEntries.length === 0) {
+                ctx.ui.notify("No parked milestones.", "info");
+                return true;
+            }
+            if (parkedEntries.length === 1) {
+                targetId = parkedEntries[0].id;
+            }
+            else {
+                ctx.ui.notify(`Parked milestones: ${parkedEntries.map((entry) => entry.id).join(", ")}. Specify which to unpark: /gsd unpark <id>`, "info");
+                return true;
+            }
+        }
+        const success = unparkMilestone(basePath, targetId);
+        ctx.ui.notify(success ? `Unparked ${targetId}. It will resume its normal position in the queue.` : `Could not unpark ${targetId} — milestone not found or not parked.`, success ? "info" : "warning");
+        return true;
+    }
+    return false;
+}
+export function getNextMilestoneId(basePath) {
+    const milestoneIds = findMilestoneIds(basePath);
+    const uniqueIds = !!loadEffectiveGSDPreferences()?.preferences?.unique_milestone_ids;
+    return nextMilestoneId(milestoneIds, uniqueIds);
+}

package/dist/resources/extensions/gsd/commands/index.js

@@ -0,0 +1,11 @@
+import { GSD_COMMAND_DESCRIPTION, getGsdArgumentCompletions } from "./catalog.js";
+export function registerGSDCommand(pi) {
+    pi.registerCommand("gsd", {
+        description: GSD_COMMAND_DESCRIPTION,
+        getArgumentCompletions: getGsdArgumentCompletions,
+        handler: async (args, ctx) => {
+            const { handleGSDCommand } = await import("./dispatcher.js");
+            await handleGSDCommand(args, ctx, pi);
+        },
+    });
+}

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

@@ -12,7 +12,7 @@ import { appendCapture, hasPendingCaptures, loadPendingCaptures } from "./captur
 import { appendOverride, appendKnowledge } from "./files.js";
 import { formatDoctorIssuesForPrompt, formatDoctorReport, formatDoctorReportJson, runGSDDoctor, selectDoctorScope, filterDoctorIssues, } from "./doctor.js";
 import { isAutoActive } from "./auto.js";
-import { projectRoot } from "./commands.js";
+import { projectRoot } from "./commands/context.js";
 import { loadPrompt } from "./prompt-loader.js";
 export function dispatchDoctorHeal(pi, scope, reportText, structuredIssues) {
     const workflowPath = process.env.GSD_WORKFLOW_PATH ?? join(process.env.HOME ?? "~", ".gsd", "agent", "GSD-WORKFLOW.md");