gsd-pi 2.33.1-dev.235d83a → 2.33.1-dev.29a8268

package/dist/resources/extensions/universal-config/tools.js

@@ -1,57 +0,0 @@
-/**
- * Universal Config Discovery — tool registry
- *
- * Known AI coding tools with their config directory locations.
- * Based on research of Oh My Pi's discovery system and direct config
- * file inspection of each tool.
- */
-export const TOOLS = [
-    {
-        id: "claude",
-        name: "Claude Code",
-        userDir: ".claude",
-        projectDir: ".claude",
-    },
-    {
-        id: "cursor",
-        name: "Cursor",
-        userDir: ".cursor",
-        projectDir: ".cursor",
-    },
-    {
-        id: "windsurf",
-        name: "Windsurf",
-        userDir: ".codeium/windsurf",
-        projectDir: ".windsurf",
-    },
-    {
-        id: "gemini",
-        name: "Gemini CLI",
-        userDir: ".gemini",
-        projectDir: ".gemini",
-    },
-    {
-        id: "codex",
-        name: "OpenAI Codex",
-        userDir: ".codex",
-        projectDir: ".codex",
-    },
-    {
-        id: "cline",
-        name: "Cline",
-        userDir: null,
-        projectDir: null, // Uses root-level .clinerules (handled specially)
-    },
-    {
-        id: "github-copilot",
-        name: "GitHub Copilot",
-        userDir: null,
-        projectDir: ".github",
-    },
-    {
-        id: "vscode",
-        name: "VS Code",
-        userDir: null,
-        projectDir: ".vscode",
-    },
-];

package/dist/resources/extensions/universal-config/types.js

@@ -1,8 +0,0 @@
-/**
- * Universal Config Discovery — shared types
- *
- * Normalized schema for discovered configuration items from all supported
- * AI coding tools: Claude Code, Cursor, Windsurf, Gemini CLI, Codex,
- * Cline, GitHub Copilot, VS Code.
- */
-export {};

package/dist/resources/extensions/voice/index.js

@@ -1,247 +0,0 @@
-import { shortcutDesc } from "../shared/mod.js";
-import { isKeyRelease, Key, matchesKey, truncateToWidth, visibleWidth } from "@gsd/pi-tui";
-import { spawn, execSync } from "node:child_process";
-import * as fs from "node:fs";
-import * as path from "node:path";
-import * as readline from "node:readline";
-const __extensionDir = import.meta.dirname;
-const SWIFT_SRC = path.join(__extensionDir, "speech-recognizer.swift");
-const RECOGNIZER_BIN = path.join(__extensionDir, "speech-recognizer");
-const PYTHON_SCRIPT = path.join(__extensionDir, "speech-recognizer.py");
-const IS_DARWIN = process.platform === "darwin";
-const IS_LINUX = process.platform === "linux";
-const VOICE_VENV_PYTHON = path.join(process.env.HOME || process.env.USERPROFILE || "/tmp", ".gsd", "voice-venv", "bin", "python3");
-/** Return the python3 binary path — prefer venv if it exists, else system. */
-function linuxPython() {
-    if (fs.existsSync(VOICE_VENV_PYTHON))
-        return VOICE_VENV_PYTHON;
-    return "python3";
-}
-function ensureBinary() {
-    if (fs.existsSync(RECOGNIZER_BIN))
-        return true;
-    try {
-        execSync(`swiftc "${SWIFT_SRC}" -o "${RECOGNIZER_BIN}" -framework Speech -framework AVFoundation`, {
-            timeout: 60000,
-        });
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-let linuxReady = false;
-function ensureLinuxReady(ctx) {
-    if (linuxReady)
-        return true;
-    // Check GROQ_API_KEY is available
-    if (!process.env.GROQ_API_KEY) {
-        ctx.ui.notify("Voice: GROQ_API_KEY not set — run 'gsd config' to configure", "error");
-        return false;
-    }
-    // Check python3 exists
-    try {
-        execSync("which python3", { stdio: "pipe" });
-    }
-    catch {
-        ctx.ui.notify("Voice: python3 not found — install with: sudo apt install python3", "error");
-        return false;
-    }
-    // Check that sounddevice is importable
-    const py = linuxPython();
-    try {
-        execSync(`${py} -c "import sounddevice"`, {
-            stdio: "pipe",
-            timeout: 10000,
-        });
-    }
-    catch (err) {
-        const stderr = err?.stderr?.toString() ?? "";
-        if (stderr.includes("sounddevice") || stderr.includes("PortAudio") || stderr.includes("portaudio")) {
-            ctx.ui.notify("Voice: install libportaudio2 with: sudo apt install libportaudio2", "error");
-        }
-        else if (stderr.includes("No module") || stderr.includes("ModuleNotFoundError")) {
-            // Deps missing — the Python script handles auto-install on first run,
-            // so we let it through. The script's own ensure_deps() will pip install.
-            ctx.ui.notify("Voice: installing dependencies on first run — this may take a moment", "info");
-            linuxReady = true;
-            return true;
-        }
-        else {
-            ctx.ui.notify(`Voice: dependency check failed — ${stderr.split("\n")[0] || "unknown error"}`, "error");
-            return false;
-        }
-        return false;
-    }
-    linuxReady = true;
-    return true;
-}
-export default function (pi) {
-    if (!IS_DARWIN && !IS_LINUX)
-        return;
-    let active = false;
-    let recognizerProcess = null;
-    let flashOn = true;
-    let flashTimer = null;
-    let footerTui = null;
-    function setVoiceFooter(ctx, on) {
-        if (!on) {
-            stopFlash();
-            ctx.ui.setFooter(undefined);
-            return;
-        }
-        flashOn = true;
-        flashTimer = setInterval(() => {
-            flashOn = !flashOn;
-            footerTui?.requestRender();
-        }, 500);
-        ctx.ui.setFooter((tui, theme, footerData) => {
-            footerTui = tui;
-            const branchUnsub = footerData.onBranchChange(() => tui.requestRender());
-            return {
-                dispose: branchUnsub,
-                invalidate() { },
-                render(width) {
-                    // Row 1: pwd (branch) ... ● transcribing
-                    let pwd = process.cwd();
-                    const home = process.env.HOME || process.env.USERPROFILE;
-                    if (home && pwd.startsWith(home))
-                        pwd = `~${pwd.slice(home.length)}`;
-                    const branch = footerData.getGitBranch();
-                    if (branch)
-                        pwd = `${pwd} (${branch})`;
-                    const dot = flashOn ? theme.fg("error", "●") : theme.fg("dim", "●");
-                    const voiceTag = `${dot} ${theme.fg("error", "transcribing")}`;
-                    const voiceTagWidth = visibleWidth(voiceTag);
-                    const maxPwdWidth = width - voiceTagWidth - 2;
-                    const pwdStr = truncateToWidth(theme.fg("dim", pwd), maxPwdWidth, theme.fg("dim", "..."));
-                    const pad1 = " ".repeat(Math.max(1, width - visibleWidth(pwdStr) - voiceTagWidth));
-                    const row1 = truncateToWidth(pwdStr + pad1 + voiceTag, width);
-                    // Row 2: stats ... model
-                    let totalInput = 0, totalOutput = 0, totalCost = 0;
-                    for (const entry of ctx.sessionManager.getEntries()) {
-                        if (entry.type === "message" && entry.message.role === "assistant") {
-                            const m = entry.message;
-                            totalInput += m.usage.input;
-                            totalOutput += m.usage.output;
-                            totalCost += m.usage.cost.total;
-                        }
-                    }
-                    const fmt = (n) => n < 1000 ? `${n}` : n < 10000 ? `${(n / 1000).toFixed(1)}k` : `${Math.round(n / 1000)}k`;
-                    const parts = [];
-                    if (totalInput)
-                        parts.push(`↑${fmt(totalInput)}`);
-                    if (totalOutput)
-                        parts.push(`↓${fmt(totalOutput)}`);
-                    if (totalCost)
-                        parts.push(`$${totalCost.toFixed(3)}`);
-                    const usage = ctx.getContextUsage();
-                    const ctxPct = usage?.percent !== null && usage?.percent !== undefined ? `${usage.percent.toFixed(1)}%` : "?";
-                    const ctxWin = usage?.contextWindow ?? ctx.model?.contextWindow ?? 0;
-                    parts.push(`${ctxPct}/${fmt(ctxWin)}`);
-                    const statsLeft = theme.fg("dim", parts.join(" "));
-                    const modelRight = theme.fg("dim", ctx.model?.id || "no-model");
-                    const statsLeftW = visibleWidth(statsLeft);
-                    const modelRightW = visibleWidth(modelRight);
-                    const pad2 = " ".repeat(Math.max(2, width - statsLeftW - modelRightW));
-                    const row2 = truncateToWidth(statsLeft + pad2 + modelRight, width);
-                    return [row1, row2];
-                },
-            };
-        });
-    }
-    function stopFlash() {
-        if (flashTimer) {
-            clearInterval(flashTimer);
-            flashTimer = null;
-        }
-        footerTui = null;
-    }
-    async function toggleVoice(ctx) {
-        if (active) {
-            killRecognizer();
-            active = false;
-            setVoiceFooter(ctx, false);
-            return;
-        }
-        if (IS_DARWIN) {
-            if (!ensureBinary()) {
-                ctx.ui.notify("Voice: failed to compile speech recognizer (need Xcode CLI tools)", "error");
-                return;
-            }
-        }
-        else if (IS_LINUX) {
-            if (!ensureLinuxReady(ctx)) {
-                return;
-            }
-        }
-        active = true;
-        setVoiceFooter(ctx, true);
-        await runVoiceSession(ctx);
-    }
-    pi.registerCommand("voice", {
-        description: "Toggle voice mode",
-        handler: async (_args, ctx) => toggleVoice(ctx),
-    });
-    pi.registerShortcut("ctrl+alt+v", {
-        description: shortcutDesc("Toggle voice mode", "/voice"),
-        handler: async (ctx) => toggleVoice(ctx),
-    });
-    function killRecognizer() {
-        if (recognizerProcess) {
-            recognizerProcess.kill("SIGTERM");
-            recognizerProcess = null;
-        }
-    }
-    function startRecognizer(onPartial, onFinal, onError, onReady) {
-        if (IS_LINUX) {
-            recognizerProcess = spawn(linuxPython(), [PYTHON_SCRIPT], {
-                stdio: ["pipe", "pipe", "pipe"],
-            });
-        }
-        else {
-            recognizerProcess = spawn(RECOGNIZER_BIN, [], { stdio: ["pipe", "pipe", "pipe"] });
-        }
-        const rl = readline.createInterface({ input: recognizerProcess.stdout });
-        rl.on("line", (line) => {
-            if (line === "READY") {
-                onReady();
-                return;
-            }
-            if (line.startsWith("PARTIAL:"))
-                onPartial(line.slice(8));
-            else if (line.startsWith("FINAL:"))
-                onFinal(line.slice(6));
-            else if (line.startsWith("ERROR:"))
-                onError(line.slice(6));
-        });
-        recognizerProcess.on("error", (err) => onError(err.message));
-        recognizerProcess.on("exit", () => { recognizerProcess = null; });
-    }
-    async function runVoiceSession(ctx) {
-        return new Promise((resolve) => {
-            // The Swift recognizer handles accumulation across pause-induced
-            // transcription resets. Both PARTIAL and FINAL messages contain
-            // the full accumulated text, so we just pass them through.
-            startRecognizer((text) => {
-                ctx.ui.setEditorText(text);
-            }, (text) => {
-                ctx.ui.setEditorText(text);
-            }, (msg) => ctx.ui.notify(`Voice: ${msg}`, "error"), () => { });
-            ctx.ui.custom((_tui, _theme, _kb, done) => ({
-                render() { return []; },
-                handleInput(data) {
-                    if (isKeyRelease(data))
-                        return;
-                    if (matchesKey(data, Key.escape) || matchesKey(data, Key.enter)) {
-                        killRecognizer();
-                        active = false;
-                        setVoiceFooter(ctx, false);
-                        done();
-                    }
-                },
-                invalidate() { },
-            }), { overlay: true, overlayOptions: { anchor: "bottom-center", width: "100%" } }).then(() => resolve());
-        });
-    }
-}

package/dist/startup-timings.d.ts

@@ -1,2 +0,0 @@
-export declare function markStartup(label: string): void;
-export declare function printStartupTimings(): void;

package/dist/startup-timings.js

@@ -1,22 +0,0 @@
-const flag = (process.env.GSD_STARTUP_TIMING ?? process.env.PI_TIMING ?? "").toLowerCase();
-const ENABLED = flag === "1" || flag === "true" || flag === "yes";
-const timings = [];
-let lastTime = Date.now();
-export function markStartup(label) {
-    if (!ENABLED)
-        return;
-    const now = Date.now();
-    timings.push({ label, ms: now - lastTime });
-    lastTime = now;
-}
-export function printStartupTimings() {
-    if (!ENABLED || timings.length === 0)
-        return;
-    const total = timings.reduce((sum, timing) => sum + timing.ms, 0);
-    process.stderr.write("\n--- GSD Startup Timings ---\n");
-    for (const timing of timings) {
-        process.stderr.write(`  ${timing.label}: ${timing.ms}ms\n`);
-    }
-    process.stderr.write(`  TOTAL: ${total}ms\n`);
-    process.stderr.write("----------------------------\n\n");
-}

package/src/resources/extensions/gsd/commands-bootstrap.ts

@@ -1,252 +0,0 @@
-import { importExtensionModule, type ExtensionAPI, type ExtensionCommandContext } 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: "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" },
-] as const;
-
-function filterStartsWith(
-  partial: string,
-  options: ReadonlyArray<{ cmd: string; desc: string }>,
-  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: string) {
-  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: ExtensionAPI): void {
-  pi.registerCommand("gsd", {
-    description: "GSD — Get Shit Done",
-    getArgumentCompletions: getGsdArgumentCompletions,
-    handler: async (args: string, ctx: ExtensionCommandContext) => {
-      const { handleGSDCommand } = await importExtensionModule<typeof import("./commands.js")>(import.meta.url, "./commands.js");
-      await handleGSDCommand(args, ctx, pi);
-    },
-  });
-}