@illuminis/comprism 0.1.0

package/out/commands/repl.js

@@ -0,0 +1,752 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runRepl = runRepl;
+/**
+ * The product, running.
+ *
+ * ── What changed and why ──────────────────────────────────────────────────
+ *
+ * Typing `comprism` used to print a screen and exit, so every question meant
+ * typing the program's name again. Nobody works that way, and it makes a
+ * conversation look like a series of unrelated commands when the product's
+ * whole value is the thread between them.
+ *
+ * So `comprism` STARTS. It opens a session, shows where you are, and then
+ * waits for work. You type a question and get an answer with its receipt. You
+ * type the next one and it continues the same session.
+ *
+ * A bare word is a command; anything else is work. That is the only rule a
+ * person has to hold, and it is the rule every shell already taught them.
+ *
+ *     comprism
+ *     > what is the capital of Canada?      ← work
+ *     > sessions                            ← a command
+ *     > new                                 ← a command
+ *     > exit                                ← or Ctrl-C
+ *
+ * ── A session with no key cannot do anything ──────────────────────────────
+ *
+ * Every answer is billed to the customer's own provider account, so with no key
+ * there is nothing to run. Rather than accept a prompt and refuse it, the
+ * session sends the person to `keys` first and will not start until one is
+ * stored. Being stopped early and told why beats being stopped late.
+ */
+const node_readline_1 = __importDefault(require("node:readline"));
+const connection_1 = require("../lib/connection");
+const keys_1 = require("./keys");
+const welcome_1 = require("./welcome");
+const attach = __importStar(require("../lib/attach"));
+const ui = __importStar(require("../lib/ui"));
+const voice = __importStar(require("../lib/voice"));
+const out = (s = '') => process.stdout.write(s + '\n');
+/**
+ * The session's reader, and the two calls that lend the keyboard out.
+ *
+ * Lending it out is for the handful of COMMANDS that open a reader of their own
+ * (`keys`, `model`, `workspace`). A job no longer needs it: the agent is handed
+ * this reader instead of opening a second one, so the session keeps the
+ * keyboard for the whole of its life. See `build`.
+ */
+let reader = null;
+let onLine = null;
+function releaseTerminal() {
+    reader?.close();
+    reader = null;
+}
+function takeTerminal() {
+    if (reader || !onLine)
+        return;
+    reader = node_readline_1.default.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        terminal: process.stdin.isTTY === true,
+    });
+    reader.on('line', onLine);
+    reader.on('SIGINT', () => leaveSession());
+}
+/** Set by the session so the handover can end it too. */
+let leaveSession = () => { };
+/** Words that are commands. Anything else typed is work. */
+const COMMANDS = new Set([
+    'new', 'sessions', 'model', 'providers', 'keys', 'workspace', 'status',
+    'voice', 'help', 'exit', 'quit', 'clear', 'login', 'logout', 'signout',
+    'disconnect',
+]);
+/**
+ * The line as a command, with a leading slash taken off.
+ *
+ * Every other tool in this space teaches a slash, so people type `/model` here.
+ * That used to miss the command list entirely and go to the agent as a piece of
+ * work: it answered the question and the answer was charged to the person's own
+ * provider account. A command is the same command whether or not it is
+ * announced with a slash, and a slashed word that is NOT a command is refused
+ * rather than billed.
+ */
+function commandWord(typed) {
+    const slashed = typed.startsWith('/');
+    // `comprism sessions`, typed at the comprism prompt. Everybody does it, and
+    // it used to be sent to the model as work: the agent looked around the
+    // project for something called "comprism sessions", found nothing, and asked
+    // what was meant. Reading the program's own name as part of a question is a
+    // product refusing to recognize itself.
+    const bare = (slashed ? typed.slice(1) : typed).trim().replace(/^comprism\s+/i, '');
+    return { word: bare.toLowerCase(), slashed };
+}
+/**
+ * Run a command that asks its own questions.
+ *
+ * The session holds the keyboard so it can read what is typed at its prompt. A
+ * command like `keys` opens its own reader to ask a question, and two readers
+ * on one keyboard divide the typing between them: the answer either reached the
+ * wrong reader or arrived nowhere at all and the session sat there waiting.
+ *
+ * So the session stands down for the length of the command, the command's own
+ * reader is closed behind it whatever happened, and the session picks the
+ * keyboard back up. The same handover a job gets, for the same reason.
+ */
+async function withTerminal(run) {
+    releaseTerminal();
+    try {
+        await run();
+    }
+    finally {
+        const { closePrompt } = await Promise.resolve().then(() => __importStar(require('../lib/prompt')));
+        closePrompt();
+        takeTerminal();
+    }
+}
+/**
+ * What this account has actually done, newest first.
+ *
+ * The in-memory list only ever knew about the current run, so closing the
+ * window lost every thread: a person who came back the next morning and typed
+ * `sessions` was shown one line, the session they were standing in, and had no
+ * way to pick up yesterday's work. The record has held all of it the whole
+ * time. Reading it is the difference between a session and a scratchpad.
+ *
+ * Returns nothing when the workspace cannot be reached. A list is not worth
+ * stopping a session over, and the person is told in the line above it.
+ */
+async function pastWork(limit = 10) {
+    const conn = (0, connection_1.readConnection)();
+    // The SESSION token, not the workspace key. The workspace key is a machine
+    // credential for intercepted requests and the portal's own routes refuse it,
+    // which reads as "no earlier work" rather than as a wrong credential.
+    if (!conn?.url || !conn.token)
+        return [];
+    try {
+        const headers = {
+            authorization: `Bearer ${conn.token}`,
+        };
+        if (conn.tenant)
+            headers['X-Tenant-ID'] = conn.tenant;
+        const res = await fetch(`${conn.url.replace(/\/+$/, '')}/api/v1/agent/jobs?limit=${limit}`, { headers });
+        if (!res.ok)
+            return [];
+        const body = await res.json();
+        return (body.jobs ?? []).map((j) => ({
+            id: String(j.id ?? ''),
+            request: String(j.request ?? ''),
+            name: j.name ?? null,
+            when: String(j.creation_date ?? ''),
+            usd: Number(j.total_usd ?? 0),
+            workspace: j.workspace ?? null,
+        })).filter((j) => j.id);
+    }
+    catch {
+        return [];
+    }
+}
+function newSession() {
+    return {
+        // Short and readable, because a person reads it in a list and types it back.
+        id: new Date().toISOString().slice(11, 19).replace(/:/g, ''),
+        startedAt: new Date().toISOString(),
+        jobs: [],
+        spentUsd: 0,
+        savedUsd: 0,
+        compared: 0,
+    };
+}
+const money = (n) => `$${n.toFixed(4)}`;
+function printHelp() {
+    out();
+    out(ui.c.dim('  Type a question and press enter. Or one of these:'));
+    out();
+    const rows = [
+        ['new', 'start a fresh session'],
+        ['sessions', 'this run and earlier work, and pick one up'],
+        ['model', 'the model your savings are measured against'],
+        ['providers', 'every vendor and model you can reach'],
+        ['voice', 'say it instead of typing it'],
+        ['keys', 'add or replace a provider key'],
+        ['workspace', 'the folder to work in'],
+        ['status', 'where you are signed in'],
+        ['logout', 'sign out, and revoke this machine\'s key'],
+        ['clear', 'clear the screen'],
+        ['exit', 'leave, or press Ctrl-C'],
+    ];
+    for (const [cmd, what] of rows) {
+        out(`  ${ui.c.bold(cmd.padEnd(11))}${ui.c.dim(what)}`);
+    }
+    out();
+    out(ui.c.dim('  A slash is fine as well, so `/model` and `model` do the same thing.'));
+    out(ui.c.dim('  Drag a file onto this window, or type @ and a path, to have it read.'));
+    out();
+}
+/**
+ * Hand a request to the coding agent, in the folder this session is working in.
+ *
+ * The agent reads the project, proposes every change before making it, and runs
+ * the tests. It is the same agent the standalone command runs; there is one
+ * implementation, so the session and the command cannot behave differently.
+ */
+async function build(session, request, confirm, onStarted, attachmentIds = []) {
+    const { runAgent } = await Promise.resolve().then(() => __importStar(require('../agent/command')));
+    const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('./settings')));
+    const folder = currentWorkspace();
+    out();
+    out(ui.c.dim(`  working in ${folder.path}`));
+    out();
+    // Counted the moment it starts, not when it returns. A person who leaves
+    // part-way through a job was told "nothing asked in that session" over work
+    // that had already been paid for, which is the one number this product cannot
+    // get wrong.
+    session.jobs.push({ request });
+    const code = await runAgent({
+        request: [request],
+        cwd: folder.path,
+        // Carry on from the last question rather than starting again. `new` clears
+        // it, which is what `new` is for.
+        continuesJob: session.lastJobId,
+        // The session's own keyboard, handed to the agent.
+        //
+        // The agent has to put a change in front of the person and wait. It used to
+        // open a reader of its own to do that, and with the session already reading
+        // the same keyboard the question landed nowhere: every command came back
+        // "needs approval and nobody is watching", refused by the product rather
+        // than by the person. One reader, owned by whoever started the process,
+        // passed down.
+        confirm,
+        onStarted,
+        // Files the person attached, already read and waiting on the server.
+        attachments: attachmentIds,
+        // Ask before a change and before a command, because now the person can
+        // actually answer. This was auto_edit only because approving a write was
+        // impossible from inside a session; it is the mode the standalone command
+        // uses, so the two behave the same way.
+        mode: 'approve_writes',
+        // The running total is the whole point of a session, so it is added up
+        // from what each job actually cost. It used to be declared and never
+        // touched, so a session ended by reporting zero spent and zero saved
+        // directly underneath a job that had just charged three cents.
+        onFinished: (r) => {
+            // Recorded even when the job did not finish. A run that was stopped or
+            // ran out of steps still said things, and the next question is usually
+            // about exactly that.
+            if (r.jobId)
+                session.lastJobId = r.jobId;
+            session.spentUsd += r.totalUsd;
+            if (r.savedUsd !== null) {
+                session.savedUsd += r.savedUsd;
+                session.compared += 1;
+            }
+        },
+    });
+    out();
+    if (code !== 0)
+        out(ui.c.amber('  the job did not finish'));
+}
+/** The running total, shown when a session ends or another is opened. */
+function summarize(s) {
+    if (s.jobs.length === 0) {
+        out(ui.c.dim('  nothing asked in that session'));
+        return;
+    }
+    // A saving is only shown when at least one job could be priced against the
+    // comparison model. Otherwise there is nothing to compare, and printing
+    // "$0.0000 saved" would state a figure nobody measured.
+    const saving = s.compared > 0
+        ? `  ${ui.c.green(money(s.savedUsd))} ${ui.c.dim('saved')}`
+        : `  ${ui.c.dim('nothing to compare against yet')}`;
+    out(`  ${ui.c.dim('session')} ${ui.c.bold(s.id)}  ${s.jobs.length} job(s)`
+        + `  ${money(s.spentUsd)} ${ui.c.dim('spent')}${saving}`);
+}
+async function runRepl() {
+    // Resolved when the person leaves. The reader is closed and reopened around
+    // every job, so waiting on it closing would end the session at the first one.
+    let done = () => { };
+    const finished = new Promise((resolve) => { done = resolve; });
+    const conn = (0, connection_1.readConnection)();
+    if (!conn?.url || !conn.workspaceKey) {
+        await (0, welcome_1.showWelcome)();
+        return;
+    }
+    await (0, welcome_1.showWelcome)();
+    // A key, before anything else. With none there is nothing to bill and nothing
+    // to measure, so a prompt accepted here could only ever be refused later.
+    //
+    // THREE outcomes, not two. Telling "your account holds no key" apart from "we
+    // could not ask your account" is the whole point: on 17 September a person
+    // whose workspace held four working keys was shown the first message and sent
+    // to a form, because an unanswered question was read as an answer of none.
+    const state = await (0, keys_1.keyState)();
+    if (!state.reached) {
+        out(ui.fail(`Your workspace could not be reached, so ${ui.c.bold('nothing is known')} about your keys.`));
+        out(`      ${ui.c.dim(state.why)}`);
+        out(`      ${ui.c.dim('check the address with')} ${ui.c.bold('comprism status')}${ui.c.dim(', or sign in again with')} ${ui.c.bold('comprism login')}`);
+        out();
+        process.exitCode = 1;
+        return;
+    }
+    if (!state.hasKey) {
+        out(ui.c.amber('  Your account has no provider key stored, so nothing can run yet.'));
+        out(ui.c.dim('  Every answer is billed to your own provider account.'));
+        out();
+        await (0, keys_1.cmdKeys)([]);
+        const after = await (0, keys_1.keyState)();
+        if (!(after.reached && after.hasKey)) {
+            out(ui.fail('Still no key stored on your account, so the session cannot start.'));
+            out(`      ${ui.c.dim('run')} ${ui.c.bold('comprism keys')} ${ui.c.dim('when you have one')}`);
+            out();
+            process.exitCode = 1;
+            return;
+        }
+        out();
+    }
+    const history = [];
+    let session = newSession();
+    history.push(session);
+    // Ctrl-C leaves, and says what the session cost on the way out. A product
+    // that vanishes without telling you what it spent is the thing this one
+    // exists to replace.
+    // Set while the agent is waiting on a yes or no. The next line typed is that
+    // answer, not the next request, so it is handed straight to whoever is
+    // waiting instead of joining the queue.
+    let answering = null;
+    const takeAnswer = (line) => {
+        if (!answering)
+            return false;
+        const waiting = answering;
+        answering = null;
+        waiting(line);
+        return true;
+    };
+    /**
+     * The keyboard, lent to the agent for one question.
+     *
+     * The session keeps its reader. The agent is given a way to use it, and gets
+     * back a plain yes or no. Anything other than yes is no, which is the same
+     * rule the standalone command applies, so an approval is never assumed from a
+     * stray keystroke.
+     */
+    const confirm = (question) => new Promise((resolve) => {
+        if (leaving || !reader) {
+            resolve(false);
+            return;
+        }
+        answering = (line) => resolve(/^y(es)?$/i.test(line.trim()));
+        reader.setPrompt(`  ${question} `);
+        reader.prompt();
+    });
+    /** The next line typed, whatever it says. The same lent keyboard, used to
+     *  wait rather than to ask: nothing is read here, the press of enter is the
+     *  whole signal. */
+    const nextLine = () => new Promise((resolve) => {
+        if (leaving || !reader) {
+            resolve('');
+            return;
+        }
+        answering = resolve;
+        reader.setPrompt('');
+        reader.prompt();
+    });
+    /**
+     * Say it instead of typing it.
+     *
+     * Recorded here, transcribed on the server, and then put INTO the prompt
+     * rather than sent. Speech is misheard often enough that sending it
+     * unseen would eventually spend somebody's money on a question they never
+     * asked, and the fix costs one glance.
+     *
+     * This draws its own prompt at the end, which is why the caller must not.
+     * The words go into the line buffer, and a buffer written before the prompt
+     * exists is echoed once by readline and again when the prompt redraws, so
+     * the person saw their sentence twice and could edit only the second copy.
+     */
+    const speak = async () => {
+        const short = voice.missing();
+        if (short) {
+            out();
+            out(ui.c.amber(`  ${short}`));
+            out();
+            return prompt();
+        }
+        let live;
+        try {
+            live = voice.start();
+        }
+        catch (err) {
+            out(ui.fail(err.message));
+            out();
+            return prompt();
+        }
+        out();
+        out(ui.c.green('  listening...') + ui.c.dim('  say it, then press enter'));
+        await nextLine();
+        const { file, bytes } = await live.stop();
+        try {
+            if (bytes < 2000) {
+                out(ui.c.dim('  nothing was recorded'));
+                out();
+                return prompt();
+            }
+            out(ui.c.dim('  writing that down...'));
+            const said = await voice.transcribe(conn.url, conn.workspaceKey, file);
+            if (!said.text) {
+                out(ui.c.dim('  no words in that one'));
+                out();
+                return prompt();
+            }
+            out();
+            // The prompt first, THEN the words into it. The person sees their own
+            // sentence at the prompt, edits it where the microphone misheard, and
+            // presses enter. Nothing has been asked or charged until they do.
+            prompt();
+            reader?.write(said.text);
+        }
+        catch (err) {
+            out(ui.fail(err.message));
+            out();
+            prompt();
+        }
+        finally {
+            // The recording is deleted here, always. It is the most personal thing
+            // this product ever touches and there is no reason on earth to keep it.
+            voice.discard(file);
+        }
+    };
+    /**
+     * Files the person pointed at, read and ready, and the question without the
+     * long paths in it.
+     *
+     * Uploading happens before the job starts and is reported before anything is
+     * charged, because the commonest complaint about any assistant is that it
+     * answered without looking at the thing you gave it.
+     */
+    const gather = async (typed) => {
+        const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('./settings')));
+        const found = attach.mentions(typed, currentWorkspace().path);
+        if (found.length === 0)
+            return { text: typed, ids: [] };
+        out();
+        out(ui.c.dim(`  reading ${found.length} file(s)...`));
+        const { attached, refused } = await attach.upload(conn.url, conn.workspaceKey, found.map((m) => m.file));
+        for (const a of attached)
+            out(ui.c.dim(`  ${attach.describe(a)}`));
+        for (const r of refused)
+            out(ui.c.amber(`  ${r.file} was not read: ${r.why}`));
+        // Only the files that actually arrived come out of the sentence. One that
+        // was refused stays written where the person put it, so the question still
+        // says what it was about rather than silently losing it.
+        const landed = found.filter((m) => !refused.some((r) => r.file === m.file));
+        return { text: attach.withoutPaths(typed, landed), ids: attached.map((a) => a.id) };
+    };
+    // A way to stop the job that is running, while it is running. Null between
+    // jobs, which is also the answer to "is anything running".
+    /** The earlier jobs shown by the last `sessions`, so `sessions w2` means the
+     *  same thing the person just read. */
+    let recent = [];
+    let cancelJob = null;
+    /** Set while a job is running, so a line typed mid job reaches it instead of
+     *  queueing up behind it as the next question. */
+    let steerJob = null;
+    let leaving = false;
+    /**
+     * Ctrl-C, or `exit`.
+     *
+     * Three things in order, and the order is the point. The question on screen
+     * is answered no, because nobody said yes. The job is stopped, because the
+     * person asked to leave and a job left running spends money nobody is
+     * watching. Then the session waits for the job to report before it says what
+     * it cost, since a figure printed before the job replies is a figure of zero
+     * over work already paid for.
+     *
+     * The wait is capped. A server that never answers must not turn Ctrl-C into
+     * something a person has to press twice.
+     */
+    const leave = () => {
+        if (leaving)
+            return;
+        leaving = true;
+        takeAnswer('n');
+        cancelJob?.();
+        const close = () => {
+            out();
+            summarize(session);
+            out();
+            releaseTerminal();
+            done();
+        };
+        if (!working)
+            return close();
+        const waitedFrom = Date.now();
+        const settle = setInterval(() => {
+            if (!working || Date.now() - waitedFrom > 5000) {
+                clearInterval(settle);
+                close();
+            }
+        }, 50);
+    };
+    leaveSession = leave;
+    const prompt = () => {
+        if (leaving || !reader)
+            return;
+        reader.setPrompt(`${ui.c.bold(ui.c.blue('comprism'))} ${ui.c.dim('>')} `);
+        reader.prompt();
+    };
+    out(ui.c.dim('  Type what you want done, or `help`. Ctrl-C to leave.'));
+    out();
+    // One line at a time, in the order they arrived.
+    //
+    // Readline keeps reading while an answer is still coming back, so two
+    // questions typed quickly ran at once and the second finished first. Pausing
+    // the reader fixed the order and THREW AWAY anything already typed, which is
+    // worse: a person who types ahead loses what they typed.
+    //
+    // So lines are queued and worked through one at a time. Nothing is dropped
+    // and nothing overtakes.
+    const queue = [];
+    let working = false;
+    const drain = async () => {
+        if (working)
+            return;
+        working = true;
+        while (queue.length > 0 && !leaving) {
+            await handle(queue.shift());
+        }
+        working = false;
+    };
+    onLine = (line) => {
+        // An answer the agent is waiting for jumps the queue, because it is not a
+        // request. Queued, it would sit behind the very job that is waiting on it.
+        if (takeAnswer(line))
+            return;
+        // Something said while a job is RUNNING goes to that job, not into the
+        // queue behind it. A person who sees the agent going the wrong way at step
+        // three had two options before this: stop it and lose everything, or watch
+        // it finish doing the wrong thing and pay for the privilege. It joins the
+        // conversation before the next step, which is the earliest moment it can
+        // change anything.
+        const said = line.trim();
+        if (steerJob && said) {
+            // The session says nothing back. `steer` already prints its own
+            // acknowledgement, and two lines for one thing typed reads as a stutter.
+            steerJob(said);
+            return;
+        }
+        queue.push(line);
+        void drain();
+    };
+    // The keyboard first, THEN the prompt. Drawing the prompt before the reader
+    // existed printed nothing, and the session looked dead on arrival.
+    takeTerminal();
+    prompt();
+    async function handle(line) {
+        const typed = line.trim();
+        if (!typed)
+            return prompt();
+        const { word, slashed } = commandWord(typed);
+        if (COMMANDS.has(word)) {
+            switch (word) {
+                case 'exit':
+                case 'quit':
+                    return leave();
+                case 'clear':
+                    process.stdout.write('\x1b[2J\x1b[H');
+                    break;
+                case 'help':
+                    printHelp();
+                    break;
+                case 'new': {
+                    summarize(session);
+                    session = newSession();
+                    history.push(session);
+                    out(ui.ok(`New session ${ui.c.bold(session.id)}.`));
+                    out();
+                    break;
+                }
+                case 'sessions': {
+                    out();
+                    history.forEach((s, i) => {
+                        const here = s === session ? ui.c.green('  now') : '     ';
+                        out(`${here} ${String(i + 1).padStart(2)}. ${ui.c.bold(s.id)}`
+                            + `  ${s.jobs.length} job(s)  ${money(s.spentUsd)}`);
+                    });
+                    // And what this account did before this window was opened. Kept
+                    // numbered separately so a number never means two different things.
+                    recent = await pastWork();
+                    if (recent.length > 0) {
+                        out();
+                        out(ui.c.dim('  earlier work on this account:'));
+                        recent.forEach((j, i) => {
+                            const said = (j.name || j.request || '(no request recorded)')
+                                .replace(/\s+/g, ' ').slice(0, 58);
+                            out(`      ${ui.c.bold(`w${i + 1}`)}. ${said}`
+                                + ui.c.dim(`  ${j.when.slice(0, 16).replace('T', ' ')}  ${money(j.usd)}`));
+                        });
+                    }
+                    out();
+                    out(ui.c.dim('  `sessions 2` reopens one from this run.'
+                        + (recent.length ? '  `sessions w1` picks up earlier work.' : '')));
+                    out();
+                    break;
+                }
+                case 'status': {
+                    const { cmdStatus } = await Promise.resolve().then(() => __importStar(require('./commands-thin')));
+                    await cmdStatus();
+                    break;
+                }
+                case 'model': {
+                    const { cmdModel } = await Promise.resolve().then(() => __importStar(require('./settings')));
+                    await withTerminal(() => cmdModel([]));
+                    break;
+                }
+                case 'providers': {
+                    const { cmdProviders } = await Promise.resolve().then(() => __importStar(require('./settings')));
+                    await cmdProviders();
+                    break;
+                }
+                case 'voice':
+                    // Returns without the redraw below: `speak` has drawn the prompt
+                    // already, and has put the dictated words into it.
+                    return speak();
+                case 'keys':
+                    await withTerminal(() => (0, keys_1.cmdKeys)([]));
+                    break;
+                case 'workspace': {
+                    const { cmdWorkspace } = await Promise.resolve().then(() => __importStar(require('./settings')));
+                    await withTerminal(() => cmdWorkspace([]));
+                    break;
+                }
+                // Signing out ends the session, because everything after it would be
+                // refused anyway. It used to answer "not available inside a session",
+                // which left quitting and running a second command as the only way.
+                case 'logout':
+                case 'signout':
+                case 'disconnect': {
+                    const { cmdDisconnect } = await Promise.resolve().then(() => __importStar(require('./commands-thin')));
+                    await withTerminal(() => cmdDisconnect());
+                    return leave();
+                }
+                default:
+                    out(ui.c.dim(`  \`${word}\` is not available inside a session.`));
+                    out();
+            }
+            return prompt();
+        }
+        // `sessions 2` reopens the second one from this run.
+        const reopen = /^sessions\s+(\d+)$/.exec(word);
+        if (reopen) {
+            const target = history[Number(reopen[1]) - 1];
+            if (!target) {
+                out(ui.fail(`There is no session ${reopen[1]}.`));
+            }
+            else {
+                summarize(session);
+                session = target;
+                out(ui.ok(`Back in session ${ui.c.bold(session.id)}, ${session.jobs.length} job(s) so far.`));
+            }
+            out();
+            return prompt();
+        }
+        // `sessions w1` picks up work from before this window was opened. A new
+        // session is started rather than an old one edited: what it inherits is the
+        // conversation, not the spending, and adding yesterday's cost to today's
+        // running total would make the session summary a wrong number.
+        const carryOn = /^sessions\s+w(\d+)$/.exec(word);
+        if (carryOn) {
+            if (recent.length === 0)
+                recent = await pastWork();
+            const target = recent[Number(carryOn[1]) - 1];
+            if (!target) {
+                out(ui.fail(`There is no earlier job w${carryOn[1]}. Type \`sessions\` for the list.`));
+            }
+            else {
+                summarize(session);
+                session = newSession();
+                session.lastJobId = target.id;
+                history.push(session);
+                out(ui.ok('Picking up where that left off.'));
+                out(ui.c.dim(`  ${(target.name || target.request).replace(/\s+/g, ' ').slice(0, 70)}`));
+                out(ui.c.dim('  Ask your next question and it will know what was already said.'));
+            }
+            out();
+            return prompt();
+        }
+        // A slash means "this is a command", so an unknown one is a typo and not a
+        // question. Sending it on would answer the typo and charge for the answer,
+        // which is exactly what `/model` used to do.
+        if (slashed) {
+            out(ui.fail(`\`${typed}\` is not a command, so nothing ran and nothing was charged.`));
+            out(ui.c.dim('  Type `help` for the list, or ask without a slash to have work done.'));
+            out();
+            return prompt();
+        }
+        // EVERYTHING is work, and work means the agent.
+        //
+        // There used to be two paths: a question was answered by a model, and only
+        // an explicit build request reached the agent. A person who asked it to
+        // build them an application got a polite description of how they might do
+        // it themselves. The agent answers questions perfectly well and can also
+        // act, so the second path was never worth the confusion it caused.
+        const explicit = /^work\s+(.+)$/i.exec(typed);
+        const asked = explicit ? explicit[1] : typed;
+        const { text, ids } = await gather(asked);
+        try {
+            await build(session, text || asked, confirm, (controls) => { cancelJob = controls.cancel; steerJob = controls.steer; }, ids);
+        }
+        finally {
+            cancelJob = null;
+            steerJob = null;
+        }
+        prompt();
+    }
+    await finished;
+}