lsd-pi 1.0.0 → 1.1.0

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

@@ -1,106 +0,0 @@
-import { getOrchestratorState, getWorkerStatuses, isParallelActive, pauseWorker, prepareParallelStart, refreshWorkerStatuses, 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";
-function emitParallelMessage(pi, content) {
-    pi.sendMessage({ customType: "gsd-parallel", content, display: true });
-}
-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 root = projectRoot();
-        const loaded = loadEffectiveGSDPreferences();
-        const config = resolveParallelConfig(loaded?.preferences);
-        if (!config.enabled) {
-            emitParallelMessage(pi, "Parallel mode is not enabled. Set `parallel.enabled: true` in your preferences.");
-            return true;
-        }
-        const candidates = await prepareParallelStart(root, loaded?.preferences);
-        const report = formatEligibilityReport(candidates);
-        if (candidates.eligible.length === 0) {
-            emitParallelMessage(pi, `${report}\n\nNo milestones are eligible for parallel execution.`);
-            return true;
-        }
-        const result = await startParallel(root, 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("; ")}`);
-        }
-        emitParallelMessage(pi, `${report}\n\n${lines.join("\n")}`);
-        return true;
-    }
-    if (subcommand === "status") {
-        const root = projectRoot();
-        refreshWorkerStatuses(root, { restoreIfNeeded: true });
-        const workers = getWorkerStatuses(root);
-        if (workers.length === 0 || !isParallelActive()) {
-            emitParallelMessage(pi, "No parallel orchestration is currently active.");
-            return true;
-        }
-        const lines = ["# Parallel Workers\n"];
-        for (const worker of workers) {
-            lines.push(`- **${worker.milestoneId}** (${worker.title}) — ${worker.state} — $${worker.cost.toFixed(2)}`);
-        }
-        const state = getOrchestratorState();
-        if (state) {
-            lines.push(`\nTotal cost: $${state.totalCost.toFixed(2)}`);
-        }
-        emitParallelMessage(pi, lines.join("\n"));
-        return true;
-    }
-    if (subcommand === "stop") {
-        const milestoneId = rest.trim() || undefined;
-        await stopParallel(projectRoot(), milestoneId);
-        emitParallelMessage(pi, milestoneId ? `Stopped worker for ${milestoneId}.` : "All parallel workers stopped.");
-        return true;
-    }
-    if (subcommand === "pause") {
-        const milestoneId = rest.trim() || undefined;
-        pauseWorker(projectRoot(), milestoneId);
-        emitParallelMessage(pi, milestoneId ? `Paused worker for ${milestoneId}.` : "All parallel workers paused.");
-        return true;
-    }
-    if (subcommand === "resume") {
-        const milestoneId = rest.trim() || undefined;
-        resumeWorker(projectRoot(), milestoneId);
-        emitParallelMessage(pi, milestoneId ? `Resumed worker for ${milestoneId}.` : "All parallel workers resumed.");
-        return true;
-    }
-    if (subcommand === "merge") {
-        const milestoneId = rest.trim() || undefined;
-        if (milestoneId) {
-            const result = await mergeCompletedMilestone(projectRoot(), milestoneId);
-            emitParallelMessage(pi, formatMergeResults([result]));
-            return true;
-        }
-        const workers = getWorkerStatuses(projectRoot());
-        if (workers.length === 0) {
-            emitParallelMessage(pi, "No parallel workers to merge.");
-            return true;
-        }
-        const results = await mergeAllCompleted(projectRoot(), workers);
-        emitParallelMessage(pi, formatMergeResults(results));
-        return true;
-    }
-    if (subcommand === "watch") {
-        const root = projectRoot();
-        const { ParallelMonitorOverlay } = await import("../../parallel-monitor-overlay.js");
-        await _ctx.ui.custom((tui, theme, _kb, done) => new ParallelMonitorOverlay(tui, theme, () => done(), root), {
-            overlay: true,
-            overlayOptions: {
-                width: "90%",
-                minWidth: 80,
-                maxHeight: "92%",
-                anchor: "center",
-            },
-        });
-        return true;
-    }
-    emitParallelMessage(pi, `Unknown parallel subcommand "${subcommand}". Usage: /gsd parallel [start|status|stop|pause|resume|merge|watch]`);
-    return true;
-}

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

@@ -1,253 +0,0 @@
-import { existsSync, readFileSync, unlinkSync } from "node:fs";
-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 { 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";
-import { createRun, listRuns } from "../../run-manager.js";
-import { setActiveEngineId, setActiveRunDir, startAuto, pauseAuto, isAutoActive, getActiveEngineId, } from "../../auto.js";
-import { validateDefinition } from "../../definition-loader.js";
-// ─── Custom Workflow Subcommands ─────────────────────────────────────────
-const WORKFLOW_USAGE = [
-    "Usage: /gsd workflow <subcommand>",
-    "",
-    "  new               — Create a new workflow definition (via skill)",
-    "  run <name> [k=v]  — Create a run and start auto-mode",
-    "  list [name]       — List workflow runs (optionally filtered by name)",
-    "  validate <name>   — Validate a workflow definition YAML",
-    "  pause             — Pause custom workflow auto-mode",
-    "  resume            — Resume paused custom workflow auto-mode",
-].join("\n");
-async function handleCustomWorkflow(sub, ctx, pi) {
-    // Bare `/gsd workflow` — show usage
-    if (!sub) {
-        ctx.ui.notify(WORKFLOW_USAGE, "info");
-        return true;
-    }
-    // ── new ──
-    if (sub === "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) {
-            ctx.ui.notify("Usage: /gsd workflow run <name> [param=value ...]", "warning");
-            return true;
-        }
-        const parts = args.split(/\s+/);
-        const defName = parts[0];
-        const overrides = {};
-        for (let i = 1; i < parts.length; i++) {
-            const eqIdx = parts[i].indexOf("=");
-            if (eqIdx > 0) {
-                overrides[parts[i].slice(0, eqIdx)] = parts[i].slice(eqIdx + 1);
-            }
-        }
-        try {
-            const base = projectRoot();
-            const runDir = createRun(base, defName, Object.keys(overrides).length > 0 ? overrides : undefined);
-            setActiveEngineId("custom");
-            setActiveRunDir(runDir);
-            ctx.ui.notify(`Created workflow run: ${defName}\nRun dir: ${runDir}`, "info");
-            await startAuto(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);
-            ctx.ui.notify(`Failed to run workflow "${defName}": ${msg}`, "error");
-        }
-        return true;
-    }
-    // ── list [name] ──
-    if (sub === "list" || sub.startsWith("list ")) {
-        const filterName = sub.slice("list".length).trim() || undefined;
-        const base = projectRoot();
-        const runs = listRuns(base, filterName);
-        if (runs.length === 0) {
-            ctx.ui.notify("No workflow runs found.", "info");
-            return true;
-        }
-        const lines = runs.map((r) => {
-            const stepInfo = `${r.steps.completed}/${r.steps.total} steps`;
-            return `• ${r.name} [${r.timestamp}] — ${r.status} (${stepInfo})`;
-        });
-        ctx.ui.notify(lines.join("\n"), "info");
-        return true;
-    }
-    // ── validate <name> ──
-    if (sub === "validate" || sub.startsWith("validate ")) {
-        const defName = sub.slice("validate".length).trim();
-        if (!defName) {
-            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;
-        }
-        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");
-            }
-            else {
-                ctx.ui.notify(`✗ "${defName}" 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");
-        }
-        return true;
-    }
-    // ── pause ──
-    if (sub === "pause") {
-        const engineId = getActiveEngineId();
-        if (engineId === "dev" || engineId === null) {
-            ctx.ui.notify("No custom workflow is running. Use /gsd pause for dev workflow.", "warning");
-            return true;
-        }
-        if (!isAutoActive()) {
-            ctx.ui.notify("Auto-mode is not active.", "warning");
-            return true;
-        }
-        await pauseAuto(ctx, pi);
-        ctx.ui.notify("Custom workflow paused.", "info");
-        return true;
-    }
-    // ── resume ──
-    if (sub === "resume") {
-        const engineId = getActiveEngineId();
-        if (engineId === "dev" || engineId === null) {
-            ctx.ui.notify("No custom workflow to resume. Use /gsd auto for dev workflow.", "warning");
-            return true;
-        }
-        try {
-            await startAuto(ctx, pi, projectRoot(), false);
-            ctx.ui.notify("Custom workflow resumed.", "info");
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            ctx.ui.notify(`Failed to resume workflow: ${msg}`, "error");
-        }
-        return true;
-    }
-    // Unknown subcommand — show usage
-    ctx.ui.notify(`Unknown workflow subcommand: "${sub}"\n\n${WORKFLOW_USAGE}`, "warning");
-    return true;
-}
-export async function handleWorkflowCommand(trimmed, ctx, pi) {
-    // ── Custom workflow commands (`/gsd workflow ...`) ──
-    if (trimmed === "workflow" || trimmed.startsWith("workflow ")) {
-        const sub = trimmed.slice("workflow".length).trim();
-        return handleCustomWorkflow(sub, 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 ")) {
-        if (isAutoActive()) {
-            ctx.ui.notify("/gsd quick cannot run while auto-mode is active.\n" +
-                "Stop auto-mode first with /gsd stop, then run /gsd quick.", "error");
-            return true;
-        }
-        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

@@ -1,11 +0,0 @@
-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-bootstrap.js

@@ -1,224 +0,0 @@
-import { importExtensionModule } from "@gsd/pi-coding-agent";
-const TOP_LEVEL_SUBCOMMANDS = [
-    { cmd: "help", desc: "Categorized command reference with descriptions" },
-    { cmd: "next", desc: "Explicit step mode (same as /gsd)" },
-    { cmd: "auto", desc: "Autonomous mode — research, plan, execute, commit, repeat" },
-    { cmd: "stop", desc: "Stop auto mode gracefully" },
-    { cmd: "pause", desc: "Pause auto-mode (preserves state, /gsd auto to resume)" },
-    { cmd: "status", desc: "Progress dashboard" },
-    { cmd: "visualize", desc: "Open workflow visualizer" },
-    { cmd: "queue", desc: "Queue and reorder future milestones" },
-    { cmd: "quick", desc: "Execute a quick task without full planning overhead" },
-    { cmd: "discuss", desc: "Discuss architecture and decisions" },
-    { cmd: "capture", desc: "Fire-and-forget thought capture" },
-    { cmd: "changelog", desc: "Show categorized release notes" },
-    { cmd: "triage", desc: "Manually trigger triage of pending captures" },
-    { cmd: "dispatch", desc: "Dispatch a specific phase directly" },
-    { cmd: "history", desc: "View execution history" },
-    { cmd: "undo", desc: "Revert last completed unit" },
-    { cmd: "skip", desc: "Prevent a unit from auto-mode dispatch" },
-    { cmd: "export", desc: "Export milestone or slice results" },
-    { cmd: "cleanup", desc: "Remove merged branches or snapshots" },
-    { cmd: "mode", desc: "Switch workflow mode (solo/team)" },
-    { cmd: "prefs", desc: "Manage preferences" },
-    { cmd: "config", desc: "Set API keys for external tools" },
-    { cmd: "keys", desc: "API key manager" },
-    { cmd: "hooks", desc: "Show configured hooks" },
-    { cmd: "run-hook", desc: "Manually trigger a specific hook" },
-    { cmd: "skill-health", desc: "Skill lifecycle dashboard" },
-    { cmd: "doctor", desc: "Runtime health checks with auto-fix" },
-    { cmd: "logs", desc: "Browse activity logs, debug logs, and metrics" },
-    { cmd: "forensics", desc: "Examine execution logs" },
-    { cmd: "init", desc: "Project init wizard" },
-    { cmd: "setup", desc: "Global setup status and configuration" },
-    { cmd: "migrate", desc: "Migrate a v1 .planning directory to .gsd format" },
-    { cmd: "remote", desc: "Control remote auto-mode" },
-    { cmd: "steer", desc: "Hard-steer plan documents during execution" },
-    { cmd: "inspect", desc: "Show SQLite DB diagnostics" },
-    { cmd: "knowledge", desc: "Add persistent project knowledge" },
-    { cmd: "new-milestone", desc: "Create a milestone from a specification document" },
-    { cmd: "parallel", desc: "Parallel milestone orchestration" },
-    { cmd: "park", desc: "Park a milestone" },
-    { cmd: "unpark", desc: "Reactivate a parked milestone" },
-    { cmd: "update", desc: "Update GSD to the latest version" },
-    { cmd: "start", desc: "Start a workflow template" },
-    { cmd: "templates", desc: "List available workflow templates" },
-    { cmd: "extensions", desc: "Manage extensions" },
-];
-function filterStartsWith(partial, options, prefix = "") {
-    const normalizedPrefix = prefix.length > 0 ? `${prefix} ` : "";
-    return options
-        .filter((option) => option.cmd.startsWith(partial))
-        .map((option) => ({
-        value: `${normalizedPrefix}${option.cmd}`,
-        label: option.cmd,
-        description: option.desc,
-    }));
-}
-function getGsdArgumentCompletions(prefix) {
-    const parts = prefix.trim().split(/\s+/);
-    if (parts.length <= 1) {
-        return filterStartsWith(parts[0] ?? "", TOP_LEVEL_SUBCOMMANDS);
-    }
-    const partial = parts[1] ?? "";
-    if (parts[0] === "auto" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "--verbose", desc: "Show detailed execution output" },
-            { cmd: "--debug", desc: "Enable debug logging" },
-        ], "auto");
-    }
-    if (parts[0] === "next" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "--verbose", desc: "Show detailed step output" },
-            { cmd: "--dry-run", desc: "Preview next step without executing" },
-        ], "next");
-    }
-    if (parts[0] === "mode" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "global", desc: "Edit global workflow mode" },
-            { cmd: "project", desc: "Edit project-specific workflow mode" },
-        ], "mode");
-    }
-    if (parts[0] === "parallel" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "start", desc: "Start parallel milestone orchestration" },
-            { cmd: "status", desc: "Show parallel worker statuses" },
-            { cmd: "stop", desc: "Stop all parallel workers" },
-            { cmd: "pause", desc: "Pause a specific worker" },
-            { cmd: "resume", desc: "Resume a paused worker" },
-            { cmd: "merge", desc: "Merge completed milestone branches" },
-        ], "parallel");
-    }
-    if (parts[0] === "setup" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "llm", desc: "Configure LLM provider settings" },
-            { cmd: "search", desc: "Configure web search provider" },
-            { cmd: "remote", desc: "Configure remote integrations" },
-            { cmd: "keys", desc: "Manage API keys" },
-            { cmd: "prefs", desc: "Configure global preferences" },
-        ], "setup");
-    }
-    if (parts[0] === "logs" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "debug", desc: "List or view debug log files" },
-            { cmd: "tail", desc: "Show last N activity log summaries" },
-            { cmd: "clear", desc: "Remove old activity and debug logs" },
-        ], "logs");
-    }
-    if (parts[0] === "keys" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "list", desc: "Show key status dashboard" },
-            { cmd: "add", desc: "Add a key for a provider" },
-            { cmd: "remove", desc: "Remove a key" },
-            { cmd: "test", desc: "Validate key(s) with API call" },
-            { cmd: "rotate", desc: "Replace an existing key" },
-            { cmd: "doctor", desc: "Health check all keys" },
-        ], "keys");
-    }
-    if (parts[0] === "prefs" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "global", desc: "Edit global preferences file" },
-            { cmd: "project", desc: "Edit project preferences file" },
-            { cmd: "status", desc: "Show effective preferences" },
-            { cmd: "wizard", desc: "Interactive preferences wizard" },
-            { cmd: "setup", desc: "First-time preferences setup" },
-            { cmd: "import-claude", desc: "Import settings from Claude Code" },
-        ], "prefs");
-    }
-    if (parts[0] === "remote" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "slack", desc: "Configure Slack integration" },
-            { cmd: "discord", desc: "Configure Discord integration" },
-            { cmd: "status", desc: "Show remote connection status" },
-            { cmd: "disconnect", desc: "Disconnect remote integrations" },
-        ], "remote");
-    }
-    if (parts[0] === "history" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "--cost", desc: "Show cost breakdown per entry" },
-            { cmd: "--phase", desc: "Filter by phase type" },
-            { cmd: "--model", desc: "Filter by model used" },
-            { cmd: "10", desc: "Show last 10 entries" },
-            { cmd: "20", desc: "Show last 20 entries" },
-            { cmd: "50", desc: "Show last 50 entries" },
-        ], "history");
-    }
-    if (parts[0] === "export" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "--json", desc: "Export as JSON" },
-            { cmd: "--markdown", desc: "Export as Markdown" },
-            { cmd: "--html", desc: "Export as HTML" },
-            { cmd: "--html --all", desc: "Export all milestones as HTML" },
-        ], "export");
-    }
-    if (parts[0] === "cleanup" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "branches", desc: "Remove merged milestone branches" },
-            { cmd: "snapshots", desc: "Remove old execution snapshots" },
-        ], "cleanup");
-    }
-    if (parts[0] === "knowledge" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "rule", desc: "Add a project rule" },
-            { cmd: "pattern", desc: "Add a code pattern" },
-            { cmd: "lesson", desc: "Record a lesson learned" },
-        ], "knowledge");
-    }
-    if (parts[0] === "start" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "bugfix", desc: "Triage, fix, test, and ship a bug fix" },
-            { cmd: "small-feature", desc: "Lightweight feature with optional discussion" },
-            { cmd: "spike", desc: "Research, prototype, and document findings" },
-            { cmd: "hotfix", desc: "Minimal: fix it, test it, ship it" },
-            { cmd: "refactor", desc: "Inventory, plan waves, migrate, verify" },
-            { cmd: "security-audit", desc: "Scan, triage, remediate, re-scan" },
-            { cmd: "dep-upgrade", desc: "Assess, upgrade, fix breaks, verify" },
-            { cmd: "full-project", desc: "Complete GSD workflow with full ceremony" },
-            { cmd: "resume", desc: "Resume an in-progress workflow" },
-            { cmd: "--list", desc: "List all available templates" },
-            { cmd: "--dry-run", desc: "Preview workflow without executing" },
-        ], "start");
-    }
-    if (parts[0] === "templates" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "info", desc: "Show detailed template info" },
-        ], "templates");
-    }
-    if (parts[0] === "extensions" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "list", desc: "List all extensions and their status" },
-            { cmd: "enable", desc: "Enable a disabled extension" },
-            { cmd: "disable", desc: "Disable an extension" },
-            { cmd: "info", desc: "Show extension details" },
-        ], "extensions");
-    }
-    if (parts[0] === "doctor" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "fix", desc: "Auto-fix detected issues" },
-            { cmd: "heal", desc: "AI-driven deep healing" },
-            { cmd: "audit", desc: "Run health audit without fixing" },
-        ], "doctor");
-    }
-    if (parts[0] === "dispatch" && parts.length <= 2) {
-        return filterStartsWith(partial, [
-            { cmd: "research", desc: "Run research phase" },
-            { cmd: "plan", desc: "Run planning phase" },
-            { cmd: "execute", desc: "Run execution phase" },
-            { cmd: "complete", desc: "Run completion phase" },
-            { cmd: "reassess", desc: "Reassess current progress" },
-            { cmd: "uat", desc: "Run user acceptance testing" },
-            { cmd: "replan", desc: "Replan the current slice" },
-        ], "dispatch");
-    }
-    return null;
-}
-export function registerLazyGSDCommand(pi) {
-    pi.registerCommand("gsd", {
-        description: "GSD — Lucent Software Developer",
-        getArgumentCompletions: getGsdArgumentCompletions,
-        handler: async (args, ctx) => {
-            const { handleGSDCommand } = await importExtensionModule(import.meta.url, "./commands.js");
-            await handleGSDCommand(args, ctx, pi);
-        },
-    });
-}