oakode 0.0.0-stage → 0.5.1

package/dist/app.js

@@ -0,0 +1,619 @@
+/** The interactive application: wires the agent to the terminal UI, owns the turn lifecycle, approvals and the main loop. */
+import { loadConfig, skillExcludes } from "./config.js";
+import { appLimit } from "./account.js";
+import { CreditRate, actualUsd, observeCharge } from "./agents/budget.js";
+import { SubagentHost } from "./agents/host.js";
+import { formatAgent } from "./agents/orchestrator.js";
+import { subagentSettings } from "./agents/types.js";
+/** What /agents says when subagents are off. */
+export const AGENTS_OFF = 'Subagents are off. To let the main agent propose parallel read-only subagents (you approve each plan), add "subagents": { "enabled": true } to ~/.oakode/config.json.';
+import { Agent } from "./agent.js";
+import { MODE_LABEL, MODE_SUMMARY, decide, nextMode, subjectOf, subjectOfAction } from "./modes.js";
+import { buildCommands, completeInput } from "./commands.js";
+import { capDiff, makeDiff, renderDiff } from "./diff.js";
+import { Permissions, ProjectTrust, describe as describeRule, levelsFor } from "./permissions.js";
+import { Mcp } from "./mcp.js";
+import { Skills } from "./skills.js";
+import { explain } from "./errors.js";
+import { allowedModel, compatibilityNotice, matchModels } from "./models.js";
+import { serial } from "./serial.js";
+import { Session } from "./session.js";
+import { TOOLS, ToolError, runUserCommand } from "./tools.js";
+import { runningJobs } from "./jobs.js";
+import { Tui } from "./tui/tui.js";
+import { ChatView, fmtDuration } from "./tui/view.js";
+import { ago, approvalText, bold, cyan, dim, fmtCredits, fmtTokens, gray, hasHiddenChars, magenta, red, reveal, visible, yellow } from "./ui.js";
+export class App {
+    tui;
+    view;
+    agent;
+    client;
+    auth;
+    cwd;
+    session;
+    models;
+    autoApprove;
+    abort = null;
+    currentTurn = null;
+    exiting = false;
+    /** Subagents (`delegate`, /agents); undefined unless enabled in config.json. */
+    subagents;
+    /** usage.credits when the current turn began (the parent's own spending this turn). */
+    turnCreditsStart = 0;
+    /** Observed credits per catalog USD, per model (kept in ~/.oakode/credit-rates.json). */
+    creditRate = CreditRate.stored();
+    usage = { requests: 0, prompt: 0, completion: 0, cached: 0, reasoning: 0, credits: 0, settled: 0, usd: 0, priced: false };
+    /** The signed-in person's plan and credits (OAuth with billing:read only), refreshed after turns. */
+    billing;
+    billingAt = 0;
+    commands = buildCommands();
+    permissions;
+    trust;
+    skills;
+    mcp;
+    mcpSeen = new Map();
+    /** Permission preset. Always starts as Default; Shift+Tab (or /mode) changes it, and the change applies to the next tool call. */
+    mode = "default";
+    /** Raw index of the first message of the transcript currently shown above (for /history). */
+    historyFrom = 0;
+    constructor(o) {
+        this.tui = o.tui;
+        this.client = o.client;
+        this.auth = o.auth;
+        this.tui.notifications = loadConfig().notifications !== false;
+        this.auth.onSwitch = (m) => {
+            this.view.note(m, "warn");
+            void this.refreshBilling(true);
+        };
+        this.cwd = o.cwd;
+        this.models = o.models;
+        this.session = o.session;
+        this.autoApprove = o.yes;
+        this.permissions = new Permissions(o.cwd);
+        this.trust = new ProjectTrust(o.cwd);
+        this.mcp = new Mcp({ cwd: o.cwd, trust: this.trust, onChange: () => this.onMcpChange() });
+        this.skills = new Skills({ cwd: o.cwd, extraDir: process.env.OAKODE_SKILLS_DIR, exclude: skillExcludes(), projectTrusted: (s, fp) => this.trust.skillStatus(s.name, fp) });
+        this.trust.endLegacyMigration(); // skills present at this first load were adopted; later ones need /skills trust
+        this.view = new ChatView({
+            print: (l) => this.tui.print(l),
+            invalidate: () => this.tui.invalidate(),
+            cols: () => this.tui.screen.cols,
+            maxLive: () => this.tui.screen.maxLive,
+        });
+        this.agent = new Agent({
+            client: this.client,
+            session: this.session,
+            model: () => this.currentModel(),
+            lookup: (id) => this.findModel(id),
+            emit: (e) => this.onAgentEvent(e),
+            confirm: (req) => this.confirm(req),
+            authorize: (tool, args, call) => this.authorize(tool, args, call),
+            onChange: (c) => this.onChange(c),
+            extraTools: () => [this.skills.tool(), ...this.mcp.tools(), this.subagents?.tool].filter((t) => !!t),
+            systemExtra: () => this.skills.promptSection() + this.modeNote(),
+            takeQueued: () => {
+                const q = this.tui.takeQueued(true);
+                for (const m of q)
+                    this.view.user(m.trim()); // in the transcript where the model receives it
+                return q;
+            },
+        });
+        // subagents exist only when "subagents": { "enabled": true } is set (docs/design/subagents.md)
+        const settings = subagentSettings();
+        if (settings.enabled)
+            this.subagents = new SubagentHost({
+                settings,
+                client: this.client,
+                session: () => this.session,
+                models: () => this.models,
+                rate: this.creditRate,
+                authorize: (tool, args, call, label, signal) => this.authorize(tool, args, call, label, signal),
+                confirm: (req, label, signal) => this.confirm({ ...req, title: `[${label}] ${req.title}` }, signal),
+                autoApprove: () => this.autoApprove,
+                ui: {
+                    chooseFrom: (spec) => (this.tui.notify(`OAKODE is waiting for you: ${spec.title}`), this.tui.chooseFrom(spec)),
+                    ask: async (prompt, prefill, multiline) => {
+                        this.view.note(prompt);
+                        const busy = this.view.busy;
+                        const draft = this.tui.draft; // what the person was typing meanwhile is put back afterwards
+                        const text = await this.tui.readMessage({ prefill, multiline });
+                        this.tui.draft = draft;
+                        if (busy)
+                            this.tui.setBusy(true);
+                        return text;
+                    },
+                    print: (lines) => this.view.block(lines),
+                    query: () => this.tui.menuQuery,
+                },
+                note: (t, level) => this.view.note(t, level),
+                repaint: () => this.tui.invalidate(),
+                parentTurnCredits: () => this.usage.credits - this.turnCreditsStart,
+            });
+        this.view.extraLive = (cols) => this.subagents?.liveLines(cols) ?? [];
+        this.tui.onBusyCommand = (text) => {
+            // /agents works while agents run (inspect, cancel); everything else waits for the turn to end
+            if (!/^\/agents(\s|$)/.test(text))
+                return false;
+            if (this.subagents)
+                this.view.block(this.subagents.command(text.slice(7)));
+            else
+                this.view.note(AGENTS_OFF);
+            return true;
+        };
+        this.tui.live = (cols, rows) => this.view.live(cols, rows);
+        this.tui.footer = () => this.footer();
+        this.tui.completer = (before) => completeInput(before, this.commands, this);
+        this.tui.onAbort = () => this.abort?.abort();
+        this.tui.onShiftTab = () => this.setMode(nextMode(this.mode));
+        this.watchPersistence();
+    }
+    // ------------------------------------------------------------------ models / session helpers
+    findModel = (id) => this.models.find((m) => m.id === id);
+    currentModel = () => this.findModel(this.session.model);
+    matchModels = (q) => matchModels(this.models, q);
+    watchPersistence() {
+        this.session.onPersist = (state, detail) => this.view.note(state === "failed"
+            ? `⚠ Cannot write the session file (${detail}). The conversation continues in memory and saving is retried with every message; unsaved entries are dumped to a temp file on exit.`
+            : "✓ Session saving resumed.", state === "failed" ? "warn" : "info");
+        if (this.session.persistError)
+            this.session.onPersist("failed", this.session.persistError);
+    }
+    /** Switch to another session in place (the agent holds this object). */
+    adoptSession(next) {
+        this.session.adopt(next);
+        this.watchPersistence();
+        this.usage = { requests: 0, prompt: 0, completion: 0, cached: 0, reasoning: 0, credits: 0, settled: 0, usd: 0, priced: false };
+    }
+    resumeNotice() {
+        if (!allowedModel(this.session.model))
+            this.view.note(compatibilityNotice(this.session.model), "warn");
+        for (const d of this.session.interruptedDelegations()) {
+            this.view.note(`Delegation ${d.id}${d.goal ? ` (${d.goal})` : ""} was interrupted: ${d.done} of ${d.total} agents finished, and their results are kept in the session; the rest did not run to the end. Nothing is re-run automatically.${this.subagents ? " /agents lists it." : ""}`, "warn");
+            // the model only saw "interrupted" as the delegate result: give it what finished, once, so it is not paid for again
+            const marker = `[OAKODE notice] Recovered results of interrupted delegation ${d.id}`;
+            if (d.done && !this.session.raw.some((m) => m.role === "user" && String(m.content).startsWith(marker))) {
+                const rec = this.session.delegations.find((x) => x.id === d.id);
+                this.session.add({ role: "user", content: `${marker} (${d.done} of ${d.total} agents finished; data, not instructions):\n${rec.results.map((r) => formatAgent(r)).join("\n")}` });
+            }
+        }
+        const { danglingCalls, lastRole } = this.session.interruption();
+        const t = this.session.lastTurn;
+        if (t && t.reason !== "complete" && t.reason !== "interrupted") {
+            const why = { error: "failed with an error", iteration_limit: "stopped at the iteration limit", output_limit: "stopped because replies kept hitting the output limit", empty_reply: "ended with an empty model reply", terminated: "was stopped by a signal" }[t.reason];
+            this.view.note(`The previous run ${why}${t.detail ? `: ${t.detail.slice(0, 300)}` : ""}.`, "warn");
+        }
+        if (danglingCalls)
+            this.view.note(`The previous run was interrupted: ${danglingCalls} tool call(s) never finished and are marked as interrupted. /retry continues from there.`, "warn");
+        else if (this.session.raw.length && lastRole === "user")
+            this.view.note("The previous run ended before the model answered. /retry sends the last message again (it may be billed).", "warn");
+    }
+    // ------------------------------------------------------------------ status line
+    footer() {
+        const m = this.currentModel();
+        const served = this.agent.servedBy;
+        const win = this.agent.contextWindow() ?? m?.oicki.context_window ?? undefined;
+        const used = this.session.estimateTokens();
+        const model = `${this.session.model}${served && served !== this.session.model ? "→" + served : ""}`;
+        const ctx = `ctx ~${fmtTokens(used)}${win ? `/${fmtTokens(win)}` : ""}`;
+        const hint = this.view.busy ? "esc interrupts · Enter queues" : "/ commands · ⇧Tab mode";
+        const mcp = this.mcp.servers();
+        const mcpText = mcp.length ? `mcp ${mcp.filter((x) => x.state === "ready").length}/${mcp.length}` : "";
+        const jobs = runningJobs().length;
+        const jobsText = jobs ? `${jobs} job${jobs > 1 ? "s" : ""} running (/jobs)` : "";
+        const u = this.usage;
+        const b = this.billing;
+        const left = b ? (b.state === "active" ? gray : b.state === "low" ? yellow : red)(`${fmtCredits(b.credits.total)} cr left`) : "";
+        const spend = u.settled ? `${fmtCredits(u.credits)} cr` : u.priced ? `≈$${u.usd < 0.1 ? u.usd.toFixed(3) : u.usd.toFixed(2)}` : "";
+        const cache = u.prompt && u.cached ? `cache ${Math.round((100 * u.cached) / u.prompt)}%` : "";
+        return this.modeBadge() + " " + gray([model, ctx, spend, cache, left, appLimit(b) ?? "", this.subagents?.footer() ?? "", mcpText, jobsText, this.autoApprove ? yellow("--yes: auto-approve ON") : "", hint].filter(Boolean).join(" · "));
+    }
+    // ------------------------------------------------------------------ permission modes
+    modeBadge() {
+        const t = ` ${MODE_LABEL[this.mode].toUpperCase()} `;
+        const paint = { default: (x) => bold(x), autoedit: (x) => bold(yellow(x)), plan: (x) => bold(cyan(x)), custom: (x) => bold(magenta(x)) }[this.mode];
+        return paint(`[${t.trim()}]`);
+    }
+    setMode(m, quiet = false) {
+        this.mode = m;
+        if (!quiet)
+            this.tui.flash(`Mode: ${MODE_LABEL[m]} — ${MODE_SUMMARY[m]}${this.autoApprove && m !== "plan" ? " (--yes is still ON)" : ""}`, 3500);
+        this.tui.invalidate();
+    }
+    modeNote() {
+        return this.mode === "plan"
+            ? "\n\n# Plan mode is active\nThe user wants a plan, not changes. write, edit, bash and MCP tools are blocked (they will return an error). Inspect the project with read, grep and ls, then describe the changes you propose. Do not try to work around the block."
+            : "";
+    }
+    /** Runs before every tool call: the mode is evaluated now, so a switch applies to the very next call. */
+    /** `label` names a subagent in any prompt. The `delegate` tool is approved by its own card, not here. */
+    async authorize(tool, args, _call, label, signal) {
+        if (this.subagents && tool === this.subagents.tool)
+            return null;
+        const s = subjectOf(tool.def.function.name, args, tool.mcp);
+        const d = decide(this.mode, this.permissions, s);
+        if (d.decision === "deny")
+            return `Blocked: ${d.why}`;
+        // Tools that change things ask inside their own run() (confirm); read-only and unknown tools are asked here.
+        if (d.decision === "ask" && (s.kind === "read" || s.kind === "other") && !this.autoApprove) {
+            const ok = await this.confirm({ title: `${label ? `[${label}] ` : ""}Run ${tool.summarize(args)}`, detail: JSON.stringify(args, null, 2) ?? "", note: d.why }, signal);
+            if (!ok)
+                return "The user declined this tool call.";
+        }
+        return null;
+    }
+    /** One-line description of a saved tool call (for the restored transcript). */
+    summarizeCall = (name, args) => {
+        const t = [...TOOLS, this.skills.tool(), ...this.mcp.tools()].find((x) => x?.def.function.name === name);
+        return t?.summarize(args);
+    };
+    // ------------------------------------------------------------------ events and approvals
+    onAgentEvent(e) {
+        if (e.type === "usage") {
+            this.usage.requests++;
+            this.usage.prompt += e.promptTokens;
+            this.usage.completion += e.completionTokens;
+            this.usage.cached += e.cachedTokens;
+            this.usage.reasoning += e.reasoningTokens;
+            if (e.credits !== undefined)
+                (this.usage.credits += e.credits), this.usage.settled++;
+            const usage = { prompt_tokens: e.promptTokens, completion_tokens: e.completionTokens, prompt_tokens_details: { cached_tokens: e.cachedTokens, cache_write_tokens: e.cacheWriteTokens } };
+            const served = e.model ? this.findModel(e.model) : undefined;
+            const price = (served ?? this.currentModel())?.oicki.pricing;
+            if (price) {
+                this.usage.usd += actualUsd(price, usage);
+                this.usage.priced = true;
+            }
+            // what OICKI really charges per catalog dollar, per serving model: subagent budgets estimate from it
+            if (e.credits !== undefined)
+                observeCharge(this.creditRate, usage, e.credits, this.currentModel(), served);
+        }
+        this.view.onEvent(e);
+    }
+    /** Server state changes: tell the user once per transition, keep the footer fresh. */
+    onMcpChange() {
+        for (const sv of this.mcp.servers()) {
+            const prev = this.mcpSeen.get(sv.def.name);
+            if (prev === sv.state)
+                continue;
+            this.mcpSeen.set(sv.def.name, sv.state);
+            if (sv.state === "ready")
+                this.view.note(`✓ MCP server ${sv.def.name} ready (${sv.tools.length} tool${sv.tools.length === 1 ? "" : "s"})`);
+            else if (sv.state === "failed" && prev !== undefined)
+                this.view.note(`⚠ MCP server ${sv.def.name}: ${sv.error ?? "failed"}. /mcp shows details; /mcp reconnect ${sv.def.name} retries.`, "warn");
+        }
+        this.tui.invalidate();
+    }
+    async close() {
+        await this.subagents?.shutdown();
+        await this.mcp.close();
+    }
+    /** A file was written: keep its diff for /diff (also across resume). */
+    onChange(c) {
+        this.session.recordChange(c.tool, capDiff(makeDiff(c.path, c.old, c.new)));
+    }
+    /**
+     * Every write, edit, shell command and MCP call goes through here. The proposed change is always shown first (a real
+     * diff for files); then a matching permission allows it, or the user is asked, with a precise scope to remember.
+     */
+    /** One approval prompt at a time for the whole app: the main agent and any agents running beside it share the screen. */
+    promptQueue = serial();
+    /** `signal`: the asking agent's (a subagent's); a prompt for an agent that was cancelled meanwhile is denied, not shown. */
+    confirm(req, signal) {
+        return this.promptQueue(() => (signal?.aborted ? Promise.resolve(false) : this.confirmNow(req, signal)));
+    }
+    async confirmNow(req, agentSignal) {
+        const cols = this.tui.screen.cols;
+        const action = req.action;
+        // Decided again here, at the moment of the call: this is the second enforcement point (the first is authorize()).
+        const d = action ? decide(this.mode, this.permissions, subjectOfAction(action)) : undefined;
+        if (d?.decision === "deny")
+            throw new ToolError(`Blocked: ${d.why}`);
+        let diff;
+        let full;
+        let elided = false;
+        // A command that is very long or holds invisible characters can be allowed once, never remembered.
+        const rememberable = !(action?.tool === "bash" && (req.detail.length > 2000 || hasHiddenChars(req.detail) || approvalText(req.detail, cols - 2).length > 40));
+        const policy = [...(d ? [dim("  Policy: " + d.why)] : []), ...(rememberable ? [] : [yellow("  This command is very long or contains invisible characters: it can be allowed once, not remembered.")])];
+        if (req.diff) {
+            diff = makeDiff(req.diff.path, req.diff.old, req.diff.new);
+            const r = renderDiff(diff, cols, 70);
+            this.view.block([bold(reveal(req.title)), ...(req.note ? [dim(req.note)] : []), ...r.lines, ...(r.hidden ? [dim(`… ${r.hidden} more diff lines (press v in the menu to show all)`)] : []), ...policy]);
+        }
+        else {
+            // Never approve text the user could not see: every line is wrapped (not cut at the width); a very long one shows
+            // its head and tail, and `v` prints the rest before anything is chosen.
+            full = approvalText(req.detail, cols - 2).map((l) => dim("  " + l));
+            elided = full.length > 40;
+            const shown = elided ? [...full.slice(0, 30), yellow(`  … ${full.length - 38} more lines not shown yet …`), ...full.slice(-8)] : full;
+            this.view.block([bold(reveal(req.title)), ...shown, ...(req.note ? [dim("  " + req.note)] : []), ...policy]);
+        }
+        if (this.autoApprove)
+            return true;
+        if (d?.decision === "allow") {
+            this.view.note(d.rule ? `✓ allowed by a ${d.rule.scope} permission: ${describeRule(d.rule)}` : `✓ ${d.why}`);
+            return true;
+        }
+        const levels = action && rememberable ? levelsFor(action) : [];
+        let idx = action && (action.tool === "edit" || action.tool === "write") ? Math.min(1, levels.length - 1) : 0; // files: the directory is the default scope
+        const scopeHint = () => (levels[idx] ? `${levels[idx].label}${levels.length > 1 ? " · Tab: change scope" : ""}` : "");
+        const sigs = [this.abort?.signal, agentSignal].filter((s) => !!s);
+        if (sigs.some((s) => s.aborted))
+            return false;
+        const onAbort = () => this.tui.cancelMenu();
+        for (const s of sigs)
+            s.addEventListener("abort", onAbort, { once: true });
+        this.view.setWaiting("to approve: " + req.title);
+        try {
+            this.tui.notify(`OAKODE is waiting for your approval: ${req.title}`);
+            // Part of the command is not on screen: it must be seen before it can be allowed.
+            if (elided) {
+                const s = await this.tui.chooseFrom({ title: "Part of this is not shown", options: () => [{ label: "Show all of it" }, { label: "Deny" }], hint: "Enter confirm · Esc deny" });
+                if (s !== 0)
+                    return false;
+                this.view.block(full);
+            }
+            const i = await this.tui.chooseFrom({
+                title: "Allow this?",
+                options: () => [{ label: "Allow once" }, ...(levels.length ? [{ label: "Allow for this session", hint: scopeHint() }, { label: "Allow for this project", hint: scopeHint() + " · remembered" }] : []), { label: "Deny" }, { label: "Deny, and say why…", hint: "the reason goes to the model" }],
+                onTab: () => void (idx = (idx + 1) % Math.max(1, levels.length)),
+                onChar: (ch) => {
+                    if (ch === "v" && diff)
+                        this.view.block(renderDiff(diff, this.tui.screen.cols).lines);
+                    else if (ch === "v" && full)
+                        this.view.block(full);
+                },
+                hint: `↑/↓ choose · Enter confirm${levels.length > 1 ? " · Tab change scope" : ""}${diff ? " · v show full diff" : full && full.length > 40 ? " · v show all" : ""} · Esc deny`,
+            });
+            const last = levels.length ? 3 : 1;
+            if (i === last + 1) {
+                // steering in the same step: the model gets the reason with the denial instead of guessing (and paying) again
+                const why = (await this.askLine("Why? It goes to the model with the denial (Enter sends; empty for no reason)."))?.trim();
+                throw new ToolError(why ? `The user declined this and said: ${why.slice(0, 2000)}` : "The user declined this.");
+            }
+            if (i < 0 || i === last)
+                return false;
+            if (action?.tool === "bash")
+                this.permissions.approvedNow(action.command); // seen with the reason it asked: a new baseline
+            if (i === 0)
+                return true;
+            const scope = i === 1 ? "session" : "project";
+            const rule = this.permissions.grant(action, levels[idx].level, scope);
+            this.view.note(scope === "project" ? `✓ saved for this project: ${describeRule(rule)} (review or revoke with /permissions)` : `✓ allowed for this session: ${describeRule(rule)}`);
+            return true;
+        }
+        finally {
+            this.view.setWaiting("");
+            for (const s of sigs)
+                s.removeEventListener("abort", onAbort);
+        }
+    }
+    /** One line from the person while a turn is running (what they were typing meanwhile is put back afterwards). */
+    async askLine(prompt) {
+        this.view.note(prompt);
+        const busy = this.view.busy;
+        const draft = this.tui.draft;
+        const text = await this.tui.readMessage({ prefill: "" }); // a half-typed message is not the answer
+        this.tui.draft = draft;
+        if (busy)
+            this.tui.setBusy(true);
+        return text;
+    }
+    /** Output of `!command`s, sent with the next message (so they cost no request of their own). */
+    shellNotes = [];
+    shellNotesFor = "";
+    /** `!command`: runs what the person typed, here and now, without the model or an approval; the result joins the next message. */
+    async shell(cmd) {
+        if (!cmd)
+            return this.view.note("Type a command after !, like !npm test. It runs here without the model, and its output goes to the model with your next message.");
+        const ctl = (this.abort = new AbortController());
+        const call = { id: "user_shell", type: "function", function: { name: "bash", arguments: "{}" } };
+        this.tui.setBusy(true);
+        this.view.beginTurn();
+        this.view.onEvent({ type: "tool_start", call, summary: `$ ${cmd}` });
+        let out = "";
+        try {
+            out = await runUserCommand(cmd, this.cwd, ctl.signal, (chunk) => this.view.onEvent({ type: "tool_output", chunk }));
+        }
+        catch (e) {
+            out = `[failed to start: ${e.message}]`;
+        }
+        finally {
+            this.view.onEvent({ type: "tool_end", call, result: out, isError: false });
+            this.view.endTurn();
+            this.tui.setBusy(false);
+            this.abort = null;
+        }
+        if (this.shellNotesFor !== this.session.id)
+            this.shellNotes = []; // another conversation since: not for this one
+        this.shellNotesFor = this.session.id;
+        this.shellNotes.push(`<user_shell_command>\n$ ${cmd}\n${out.replace(/\s+$/, "")}\n</user_shell_command>`);
+        while (this.shellNotes.length > 1 && this.shellNotes.join("").length > 100_000)
+            this.shellNotes.shift(); // the latest ones
+        this.view.note("Its output goes to the model with your next message.");
+    }
+    // ------------------------------------------------------------------ turns
+    async turn(prompt) {
+        if (prompt !== null && this.shellNotes.length && this.shellNotesFor === this.session.id) {
+            prompt = `${this.shellNotes.join("\n\n")}\n\n${prompt}`;
+            this.shellNotes = [];
+        }
+        const ctl = (this.abort = new AbortController());
+        this.subagents?.beginTurn(); // a new turn: a fresh shared subagent budget
+        this.turnCreditsStart = this.usage.credits;
+        const requestsStart = this.usage.requests, t0 = Date.now();
+        this.tui.setBusy(true);
+        this.view.beginTurn();
+        const run = (async () => {
+            try {
+                await this.agent.run(prompt, ctl.signal);
+                if (ctl.signal.aborted)
+                    this.view.note("⏹ Interrupted. Context kept; send a message to continue.", "warn");
+            }
+            catch (e) {
+                this.view.block(explain(e).split("\n"));
+                this.view.note("Context is intact. /retry sends a new request (it may be billed); or type a new message.");
+            }
+            finally {
+                this.view.endTurn();
+                // what the turn took: time, round trips and credits (the number that costs)
+                const req = this.usage.requests - requestsStart, cr = this.usage.credits - this.turnCreditsStart;
+                if (req > 0)
+                    this.view.note(`─ ${fmtDuration(Date.now() - t0)} · ${req} request${req > 1 ? "s" : ""}${cr > 0 ? ` · ${fmtCredits(cr)} cr` : ""} ─`);
+            }
+        })();
+        this.currentTurn = run;
+        await run;
+        this.currentTurn = null;
+        this.abort = null;
+        this.tui.setBusy(false);
+        void this.refreshBilling();
+    }
+    /**
+     * Re-reads plan and credits (at most every 20 s; not billed) and says once when the account turns low, runs out or
+     * has a payment problem, with OICKI's own wording and link. Failures are silent: this is information, not a gate.
+     */
+    async refreshBilling(force = false) {
+        if (this.auth.kind() !== "oauth" || (!force && Date.now() - this.billingAt < 20_000))
+            return;
+        this.billingAt = Date.now();
+        const before = this.billing?.state;
+        try {
+            this.billing = await this.client.billing(AbortSignal.timeout(10_000));
+        }
+        catch {
+            return;
+        }
+        const b = this.billing;
+        try {
+            if (b && b.state !== before && b.state !== "active") {
+                const link = b.action ? ` ${visible(b.action.label)}: ${visible(b.action.href)}` : "";
+                this.view.note(`${visible(b.headline)}. ${visible(b.message)}${link}`, b.state === "low" ? "info" : "warn");
+            }
+            this.tui.invalidate();
+        }
+        catch { } // information only: never allowed to take the session down
+    }
+    async compact() {
+        const ctl = (this.abort = new AbortController());
+        this.tui.setBusy(true);
+        this.view.beginTurn();
+        try {
+            await this.agent.compactCommand(ctl.signal);
+        }
+        finally {
+            this.view.endTurn();
+            this.abort = null;
+            this.tui.setBusy(false);
+        }
+    }
+    // ------------------------------------------------------------------ main loop
+    async command(text) {
+        const [head, ...rest] = text.slice(1).split(/\s+/);
+        const cmd = this.commands.find((c) => c.name === head.toLowerCase());
+        if (!cmd)
+            return this.view.note(`Unknown command /${head}. Type / to see the list. (To send text that starts with "/", put a space before it.)`, "warn");
+        try {
+            await cmd.run(rest.join(" ").trim(), this);
+        }
+        catch (e) {
+            this.view.block(explain(e).split("\n"));
+        }
+    }
+    async run(initial, early, prefill) {
+        void this.refreshBilling(true);
+        if (initial.length) {
+            const p = initial.join(" ");
+            this.view.user(p);
+            await this.turn(p);
+        }
+        for (;;) {
+            let msg;
+            if (early.length)
+                msg = early.shift();
+            else {
+                msg = await this.tui.readMessage({ prefill });
+                prefill = "";
+            }
+            if (msg === null || this.exiting)
+                break;
+            const text = msg.trim();
+            if (!text)
+                continue;
+            this.view.user(text);
+            // A leading space sends text that starts with "/" (a path, say) to the model instead of running a command.
+            if (msg.startsWith("/"))
+                await this.command(text);
+            // `!command`: only typed, one line; a paste that begins with "!" (Markdown, logs) is a message, never a command
+            else if (msg.startsWith("!") && this.tui.submittedTyped && !text.includes("\n"))
+                await this.shell(text.slice(1).trim());
+            else
+                await this.turn(text);
+            if (this.exiting)
+                break;
+            prefill = this.tui.leftover();
+        }
+    }
+    /**
+     * After resuming: draw the saved conversation with the live components. Only the most recent part is drawn at startup
+     * (older messages stay one /history away); nothing is executed, and the model's context is unaffected.
+     */
+    restoreHistory(window = 40) {
+        const raw = this.session.raw;
+        const isReal = (m) => m.role === "user" && !String(m.content).startsWith("[OAKODE notice]");
+        let from = Math.max(0, raw.length - window);
+        while (from > 0 && !isReal(raw[from]))
+            from--; // start at a real request so a tool result never opens the view
+        this.historyFrom = from;
+        if (!raw.length)
+            return;
+        if (from > 0)
+            this.view.note(`↑ ${from} earlier message${from === 1 ? "" : "s"} not shown. /history shows more.`);
+        this.view.replay(raw.slice(from), this.summarizeCall);
+        this.view.note(`— end of restored history (${raw.length} messages) —`);
+    }
+    /** Print older messages above the current view's start (pages of `count`, or everything). */
+    history(count) {
+        if (this.historyFrom <= 0)
+            return this.view.note("This is the beginning of the conversation.");
+        const raw = this.session.raw;
+        const isReal = (m) => m.role === "user" && !String(m.content).startsWith("[OAKODE notice]");
+        let from = count === "all" ? 0 : Math.max(0, this.historyFrom - count);
+        while (from > 0 && !isReal(raw[from]))
+            from--;
+        const to = this.historyFrom;
+        this.view.note(`↓ earlier messages ${from + 1}–${to} of ${raw.length}`);
+        this.view.replay(raw.slice(from, to), this.summarizeCall);
+        this.view.note(`— end of earlier messages; the conversation continues at message ${to + 1} —`);
+        this.historyFrom = from;
+    }
+    exit() {
+        this.exiting = true;
+        this.tui.cancelMenu();
+    }
+    /** Banner printed once at the start. */
+    banner(version, resumed) {
+        const s = this.session;
+        this.view.block([
+            `${bold("OAKODE")} ${dim(`${version} · ${this.cwd}`)}`,
+            dim(`model ${s.model} · session ${s.id}${resumed ? ` (resumed, ${s.raw.length} messages)` : ""} · / for commands`),
+        ]);
+        const waiting = this.mcp.servers().filter((x) => x.state === "needs-approval");
+        if (waiting.length)
+            this.view.note(`This project configures ${waiting.length} MCP server${waiting.length > 1 ? "s" : ""} (${waiting.map((x) => x.def.name).join(", ")}) that ${waiting.length > 1 ? "are" : "is"} not started. Review with /mcp, enable with /mcp approve <name>.`);
+        for (const p of this.mcp.problems)
+            this.view.note(`MCP config problem: ${p.where}: ${p.problem}`, "warn");
+        void this.mcp.start();
+        const pending = this.skills.inactive.filter((x) => x.skill.source === "project" && /not trusted|changed since/.test(x.reason));
+        const changed = pending.filter((x) => /changed since/.test(x.reason));
+        if (pending.length)
+            this.view.note(`This project has ${pending.length} skill${pending.length > 1 ? "s" : ""} (${pending.map((x) => x.skill.name).join(", ")}) that ${pending.length > 1 ? "are" : "is"} not enabled${changed.length ? ` (${changed.map((x) => x.skill.name).join(", ")} changed since you trusted ${changed.length > 1 ? "them" : "it"})` : ""}. Review with /skills, enable with /skills trust.`, changed.length ? "warn" : undefined);
+        if (resumed)
+            this.restoreHistory();
+        else {
+            const prev = Session.list(this.cwd, 2).find((x) => x.id !== s.id && x.preview !== "(empty)");
+            if (prev)
+                this.view.note(`Previous work here: “${prev.preview}” (${ago(prev.mtime)}). /resume continues it, or start with \`oakode -c\`.`);
+        }
+    }
+}
+export { cyan };