oakode 0.0.0-stage → 0.5.0

package/dist/commands.js

@@ -0,0 +1,587 @@
+/** Slash commands: one registry drives dispatch, /help and completion. */
+import { AGENTS_OFF } from "./app.js";
+import { VERSION, home, loadConfig, saveConfig } from "./config.js";
+import { renderDiff } from "./diff.js";
+import { allJobs, jobById, runningJobs, stateOf } from "./jobs.js";
+import { describe as describeRule } from "./permissions.js";
+import { MODES, MODE_LABEL, MODE_SUMMARY, parseMode } from "./modes.js";
+import { permissionsUi } from "./permissions_ui.js";
+import { basename } from "node:path";
+import { accessNote, allowedModel, curatedModels, defaultModel, curatedNote, describeModel, experimentalHint, experimentalModels, isSupported, matchModels, notSupported, selectableModels } from "./models.js";
+import { REASONING_EFFORTS } from "./oicki.js";
+import { reasoningEffort } from "./agent.js";
+import { billingLines } from "./account.js";
+import { clientIdSetting } from "./auth.js";
+import { Session } from "./session.js";
+import { MAX_SKILL_ENTRIES, skillFingerprint } from "./skills.js";
+import { ago, bold, dim, fmtCredits, fmtTokens, green, red, stripAnsi, wrap, yellow } from "./ui.js";
+const SHOWN_MODELS = 60;
+const stamp = (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")} ${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}`;
+/** Every word of the query must appear in the session's first prompts, id, project name or date. */
+function filterSessions(list, q) {
+    const words = q.toLowerCase().split(/\s+/).filter(Boolean);
+    if (!words.length)
+        return list;
+    return list.filter((x) => {
+        const hay = [x.preview, ...x.prompts, x.id, basename(x.cwd), stamp(x.mtime), x.created ? stamp(x.created) : ""].join("\n").toLowerCase();
+        return words.every((w) => hay.includes(w));
+    });
+}
+export function buildCommands() {
+    return [
+        {
+            name: "help",
+            desc: "show commands and keys",
+            run: (_a, app) => {
+                const w = Math.max(...app.commands.map((c) => c.name.length + (c.args ? c.args.length + 1 : 0)));
+                app.view.block([
+                    bold("Commands"),
+                    ...app.commands.map((c) => `  ${bold("/" + c.name)}${c.args ? " " + dim(c.args) : ""}${" ".repeat(w - c.name.length - (c.args ? c.args.length + 1 : 0))}  ${c.desc}`),
+                    "",
+                    bold("Keys"),
+                    "  Enter send · Ctrl+J / Alt+Enter newline · ↑/↓ history · Tab complete a /command",
+                    "  Esc or Ctrl+C interrupts a running turn · Ctrl+C twice or Ctrl+D exits",
+                    "  Typing while the agent works queues your message · pasted text is never sent by itself",
+                ]);
+            },
+        },
+        {
+            name: "model",
+            desc: "show or switch the model",
+            args: "[id or text]",
+            complete: (p, app) => matchModels(selectableModels(app.matchModels("")), p).slice(0, 40).map((m) => ({ value: m.id, desc: modelHint(m) })),
+            run: async (args, app) => {
+                if (!app.models.length)
+                    app.models = await app.client.listModels();
+                const choices = selectableModels(app.models);
+                const exp = experimentalModels();
+                let m;
+                if (!args) {
+                    // the supported models; with experimental models on, the rest of the catalog one step further
+                    const supported = curatedModels(app.models);
+                    const others = choices.filter((x) => !isSupported(x.id));
+                    const i = await app.tui.chooseFrom({
+                        title: "Select a model",
+                        options: () => [...supported.map((x) => ({ label: x.id + (x.id === app.session.model ? green("  (current)") : ""), hint: modelHint(x) })), ...(others.length ? [{ label: "All models (experimental)…", hint: `${others.length} more, unsupported (or /model <text>)` }] : [])],
+                        initial: Math.max(0, supported.findIndex((x) => x.id === app.session.model)),
+                    });
+                    if (i < 0)
+                        return;
+                    m = i < supported.length ? supported[i] : await pickModel(app, others);
+                    if (!m)
+                        return;
+                }
+                else {
+                    const found = matchModels(choices, args);
+                    if (found.length === 1)
+                        m = found[0];
+                    else if (found.length > 1)
+                        m = await pickModel(app, found);
+                    else if (exp || isSupported(args))
+                        m = await app.client.getModel(args).catch(() => undefined); // an exact id the cached list does not have yet
+                    else {
+                        const other = matchModels(app.models, args);
+                        if (other.length)
+                            return app.view.note(other.length === 1 ? notSupported(other[0].id) : `"${args}" matches ${other.length} models, none of them supported. ${experimentalHint()}`, "warn");
+                    }
+                    if (!m)
+                        return found.length > 1 ? undefined : app.view.note(`No ${exp ? "" : "supported "}model matches "${args}".`, "warn");
+                }
+                if (!allowedModel(m.id))
+                    return app.view.note(notSupported(m.id), "warn");
+                if (!app.models.some((x) => x.id === m.id))
+                    app.models.push(m);
+                app.session.setModel(m.id);
+                saveConfig({ model: m.id });
+                const lines = [describeModel(m, m.id)];
+                const note = accessNote(m);
+                if (note)
+                    lines.push(yellow(`This model ${note}; such requests are refused (403) for this credential.`));
+                if (!m.oicki.capabilities.tools)
+                    lines.push(yellow("This model does not support tools: OAKODE can chat with it but cannot read files, edit or run commands."));
+                if (!isSupported(m.id))
+                    lines.push(yellow("Experimental model: not supported by OAKODE; tool use, caching and limits may not work as with the supported ones."));
+                app.view.block(lines);
+            },
+        },
+        {
+            name: "models",
+            desc: "list the supported models (all, or filter by text)",
+            args: "[all | text]",
+            run: async (args, app) => {
+                app.models = await app.client.listModels();
+                const exp = experimentalModels();
+                const supported = curatedModels(app.models);
+                const rest = app.models.length - supported.length;
+                if (!args)
+                    return app.view.block([
+                        ...supported.map((m) => describeModel(m, app.session.model)),
+                        dim(exp ? `Supported models. Experimental models are on: /models all or /models <text> for the other ${rest}.` : `Supported models. ${rest} more in OICKI's catalog are experimental. ${experimentalHint()}`),
+                    ]);
+                const pool = (all) => (args === "all" ? all : matchModels(all, args));
+                const list = pool(selectableModels(app.models));
+                const hidden = exp ? 0 : pool(app.models).length - list.length;
+                app.view.block([
+                    ...list.slice(0, SHOWN_MODELS).map((m) => describeModel(m, app.session.model)),
+                    ...(list.length > SHOWN_MODELS ? [dim(`… ${list.length - SHOWN_MODELS} more; narrow with /models <text>`)] : []),
+                    ...(hidden ? [dim(`${hidden} more ${args === "all" ? "" : "matching "}model${hidden === 1 ? " is" : "s are"} experimental. ${experimentalHint()}`)] : []),
+                    ...(!list.length && !hidden ? [dim(`No model matches "${args}".`)] : []),
+                ]);
+            },
+        },
+        {
+            name: "login",
+            desc: "sign in with your OICKI account (again)",
+            args: "[--expensive]",
+            run: async (args, app) => {
+                if (process.env.OICKI_API_KEY?.trim())
+                    return app.view.note("OICKI_API_KEY is set, so it is used instead of a sign-in. Unset it to sign in with your account.", "warn");
+                if (!clientIdSetting())
+                    return app.view.note("Browser sign-in is not available in this build. Quit and run `oakode login --api-key`.", "warn");
+                const ctl = (app.abort = new AbortController());
+                app.tui.setBusy(true);
+                try {
+                    const { scopes } = await app.auth.login({ expensive: /--expensive/.test(args), log: (s) => app.view.block(s.split("\n")), signal: ctl.signal });
+                    app.view.note(`✓ Signed in to OICKI${scopes.includes("billing:read") ? "" : " (credits will not be shown: the plan-and-credits permission was not granted)"}.`);
+                    await app.refreshBilling(true);
+                }
+                catch (e) {
+                    app.view.note(e.message, "warn");
+                }
+                finally {
+                    app.abort = null;
+                    app.tui.setBusy(false);
+                }
+            },
+        },
+        {
+            name: "status",
+            desc: "model, session, context, credentials",
+            run: async (_a, app) => {
+                await app.refreshBilling(true);
+                const s = app.session;
+                const win = app.agent.contextWindow();
+                const src = app.auth.source();
+                app.view.block([
+                    `${bold("OAKODE")} ${VERSION}  ·  ${app.cwd}`,
+                    `model       ${s.model}${app.agent.servedBy && app.agent.servedBy !== s.model ? ` (served by ${app.agent.servedBy})` : ""}`,
+                    `session     ${s.id} · ${s.raw.length} messages · ${s.file}`,
+                    `context     ~${fmtTokens(s.estimateTokens())}${win ? ` of ${fmtTokens(win)}` : ""}${s.summary ? " (compacted)" : ""}`,
+                    `credentials ${src === "env" ? "API key from $OICKI_API_KEY" : src === "stored-apikey" ? `API key stored in ${home()}/auth.json` : src === "oauth" ? "OAuth session" : "none"}`,
+                    `approvals   ${app.autoApprove ? yellow("OFF (--yes): everything runs unattended") : "every write, edit and command asks first"}${app.permissions.all().length ? dim(` · ${app.permissions.all().filter((r) => r.scope === "session").length} session / ${app.permissions.all().filter((r) => r.scope === "project").length} project permissions (/permissions)`) : ""}`,
+                    ...billingLines(app.billing, app.auth.kind()),
+                    `default     ${defaultModel().id}${defaultModel().ignored ? yellow(` (saved "${defaultModel().ignored}" is not supported, so ignored)`) : ""}`,
+                ]);
+            },
+        },
+        {
+            name: "effort",
+            desc: "reasoning effort for models that reason",
+            args: `[${REASONING_EFFORTS.join("|")}|default]`,
+            complete: (p) => [...REASONING_EFFORTS, "default"].filter((x) => x.startsWith(p)).map((value) => ({ value })),
+            run: (args, app) => {
+                const want = args.trim();
+                const reasons = !!app.currentModel()?.oicki.capabilities.reasoning;
+                const support = reasons ? "" : dim(" (the current model does not take a reasoning effort; it applies when you switch to one that does)");
+                if (!want)
+                    return app.view.block([`reasoning effort: ${reasoningEffort() ?? "provider default"}${support}`]);
+                if (want === "default")
+                    saveConfig({ reasoningEffort: undefined });
+                else if (REASONING_EFFORTS.includes(want))
+                    saveConfig({ reasoningEffort: want });
+                else
+                    return app.view.note(`Unknown effort "${want}". Use one of: ${REASONING_EFFORTS.join(", ")}, default.`, "warn");
+                app.view.note(`Reasoning effort: ${reasoningEffort() ?? "provider default"}.${support}`);
+            },
+        },
+        {
+            name: "agents",
+            desc: "subagents: status, details, transcript, cancel (works while they run)",
+            args: "[id | log <id> | cancel <id|all>]",
+            run: (args, app) => (app.subagents ? app.view.block(app.subagents.command(args)) : app.view.note(AGENTS_OFF)),
+        },
+        {
+            name: "cost",
+            desc: "tokens, cost and credits",
+            run: async (_a, app) => {
+                await app.refreshBilling(true);
+                const u = app.usage;
+                app.view.block([
+                    `${u.requests} request${u.requests === 1 ? "" : "s"} this run · ${fmtTokens(u.prompt)} tokens in · ${fmtTokens(u.completion)} out`,
+                    ...(u.cached || u.reasoning ? [`${fmtTokens(u.cached)} of the input read from the prompt cache (${u.prompt ? Math.round((100 * u.cached) / u.prompt) : 0}%) · ${fmtTokens(u.reasoning)} reasoning tokens`] : []),
+                    ...(u.settled ? [`charged ${fmtCredits(u.credits)} credits (as settled by OICKI${u.settled < u.requests ? `; ${u.requests - u.settled} request(s) did not report a charge` : ""})`] : []),
+                    u.priced ? `estimated cost ≈ $${u.usd < 0.01 ? u.usd.toFixed(5) : u.usd.toFixed(3)} (catalog prices, cache-aware)` : dim("no price known for the model(s) used"),
+                    ...(app.subagents?.costLines(u.credits) ?? []),
+                    ...billingLines(app.billing, app.auth.kind()),
+                    dim("Compaction summaries count as requests. The figures above the subagent lines are the main agent's own."),
+                ]);
+            },
+        },
+        {
+            name: "permissions",
+            desc: "view and edit what is allowed, asked or denied",
+            args: "[list|revoke <id>|all]",
+            complete: (p, app) => {
+                const rules = app.permissions.all();
+                const items = [{ value: "revoke", desc: "remove a permission", space: true }, ...rules.map((r) => ({ value: `revoke ${r.id}`, desc: `[${r.scope}] ${describeRule(r)}` })), ...(rules.length ? [{ value: "revoke all", desc: "remove every permission" }] : [])];
+                return items.filter((i) => i.value.startsWith(p));
+            },
+            run: async (args, app) => {
+                const [sub, id] = args.split(/\s+/);
+                if (sub === "revoke") {
+                    if (!id)
+                        return app.view.note("Usage: /permissions revoke <id> | all", "warn");
+                    const n = app.permissions.revoke(id);
+                    return app.view.note(n ? `Revoked ${n} permission${n > 1 ? "s" : ""}.` : `No permission with id "${id}".`, n ? "info" : "warn");
+                }
+                if (!sub)
+                    return permissionsUi(app);
+                if (sub !== "list")
+                    return app.view.note("Usage: /permissions [list|revoke <id>|all]", "warn");
+                const rules = app.permissions.all();
+                const pol = app.permissions.policyKeys().map((k) => ({ k, ...app.permissions.shownPolicy(k) }));
+                app.view.block([
+                    bold(`Permissions · ${MODE_LABEL[app.mode]}`),
+                    dim(`  ${MODE_SUMMARY[app.mode]}${app.autoApprove ? yellow("   (--yes is ON: nothing asks)") : ""}`),
+                    ...(pol.length ? ["", bold("Custom policy entries"), ...pol.map((p) => `  ${p.k.padEnd(28)} ${p.policy.padEnd(6)} ${p.scope === "session" ? "session only" : "saved"}`)] : []),
+                    ...(rules.length ? ["", bold("Allowed without asking"), ...rules.map((r) => `  ${r.id.padEnd(4)} ${r.scope.padEnd(8)} ${describeRule(r)}`)] : ["", dim("No granted permissions. Choose \"Allow for this session/project\" in an approval menu to add one.")]),
+                    ...(app.permissions.storagePath ? [dim(`Saved settings live outside the repository: ${app.permissions.storagePath}`)] : []),
+                ]);
+            },
+        },
+        {
+            name: "mode",
+            desc: "show or switch the permission mode (Shift+Tab cycles)",
+            args: "[default|auto-edit|plan|custom]",
+            complete: (p) => MODES.map((m) => ({ value: m === "autoedit" ? "auto-edit" : m, desc: MODE_SUMMARY[m] })).filter((i) => i.value.startsWith(p)),
+            run: (args, app) => {
+                if (!args)
+                    return app.view.note(`Mode: ${MODE_LABEL[app.mode]} — ${MODE_SUMMARY[app.mode]}. Shift+Tab or /mode <name> switches (default, auto-edit, plan, custom).`);
+                const m = parseMode(args);
+                if (!m)
+                    return app.view.note(`Unknown mode "${args}". Use default, auto-edit, plan or custom.`, "warn");
+                app.setMode(m, true);
+                app.view.note(`Mode: ${MODE_LABEL[m]} — ${MODE_SUMMARY[m]}${app.autoApprove && m !== "plan" ? " (--yes is still ON)" : ""}`);
+            },
+        },
+        {
+            name: "history",
+            desc: "show earlier messages of a resumed conversation",
+            args: "[count|all]",
+            complete: (p) => [{ value: "all", desc: "everything before what is shown" }].filter((i) => i.value.startsWith(p)),
+            run: (args, app) => app.history(args === "all" ? "all" : Math.max(1, Math.min(500, Number(args) || 50))),
+        },
+        {
+            name: "diff",
+            desc: "review file changes made in this session",
+            args: "[number|path|all]",
+            complete: (p, app) => [{ value: "all", desc: "every change" }, ...[...new Set(app.session.changes.map((c) => c.diff.path))].map((v) => ({ value: v }))].filter((i) => i.value.startsWith(p)),
+            run: (args, app) => {
+                const ch = app.session.changes;
+                if (!ch.length)
+                    return app.view.note("No file changes in this session yet.");
+                const cols = app.tui.screen.cols;
+                const row = (c, i) => `  ${String(i + 1).padStart(2)}. ${new Date(c.ts).toLocaleTimeString()}  ${c.tool.padEnd(5)} ${c.diff.path}  ${green("+" + c.diff.added)} ${red("−" + c.diff.removed)}`;
+                const show = (idx) => idx.flatMap((i) => ["", ...renderDiff(ch[i].diff, cols, 200).lines]);
+                let pick;
+                if (!args)
+                    pick = [ch.length - 1];
+                else if (args === "all")
+                    pick = ch.map((_, i) => i);
+                else if (/^\d+$/.test(args))
+                    pick = ch[Number(args) - 1] ? [Number(args) - 1] : [];
+                else
+                    pick = ch.map((c, i) => (c.diff.path === args ? i : -1)).filter((i) => i >= 0);
+                if (!pick.length)
+                    return app.view.note(`No change matches "${args}". /diff lists them.`, "warn");
+                app.view.block([bold(`File changes this session (${ch.length})`), ...ch.map(row), ...show(pick), ...(!args && ch.length > 1 ? [dim("/diff <number> or /diff all shows the others")] : [])]);
+            },
+        },
+        {
+            name: "skills",
+            desc: "list available skills; trust this project's skills",
+            args: "[name|trust|untrust|reload]",
+            complete: (p, app) => [...["trust", "untrust", "reload"].map((v) => ({ value: v, desc: v === "trust" ? "enable skills shipped in this project" : v === "untrust" ? "disable them again" : "rescan the skill folders" })), ...app.skills.list().map((s) => ({ value: s.name, desc: s.description.slice(0, 60) }))].filter((i) => i.value.startsWith(p)),
+            run: async (args, app) => {
+                const sk = app.skills;
+                if (args === "reload") {
+                    sk.load();
+                    return app.view.note(`Rescanned: ${sk.list().length} skill${sk.list().length === 1 ? "" : "s"} available.`);
+                }
+                if (args === "untrust") {
+                    app.trust.untrustSkills();
+                    sk.load();
+                    return app.view.note("Project skills are disabled again.");
+                }
+                if (args === "trust") {
+                    const pending = sk.inactive.filter((x) => x.skill.source === "project" && /not trusted|changed since/.test(x.reason));
+                    if (app.trust.skills && !pending.length)
+                        return app.view.note("This project's skills are already trusted.");
+                    if (!pending.length)
+                        return app.view.note("This project has no skills in .agents/skills/.");
+                    const i = await app.tui.chooseFrom({
+                        title: "Trust the skills in this project?",
+                        lines: [...pending.map((x) => `  ${x.skill.name}  ${dim(x.skill.description.slice(0, 80))}${/changed since/.test(x.reason) ? yellow("  (changed since you trusted it)") : ""}`), dim(`  from ${sk.dirs()[0].dir}`), dim("  Trust covers their current contents; if they change later, they are disabled until you review them again."), yellow("  Skills are instructions written by whoever made this repository. The model may read and follow them;"), yellow("  it still needs your approval to edit files or run commands.")],
+                        options: () => [{ label: "Trust this project's skills" }, { label: "Cancel" }],
+                        initial: 1,
+                    });
+                    if (i !== 0)
+                        return app.view.note("Not enabled.");
+                    const fps = pending.map((x) => ({ name: x.skill.name, fingerprint: skillFingerprint(x.skill.dir) }));
+                    app.trust.trustSkills(fps);
+                    sk.load();
+                    const tooBig = fps.filter((f) => !f.fingerprint).map((f) => f.name);
+                    if (tooBig.length)
+                        app.view.note(`Not enabled: ${tooBig.join(", ")} (more than ${MAX_SKILL_ENTRIES} files, too many to verify).`, "warn");
+                    return app.view.note(`Enabled. ${sk.list().length} skill${sk.list().length === 1 ? "" : "s"} available.`);
+                }
+                if (args) {
+                    const s = sk.get(args) ?? sk.inactive.find((x) => x.skill.name === args)?.skill;
+                    if (!s)
+                        return app.view.note(`No skill "${args}". /skills lists them.`, "warn");
+                    const off = sk.inactive.find((x) => x.skill === s);
+                    return app.view.block([
+                        `${bold(s.name)}  ${dim(`${s.source} skill${off ? " · NOT ACTIVE: " + off.reason : ""}`)}`,
+                        ...wrap(s.description, app.tui.screen.cols),
+                        dim(`directory  ${s.dir}`),
+                        ...(s.license ? [dim(`license    ${s.license}`)] : []),
+                        ...(s.compatibility ? [dim(`requires   ${s.compatibility}`)] : []),
+                        ...(s.allowedTools ? [dim(`allowed-tools: ${s.allowedTools} (ignored: skills cannot pre-approve tools)`)] : []),
+                        ...Object.entries(s.metadata ?? {}).map(([k, v]) => dim(`${k}: ${v}`)),
+                    ]);
+                }
+                const active = sk.list();
+                app.view.block([
+                    bold(`Skills (${active.length} available)`),
+                    ...(active.length ? active.map((s) => `  ${bold(s.name.padEnd(Math.min(24, Math.max(...active.map((x) => x.name.length)))))} ${dim(s.source.padEnd(8))} ${s.description.length > 90 ? s.description.slice(0, 89) + "…" : s.description}`) : [dim("  none found")]),
+                    ...(sk.inactive.length ? ["", bold("Not active"), ...sk.inactive.map((x) => `  ${x.skill.name.padEnd(24)} ${dim(x.reason)}`)] : []),
+                    ...(sk.diagnostics.length ? ["", bold("Problems"), ...sk.diagnostics.map((d) => yellow(`  ${d.path.replace(home(), "~")}: ${d.problem}`))] : []),
+                    "",
+                    dim(`Searched: ${sk.dirs().map((d) => d.dir.replace(home().replace(/\.oakode$/, ""), "~/")).join(" · ")}`),
+                    dim("The model loads a skill itself when your request matches its description. /skills <name> shows details."),
+                ]);
+            },
+        },
+        {
+            name: "jobs",
+            desc: "Background jobs the agent started: list, or stop one or all",
+            args: "[kill <id|all>]",
+            complete: (p) => ["kill all", ...runningJobs().map((j) => `kill ${j.id}`)].filter((v) => v.startsWith(p)).map((value) => ({ value })),
+            run: async (args, app) => {
+                const [sub, which] = args.trim().split(/\s+/);
+                if (sub === "kill") {
+                    const targets = which === "all" ? runningJobs() : [jobById(Number(which))].filter((j) => j?.alive);
+                    if (!targets.length)
+                        return app.view.note(which === "all" ? "No background jobs are running." : `No running job ${which ?? ""}. /jobs lists them.`, "warn");
+                    await Promise.all(targets.map((j) => j.stop("kill")));
+                    return app.view.note(`Stopped ${targets.map((j) => `job ${j.id}`).join(", ")}.`);
+                }
+                const all = allJobs();
+                if (!all.length)
+                    return app.view.note("No background jobs. The agent starts one with bash {background: true} (a dev server, a watcher, a slow test suite); it asks first like any command.");
+                app.view.block([
+                    bold("Background jobs"),
+                    ...all.map((j) => `  ${bold(String(j.id))}  ${j.running ? green("running") : dim(stateOf(j))}  ${j.command.split("\n")[0].slice(0, 80)}  ${dim(j.log)}`),
+                    dim("/jobs kill <id|all> stops them; all are stopped when OAKODE exits."),
+                ]);
+            },
+        },
+        {
+            name: "mcp",
+            desc: "MCP servers: status, tools, approve, reconnect",
+            args: "[name|approve|revoke|reconnect|reload]",
+            complete: (p, app) => {
+                const names = app.mcp.servers().map((x) => x.def.name);
+                const items = [
+                    ...["approve", "revoke", "reconnect", "reload"].map((v) => ({ value: v, desc: v === "approve" ? "start a server this project configures" : v === "revoke" ? "stop trusting a project server" : v === "reconnect" ? "retry a failed server" : "re-read the config files", space: v !== "reload" })),
+                    ...["approve", "revoke", "reconnect"].flatMap((v) => names.map((n) => ({ value: `${v} ${n}` }))),
+                    ...names.map((n) => ({ value: n })),
+                ];
+                return items.filter((i) => i.value.startsWith(p));
+            },
+            run: async (args, app) => {
+                const m = app.mcp;
+                const [sub, name] = args.split(/\s+/);
+                const need = (n) => {
+                    const s = n ? m.get(n) : undefined;
+                    if (!s)
+                        throw new Error(n ? `No MCP server "${n}". /mcp lists them.` : `Usage: /mcp ${sub} <server>`);
+                    return s;
+                };
+                if (sub === "reload") {
+                    m.load();
+                    void m.start();
+                    return app.view.note(`Config re-read: ${m.servers().length} server${m.servers().length === 1 ? "" : "s"}.`);
+                }
+                if (sub === "reconnect") {
+                    if (name === "all" || !name) {
+                        await Promise.all(m.servers().filter((s) => s.def.source === "user" || s.state !== "needs-approval").map((s) => m.reconnect(s.def.name).catch(() => { })));
+                        return;
+                    }
+                    need(name);
+                    return void (await m.reconnect(name));
+                }
+                if (sub === "revoke") {
+                    need(name);
+                    m.revoke(name);
+                    return app.view.note(`Stopped ${name} and withdrew its approval.`);
+                }
+                if (sub === "approve") {
+                    const s = need(name);
+                    if (s.def.source === "user")
+                        return app.view.note(`${name} comes from your own config and needs no approval.`);
+                    const spec = s.def.spec;
+                    const i = await app.tui.chooseFrom({
+                        title: `Start MCP server "${name}" from this project?`,
+                        lines: [
+                            spec.type === "stdio" ? `  runs      ${bold([spec.command, ...spec.args].join(" "))}` : `  connects  ${bold(spec.url)}`,
+                            ...(spec.type === "stdio" && Object.keys(spec.env).length ? [dim(`  env       ${Object.keys(spec.env).join(", ")} (values not shown)`)] : []),
+                            ...(spec.type === "http" && Object.keys(spec.headers).length ? [dim(`  headers   ${Object.keys(spec.headers).join(", ")} (values not shown)`)] : []),
+                            dim(`  from      ${s.def.configPath}`),
+                            yellow(spec.type === "stdio" ? "  This program would run on your computer with your permissions, started by a file in the repository." : "  The server's tools and replies are untrusted; every tool call still asks you first."),
+                            yellow("  If the configuration changes later, you will be asked again."),
+                        ],
+                        options: () => [{ label: "Start this server" }, { label: "Cancel" }],
+                        initial: 1,
+                    });
+                    if (i !== 0)
+                        return app.view.note("Not started.");
+                    m.approve(name);
+                    return void (await m.reconnect(name));
+                }
+                if (sub && !m.get(sub))
+                    return app.view.note(`No MCP server "${sub}". /mcp lists them.`, "warn");
+                const cols = app.tui.screen.cols;
+                const icon = (s) => (s.state === "ready" ? green("●") : s.state === "starting" ? yellow("◌") : s.state === "failed" ? red("✗") : s.state === "needs-approval" ? yellow("!") : dim("○"));
+                const label = (s) => (s.state === "needs-approval" ? yellow("needs approval: /mcp approve " + s.def.name) : s.state === "ready" ? `${s.tools.length} tool${s.tools.length === 1 ? "" : "s"}` : s.state === "failed" ? red("failed") : s.state);
+                const servers = sub ? [m.get(sub)] : m.servers();
+                if (!servers.length && !m.problems.length)
+                    return app.view.block([bold("MCP servers"), dim("  none configured"), dim("  Add servers to ~/.oakode/mcp.json (yours) or .mcp.json in a project (needs your approval):"), dim('  {"mcpServers": {"files": {"command": "node", "args": ["server.js"]}, "web": {"type": "http", "url": "https://…"}}}')]);
+                app.view.block([
+                    bold(`MCP servers (${m.servers().filter((s) => s.state === "ready").length} of ${m.servers().length} ready)`),
+                    ...servers.flatMap((s) => [
+                        `  ${icon(s)} ${bold(s.def.name)}  ${dim(`${s.def.spec.type === "stdio" ? "stdio" : "http"} · ${s.def.source === "user" ? "your config" : "project config"}`)}  ${label(s)}${s.serverName ? dim("  " + s.serverName) : ""}`,
+                        dim(`      ${s.def.spec.type === "stdio" ? "$ " : ""}${s.description.slice(0, cols - 10)}`),
+                        ...(s.state === "failed" && s.error ? [red(`      ${s.error.slice(0, cols - 10)}`)] : []),
+                        ...(sub ? s.tools.flatMap((t) => [`      ${bold(t.name)}${dim(" — " + (t.description.replace(/\s+/g, " ").slice(0, 90) || "(no description)"))}`]) : []),
+                    ]),
+                    ...(m.problems.length ? ["", bold("Config problems"), ...m.problems.map((p) => yellow(`  ${p.where}: ${p.problem}`))] : []),
+                    "",
+                    dim("Calls to MCP tools always ask first; server descriptions and replies are treated as untrusted. /mcp <name> lists a server's tools."),
+                ]);
+            },
+        },
+        {
+            name: "compact",
+            desc: "summarize older history to free context",
+            run: async (_a, app) => {
+                await app.compact();
+            },
+        },
+        {
+            name: "clear",
+            desc: "start a fresh conversation (the old one stays resumable)",
+            run: (_a, app) => {
+                // a fresh conversation keeps the model, unless it is one that may no longer be chosen
+                const before = app.session.model;
+                app.adoptSession(Session.create(app.cwd, allowedModel(before) ? before : defaultModel().id));
+                app.tui.clearScreen();
+                app.banner(VERSION, false);
+                if (app.session.model !== before)
+                    app.view.note(`The new conversation uses ${app.session.model}: "${before}" is not one of OAKODE's supported models. ${experimentalHint()}`, "warn");
+            },
+        },
+        {
+            name: "sessions",
+            desc: "list previous sessions in this directory",
+            run: (_a, app) => {
+                const list = Session.list(app.cwd, 20);
+                if (!list.length)
+                    return app.view.note("No previous sessions in this directory.");
+                app.view.block([
+                    bold(`Sessions in ${app.cwd}`),
+                    ...list.map((x, i) => `  ${String(i + 1).padStart(2)}. ${x.id}  ${stamp(x.mtime)} ${ago(x.mtime).padEnd(9)} ${(x.messages === undefined ? "large" : x.messages + " msgs").padEnd(9)} ${x.preview}${x.id === app.session.id ? green("  (current)") : ""}`),
+                    dim("Resume one with /resume <number or id>, or /resume to search and pick."),
+                ]);
+            },
+        },
+        {
+            name: "resume",
+            desc: "search and resume a previous session",
+            args: "[number or id]",
+            complete: (p, app) => Session.list(app.cwd, 20).filter((x) => x.id.startsWith(p)).map((x) => ({ value: x.id, desc: `${ago(x.mtime)} · ${x.preview}` })),
+            run: async (args, app) => {
+                const all = Session.list(app.cwd, 60); // same numbering as /sessions
+                const others = all.filter((x) => x.id !== app.session.id);
+                if (!others.length)
+                    return app.view.note("No other sessions in this directory.");
+                let pick = args ? all[Number(args) - 1] ?? all.find((x) => x.id.startsWith(args)) : undefined;
+                if (!pick && args)
+                    return app.view.note(`No session "${args}". /sessions lists them.`, "warn");
+                if (pick?.id === app.session.id)
+                    return app.view.note("That is the current session.");
+                if (!pick) {
+                    const i = await app.tui.chooseFrom({
+                        title: `Resume a session · ${app.cwd}`,
+                        search: true,
+                        options: (q) => filterSessions(others, q).map((x) => ({ label: x.preview, hint: `${basename(x.cwd)} · ${stamp(x.mtime)} (${ago(x.mtime)}) · ${x.messages === undefined ? "large" : x.messages + " msgs"} · ${x.id}` })),
+                        hint: "type to search (text, id, date) · ↑/↓ choose · Enter resume · Esc cancel",
+                    });
+                    if (i < 0)
+                        return;
+                    pick = filterSessions(others, app.tui.menuQuery)[i];
+                    if (!pick)
+                        return;
+                }
+                app.adoptSession(Session.open(pick.file, app.session.model, app.cwd));
+                app.tui.clearScreen();
+                app.banner(VERSION, true);
+                app.resumeNotice();
+            },
+        },
+        {
+            name: "retry",
+            desc: "send the last request again (may be billed)",
+            run: async (_a, app) => {
+                await app.turn(null);
+            },
+        },
+        {
+            name: "exit",
+            desc: "Quit OAKODE",
+            run: (_a, app) => app.exit(),
+        },
+    ];
+}
+/** Choose among several models (at most 100 shown). */
+async function pickModel(app, list) {
+    const shown = list.slice(0, 100);
+    const i = await app.tui.chooseFrom({
+        title: `Select a model${list.length > shown.length ? ` (${list.length} match; narrow with /model <text>)` : ""}`,
+        options: () => shown.map((x) => ({ label: x.id + (x.id === app.session.model ? green("  (current)") : ""), hint: modelHint(x) })),
+        initial: Math.max(0, shown.findIndex((x) => x.id === app.session.model)),
+    });
+    return i >= 0 ? shown[i] : undefined;
+}
+const modelHint = (m) => {
+    const o = m.oicki;
+    const note = curatedNote(m.id) ?? "experimental";
+    return `${note ? `${note} · ` : ""}ctx ${o.context_window ? fmtTokens(o.context_window) : "?"}${o.pricing ? ` · $${o.pricing.input_usd_per_million}/${o.pricing.output_usd_per_million}` : ""}${o.capabilities.tools ? "" : " · no tools"}${accessNote(m) ? " · needs permission" : ""}`;
+};
+/** Completion for the text before the cursor, or null if it is not a /command. */
+export function completeInput(before, cmds, app) {
+    if (!before.startsWith("/") || before.includes("\n"))
+        return null;
+    const sp = before.indexOf(" ");
+    if (sp < 0) {
+        const p = before.slice(1).toLowerCase();
+        const items = cmds.filter((c) => c.name.startsWith(p)).map((c) => ({ value: "/" + c.name, desc: (c.args ? c.args + "  " : "") + c.desc, space: !!c.args }));
+        return { from: 0, items };
+    }
+    const cmd = cmds.find((c) => c.name === before.slice(1, sp).toLowerCase());
+    if (!cmd?.complete)
+        return null;
+    const partial = before.slice(sp + 1);
+    return { from: sp + 1, items: cmd.complete(partial, app) };
+}
+export { red, stripAnsi };