sakuracode 0.0.0-stage → 0.1.0

package/dist/code/src/providers.js

@@ -0,0 +1,56 @@
+// Model providers: the built-in ones, the ones from the config file, and turning a choice into the framework's ModelConfig.
+import { compatPresets } from "./framework.js";
+export class ProviderSetupError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "ProviderSetupError";
+    }
+}
+/** Chat Completions providers that are known to work. The order is the order tried when the user chose none. */
+export const BUILTIN_PROVIDERS = {
+    deepseek: { baseUrl: "https://api.deepseek.com", model: "deepseek-flash", keyEnv: "DEEPSEEK_API_KEY", contextWindow: 128_000, compat: "deepseek", images: true },
+    // OpenCode Go refuses a request without a session id (error MissingSessionID); the id is the terminal session's id.
+    opencode: { baseUrl: "https://opencode.ai/zen/go/v1", model: "deepseek-v4.1-flash", keyEnv: "OPENCODE_API_KEY", contextWindow: 128_000, compat: "deepseek", images: true, sessionHeader: "x-opencode-session" },
+};
+export function allProviders(settings) {
+    return { ...BUILTIN_PROVIDERS, ...settings.providers };
+}
+export function listProviders(settings, env) {
+    return Object.entries(allProviders(settings)).map(([name, definition]) => ({ name, definition, keyPresent: Boolean(env[definition.keyEnv]), builtin: name in BUILTIN_PROVIDERS && !(name in settings.providers) }));
+}
+/** The provider to use: the one the user chose, else the first one whose key is set. */
+export function chooseProvider(settings, env) {
+    const all = allProviders(settings);
+    if (settings.provider !== undefined) {
+        if (!(settings.provider in all))
+            throw new ProviderSetupError(`unknown provider "${settings.provider}" (known: ${Object.keys(all).join(", ")})`);
+        return settings.provider;
+    }
+    const withKey = listProviders(settings, env).find((entry) => entry.keyPresent);
+    if (!withKey) {
+        const needed = Object.values(all).map((definition) => definition.keyEnv);
+        throw new ProviderSetupError(`no API key found; set one of: ${needed.join(", ")} (\`sakuracode providers\` shows what is set)`);
+    }
+    return withKey.name;
+}
+export function buildModelConfig(request) {
+    const definition = allProviders(request.settings)[request.provider];
+    if (!definition)
+        throw new ProviderSetupError(`unknown provider "${request.provider}"`);
+    const apiKey = request.env[definition.keyEnv];
+    if (!apiKey)
+        throw new ProviderSetupError(`provider "${request.provider}" needs the environment variable ${definition.keyEnv}`);
+    const compat = definition.compat === undefined ? undefined : compatPresets[definition.compat];
+    if (definition.compat !== undefined && !compat)
+        throw new ProviderSetupError(`provider "${request.provider}": unknown compat preset "${definition.compat}" (known: ${Object.keys(compatPresets).join(", ")})`);
+    const headers = { ...definition.headers, ...(definition.sessionHeader ? { [definition.sessionHeader]: request.sessionId } : {}) };
+    const withImages = compat || definition.images ? { ...compat, ...(definition.images ? { images: true } : {}) } : undefined;
+    return {
+        baseUrl: definition.baseUrl,
+        apiKey,
+        model: request.model ?? definition.model,
+        contextWindow: definition.contextWindow,
+        ...(withImages ? { compat: withImages } : {}),
+        ...(Object.keys(headers).length > 0 ? { headers } : {}),
+    };
+}

package/dist/code/src/reports.js

@@ -0,0 +1,81 @@
+import { PERMISSION_NAMES, PERMISSION_PRESETS } from "./permissions.js";
+const number = (value) => value.toLocaleString("en-US");
+/** Token counts the short way (12.3k, 6.40M), as the mature tools print them. */
+export function tokens(value) {
+    if (value < 1000)
+        return String(value);
+    if (value < 999_500)
+        return `${(value / 1000).toFixed(value < 100_000 ? 1 : 0)}k`;
+    return `${(value / 1_000_000).toFixed(2)}M`;
+}
+/** The share of one reply's input that came from the cache: cache read / (cache read + new input + cache write). */
+function replyHitRate(usage) {
+    const total = usage.input + usage.cacheRead + usage.cacheWrite;
+    return total > 0 ? usage.cacheRead / total : undefined;
+}
+/** The middle one of the per-reply cache hit rates of the model replies in a log (compaction and goal-check requests are not replies). */
+export function medianReplyHitRate(entries) {
+    const rates = [];
+    for (const entry of entries) {
+        if (entry.type !== "message" || entry.message.role !== "assistant" || !entry.message.usage)
+            continue;
+        const rate = replyHitRate(entry.message.usage);
+        if (rate !== undefined)
+            rates.push(rate);
+    }
+    if (rates.length === 0)
+        return undefined;
+    rates.sort((a, b) => a - b);
+    const middle = Math.floor(rates.length / 2);
+    return rates.length % 2 === 1 ? rates[middle] : (rates[middle - 1] + rates[middle]) / 2;
+}
+const percent = (share) => `${(share * 100).toFixed(1)}%`;
+export function statusReport(input) {
+    const free = input.context.window > 0 ? Math.round((input.context.free / input.context.window) * 100) : 0;
+    const rows = [
+        ["Session", `\`${input.sessionId}\``],
+        ["Session file", `\`${input.sessionFile}\``],
+        ["Directory", `\`${input.cwd}\` (not restricted: the agent may go anywhere)`],
+        ["Model", `${input.model} via ${input.provider}${input.thinking ? `, thinking ${input.thinking}` : ""}`],
+        ["Permissions", `${input.permissions}: ${PERMISSION_PRESETS[input.permissions].summary}`],
+        ["Redaction", input.redaction ? "on" : "off"],
+        ["Context", `${number(input.context.tokens)} of ${number(input.context.window)} tokens used, ${free}% left${input.context.compactAt ? `, compacts at ${number(input.context.compactAt)}` : ""}`],
+        ...usageRows(input),
+        ["Goal", input.goal ? `${input.goal.status}: ${input.goal.objective}` : "none"],
+        ["Idle compaction", input.idleCompaction],
+        ["State", input.working ? "working" : "idle"],
+    ];
+    return ["| Item | Value |", "|---|---|", ...rows.map(([key, value]) => `| **${key}** | ${value} |`)].join("\n");
+}
+export function modelsReport(listings, current) {
+    const rows = listings.map((entry) => {
+        const here = entry.name === current.provider;
+        return `| ${here ? "▶ " : ""}\`${entry.name}\` | ${here ? current.model : entry.definition.model} | \`${entry.definition.keyEnv}\` ${entry.keyPresent ? "set" : "**not set**"} |`;
+    });
+    return ["| Provider | Model | Key |", "|---|---|---|", ...rows, "", "Switch with `/model <provider>` or `/model <provider> <model>`."].join("\n");
+}
+export function permissionsReport(current, redaction) {
+    const rows = PERMISSION_NAMES.map((name) => `| ${name === current ? "▶ " : ""}\`${name}\` | ${PERMISSION_PRESETS[name].summary} |`);
+    return ["| Preset | Meaning |", "|---|---|", ...rows, "", `Redaction is **${redaction ? "on" : "off"}** (\`/redaction on\`). The working directory is never restricted.`].join("\n");
+}
+export function mcpReport(status) {
+    const names = Object.keys(status);
+    if (names.length === 0)
+        return "No MCP servers are configured. Add them under `[mcp.servers.NAME]` in the config file.";
+    return ["| Server | State | Tools |", "|---|---|---|", ...names.map((name) => `| \`${name}\` | ${status[name].ok ? "connected" : `failed: ${status[name].error ?? "unknown"}`} | ${status[name].toolCount} |`)].join("\n");
+}
+/**
+ * Token use in the shape of the mature tools: the whole input with the cached part named (as Claude Code's /usage does),
+ * the cache hit rate (as its "Prompt cache" line does), the output, and the replies they belong to.
+ */
+function usageRows(input) {
+    const { usage } = input;
+    const totalInput = usage.input + usage.cacheRead + usage.cacheWrite;
+    const written = usage.cacheWrite > 0 ? `, ${tokens(usage.cacheWrite)} written to the cache` : "";
+    const hit = totalInput > 0 ? `${percent(usage.cacheRead / totalInput)} of input tokens from the cache${input.medianHitRate === undefined ? "" : `; median reply ${percent(input.medianHitRate)}`}` : "no requests yet";
+    return [
+        ["Input", totalInput > 0 ? `${tokens(totalInput)} tokens: ${tokens(usage.cacheRead)} cached, ${tokens(usage.input)} new${written}` : "none yet"],
+        ["Cache hit rate", `${hit} (${number(usage.turns)} replies; compaction and goal checks included in the totals, review requests not counted)`],
+        ["Output", `${tokens(usage.output)} tokens`],
+    ];
+}

package/dist/code/src/run-driver.js

@@ -0,0 +1,76 @@
+import { textOf } from "./transcript.js";
+export function createRunDriver(transcript) {
+    let working = false;
+    let current;
+    let pending = [];
+    const eventListeners = new Set();
+    const changeListeners = new Set();
+    const changed = () => {
+        for (const listener of changeListeners)
+            listener();
+    };
+    /** The kernel announces a steered or queued message with a user `message_end` when it takes it. */
+    function delivered(event) {
+        if (event.type !== "message_end" || event.message.role !== "user")
+            return;
+        const text = textOf(event.message.content);
+        const index = pending.findIndex((item) => item.text === text);
+        if (index !== -1) {
+            pending.splice(index, 1);
+            changed();
+        }
+    }
+    return {
+        get working() {
+            return working;
+        },
+        pending: () => pending,
+        async run(agent, input, options) {
+            working = true;
+            pending = [];
+            current = { agent };
+            changed();
+            const handle = agent.run(input, options);
+            try {
+                for await (const event of handle.events) {
+                    transcript.apply(event);
+                    for (const listener of eventListeners)
+                        listener(event);
+                    delivered(event);
+                }
+                const result = await handle.result;
+                const leftover = pending;
+                pending = [];
+                return { result, leftover };
+            }
+            finally {
+                working = false;
+                current = undefined;
+                changed();
+            }
+        },
+        steer(text) {
+            if (!working || !current)
+                return;
+            pending.push({ kind: "steer", text });
+            current.agent.steer(text);
+            changed();
+        },
+        queue(text) {
+            if (!working || !current)
+                return;
+            pending.push({ kind: "queue", text });
+            current.agent.queue(text);
+            changed();
+        },
+        cancel: () => current?.agent.cancel(),
+        onEvent(listener) {
+            eventListeners.add(listener);
+            return () => eventListeners.delete(listener);
+        },
+        onChange(listener) {
+            changeListeners.add(listener);
+            return () => changeListeners.delete(listener);
+        },
+    };
+}

package/dist/code/src/session-controller.js

@@ -0,0 +1,405 @@
+// The application core. It owns the current agent session and decides what a submitted line means: a prompt, a slash command,
+// a shell command, or a steering/queued message while the agent works. It has no terminal I/O; it talks to the outside only
+// through the Transcript (what to show) and the Surface (what only a screen can do).
+import { openAgentSession } from "./agent-session.js";
+import { expandMentions } from "./mentions.js";
+import { isPermissionName } from "./permissions.js";
+import { allProviders, chooseProvider, listProviders } from "./providers.js";
+import { mcpReport, medianReplyHitRate, modelsReport, permissionsReport, statusReport } from "./reports.js";
+import { createRunDriver } from "./run-driver.js";
+import { sessionLabel, titleFromPrompt } from "./session-store.js";
+import { runShell } from "./shell.js";
+import { findCommand, helpMarkdown, parseSlash } from "./slash-commands.js";
+import { contextLeftPercent } from "./status-line.js";
+import { excerpt, replayLog } from "./transcript.js";
+import { imageMediaType } from "./images.js";
+/** Below this a context is never compacted on its own, whatever the setting says. */
+const MIN_COMPACT_TOKENS = 1000;
+const thousands = (tokens) => (tokens < 1000 ? String(tokens) : `${Math.round(tokens / 1000)}k`);
+// tracked changes against HEAD (or the index in a repository without commits), then every untracked file as an addition
+const DIFF_COMMAND = 'git --no-pager diff HEAD 2>/dev/null || git --no-pager diff; git ls-files --others --exclude-standard | while read -r f; do git --no-pager diff --no-index -- /dev/null "$f"; done';
+export function createController(deps) {
+    const { transcript, surface, store } = deps;
+    const openSession = deps.openSession ?? openAgentSession;
+    const shell = deps.runShell ?? runShell;
+    const driver = createRunDriver(transcript);
+    let session;
+    let meta;
+    let contextPercent;
+    const firstImages = [...(deps.images ?? [])];
+    let choice = {
+        provider: deps.clients ? "scripted" : chooseProvider(deps.settings, deps.env),
+        model: deps.settings.model,
+        permissions: deps.settings.permissions,
+        redaction: deps.settings.redaction,
+        thinking: deps.settings.thinking,
+    };
+    driver.onChange(() => surface.changed());
+    const notice = (level, text) => transcript.add({ kind: "notice", level, text });
+    const requireSession = () => {
+        if (!session)
+            throw new Error("no session is open");
+        return session;
+    };
+    // ---------- opening and closing ----------
+    async function open(target, next) {
+        const opened = await openSession({
+            settings: deps.settings,
+            provider: next.provider,
+            model: next.model,
+            sessionId: target.id,
+            sessionFile: store.sessionFile(target.id),
+            cwd: deps.cwd,
+            permissions: next.permissions,
+            redaction: next.redaction,
+            thinking: next.thinking,
+            maxTokens: deps.settings.maxTokens,
+            env: deps.env,
+            onRetry: (message) => notice("warn", message),
+            ...(deps.clients ? { clients: deps.clients } : {}),
+        });
+        session = opened;
+        choice = { ...next, model: opened.model };
+        meta = await store.update(target.id, { provider: next.provider, model: opened.model });
+        await refreshContext();
+        surface.changed();
+    }
+    async function closeCurrent(options) {
+        if (!session || !meta)
+            return;
+        const closing = meta;
+        await session.close();
+        session = undefined;
+        if (options.discardIfEmpty && closing.title === undefined)
+            await store.remove(closing.id);
+    }
+    /** Reopens the current session with other settings; if that fails the old settings are restored. */
+    async function reopen(patch) {
+        if (!meta)
+            return false;
+        const previous = choice;
+        const target = meta;
+        await closeCurrent({ discardIfEmpty: false });
+        try {
+            await open(target, { ...previous, ...patch });
+            return true;
+        }
+        catch (error) {
+            notice("error", `Could not switch: ${error.message}`);
+            await open(target, previous);
+            return false;
+        }
+    }
+    async function startFresh() {
+        const created = await store.create({ cwd: deps.cwd, provider: choice.provider, model: choice.model ?? "" });
+        await open(created, choice);
+    }
+    async function switchTo(target) {
+        await closeCurrent({ discardIfEmpty: true });
+        const known = target.provider in allProviders(deps.settings) || deps.clients !== undefined;
+        const keyed = deps.clients !== undefined || Boolean(deps.env[allProviders(deps.settings)[target.provider]?.keyEnv ?? ""]);
+        const next = known && keyed && deps.settings.provider === undefined ? { ...choice, provider: target.provider, model: target.model } : choice;
+        transcript.reset();
+        await open(target, next);
+        const entries = await requireSession().agent.log.branch();
+        replayLog(transcript, entries);
+        notice("info", `Resumed ${sessionLabel(meta ?? target)} (${target.id.slice(0, 8)}).`);
+    }
+    async function refreshContext() {
+        if (!session)
+            return;
+        const status = await session.agent.context();
+        contextPercent = contextLeftPercent(status.free, status.window);
+    }
+    // ---------- running ----------
+    async function runInput(input, options) {
+        const active = requireSession();
+        let next = input;
+        let outcome;
+        for (;;) {
+            outcome = await driver.run(active.agent, next, options?.compact ? { compact: true } : undefined);
+            reportEnd(outcome.result);
+            await refreshContext();
+            if (outcome.leftover.length === 0 || outcome.result.reason !== "done")
+                break;
+            next = outcome.leftover.map((item) => item.text).join("\n\n");
+            options = undefined;
+        }
+        if (meta)
+            meta = await store.update(meta.id, {});
+        return outcome.result;
+    }
+    function reportEnd(result) {
+        if (result.reason === "error")
+            notice("error", `The run failed: ${result.error ?? "unknown error"}`);
+        else if (result.reason === "paused" && result.pause === "approval")
+            notice("warn", "The run was paused because too many actions were refused. Send a message to continue.");
+    }
+    // Between "a prompt was submitted" and "the driver is working" there are a few awaits; a second line typed in that
+    // moment must wait for the run to exist, or it would start a second run.
+    let launching;
+    async function startPrompt(text) {
+        let ready;
+        launching = new Promise((resolve) => (ready = resolve));
+        try {
+            if (meta && meta.title === undefined)
+                meta = await store.update(meta.id, { title: titleFromPrompt(text) });
+            const mentions = await expandMentions(text, deps.cwd, deps.home);
+            const images = [...firstImages.splice(0), ...mentions.images];
+            const body = mentions.text;
+            const running = runInput(images.length === 0 ? body : [{ type: "text", text: body }, ...images.map((path) => ({ type: "image", mediaType: imageMediaType(path) ?? "image/png", ref: path }))]);
+            // driver.run marks the driver as working before its first await
+            launching = undefined;
+            ready();
+            return await running;
+        }
+        finally {
+            launching = undefined;
+            ready();
+        }
+    }
+    async function runShellForUser(command) {
+        const result = await shell(command, deps.cwd);
+        const { lines, hidden } = excerpt(result.output, 40);
+        transcript.add({ kind: "shell", command, output: lines, hidden, exitCode: result.exitCode });
+    }
+    // ---------- the commands ----------
+    const host = {
+        print: (markdown) => transcript.add({ kind: "info", markdown }),
+        fail: (text) => notice("error", text),
+        help: helpMarkdown,
+        async status() {
+            const active = requireSession();
+            return statusReport({
+                sessionId: meta?.id ?? "?",
+                sessionFile: store.sessionFile(meta?.id ?? "?"),
+                cwd: deps.cwd,
+                provider: active.provider,
+                model: active.model,
+                thinking: active.thinking,
+                permissions: active.permissions,
+                redaction: active.redaction,
+                context: await active.agent.context(),
+                usage: await active.agent.usage(),
+                medianHitRate: medianReplyHitRate(await active.agent.log.branch()),
+                goal: await active.agent.goal(),
+                working: driver.working,
+                idleCompaction: deps.settings.autoCompactIdle ? `after ${deps.settings.cacheTtlMinutes} min idle, from ${deps.settings.autoCompactMinTokens.toLocaleString("en-US")} tokens` : "off",
+            });
+        },
+        models: () => modelsReport(listProviders(deps.settings, deps.env), { provider: choice.provider, model: choice.model ?? "" }),
+        async switchModel(provider, model) {
+            if (provider === undefined)
+                return;
+            if (!(provider in allProviders(deps.settings)))
+                return notice("error", `Unknown provider "${provider}". Known: ${Object.keys(allProviders(deps.settings)).join(", ")}.`);
+            if (await reopen({ provider, model }))
+                notice("info", `Now using ${choice.model} via ${choice.provider}. The conversation continues.`);
+        },
+        async permissions(name) {
+            if (name === undefined)
+                return host.print(permissionsReport(choice.permissions, choice.redaction));
+            if (!isPermissionName(name))
+                return notice("error", `Unknown preset "${name}". Use auto, read-only, strict or full-access.`);
+            if (await reopen({ permissions: name }))
+                notice("info", `Permissions: ${name}.`);
+        },
+        async redaction(value) {
+            if (value === undefined)
+                return host.print(`Redaction is **${choice.redaction ? "on" : "off"}**. Use \`/redaction on\` or \`/redaction off\`.`);
+            if (await reopen({ redaction: value === "on" }))
+                notice("info", `Redaction is ${value}.`);
+        },
+        async compact() {
+            let compacted = false;
+            const stop = driver.onEvent((event) => {
+                if (event.type === "compaction")
+                    compacted = true;
+            });
+            const result = await runInput(undefined, { compact: true });
+            stop();
+            if (result.reason === "done" && !compacted)
+                notice("info", "Nothing worth summarising yet.");
+        },
+        async newSession() {
+            await closeCurrent({ discardIfEmpty: true });
+            transcript.reset();
+            await startFresh();
+            notice("info", `New session ${meta?.id.slice(0, 8)}.`);
+        },
+        async clearScreen() {
+            surface.clearScreen();
+            await host.newSession();
+        },
+        async resume(reference) {
+            let target;
+            if (reference === undefined) {
+                const all = (await store.list()).filter((item) => item.title !== undefined && item.id !== meta?.id);
+                if (all.length === 0)
+                    return notice("info", "There are no earlier sessions to resume.");
+                target = await surface.pickSession(all);
+                if (!target)
+                    return;
+            }
+            else {
+                target = await store.find(reference, reference === "last" ? { cwd: deps.cwd } : {});
+                if (!target && reference === "last")
+                    target = (await store.list()).find((item) => item.title !== undefined && item.id !== meta?.id);
+                if (!target)
+                    return notice("error", `No session matches "${reference}".`);
+            }
+            await switchTo(target);
+        },
+        async fork() {
+            const active = requireSession();
+            if (!meta || meta.title === undefined)
+                return notice("info", "There is nothing to fork yet.");
+            const child = await store.create({ cwd: deps.cwd, provider: choice.provider, model: choice.model ?? "", parentId: meta.id });
+            await active.agent.fork(store.sessionFile(child.id));
+            await store.update(child.id, { title: `fork: ${meta.title}` });
+            const forked = (await store.get(child.id));
+            await closeCurrent({ discardIfEmpty: false });
+            await open(forked, choice);
+            notice("info", `Forked into session ${forked.id.slice(0, 8)}. The original session is unchanged.`);
+        },
+        async undo() {
+            const active = requireSession();
+            const entries = await active.agent.log.branch();
+            const index = entries.findLastIndex((entry) => entry.type === "message" && entry.message.role === "user");
+            const entry = entries[index];
+            if (!entry || entry.type !== "message")
+                return notice("info", "There is no message to undo.");
+            active.agent.rewindTo(entry.parentId);
+            const text = entry.message.content.flatMap((part) => (part.type === "text" ? [part.text] : [])).join("");
+            notice("info", "Went back to before your last message. It is in the prompt; edit it and send it again.");
+            surface.prefill(text);
+            await refreshContext();
+        },
+        async rename(title) {
+            if (!meta)
+                return;
+            meta = await store.update(meta.id, { title });
+            notice("info", `Session renamed to "${title}".`);
+        },
+        runPrompt(prompt) {
+            void startPrompt(prompt).catch((error) => notice("error", error.message));
+        },
+        async diff() {
+            const result = await shell(DIFF_COMMAND, deps.cwd);
+            const body = result.output.trim();
+            host.print(body === "" ? "No uncommitted changes." : ["````diff", body.length > 20_000 ? `${body.slice(0, 20_000)}\n… (cut)` : body, "````"].join("\n"));
+        },
+        async goal(argument) {
+            const active = requireSession();
+            if (argument === undefined) {
+                const goal = await active.agent.goal();
+                return host.print(goal ? `Goal (${goal.status}): ${goal.objective}` : "No goal is set. Use `/goal <objective>`.");
+            }
+            if (argument === "clear") {
+                await active.agent.clearGoal();
+                return notice("info", "Goal cleared.");
+            }
+            await active.agent.setGoal({ objective: argument });
+            notice("info", "Goal set. Working on it now; it is checked before the agent may stop.");
+            await startPrompt(argument);
+        },
+        mcp: () => mcpReport(requireSession().agent.mcp),
+        exit: () => surface.exit(),
+    };
+    // ---------- the public side ----------
+    async function dispatchSlash(name, args) {
+        const command = findCommand(name);
+        if (!command)
+            return notice("error", `Unknown command /${name}. Type /help for the list.`);
+        if (driver.working && !command.duringRun)
+            return notice("warn", `/${command.name} cannot be used while the agent is working. Press Esc to cancel the run first.`);
+        try {
+            await command.run(args, host);
+        }
+        catch (error) {
+            notice("error", `/${command.name} failed: ${error.message}`);
+        }
+        surface.changed();
+    }
+    return {
+        driver,
+        async start(options = {}) {
+            if (options.resume !== undefined) {
+                const target = await store.find(options.resume, options.resume === "last" ? { cwd: deps.cwd } : {});
+                const found = target ?? (options.resume === "last" ? (await store.list())[0] : undefined);
+                if (!found)
+                    throw new Error(`No session matches "${options.resume}".`);
+                await switchTo(found);
+            }
+            else
+                await startFresh();
+        },
+        async submit(raw, mode = "steer") {
+            const text = raw.trim();
+            if (text === "")
+                return;
+            const slash = parseSlash(text);
+            if (slash)
+                return dispatchSlash(slash.name, slash.args);
+            if (text.startsWith("!") && text.length > 1 && !text.startsWith("!!"))
+                return runShellForUser(text.slice(1).trim());
+            if (launching)
+                await launching;
+            if (driver.working) {
+                const mentioned = await expandMentions(text, deps.cwd, deps.home);
+                const expanded = mentioned.images.length === 0 ? mentioned.text : `${mentioned.text}\nImage files (open them with the read tool):\n${mentioned.images.map((path) => `- ${path}`).join("\n")}`;
+                if (mode === "queue")
+                    driver.queue(expanded);
+                else
+                    driver.steer(expanded);
+                return;
+            }
+            await startPrompt(text);
+        },
+        runPrompt: (text) => startPrompt(text),
+        cancel: () => driver.cancel(),
+        async compactIdle(minTokens, idleMinutes) {
+            if (!session || driver.working)
+                return false;
+            const before = (await session.agent.context()).tokens;
+            if (before < Math.max(MIN_COMPACT_TOKENS, minTokens))
+                return false;
+            let compacted = false;
+            const stop = driver.onEvent((event) => {
+                if (event.type === "compaction")
+                    compacted = true;
+            });
+            transcript.muteCompaction(true);
+            try {
+                const result = await runInput(undefined, { compact: true });
+                if (result.reason !== "done" || !compacted)
+                    return false;
+            }
+            finally {
+                transcript.muteCompaction(false);
+                stop();
+            }
+            const after = (await requireSession().agent.context()).tokens;
+            notice("info", `compacted after ${idleMinutes} min idle, ${thousands(before)} to ${thousands(after)} tokens`);
+            return true;
+        },
+        statusInfo: () => ({
+            provider: choice.provider,
+            model: choice.model ?? "",
+            thinking: session?.thinking,
+            cwd: deps.cwd,
+            home: deps.home,
+            contextLeftPercent: contextPercent,
+            permissions: choice.permissions,
+            redaction: choice.redaction,
+            working: driver.working,
+            queued: driver.pending().length,
+        }),
+        pending: () => driver.pending(),
+        current: () => session,
+        currentMeta: () => meta,
+        async close() {
+            await closeCurrent({ discardIfEmpty: true });
+        },
+    };
+}