kritya 0.8.2-beta

package/dist/commands/registry.js

@@ -0,0 +1,739 @@
+import fs from "node:fs";
+import path from "node:path";
+import { AuditLog, summarizeAudit } from "../audit/audit.js";
+import { runMcpCommand } from "./mcpCommand.js";
+import { mcpPrompts } from "../mcp/client.js";
+import { scanSkillsDetailed, skillsDir, userSkillsDir } from "../agent/skills.js";
+import { pluginsDir, pluginSkillsRoots, scanPlugins, scanPluginsDetailed, userPluginsDir, } from "../plugins/discover.js";
+import { scanPluginMcpServers } from "../plugins/mcp.js";
+import { listProviders } from "../config/config.js";
+import { expandCommand } from "./custom.js";
+import { artifactPath, clearProjectState, loadProjectState, parseIdea, parsePhase, phaseBlocker, phasePrompt, renameProject, staleArtifacts, PHASE_COMMAND, PHASE_ORDER, PHASE_SUMMARY, saveProjectState, slugify, } from "../agent/workflow.js";
+export const BUILTIN_COMMANDS = [
+    { name: "/help", description: "show available commands" },
+    { name: "/model", description: "pick a model, or /model <id> for any provider model ID" },
+    {
+        name: "/provider",
+        description: "list providers, or /provider <name> to switch mid-session (keeps history); add --default to persist",
+    },
+    {
+        name: "/flow-brainstorm",
+        description: "start a new-project workflow: /flow-brainstorm <idea> (brainstorm→spec→plan→build→review→fix)",
+    },
+    {
+        name: "/flow-spec",
+        description: "project workflow: write the spec from the approved brainstorm",
+    },
+    { name: "/plan", description: "toggle plan mode: /plan, /plan on, /plan off" },
+    { name: "/flow-plan", description: "project workflow: plan from the spec (read-only)" },
+    { name: "/flow-build", description: "project workflow: implement the plan, with tests" },
+    { name: "/flow-review", description: "project workflow: spec-compliance and security review" },
+    { name: "/flow-fix", description: "project workflow: fix the review's findings, re-verified" },
+    {
+        name: "/project",
+        description: "workflow status · /project goto <phase> · rename <name> · clear",
+    },
+    { name: "/diff", description: "show the cumulative git diff of this session's changes" },
+    { name: "/redo", description: "reapply the change most recently undone" },
+    { name: "/init", description: "scan the repo and generate a KRITYA.md project-memory file" },
+    { name: "/web-search", description: "search the web: /web-search <query>" },
+    {
+        name: "/mcp",
+        description: "MCP servers: status, /mcp add|remove <name>, /mcp login|logout <name>",
+    },
+    {
+        name: "/skills",
+        description: "list discovered skills (project + user-global) and why any were skipped",
+    },
+    {
+        name: "/plugins",
+        description: "list discovered Agent Plugins, what each contributes, and why any were skipped",
+    },
+    { name: "/undo", description: "revert the file changes from the agent's last turn" },
+    {
+        name: "/checkpoint",
+        description: "save a named point: /checkpoint <name> (no name lists saved ones)",
+    },
+    {
+        name: "/rewind",
+        description: "rewind the conversation and files to a checkpoint: /rewind <name>",
+    },
+    { name: "/commit", description: "have the agent stage and commit the current changes" },
+    { name: "/compact", description: "summarize older conversation to free context space" },
+    { name: "/clear", description: "start a fresh conversation" },
+    { name: "/cost", description: "show token usage and estimated cost" },
+    {
+        name: "/audit",
+        description: "show this session's permission decisions and verify the audit log's chain",
+    },
+    {
+        name: "/budget",
+        description: "show session token budget, /budget reset, or /budget <number> to set it",
+    },
+    {
+        name: "/kill",
+        description: "emergency stop: /kill [reason] halts everything · /kill off releases (Ctrl+K)",
+    },
+    { name: "/exit", description: "leave" },
+    { name: "/quit", description: "leave" },
+];
+export const HELP_TEXT = `Commands:
+${BUILTIN_COMMANDS.map((c) => `  ${c.name.padEnd(14)} ${c.description}`).join("\n")}
+
+Also: @path/to/file attaches a file to your message (with autocomplete).
+@image.png attaches an image for vision-capable models.
+@mcp:server/name attaches a document an MCP server offers.
+MCP servers can also contribute their own /server-prompt commands.
+Project memory: put standing instructions in KRITYA.md at your workspace root.
+Keys: Esc cancels · Tab completes · Shift+Tab cycles normal/accept-edits/dry-run
+mode · ↑/↓ recalls history · Ctrl+O toggles full tool output · Ctrl+K is the
+kill switch (stops everything until /kill off) · Ctrl+C exits`;
+/**
+ * A phase boundary is the one place compaction is unambiguously safe: the
+ * phase that just ended wrote its conclusions to a durable artifact on disk,
+ * so the transcript that produced them is redundant. Compacting here is what
+ * keeps a five-phase project from dragging every phase's exploration into the
+ * next phase's context window.
+ */
+async function compactAtPhaseBoundary(ctx, phase) {
+    // Compaction is a full model call, so the UI has to show it. Without this the
+    // terminal sits silent — the spinner only renders while the phase is
+    // "working", and the elapsed-time counter is gated the same way.
+    ctx.setPhase("working");
+    ctx.setActivity(`Compacting before the ${phase} phase…`);
+    try {
+        const note = await ctx.agent.compact();
+        if (/^nothing to compact/i.test(note))
+            return;
+        ctx.addItem({ kind: "info", text: note });
+        ctx.setCtxPct(Math.round(ctx.agent.contextUsage() * 100));
+    }
+    catch {
+        // Compaction is a cost optimization. Failing it must never cost the user
+        // their phase — the phase runs either way.
+    }
+    finally {
+        // runAgent takes the phase from here; only the label needs clearing, or it
+        // would outlive the compaction it describes.
+        ctx.setActivity(null);
+    }
+}
+/** Strip a trailing/leading `--force` from a command argument. */
+function takeForce(arg) {
+    const force = /(^|\s)--force(\s|$)/.test(arg);
+    return { arg: arg.replace(/(^|\s)--force(\s|$)/, " ").trim(), force };
+}
+/** Strip a trailing/leading `--default` from a command argument. */
+function takeDefault(arg) {
+    const makeDefault = /(^|\s)--default(\s|$)/.test(arg);
+    return { arg: arg.replace(/(^|\s)--default(\s|$)/, " ").trim(), makeDefault };
+}
+/**
+ * Run one workflow phase: check its prerequisite artifact exists, set the mode
+ * the phase needs, record the phase, compact, then hand the prompt to the agent.
+ */
+async function runPhase(ctx, phase) {
+    const project = loadProjectState(ctx.workspace);
+    if (!project) {
+        ctx.addItem({
+            kind: "info",
+            text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
+        });
+        return;
+    }
+    const { arg, force } = takeForce(ctx.arg);
+    const blocker = phaseBlocker(ctx.workspace, project.name, phase);
+    if (blocker && !force) {
+        ctx.addItem({
+            kind: "info",
+            text: `${blocker}\nTo run ${PHASE_COMMAND[phase]} anyway: ${PHASE_COMMAND[phase]} --force`,
+        });
+        return;
+    }
+    // Warn (never block) if an earlier artifact was edited after this phase's
+    // input was written from it — e.g. spec.md changed after plan.md already
+    // read it. The phase still runs on whatever's on disk right now.
+    const stale = staleArtifacts(ctx.workspace, project.name, phase);
+    if (stale.length) {
+        ctx.addItem({ kind: "info", text: stale.join("\n") });
+    }
+    // The plan phase is read-only by design; every other phase needs to write.
+    const wantPlanMode = phase === "plan";
+    if (ctx.planMode !== wantPlanMode) {
+        ctx.agent.planMode = wantPlanMode;
+        ctx.setPlanMode(wantPlanMode);
+    }
+    if (wantPlanMode && ctx.acceptEdits) {
+        ctx.agent.acceptEdits = false;
+        ctx.setAcceptEdits(false);
+    }
+    saveProjectState(ctx.workspace, project.name, phase);
+    const artifact = artifactPath(project.name, phase);
+    ctx.addItem({
+        kind: "info",
+        text: `${phase} phase for "${project.name}" — ${PHASE_SUMMARY[phase]}` +
+            (artifact ? ` → ${artifact}` : "") +
+            (wantPlanMode ? " (plan mode ON: read-only apart from that doc)" : "") +
+            (blocker && force ? "\n⚠ Forced past a missing prerequisite." : ""),
+    });
+    ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+    ctx.setRunningPhase(phase);
+    ctx.refreshWorkflow();
+    await compactAtPhaseBoundary(ctx, phase);
+    return ctx.runAgent(phasePrompt(project.name, phase, arg));
+}
+const handlers = {
+    "/help": (ctx) => {
+        const customList = ctx.customCommands.length
+            ? `\n\nCustom commands (from .kritya/commands/):\n${ctx.customCommands
+                .map((c) => `  ${c.name.padEnd(14)} ${c.description}${c.pluginName ? ` (plugin: ${c.pluginName})` : ""}`)
+                .join("\n")}`
+            : "";
+        const mcpNote = ctx.mcpToolCount > 0 ? `\n\n${ctx.mcpToolCount} MCP tool(s) loaded.` : "";
+        ctx.addItem({ kind: "info", text: HELP_TEXT + customList + mcpNote });
+    },
+    "/model": (ctx) => {
+        if (ctx.arg)
+            ctx.setModelEverywhere(ctx.arg);
+        else
+            ctx.setPhase("model");
+    },
+    "/provider": (ctx) => {
+        const { arg, makeDefault } = takeDefault(ctx.arg);
+        if (!arg) {
+            const lines = listProviders(ctx.config).map((p) => {
+                const marker = p.name === ctx.provider ? "*" : " ";
+                const note = p.hasKey ? "" : "  (no API key configured)";
+                return `  ${marker} ${p.name}${note}`;
+            });
+            ctx.addItem({
+                kind: "info",
+                text: `Providers (* = active):\n${lines.join("\n")}\n\n` +
+                    `Switch with /provider <name> — session only, conversation history is kept. ` +
+                    `Add --default to also make it the default for future launches. ` +
+                    `If a request keeps failing (429/5xx after retries), switch to any provider marked with a key.`,
+            });
+            return;
+        }
+        ctx.setProviderEverywhere(arg, makeDefault);
+    },
+    "/mcp": (ctx) => {
+        // Bare /mcp is read-only and stays available while the kill switch is
+        // engaged (see ALLOWED_WHILE_KILLED); its subcommands connect servers,
+        // write config, and mint tokens, so they are not.
+        if (ctx.killed && ctx.arg.trim()) {
+            ctx.addItem({
+                kind: "info",
+                text: `⛔ Kill switch ACTIVE${ctx.killReason ? ` — ${ctx.killReason}` : ""}. ` +
+                    `/mcp ${ctx.arg.trim().split(/\s+/)[0]} is blocked; plain /mcp still works. Release it with /kill off.`,
+            });
+            return;
+        }
+        return runMcpCommand(ctx);
+    },
+    "/skills": (ctx) => {
+        const projectRoot = skillsDir(ctx.workspace);
+        const userRoot = userSkillsDir();
+        const plugins = scanPlugins([pluginsDir(ctx.workspace), userPluginsDir()]);
+        const pluginRoots = pluginSkillsRoots(plugins);
+        const { loaded, skipped } = scanSkillsDetailed([
+            projectRoot,
+            userRoot,
+            ...pluginRoots.map((r) => r.dir),
+        ]);
+        if (!loaded.length && !skipped.length) {
+            ctx.addItem({
+                kind: "info",
+                text: `No skills found under ${projectRoot} or ${userRoot}.`,
+            });
+            return;
+        }
+        const truncate = (s, max) => (s.length > max ? `${s.slice(0, max - 1)}…` : s);
+        const rows = loaded.map((s) => {
+            const plugin = pluginRoots.find((r) => s.dir === r.dir || s.dir.startsWith(r.dir + path.sep));
+            const source = plugin
+                ? `plugin: ${plugin.pluginName}`
+                : s.dir.startsWith(projectRoot + path.sep) || s.dir === projectRoot
+                    ? "project"
+                    : "user";
+            return { name: s.name, source, description: truncate(s.description, 60) };
+        });
+        const nameWidth = Math.max(4, ...rows.map((r) => r.name.length), ...skipped.map((s) => s.name.length));
+        const lines = [
+            ...rows.map((r) => `  ${r.name.padEnd(nameWidth)}   (${r.source})  ${r.description}`),
+            ...skipped.map((s) => `  ${s.name.padEnd(nameWidth)}   SKIPPED: ${s.reason}`),
+        ];
+        ctx.addItem({ kind: "info", text: lines.join("\n") });
+    },
+    "/plugins": (ctx) => {
+        const workspaceRoot = pluginsDir(ctx.workspace);
+        const userRoot = userPluginsDir();
+        const { loaded, skipped } = scanPluginsDetailed([workspaceRoot, userRoot]);
+        if (!loaded.length && !skipped.length) {
+            ctx.addItem({
+                kind: "info",
+                text: `No plugins found under ${workspaceRoot} or ${userRoot}.`,
+            });
+            return;
+        }
+        const rows = loaded.map((p) => {
+            const source = p.dir.startsWith(workspaceRoot + path.sep) || p.dir === workspaceRoot
+                ? "workspace"
+                : "user";
+            const version = typeof p.manifest.version === "string" ? p.manifest.version : "?";
+            const { loaded: skillsLoaded } = scanSkillsDetailed([path.join(p.dir, "skills")]);
+            const { loaded: mcpLoaded, skipped: mcpSkipped } = scanPluginMcpServers([p]);
+            let commandCount = 0;
+            try {
+                commandCount = fs
+                    .readdirSync(path.join(p.dir, "commands"))
+                    .filter((f) => f.endsWith(".md")).length;
+            }
+            catch {
+                // No commands/ subfolder -- not a mistake, just nothing to count.
+            }
+            const contributions = [
+                skillsLoaded.length ? `${skillsLoaded.length} skill(s)` : "",
+                mcpLoaded.length ? `${mcpLoaded.length} MCP server(s)` : "",
+                commandCount ? `${commandCount} command(s)` : "",
+            ].filter(Boolean);
+            const mcpSkipNote = mcpSkipped.length
+                ? ` — skipped MCP server(s): ${mcpSkipped.map((s) => `${s.name} (${s.reason})`).join("; ")}`
+                : "";
+            return `  ${p.name}@${version} (${source})  ${contributions.join(", ") || "(nothing)"}${mcpSkipNote}`;
+        });
+        const skipLines = skipped.map((s) => `  ${s.name}  SKIPPED: ${s.reason}`);
+        ctx.addItem({ kind: "info", text: [...rows, ...skipLines].join("\n") });
+    },
+    "/web-search": (ctx) => {
+        if (!ctx.arg) {
+            ctx.addItem({ kind: "info", text: "Usage: /web-search <query>" });
+            return;
+        }
+        return ctx.runWebSearch(ctx.arg);
+    },
+    "/undo": (ctx) => {
+        const result = ctx.undoStack.undo();
+        if (result === null) {
+            ctx.addItem({ kind: "info", text: "Nothing to undo." });
+        }
+        else {
+            ctx.addItem({ kind: "info", text: `Undo: ${result}` });
+            ctx.agent.addUserNote(`[I reverted your last file change via /undo: ${result}]`);
+            ctx.refreshFileList();
+        }
+    },
+    "/checkpoint": (ctx) => {
+        const name = ctx.arg.trim();
+        if (!name) {
+            const list = ctx.agent.listCheckpoints();
+            if (!list.length) {
+                ctx.addItem({
+                    kind: "info",
+                    text: "No checkpoints yet. Save one with /checkpoint <name>.",
+                });
+                return;
+            }
+            const lines = list.map((c) => `  ${c.name}  (${new Date(c.createdAt).toLocaleTimeString()})`);
+            ctx.addItem({
+                kind: "info",
+                text: `Checkpoints:\n${lines.join("\n")}\n\nRewind to one with /rewind <name>.`,
+            });
+            return;
+        }
+        ctx.agent.saveCheckpoint(name, ctx.undoStack.currentTurn());
+        ctx.addItem({
+            kind: "info",
+            text: `Saved checkpoint "${name}". Rewind here later with /rewind ${name}.`,
+        });
+    },
+    "/rewind": (ctx) => {
+        const name = ctx.arg.trim();
+        if (!name) {
+            ctx.addItem({
+                kind: "info",
+                text: "Usage: /rewind <name>. List saved points with /checkpoint.",
+            });
+            return;
+        }
+        const cp = ctx.agent.getCheckpoint(name);
+        if (!cp) {
+            ctx.addItem({
+                kind: "info",
+                text: `No checkpoint named "${name}". See /checkpoint for the list.`,
+            });
+            return;
+        }
+        // Roll files back first, then trim the conversation to the same point.
+        const fileResult = ctx.undoStack.rewindTo(cp.undoTurn);
+        ctx.agent.truncateHistory(cp.historyLength);
+        const filePart = fileResult ? `\n${fileResult}` : "\nNo file changes to roll back.";
+        ctx.addItem({ kind: "info", text: `Rewound to "${name}".${filePart}` });
+        ctx.refreshFileList();
+    },
+    "/clear": (ctx) => {
+        ctx.agent.reset();
+        ctx.setTasks([]);
+        ctx.addItem({ kind: "info", text: "Conversation cleared." });
+    },
+    "/cost": (ctx) => {
+        ctx.addItem({ kind: "info", text: ctx.costReport() });
+    },
+    "/audit": (ctx) => {
+        const audit = ctx.agent.audit;
+        if (!audit) {
+            ctx.addItem({
+                kind: "info",
+                text: "Auditing is off for this session (KRITYA_AUDIT=off).",
+            });
+            return;
+        }
+        const records = AuditLog.readRecords(audit.path);
+        if (!records.length) {
+            ctx.addItem({ kind: "info", text: `No audit records yet.\nLog: ${audit.path}` });
+            return;
+        }
+        const fmt = (m) => Object.entries(m)
+            .sort((a, b) => (b[1] ?? 0) - (a[1] ?? 0))
+            .map(([k, v]) => `${k}: ${v}`)
+            .join(", ") || "(none)";
+        const verify = AuditLog.verify(audit.path);
+        const chainLine = verify.ok
+            ? `chain verified — ${verify.records} record(s)`
+            : verify.reason === "unreadable"
+                ? "chain check FAILED — log file could not be read"
+                : `chain check FAILED — broken at record ${verify.line}`;
+        const s = summarizeAudit(records);
+        const latencyLine = s.durationMsP50 || s.waitMsP50
+            ? `Tool latency: p50 ${s.durationMsP50}ms / p95 ${s.durationMsP95}ms — ` +
+                `permission wait: p50 ${s.waitMsP50}ms / p95 ${s.waitMsP95}ms\n`
+            : "";
+        ctx.addItem({
+            kind: "info",
+            text: `Audit log: ${audit.path}\n` +
+                `${chainLine}\n\n` +
+                `Permission decisions by source: ${fmt(s.permissionsBySource)}\n` +
+                `Tool outcomes: ${fmt(s.toolCallsByOutcome)}\n` +
+                latencyLine +
+                `\nFull history: kritya audit --show ${path.basename(audit.path)}`,
+        });
+    },
+    "/budget": (ctx) => {
+        const arg = ctx.arg.trim().toLowerCase();
+        if (!arg) {
+            const status = ctx.budgetStopped ? " — STOPPED" : "";
+            ctx.addItem({
+                kind: "info",
+                text: `Token budget: ${ctx.budgetUsed.toLocaleString()} / ${ctx.tokenBudget.toLocaleString()} ` +
+                    `(${ctx.budgetPct}%)${status}\nUsage: /budget reset · /budget <number>`,
+            });
+            return;
+        }
+        if (arg === "reset") {
+            ctx.resetBudget();
+            return;
+        }
+        const n = Number(arg.replace(/[,_]/g, ""));
+        if (!Number.isFinite(n) || n <= 0) {
+            ctx.addItem({
+                kind: "info",
+                text: `Invalid budget "${ctx.arg}". Use /budget <number>, e.g. /budget 2000000.`,
+            });
+            return;
+        }
+        ctx.setBudgetLimit(Math.round(n));
+    },
+    "/compact": (ctx) => {
+        ctx.setPhase("working");
+        ctx.setActivity("Compacting context…");
+        return ctx.agent
+            .compact()
+            .then((note) => {
+            ctx.addItem({ kind: "info", text: note });
+            ctx.setCtxPct(Math.round(ctx.agent.contextUsage() * 100));
+        })
+            .catch((err) => ctx.addItem({
+            kind: "info",
+            text: `Compaction failed: ${err instanceof Error ? err.message : String(err)}`,
+        }))
+            .finally(() => {
+            ctx.setActivity(null);
+            ctx.setPhase("input");
+        });
+    },
+    "/init": (ctx) => {
+        ctx.addItem({ kind: "user", text: "/init" });
+        return ctx.runAgent("Explore this repository (README, package/build files, src layout, test setup) and write " +
+            "a concise KRITYA.md at the workspace root: what the project is, key commands " +
+            "(build/test/run), architecture in 5-10 bullets, and conventions a coding agent must " +
+            "follow when working here. Keep it under 60 lines.");
+    },
+    "/commit": (ctx) => {
+        ctx.addItem({ kind: "user", text: "/commit" });
+        const attribution = ctx.config.commitAttribution !== false;
+        const trailerInstruction = attribution
+            ? ` End the commit message with a trailer on its own line: ` +
+                `"Generated-By: kritya (${ctx.provider}/${ctx.model})".`
+            : "";
+        return ctx.runAgent("Review the current git changes (git status, git diff), stage the appropriate files, " +
+            "and create a commit with a well-written conventional-commit message that describes " +
+            `the change.${trailerInstruction} Do not push. Show the final commit hash and message.`);
+    },
+    "/flow-brainstorm": async (ctx) => {
+        const input = ctx.arg.trim();
+        const existing = loadProjectState(ctx.workspace);
+        if (!existing && !input) {
+            ctx.addItem({
+                kind: "info",
+                text: `Usage: /flow-brainstorm <your project idea>. Starts the ${PHASE_ORDER.join(" → ")} workflow.\n` +
+                    `Name it yourself with a short prefix: /flow-brainstorm reverser: a script that reverses a string`,
+            });
+            return;
+        }
+        // An idea always names the project. Reusing the existing project's name for
+        // a freshly described idea (the old behaviour) silently wrote one project's
+        // brainstorm into another project's folder.
+        const parsed = parseIdea(input);
+        const idea = input ? parsed.idea : "";
+        const name = input ? slugify(parsed.name) : existing.name;
+        if (existing && existing.name !== name) {
+            ctx.addItem({
+                kind: "info",
+                text: `Starting a new project "${name}". The previous project "${existing.name}" was in the ` +
+                    `${existing.phase} phase; its docs/${existing.name}/ artifacts are untouched, and ` +
+                    `/project goto ${existing.phase} after /flow-brainstorm ${existing.name} returns to it.`,
+            });
+        }
+        saveProjectState(ctx.workspace, name, "brainstorm");
+        // Brainstorming writes its doc, so make sure plan mode isn't left on.
+        if (ctx.planMode) {
+            ctx.agent.planMode = false;
+            ctx.setPlanMode(false);
+        }
+        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+        ctx.setRunningPhase("brainstorm");
+        ctx.refreshWorkflow();
+        // A no-op at the start of a session; earns its keep when a second project
+        // is started in a session that already ran one.
+        await compactAtPhaseBoundary(ctx, "brainstorm");
+        return ctx.runAgent(phasePrompt(name, "brainstorm", idea));
+    },
+    // `/plan` (no `flow-` prefix) is pure plan-mode control — on/off or a bare
+    // toggle — and never touches the project workflow. `/flow-plan` runs the
+    // workflow's plan phase. Splitting these removes the ambiguity the old
+    // combined `/plan` had, where a bare call meant different things depending
+    // on whether a project happened to be active.
+    "/plan": (ctx) => {
+        const explicit = ctx.arg.trim().toLowerCase();
+        const next = explicit ? explicit === "on" : !ctx.planMode;
+        ctx.setPlanMode(next);
+        ctx.agent.planMode = next;
+        // Plan mode and accept-edits are mutually exclusive; entering one via
+        // either path must turn the other off.
+        if (next && ctx.acceptEdits) {
+            ctx.agent.acceptEdits = false;
+            ctx.setAcceptEdits(false);
+        }
+        ctx.addItem({
+            kind: "info",
+            text: next
+                ? "Plan mode ON — read-only. The agent will explore and propose a plan; edits and shell are blocked. Run /plan off to execute."
+                : "Plan mode OFF — the agent can make changes again.",
+        });
+    },
+    "/flow-spec": (ctx) => runPhase(ctx, "spec"),
+    "/flow-plan": (ctx) => runPhase(ctx, "plan"),
+    "/flow-build": (ctx) => runPhase(ctx, "build"),
+    "/flow-review": (ctx) => runPhase(ctx, "review"),
+    "/flow-fix": (ctx) => runPhase(ctx, "fix"),
+    "/project": (ctx) => {
+        const [sub = "", ...rest] = ctx.arg.trim().split(/\s+/);
+        const project = loadProjectState(ctx.workspace);
+        if (sub.toLowerCase() === "clear") {
+            if (!project) {
+                ctx.addItem({ kind: "info", text: "No active project workflow." });
+                return;
+            }
+            clearProjectState(ctx.workspace);
+            ctx.refreshWorkflow();
+            ctx.addItem({
+                kind: "info",
+                text: `Workflow for "${project.name}" ended. Its docs/${project.name}/ artifacts are kept.`,
+            });
+            return;
+        }
+        if (!project) {
+            ctx.addItem({
+                kind: "info",
+                text: "No active project workflow. Start one with /flow-brainstorm <idea>.",
+            });
+            return;
+        }
+        if (sub.toLowerCase() === "rename") {
+            const result = renameProject(ctx.workspace, project.name, rest.join(" "));
+            if (!result.ok) {
+                ctx.addItem({ kind: "info", text: result.error });
+                return;
+            }
+            ctx.refreshWorkflow();
+            ctx.addItem({
+                kind: "info",
+                text: `Renamed "${project.name}" to "${result.name}" — artifacts moved to docs/${result.name}/.`,
+            });
+            return;
+        }
+        if (sub.toLowerCase() === "goto") {
+            const target = parsePhase(rest.join(" "));
+            if (!target) {
+                ctx.addItem({ kind: "info", text: `Usage: /project goto <${PHASE_ORDER.join("|")}>` });
+                return;
+            }
+            saveProjectState(ctx.workspace, project.name, target);
+            ctx.refreshWorkflow();
+            ctx.addItem({
+                kind: "info",
+                text: `"${project.name}" set to the ${target} phase. Run ${PHASE_COMMAND[target]} to start it.`,
+            });
+            return;
+        }
+        const lines = PHASE_ORDER.map((p) => {
+            const marker = p === project.phase ? "*" : " ";
+            const artifact = artifactPath(project.name, p);
+            return `  ${marker} ${p.padEnd(11)}${PHASE_SUMMARY[p]}\n      ${artifact ?? "(application code)"}`;
+        });
+        const stale = staleArtifacts(ctx.workspace, project.name, project.phase);
+        const staleBlock = stale.length ? `\n\n${stale.join("\n")}` : "";
+        ctx.addItem({
+            kind: "info",
+            text: `Project "${project.name}" — ${project.phase} phase` +
+                (project.updatedAt ? ` (since ${project.updatedAt.slice(0, 10)})` : "") +
+                `\n\n${lines.join("\n")}` +
+                staleBlock +
+                `\n\nRun ${PHASE_COMMAND[project.phase]} to continue · /project goto <phase> to move · ` +
+                `/project rename <name> · /project clear to end the workflow.`,
+        });
+    },
+    "/diff": (ctx) => {
+        const d = ctx.gitDiffStat(ctx.workspace);
+        ctx.addItem({ kind: "info", text: d || "No git changes (or not a git repo)." });
+    },
+    "/redo": (ctx) => {
+        const result = ctx.undoStack.redo();
+        if (result === null) {
+            ctx.addItem({ kind: "info", text: "Nothing to redo." });
+        }
+        else {
+            ctx.addItem({ kind: "info", text: `Redo: ${result}` });
+            ctx.agent.addUserNote(`[I reapplied a previously undone change via /redo: ${result}]`);
+            ctx.refreshFileList();
+        }
+    },
+    /**
+     * The emergency stop. `/kill off` (or release/clear/resume) is the only way
+     * back; anything else is treated as the reason it was pulled, which is what
+     * shows up in the audit log and on every subsequent refusal.
+     */
+    "/kill": (ctx) => {
+        const arg = ctx.arg.trim();
+        const word = arg.toLowerCase();
+        if (word === "off" || word === "release" || word === "clear" || word === "resume") {
+            ctx.releaseKill();
+            return;
+        }
+        if (word === "status") {
+            ctx.addItem({
+                kind: "info",
+                text: ctx.killed
+                    ? `⛔ Kill switch ACTIVE${ctx.killReason ? ` — ${ctx.killReason}` : ""}. Release it with /kill off.`
+                    : "Kill switch is off. Engage it with /kill [reason], or Ctrl+K from anywhere.",
+            });
+            return;
+        }
+        if (ctx.killed) {
+            ctx.addItem({
+                kind: "info",
+                text: `⛔ Kill switch is already ACTIVE${ctx.killReason ? ` — ${ctx.killReason}` : ""}. Release it with /kill off.`,
+            });
+            return;
+        }
+        ctx.engageKill(arg || undefined);
+    },
+    "/exit": (ctx) => ctx.exit(),
+    "/quit": (ctx) => ctx.exit(),
+};
+/**
+ * Commands that still work while the kill switch is engaged: releasing it,
+ * leaving, and reading back what happened. Everything else — anything that
+ * drives the agent, spends tokens, or touches the workspace — is refused,
+ * including custom commands (which are just prompts in disguise).
+ */
+const ALLOWED_WHILE_KILLED = new Set([
+    "/kill",
+    "/help",
+    "/exit",
+    "/quit",
+    "/audit",
+    "/cost",
+    "/diff",
+    "/budget",
+    "/mcp",
+    "/checkpoint",
+    "/skills",
+    "/plugins",
+]);
+/** Dispatch a slash command: built-in, then custom, then MCP prompt, then "unknown". */
+export async function runCommand(cmd, ctx) {
+    if (ctx.killed && !ALLOWED_WHILE_KILLED.has(cmd)) {
+        ctx.addItem({
+            kind: "info",
+            text: `⛔ Kill switch ACTIVE${ctx.killReason ? ` — ${ctx.killReason}` : ""}. ` +
+                `${cmd} is blocked. Release it with /kill off.`,
+        });
+        return;
+    }
+    const handler = handlers[cmd];
+    if (handler)
+        return handler(ctx);
+    const custom = ctx.customCommands.find((c) => c.name === cmd);
+    if (custom) {
+        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+        return ctx.runAgent(expandCommand(custom.body, await ctx.expandMentions(ctx.arg)));
+    }
+    // Checked after built-ins and the user's own command files, so a server
+    // can't redefine /plan by naming a prompt "plan".
+    const prompt = mcpPrompts().find((p) => p.command === cmd);
+    if (prompt) {
+        const missing = prompt.args.filter((a) => a.required).map((a) => a.name);
+        if (missing.length && !ctx.arg.trim()) {
+            ctx.addItem({
+                kind: "info",
+                text: `${cmd} needs ${missing.join(", ")}.\n\nUsage: ${cmd} <${missing.join("> <")}>`,
+            });
+            return;
+        }
+        ctx.addItem({ kind: "user", text: ctx.raw.trim() });
+        ctx.setActivity(`Fetching ${prompt.name} from ${prompt.server}…`);
+        let expanded;
+        try {
+            expanded = await prompt.expand(ctx.arg);
+        }
+        catch (err) {
+            ctx.addItem({
+                kind: "info",
+                text: `${cmd} failed: ${err instanceof Error ? err.message : String(err)}`,
+            });
+            return;
+        }
+        finally {
+            ctx.setActivity(null);
+        }
+        if (!expanded.trim()) {
+            ctx.addItem({ kind: "info", text: `${cmd} returned an empty prompt.` });
+            return;
+        }
+        // The server wrote this text, so it's untrusted input being handed to the
+        // model as if the user typed it — label it rather than let it pass as ours.
+        return ctx.runAgent(`[MCP prompt "${prompt.name}" from server "${prompt.server}" — external content]\n\n${expanded}`);
+    }
+    ctx.addItem({ kind: "info", text: `Unknown command: ${cmd}. Try /help` });
+}