@illuminis/comprism 0.1.3 → 0.1.5

package/out/commands/repl.js

@@ -67,12 +67,20 @@ exports.runRepl = runRepl;
  * 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_crypto_1 = require("node:crypto");
+const path = __importStar(require("node:path"));
 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 commandlist_1 = require("../lib/commandlist");
+const history_1 = require("../lib/history");
+const keyboard_1 = require("../lib/keyboard");
+const machine_1 = require("../lib/machine");
 const ui = __importStar(require("../lib/ui"));
+const render_1 = require("../agent/render");
+const shell_1 = require("../executor/shell");
 const voice = __importStar(require("../lib/voice"));
 const out = (s = '') => process.stdout.write(s + '\n');
 /**
@@ -85,29 +93,274 @@ const out = (s = '') => process.stdout.write(s + '\n');
  */
 let reader = null;
 let onLine = null;
+/** Earlier requests, for Up, Down and Ctrl+R (manual 6.5). */
+const earlier = new history_1.History();
+/** Pastes, Alt+Enter and Ctrl+R, between the keyboard and the reader (6.2,
+ *  6.3, 6.5). Only in a terminal: piped input is read as lines, as before. */
+const keyboard = new keyboard_1.Keyboard(() => earlier.entries);
+/** Where the session's keystrokes arrive, for a key the session handles
+ *  itself such as Shift+Tab. Nothing arrives while a command has the keyboard. */
+const keys = () => (process.stdin.isTTY ? keyboard.input : process.stdin);
 function releaseTerminal() {
     reader?.close();
     reader = null;
+    // The keyboard goes back with the reader, so the command that asks its own
+    // question is the only thing reading it (manual 6.1).
+    keyboard.bind(null);
+    keyboard.detach();
 }
 function takeTerminal() {
     if (reader || !onLine)
         return;
+    const tty = process.stdin.isTTY === true;
+    if (tty)
+        keyboard.attach();
     reader = node_readline_1.default.createInterface({
-        input: process.stdin,
+        input: tty ? keyboard.input : process.stdin,
         output: process.stdout,
-        terminal: process.stdin.isTTY === true,
+        terminal: tty,
+        // The session's own list, walked by Up and Down. Size 0 so the reader
+        // never adds to it itself: it would add each half of a request continued
+        // with a backslash, and the session adds the whole request once sent.
+        history: earlier.entries,
+        historySize: 0,
+        completer: complete,
+    });
+    keyboard.bind(reader);
+    // Enter has already moved the cursor onto the first line of the live list,
+    // so clearing from here down removes it before anything else prints.
+    reader.on('line', () => {
+        if (popupShown)
+            process.stdout.write(`${CSI}J`);
+        popupShown = 0;
     });
     reader.on('line', onLine);
-    reader.on('SIGINT', () => leaveSession());
+    reader.on('SIGINT', () => interrupt());
+}
+/**
+ * Tab (manual 3.1 and 6.4). After `/` it offers the service's list of
+ * commands and skills, one line each; after `@` the project's file names.
+ * Anywhere else it offers nothing, so it never rewrites a sentence.
+ */
+function complete(line, done) {
+    clearPopup();
+    const slash = /^\/(\S*)$/.exec(line);
+    if (!slash) {
+        done(null, attach.completeAt(line, () => {
+            if (!completion.files || Date.now() - completion.at > 30_000) {
+                completion.files = attach.projectFiles(completion.root);
+                completion.at = Date.now();
+            }
+            return completion.files;
+        }));
+        return;
+    }
+    const typed = slash[1].toLowerCase();
+    const hits = listedItems().filter((i) => i.name.startsWith(typed));
+    if (hits.length === 1) {
+        done(null, [[`/${hits[0].name} `], line]);
+        return;
+    }
+    done(null, [[], line]);
+    if (hits.length === 0 || !reader)
+        return;
+    out();
+    drawList(hits);
+    // Filled in as far as every match agrees, then the prompt drawn again under
+    // the list with the cursor at the end.
+    const common = hits.map((h) => h.name).reduce((a, b) => {
+        let n = 0;
+        while (n < a.length && a[n] === b[n])
+            n += 1;
+        return a.slice(0, n);
+    });
+    const edit = reader;
+    if (common.length > typed.length)
+        edit.line = `/${common}`;
+    edit.cursor = edit.line.length;
+    reader.prompt(true);
+}
+const CSI = `${String.fromCharCode(27)}[`;
+const SAVE = `${String.fromCharCode(27)}7`;
+const RESTORE = `${String.fromCharCode(27)}8`;
+/** How many lines the live list under the prompt holds now, 0 when none. */
+let popupShown = 0;
+const POPUP_ROWS = 8;
+/** What the list under the prompt holds, and which of it is marked (-1: none). */
+let popupHits = [];
+let popupAt = -1;
+/**
+ * Up and Down move through the list under the prompt; Enter runs the marked
+ * command, Tab fills it in to add to. With nothing marked, or no list showing,
+ * every key does what it always did (Up and Down recall earlier requests).
+ */
+keyboard.onMenuKey = (key) => {
+    if (!popupShown || !reader || popupHits.length === 0)
+        return false;
+    const edit = reader;
+    if (key === 'up' || key === 'down') {
+        popupAt = key === 'down' ? Math.min(popupHits.length - 1, popupAt + 1) : Math.max(-1, popupAt - 1);
+        updatePopup();
+        return true;
+    }
+    if (popupAt < 0)
+        return false;
+    const chosen = `/${popupHits[popupAt].name}`;
+    if (key === 'tab') {
+        edit.line = `${chosen} `;
+        edit.cursor = edit.line.length;
+        edit._refreshLine();
+        clearPopup();
+        return true;
+    }
+    // Enter: the marked command replaces what was typed, then Enter goes on.
+    edit.line = chosen;
+    edit.cursor = chosen.length;
+    popupAt = -1;
+    return false;
+};
+/** Takes the live list away, leaving the prompt and the cursor where they are. */
+function clearPopup() {
+    if (!popupShown || !process.stdout.isTTY)
+        return;
+    // Each row the list used, blanked; never a clear to the end of the screen.
+    process.stdout.write(`${SAVE}${`${CSI}1E${CSI}2K`.repeat(popupShown)}${RESTORE}`);
+    popupShown = 0;
 }
+/**
+ * The commands and skills that match what is typed, shown under the prompt
+ * while it is typed (manual 6.4). The same list Tab and `help` offer, from the
+ * service, so a skill added on the server appears here with no new build.
+ * Drawn only while the line is `/` and a word; anything else clears it.
+ */
+function updatePopup() {
+    if (!reader || !process.stdout.isTTY)
+        return;
+    const line = reader.line ?? '';
+    const slash = /^\/(\S*)$/.exec(line);
+    const typed = slash ? slash[1].toLowerCase() : '';
+    const hits = slash ? listedItems().filter((i) => i.name.startsWith(typed)) : [];
+    // A different set of matches starts with nothing marked, so Enter still
+    // sends what was typed until Down is pressed.
+    if (hits.map((h) => h.name).join() !== popupHits.map((h) => h.name).join())
+        popupAt = -1;
+    popupHits = hits;
+    // Shown for a whole word too, so the list stays in sight while it is chosen.
+    if (!hits.length) {
+        clearPopup();
+        return;
+    }
+    const first = Math.max(0, Math.min(popupAt - POPUP_ROWS + 1, hits.length - POPUP_ROWS));
+    const shown = hits.slice(first, first + POPUP_ROWS);
+    const width = Math.min(18, Math.max(...shown.map((i) => i.name.length)) + 1);
+    const room = Math.max(20, (process.stdout.columns || 100) - width - 8);
+    const rows = shown.map((i, k) => {
+        const from = i.source === 'session' ? '' : `  ${i.source}`;
+        const words = `${i.description}${from}`;
+        const name = `/${i.name}`.padEnd(width + 1);
+        const marked = first + k === popupAt;
+        return `${marked ? ui.c.blue('\u25B8 ') : '  '}${marked ? ui.c.bold(ui.c.blue(name)) : ui.c.bold(name)} `
+            + ui.c.dim(words.length > room ? `${words.slice(0, room - 3)}...` : words);
+    });
+    if (hits.length > shown.length)
+        rows.push(ui.c.dim(`  ${hits.length - shown.length} more, Down to see them`));
+    const col = reader.getCursorPos().cols;
+    // A shorter list than last time blanks the rows it no longer uses, rather
+    // than clearing to the end of the screen: on the bottom row there is no line
+    // below to move to, and that clear wiped the list's own last row.
+    const height = rows.length;
+    while (rows.length < popupShown)
+        rows.push('');
+    // Room is made first, so a prompt on the bottom row scrolls up rather than
+    // the list running off the screen, and the cursor comes back to its column.
+    process.stdout.write(`${'\n'.repeat(rows.length)}${CSI}${rows.length}A${CSI}${col + 1}G${SAVE}`
+        + rows.map((r) => `${CSI}1E${CSI}2K${r}`).join('') + RESTORE);
+    popupShown = Math.max(height, 1);
+}
+/** The service's list for this session, once fetched (manual 6.4). */
+let listed = null;
+/** The session words this tool runs. Sent to the service, which lists only
+ *  these and counts the rest as needing a newer version. */
+function sessionWords() {
+    return [...COMMANDS, 'project', 'folders', 'instructions', 'remember', 'detach', 'output', 'processes', 'stop', 'agents'];
+}
+async function refreshList() {
+    const { resolveProject } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+    const root = resolveProject(await sessionFolder(), place.added).root;
+    const got = await (0, commandlist_1.fetchCommandList)(root, sessionWords());
+    // A failed refresh keeps the list already held rather than emptying it.
+    if (got.ok || !listed)
+        listed = got;
+}
+/** What Tab and `help` offer: the service's list, or, when it could not be
+ *  asked, this tool's own words with no descriptions. */
+function listedItems() {
+    if (listed?.ok)
+        return listed.items;
+    return sessionWords().map((name) => ({ name, description: '', source: 'session' }));
+}
+function drawList(items) {
+    const width = Math.min(18, Math.max(...items.map((i) => i.name.length)) + 1);
+    for (const i of items) {
+        const from = i.source === 'session' ? '' : `  ${ui.c.dim(i.source)}`;
+        out(`  ${ui.c.bold(`/${i.name}`.padEnd(width + 1))} ${ui.c.dim(i.description)}${from}`);
+    }
+    out();
+}
+/** The project whose files Tab offers after `@`, and the list, briefly kept. */
+const completion = {
+    root: process.cwd(), files: null, at: 0,
+};
 /** Set by the session so the handover can end it too. */
 let leaveSession = () => { };
+/** Ctrl+C (manual 6.7): stop the job, clear the line, or leave. Set by the
+ *  session; before one starts it leaves. */
+let interrupt = () => 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',
+    'new', 'sessions', 'branch', 'remote', 'model', 'providers', 'keys', 'status',
+    'voice', 'help', 'exit', 'quit', 'clear', 'login', 'logout', 'signout', 'history',
+    'disconnect', 'cost', 'spend', 'attached', 'paste', 'plan', 'todo', 'mode',
+    'queue', 'transcript', 'edit', 'context', 'compact', 'why', 'unpin', 'pin', 'effort',
+    'optimize',
 ]);
+/** `processes` and `stop pN` (manual 5.13): what this session started, and
+ *  stopping one by its number. Works while a job runs, too. True if handled. */
+function processWord(said) {
+    if (/^\/?processes$/i.test(said)) {
+        const rows = (0, shell_1.listProcesses)();
+        if (!rows.length)
+            out(ui.c.dim('  No background processes were started in this session.'));
+        for (const p of rows) {
+            const age = p.seconds < 60 ? `${p.seconds} s` : `${Math.round(p.seconds / 60)} min`;
+            out(`  ${ui.c.bold(p.id)}  ${p.command}  ${ui.c.dim(p.running ? `running ${age}` : 'finished')}`
+                + (p.port ? ui.c.dim(`  port ${p.port}`) : ''));
+        }
+        out();
+        return true;
+    }
+    const stop = /^\/?stop\s+(p\d+)$/i.exec(said);
+    if (stop) {
+        const r = (0, shell_1.stopProcess)(stop[1].toLowerCase());
+        out(r.isError ? ui.fail(r.content) : ui.c.dim(`  ${r.content}`));
+        out();
+        return true;
+    }
+    return false;
+}
+/** `agents` between jobs: the helpers defined here (manual 5.24). */
+async function showHelpers() {
+    const { helperLines } = await Promise.resolve().then(() => __importStar(require('./agents')));
+    for (const line of await helperLines(await sessionFolder()))
+        out(`  ${line}`);
+    out();
+}
+/** The permission modes, in the order Shift+Tab moves through them (4.5). */
+const MODES = ['read_only', 'approve_writes', 'auto_edit', 'full_auto'];
+/** How the next job in this session runs: its mode and whether it plans first
+ *  (manual 4.1, 4.5). Changed by `mode`, Shift+Tab, `plan` and `plan off`, and
+ *  applied from the next job; the service still decides what each mode allows. */
+const steering_ = { mode: 'approve_writes', plan: false, pin: '', effort: '' };
 /**
  * The line as a command, with a leading slash taken off.
  *
@@ -152,51 +405,45 @@ async function withTerminal(run) {
     }
 }
 /**
- * What this account has actually done, newest first.
+ * This account's earlier sessions, from the service's record (manual 8.5).
  *
  * 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.
+ * window lost every thread. The record has held all of it the whole time.
+ * Sessions of this run are left out, since they are listed above it, and their
+ * names are taken from the record, which names a session from its first
+ * request. Returns nothing when the workspace cannot be reached: a list is not
+ * worth stopping a session over.
  */
-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)
+async function earlierSessions(run, limit = 10) {
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const reply = await sessions('list', { limit });
+    if (!reply.ok || !reply.sessions?.sessions)
         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 [];
-    }
+    const rows = reply.sessions.sessions;
+    const lines = reply.sessions.lines;
+    const found = [];
+    rows.forEach((r, i) => {
+        const here = run.find((s) => s.serverId === r.session_id);
+        if (here) {
+            if (r.title)
+                here.title = r.title;
+            here.id = r.number;
+            return;
+        }
+        found.push({ number: r.number, line: lines[i] ?? r.number, card: r.card });
+    });
+    return found;
 }
 function newSession() {
+    // A UUID, because that is what the job record's session column holds. A
+    // dated `cli_...` string was refused by the database, so no job started
+    // in a session was ever recorded (found 23 September 2026, prompt 03).
+    const serverId = (0, node_crypto_1.randomUUID)();
     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, ''),
+        // The session's number, the same one the portal shows (manual 8.1). The
+        // service writes it; `numbered` asks for it as soon as the session opens.
+        id: serverId,
+        serverId,
         startedAt: new Date().toISOString(),
         jobs: [],
         spentUsd: 0,
@@ -205,56 +452,335 @@ function newSession() {
     };
 }
 const money = (n) => `$${n.toFixed(4)}`;
+/**
+ * Ask the service for a new session's number and its opening line (8.2).
+ * Returns the line to print, or null when the service could not be asked, in
+ * which case the session keeps its full id until the next answer names it.
+ */
+async function numbered(s) {
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const reply = await sessions('opened', { session_id: s.serverId });
+    if (!reply.ok || !reply.sessions?.number)
+        return null;
+    s.id = reply.sessions.number;
+    return reply.sessions.lines?.[0] ?? null;
+}
+/**
+ * A session the service already holds, opened again (manual 8.4, 8.5).
+ *
+ * Same id, so every new job files under the same record; its jobs and its cost
+ * so far, so the running total carries on without counting anything twice; and
+ * the last job to continue from only when the service says the conversation
+ * was kept. Session approvals (`a` answers) belong to the run that gave them
+ * and are not carried over.
+ */
+function reopened(r) {
+    return {
+        id: r.number ?? r.session_id ?? '',
+        serverId: r.session_id ?? '',
+        title: r.title ?? null,
+        startedAt: new Date().toISOString(),
+        jobs: Array.from({ length: Number(r.jobs ?? 0) }, () => ({ request: '' })),
+        spentUsd: Number(r.cost_usd ?? 0),
+        savedUsd: 0,
+        compared: 0,
+        ...(r.continues_job ? { lastJobId: r.continues_job } : {}),
+    };
+}
+/** Ask the service for the session to open, choosing from the list when no
+ *  number was given. Prints the resume lines, or why there are none. */
+async function opening(how) {
+    const { sessions, pick, failure, exitFor } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    let key = how.resume;
+    if (how.pick) {
+        const listed = await sessions('list', { limit: 20 });
+        if (!listed.ok || !listed.sessions) {
+            out(ui.fail(failure(listed)));
+            process.exitCode = exitFor(listed);
+            return null;
+        }
+        const rows = listed.sessions.sessions ?? [];
+        if (rows.length === 0) {
+            for (const line of listed.sessions.lines)
+                out(line);
+            return null;
+        }
+        const chosen = await pick(listed.sessions.lines);
+        if (chosen === null)
+            return null;
+        key = rows[chosen]?.number;
+    }
+    const reply = how.latest
+        ? await sessions('latest')
+        : await sessions('resume', { key: key ?? '' });
+    if (!reply.ok || !reply.sessions?.session_id) {
+        out(ui.fail(failure(reply)));
+        process.exitCode = exitFor(reply);
+        return null;
+    }
+    out();
+    for (const line of reply.sessions.lines)
+        out(line);
+    out();
+    // What the session was about, before the next question goes in.
+    await showConversation(reply.sessions.session_id, false);
+    return reopened(reply.sessions);
+}
+/**
+ * A session's earlier questions and answers, read back (manual 8.4).
+ *
+ * On reopening, the last three exchanges, each answer cut to its first lines,
+ * so the screen says what the session was about without filling it. `history`
+ * shows every turn in full. Answers are drawn the way a new answer is: tables
+ * as tables, emphasis as emphasis.
+ */
+async function showConversation(key, full) {
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const { plain } = await Promise.resolve().then(() => __importStar(require('../agent/render')));
+    const reply = await sessions('read', { key });
+    let turns = (reply.sessions?.turns) ?? [];
+    // A service released before it sent the turns still hands over the whole
+    // session on export, every request and answer in full. Read from there, so
+    // the answers are drawn with their headings and tables rather than as the
+    // one line summaries an older service lists.
+    if (reply.ok && turns.length === 0)
+        turns = await exportedTurns(key);
+    if (!reply.ok || turns.length === 0) {
+        if (full) {
+            out(ui.c.dim('  Nothing earlier in this session was kept to show.'));
+            out();
+        }
+        return;
+    }
+    const exchanges = turns.filter((t) => t.role === 'you').length;
+    let shown = turns;
+    if (!full) {
+        // From the third question from the end, so what is shown is whole exchanges.
+        let asked = 0;
+        let from = turns.length;
+        for (let i = turns.length - 1; i >= 0; i--) {
+            if (turns[i].role === 'you' && ++asked === 3) {
+                from = i;
+                break;
+            }
+            if (i === 0)
+                from = 0;
+        }
+        shown = turns.slice(from);
+    }
+    out(ui.c.dim(full ? `  The whole session, ${exchanges} question(s):`
+        : `  Earlier in this session${exchanges > 3 ? `, the last 3 of ${exchanges} questions` : ''}:`));
+    out();
+    for (const t of shown) {
+        if (t.role === 'you') {
+            out(`  ${ui.c.bold(ui.c.blue('you'))}  ${ui.c.bold(t.text.trim())}`);
+            out();
+            continue;
+        }
+        // Drawn exactly as a new answer is, rail and all, never indented further.
+        const lines = plain(t.text.trim()).split('\n');
+        const keep = full ? lines : lines.slice(0, openingCut(lines));
+        for (const l of keep)
+            out(l);
+        if (keep.length < lines.length)
+            out(ui.c.dim(`  ... ${lines.length - keep.length} more lines. Type /history to read it all.`));
+        out();
+    }
+}
+/**
+ * Where to cut an earlier answer on reopening: the last paragraph break in its
+ * first dozen lines, so a table or a list is never shown half drawn. An answer
+ * with no break that early is cut at eight lines, as before.
+ */
+function openingCut(lines) {
+    if (lines.length <= 12)
+        return lines.length;
+    // A break is the rail on its own; a blank row inside a table has more rules.
+    const isBreak = (l) => /^│?$/.test(l.replace(/\x1b\[[0-9;]*m/g, '').trim());
+    for (let i = 12; i >= 3; i--)
+        if (isBreak(lines[i]))
+            return i;
+    return 8;
+}
+/** A session's questions and answers in full, from the service's export. */
+async function exportedTurns(key) {
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const reply = await sessions('export', { key, format: 'json' });
+    const doc = reply.sessions?.document;
+    const turns = [];
+    for (const job of doc?.work ?? []) {
+        if (job.request)
+            turns.push({ role: 'you', text: job.request });
+        if (job.answer)
+            turns.push({ role: 'agent', text: job.answer });
+    }
+    return turns;
+}
+/** The command and skill list, as the service sent it (manual 6.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)}`);
+    drawList(listedItems());
+    if (!listed?.ok) {
+        out(ui.c.amber('  Your workspace could not be asked for its skills, so only this tool\'s own words are shown.'));
+        out();
     }
-    out();
-    out(ui.c.dim('  A slash is fine as well, so `/model` and `model` do the same thing.'));
+    else if (listed.needsUpdate.length > 0) {
+        out(ui.c.dim(`  ${listed.needsUpdate.length} more need a newer comprism: npm install -g @illuminis/comprism`));
+        out();
+    }
+    out(ui.c.dim('  A slash is fine as well, so `/model` and `model` do the same thing. Type / and press Tab to pick one.'));
     out(ui.c.dim('  Drag a file onto this window, or type @ and a path, to have it read.'));
+    out(ui.c.dim('  End a line with \\ or press Alt+Enter for a new line. Up and Down recall earlier requests; Ctrl+R searches them.'));
     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 agent reads the project, shows every change as it makes 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')));
+/**
+ * The folders this session works in (manual 2.1 and 2.3). `project <path>`
+ * changes the folder for the rest of the session; `folders add <path>` allows
+ * another. Neither changes the saved default, which is `comprism project`.
+ */
+const place = { folder: null, added: [] };
+async function sessionFolder() {
+    if (place.folder)
+        return place.folder;
     const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('./settings')));
-    const folder = currentWorkspace();
+    return currentWorkspace().path;
+}
+/** The line this session begins with, as the service wrote it (manual 2.2). */
+async function projectLine() {
+    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+    const { ask } = await Promise.resolve().then(() => __importStar(require('../lib/gateway')));
+    const facts = resolveProject(await sessionFolder(), place.added);
+    const reply = await ask({ intent: 'project', prompt: '', project: asWire(facts, 'approve_writes') });
+    // Drawn as sent. When the service cannot answer, the folder alone, so the
+    // person still knows where they are.
+    return reply.ok && reply.project_line ? reply.project_line : `  ${facts.root}`;
+}
+/** `asked` is the same line already on its way, when startup asked early. */
+async function showProjectLine(asked) {
+    out(ui.c.bold(await (asked ?? projectLine())));
     out();
-    out(ui.c.dim(`  working in ${folder.path}`));
+}
+/** Ctrl+O's choice, kept for the next job too, and notes left over from the
+ *  last one (manual 6.8, 6.9). */
+const view = { full: false, late: [] };
+/** `context` and `compact [what to keep]`, answered and worded by the
+ *  service for the session's latest job (manual 6.13, 6.15). */
+async function contextOf(intent, jobId, keep = '', sessionKey) {
+    const { ask } = await Promise.resolve().then(() => __importStar(require('../lib/gateway')));
+    out();
+    if (intent === 'compact')
+        out(ui.c.dim('  summarizing the conversation so far to keep it affordable'));
+    // The session is named too, so a session with no job yet (questions asked in
+    // Work) gets the same figure the web meter shows (web manual 3.11).
+    const reply = await ask({
+        intent, prompt: keep, ...(jobId ? { jobId } : {}), ...(sessionKey ? { spendSession: sessionKey } : {}),
+    });
+    if (!reply.ok || !reply.context) {
+        out(ui.fail(reply.message || 'Your workspace could not answer that.'));
+    }
+    else {
+        for (const line of reply.context.lines)
+            out(line);
+    }
+    out();
+}
+/** One job's full record, as the service writes it (manual 6.9). */
+async function showTranscript(jobId) {
+    out();
+    if (!jobId) {
+        out(ui.c.dim('  Nothing has run in this session yet, so there is no transcript.'));
+        out();
+        return;
+    }
+    const { ask } = await Promise.resolve().then(() => __importStar(require('../lib/gateway')));
+    const reply = await ask({ intent: 'transcript', prompt: '', jobId });
+    if (!reply.ok || !reply.transcript) {
+        out(ui.fail(reply.message || 'The transcript could not be read from your workspace.'));
+    }
+    else {
+        for (const line of reply.transcript.lines)
+            out(line);
+    }
+    out();
+}
+/**
+ * Open the request in the person's editor and put what they saved back at the
+ * prompt, unsent (manual 6.6). The file exists only while the editor is open,
+ * in a folder only this account can read, and is removed the moment it closes.
+ */
+async function editRequest(current) {
+    const chosen = process.env.VISUAL || process.env.EDITOR || (0, machine_1.machineSettings)().editor;
+    const put = (text) => {
+        if (!reader)
+            return;
+        reader.setPrompt(`${ui.c.bold(ui.c.blue('comprism'))} ${ui.c.dim('>')} `);
+        reader.prompt();
+        reader.write((0, keyboard_1.asOneLine)(text));
+    };
+    if (!chosen) {
+        out();
+        out(ui.fail('No editor is set. Set VISUAL or EDITOR, or run: comprism config set editor <command>'));
+        put(current);
+        return;
+    }
+    const fs = await Promise.resolve().then(() => __importStar(require('node:fs')));
+    const os = await Promise.resolve().then(() => __importStar(require('node:os')));
+    const { spawnSync } = await Promise.resolve().then(() => __importStar(require('node:child_process')));
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'comprism-edit-'));
+    const file = path.join(dir, 'request.md');
+    fs.writeFileSync(file, current, { mode: 0o600 });
+    releaseTerminal();
+    let back = current;
+    try {
+        const [program, ...extra] = chosen.split(/\s+/).filter(Boolean);
+        // nosemgrep: javascript.lang.security.detect-child-process.detect-child-process
+        spawnSync(program, [...extra, file], { stdio: 'inherit' });
+        const saved = fs.readFileSync(file, 'utf8');
+        // Closed without saving leaves the prompt exactly as it was.
+        if (saved !== current)
+            back = saved.replace(/\r?\n$/, '');
+    }
+    catch {
+        out(ui.fail(`${chosen} could not be opened, so the request is as it was.`));
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true });
+        takeTerminal();
+    }
+    put(back);
+}
+async function build(session, request, confirm, onStarted, attachmentIds = [], leftOut = [], ask) {
+    const { runAgent } = await Promise.resolve().then(() => __importStar(require('../agent/command')));
     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 began = Date.now();
+    let busy = false;
     const code = await runAgent({
         request: [request],
-        cwd: folder.path,
+        cwd: await sessionFolder(),
+        addFolders: place.added,
         // Carry on from the last question rather than starting again. `new` clears
         // it, which is what `new` is for.
         continuesJob: session.lastJobId,
+        // The session the person is actually in. Without it the server files every
+        // job of the day under one row, which is why `sessions` here listed three
+        // and the Sessions screen showed one.
+        conversationId: session.serverId,
+        // A server started by one question is still there for the next (5.13).
+        keepProcesses: true,
         // 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
@@ -264,24 +790,47 @@ async function build(session, request, confirm, onStarted, attachmentIds = []) {
         // than by the person. One reader, owned by whoever started the process,
         // passed down.
         confirm,
+        prompt: ask,
         onStarted,
+        fullView: view.full,
         // Files the person attached, already read and waiting on the server.
         attachments: attachmentIds,
+        // Files named that could not be attached, so the agent is told (3.10).
+        leftOut,
         // 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',
+        mode: steering_.mode,
+        plan: steering_.plan,
+        // A pin and effort set with `pin` and `effort` are the session's, held by
+        // the service (manual 4.17, 4.18; web manual 4.5, 4.6), which applies them
+        // to this job. So a pin set in the browser applies here, and the reverse.
         // 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) => {
+            // Busy in another place (manual 8.8): nothing ran, nothing was charged.
+            if (r.outcome === 'busy') {
+                busy = true;
+                return;
+            }
             // 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;
+            // Which job answered which request, for `rewind` (manual 7.4 to 7.6).
+            const asked = session.jobs[session.jobs.length - 1];
+            if (asked && r.jobId && !asked.jobId)
+                asked.jobId = r.jobId;
+            session.todos = r.todos;
+            if (r.why && r.why.length)
+                session.why = r.why;
+            // Notes that arrived after the last step become requests of their own
+            // (manual 6.8); the service has already said so on screen.
+            view.late = r.lateNotes;
             session.spentUsd += r.totalUsd;
             if (r.savedUsd !== null) {
                 session.savedUsd += r.savedUsd;
@@ -289,12 +838,108 @@ async function build(session, request, confirm, onStarted, attachmentIds = []) {
             }
         },
     });
+    if (busy) {
+        session.jobs.pop();
+        return whileBusy(session, request, confirm, onStarted, attachmentIds, leftOut, ask);
+    }
     out();
     if (code !== 0)
         out(ui.c.amber('  the job did not finish'));
+    // A job long enough to switch windows during is worth being told about
+    // (manual 6.11).
+    if (Date.now() - began > 30_000) {
+        const { notify } = await Promise.resolve().then(() => __importStar(require('../lib/notify')));
+        notify(code === 0 ? 'Your job finished.' : 'Your job stopped before finishing.', (l) => out(ui.c.dim(l)));
+    }
+}
+/**
+ * The session is busy in another place (manual 8.8). Offer to wait, or to read
+ * it here. Waiting asks the service until the session is free, then runs the
+ * request; reading prints the session's turns and runs nothing.
+ */
+async function whileBusy(session, request, confirm, onStarted, attachmentIds, leftOut, ask) {
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const said = ((await ask?.('w to wait for it, r to read it here: ')) ?? 'r').trim().toLowerCase();
+    if (said.startsWith('w')) {
+        out(ui.c.dim('  waiting for the session to be free...'));
+        for (let i = 0; i < 120; i++) {
+            await new Promise((r) => setTimeout(r, 3000));
+            const now = await sessions('lease', { key: session.serverId });
+            if (now.ok && now.sessions && !now.sessions.busy_in) {
+                return build(session, request, confirm, onStarted, attachmentIds, leftOut, ask);
+            }
+        }
+        out(ui.c.amber('  still busy after six minutes, so nothing was run.'));
+        return;
+    }
+    const read = await sessions('read', { key: session.serverId });
+    out();
+    for (const line of read.sessions?.lines ?? [read.message ?? ''])
+        out(line);
+    out(ui.c.dim('  Read only: nothing was run.'));
+    out();
+}
+/** What `remote` holds while it is on (manual 8.11). */
+const remote = { timer: null, session: null, take: () => undefined, idle: () => false };
+async function remoteOn(session) {
+    const { sessions, failure } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const reply = await sessions('remote_on', { key: session.serverId });
+    if (!reply.ok || !reply.sessions) {
+        out(ui.fail(failure(reply)));
+        out();
+        return;
+    }
+    for (const line of reply.sessions.lines)
+        out(line);
+    out();
+    remote.session = session.serverId;
+    if (remote.timer)
+        clearInterval(remote.timer);
+    let asking = false;
+    remote.timer = setInterval(() => {
+        if (asking || !remote.idle() || !remote.session)
+            return;
+        asking = true;
+        void sessions('remote_poll', { key: remote.session }).then((got) => {
+            const body = got.sessions;
+            if (body?.off) {
+                stopRemoteTimer();
+                return;
+            }
+            for (const text of body?.requests ?? [])
+                remote.take(text);
+        }).finally(() => { asking = false; });
+    }, 2000);
+    remote.timer.unref();
+}
+function stopRemoteTimer() {
+    if (remote.timer)
+        clearInterval(remote.timer);
+    remote.timer = null;
+    remote.session = null;
+}
+async function remoteOff(session, quiet = false) {
+    const key = remote.session ?? session.serverId;
+    const was = remote.session;
+    stopRemoteTimer();
+    if (quiet && !was)
+        return;
+    const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+    const reply = await sessions('remote_off', { key });
+    if (!quiet) {
+        for (const line of reply.sessions?.lines ?? ['  Remote was not on.'])
+            out(line);
+        out();
+    }
 }
 /** The running total, shown when a session ends or another is opened. */
 function summarize(s) {
+    // The session is over: where the company keeps no content, its checkpoints
+    // end with it (manual 7.3). The service decides; nothing is kept here.
+    if (s.jobs.length > 0) {
+        void Promise.resolve().then(() => __importStar(require('./review'))).then((m) => m.review('session_ended', { session_id: s.serverId }))
+            .catch(() => undefined);
+    }
     if (s.jobs.length === 0) {
         out(ui.c.dim('  nothing asked in that session'));
         return;
@@ -308,17 +953,55 @@ function summarize(s) {
     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() {
+async function runRepl(how = {}) {
     // 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)();
+        await (0, welcome_1.showWelcome)(undefined, process.stdin.isTTY === true && !how.noSignIn);
+        // Signed out: sign in right here rather than naming another command to
+        // type. The last person is offered, so it is usually Enter and a password.
+        if (process.stdin.isTTY === true && !how.noSignIn) {
+            const { cmdLogin } = await Promise.resolve().then(() => __importStar(require('./login')));
+            await cmdLogin(['--into-session']);
+            const { closePrompt } = await Promise.resolve().then(() => __importStar(require('../lib/prompt')));
+            closePrompt();
+            if ((0, connection_1.readConnection)()?.workspaceKey)
+                return runRepl({ ...how, noSignIn: true, noMark: true });
+        }
         return;
     }
-    await (0, welcome_1.showWelcome)();
+    // Everything the opening screen needs is asked for AT ONCE, then drawn in
+    // order as it arrives. Asked one after another it was five round trips end
+    // to end, about fifteen seconds on a laptop before the prompt appeared.
+    //
+    // And what the service said LAST time is drawn at once, so the prompt is
+    // ready in well under a second. The same questions are still asked; their
+    // answers are kept for next time, and a change that matters is said as soon
+    // as it arrives. A first start, or another workspace, waits as before.
+    const { readStart, saveStart } = await Promise.resolve().then(() => __importStar(require('../lib/startcache')));
+    const { session: whoAmI } = await Promise.resolve().then(() => __importStar(require('./welcome')));
+    const known = readStart(conn.url);
+    const here = await sessionFolder();
+    const meAsked = whoAmI().then((me) => { if (me)
+        saveStart(conn.url, { me }); return me; });
+    const stateAsked = (0, keys_1.keyState)().then((s) => {
+        if (s.reached)
+            saveStart(conn.url, { hasKey: s.hasKey });
+        return s;
+    });
+    const lineAsked = projectLine()
+        .then((l) => { saveStart(conn.url, { lines: { [here]: l } }); return l; })
+        .catch(() => '');
+    const listAsked = refreshList()
+        .then(() => { if (listed?.ok)
+        saveStart(conn.url, { list: listed }); })
+        .catch(() => undefined);
+    if (known.list?.ok && !listed)
+        listed = known.list;
+    await (0, welcome_1.showWelcome)(known.me ? known.me : await meAsked, false, !how.noMark);
     // 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.
     //
@@ -326,7 +1009,18 @@ async function runRepl() {
     // 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)();
+    const state = known.hasKey === true ? { reached: true, hasKey: true } : await stateAsked;
+    if (known.hasKey === true) {
+        // Drawn from the last answer; the fresh one says so if the key has gone.
+        void stateAsked.then((fresh) => {
+            if (fresh.reached && !fresh.hasKey) {
+                out();
+                out(ui.c.amber('  Your account no longer has a provider key stored, so requests will be refused.'));
+                out(`      ${ui.c.dim('run')} ${ui.c.bold('keys')} ${ui.c.dim('to add one')}`);
+                reader?.prompt(true);
+            }
+        });
+    }
     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)}`);
@@ -352,6 +1046,35 @@ async function runRepl() {
     }
     const history = [];
     let session = newSession();
+    /** Read, or change, this session's pin and effort on the service (manual
+     *  4.17, 4.18). Says the service's refusal and returns null on one. */
+    const steer = async (change) => {
+        const { sessions, failure } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+        const changing = Object.keys(change).length > 0;
+        const reply = await sessions(changing ? 'steer' : 'steering', { session_id: session.serverId, ...change });
+        const said = reply.sessions;
+        if (!reply.ok || !said || reply.granted === false) {
+            out(ui.fail(failure(reply)));
+            return null;
+        }
+        steering_.pin = said.pin ?? '';
+        steering_.effort = said.effort === 'normal' ? '' : said.effort;
+        return said;
+    };
+    if (how.latest || how.resume || how.pick) {
+        const found = await opening(how);
+        if (!found) {
+            out();
+            if (!process.exitCode)
+                process.exitCode = 1;
+            return;
+        }
+        session = found;
+    }
+    else {
+        // The session's number arrives while the person is already typing.
+        void numbered(session);
+    }
     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
@@ -360,7 +1083,21 @@ async function runRepl() {
     // answer, not the next request, so it is handed straight to whoever is
     // waiting instead of joining the queue.
     let answering = null;
+    /** Rings or notifies when an approval has waited 30 seconds (6.11). */
+    let waitingTimer = null;
+    const startWaiting = () => {
+        if (waitingTimer)
+            clearTimeout(waitingTimer);
+        waitingTimer = setTimeout(() => {
+            void Promise.resolve().then(() => __importStar(require('../lib/notify'))).then(({ notify }) => notify('comprism is waiting for your answer.', (l) => out(ui.c.dim(l))));
+        }, 30_000);
+        waitingTimer.unref();
+    };
     const takeAnswer = (line) => {
+        if (waitingTimer) {
+            clearTimeout(waitingTimer);
+            waitingTimer = null;
+        }
         if (!answering)
             return false;
         const waiting = answering;
@@ -381,7 +1118,20 @@ async function runRepl() {
             resolve(false);
             return;
         }
-        answering = (line) => resolve(/^y(es)?$/i.test(line.trim()));
+        answering = (line) => resolve(/^y(es)?$/i.test((line ?? '').trim()));
+        startWaiting();
+        reader.setPrompt(`  ${question} `);
+        reader.prompt();
+    });
+    /** The same lent keyboard, for a line of text: the plan question and the
+     *  agent's questions (manual 4.2, 4.3). Null when the person left. */
+    const askLine = (question) => new Promise((resolve) => {
+        if (leaving || !reader) {
+            resolve(null);
+            return;
+        }
+        answering = resolve;
+        startWaiting();
         reader.setPrompt(`  ${question} `);
         reader.prompt();
     });
@@ -393,7 +1143,7 @@ async function runRepl() {
             resolve('');
             return;
         }
-        answering = resolve;
+        answering = (line) => resolve(line ?? '');
         reader.setPrompt('');
         reader.prompt();
     });
@@ -411,6 +1161,52 @@ async function runRepl() {
      * the person saw their sentence twice and could edit only the second copy.
      */
     const speak = async () => {
+        // On a Mac, the words appear as they are spoken, the way the web app shows
+        // them, from the Mac's own recogniser. Anywhere it cannot listen (no
+        // helper, or permission not given) this falls through to recording and
+        // having the server write it down when Enter is pressed.
+        if (process.stdout.isTTY) {
+            const live = voice.listenLive();
+            if (live) {
+                await new Promise((r) => setTimeout(r, 400));
+                if (live.problem() && !live.words()) {
+                    await live.stop();
+                    out(ui.c.dim(`  ${live.problem()}`));
+                }
+                else {
+                    out();
+                    out(ui.c.green('  listening...') + ui.c.dim('  say it, then press enter'));
+                    const draw = () => {
+                        const bars = Math.round(live.level() * 12);
+                        const meter = ui.c.green('█'.repeat(bars)) + ui.c.dim('░'.repeat(12 - bars));
+                        const room = Math.max(20, (process.stdout.columns || 100) - 20);
+                        const heard = live.words();
+                        const shown = heard.length > room ? `...${heard.slice(-(room - 3))}` : heard;
+                        process.stdout.write(`\r${CSI}2K  ${meter}  ${shown}`);
+                    };
+                    const ticking = setInterval(draw, 80);
+                    await nextLine();
+                    clearInterval(ticking);
+                    process.stdout.write(`${CSI}1A\r${CSI}2K`);
+                    const said = await live.stop();
+                    if (said === null) {
+                        out(ui.c.dim(`  ${live.problem() || 'dictation stopped'}`));
+                        out();
+                        return prompt();
+                    }
+                    if (!said) {
+                        out(ui.c.dim('  no words in that one'));
+                        out();
+                        return prompt();
+                    }
+                    // Into the prompt, not sent: the person reads it, fixes what was
+                    // misheard, and presses Enter. Nothing is asked or charged until then.
+                    prompt();
+                    reader?.write(said);
+                    return;
+                }
+            }
+        }
         const short = voice.missing();
         if (short) {
             out();
@@ -429,11 +1225,53 @@ async function runRepl() {
         }
         out();
         out(ui.c.green('  listening...') + ui.c.dim('  say it, then press enter'));
+        // What it hears, while it hears it: a meter that moves with the voice at
+        // once, and the words so far, refreshed every few seconds. Without these
+        // a person talks into a blank line with no idea whether anything is
+        // arriving. The words so far are a preview; the whole recording is
+        // written down again when they press Enter, and that is what they get.
+        const tty = process.stdout.isTTY === true;
+        let heard = '';
+        let asking = false;
+        let lastAsked = 0;
+        const draw = () => {
+            const bars = Math.round(voice.level(live.file) * 12);
+            const meter = ui.c.green('█'.repeat(bars)) + ui.c.dim('░'.repeat(12 - bars));
+            const room = Math.max(20, (process.stdout.columns || 100) - 20);
+            const words = heard.length > room ? `...${heard.slice(-(room - 3))}` : heard;
+            process.stdout.write(`\r${CSI}2K  ${meter}  ${words}`);
+        };
+        const preview = async () => {
+            if (asking || Date.now() - lastAsked < 2500)
+                return;
+            const part = voice.soFar(live.file);
+            if (!part)
+                return;
+            asking = true;
+            lastAsked = Date.now();
+            try {
+                const got = await voice.transcribe(conn.url, conn.workspaceKey, part);
+                if (got.text)
+                    heard = got.text.trim();
+            }
+            catch { /* a preview that fails leaves the last one showing */ }
+            asking = false;
+        };
+        const ticking = tty ? setInterval(() => { draw(); void preview(); }, 120) : null;
         await nextLine();
+        if (ticking)
+            clearInterval(ticking);
+        // The line the typed Enter left behind is the meter's; clear it.
+        if (tty)
+            process.stdout.write(`${CSI}1A\r${CSI}2K`);
         const { file, bytes } = await live.stop();
         try {
             if (bytes < 2000) {
-                out(ui.c.dim('  nothing was recorded'));
+                // Nothing heard is usually the microphone permission, never asked for
+                // or refused, so it is named (manual 6.16).
+                out(ui.c.dim(process.platform === 'darwin'
+                    ? '  nothing was recorded. Your terminal may not have microphone permission: System Settings, Privacy and Security, Microphone.'
+                    : '  nothing was recorded. Check that a microphone is connected and not muted.'));
                 out();
                 return prompt();
             }
@@ -462,31 +1300,94 @@ async function runRepl() {
             voice.discard(file);
         }
     };
+    /** Files attached and not yet sent: they go with the next request
+     *  (manual 3.6). `attached` lists them and `detach N` takes one off. */
+    let pending = [];
+    /** Pastes this session, so each is `clipboard-N.png` with its own N. */
+    let pastes = 0;
+    /**
+     * The clipboard's picture, attached to the next request (manual 3.4). Saved
+     * to a temporary file, uploaded like any file, and the file removed
+     * whatever happened.
+     */
+    const pasteImage = async () => {
+        const { readClipboardImage, discard } = await Promise.resolve().then(() => __importStar(require('../lib/clipboard')));
+        const clip = await readClipboardImage(pastes + 1);
+        out();
+        if (!clip.ok) {
+            out(ui.c.amber(`  ${clip.why}`));
+            out();
+            return;
+        }
+        pastes += 1;
+        try {
+            const { attached, refused } = await attach.upload(conn.url, conn.workspaceKey, [clip.file]);
+            for (const line of attach.describe(attached))
+                out(ui.c.dim(`  ${line}`));
+            for (const r of refused)
+                out(ui.c.amber(`  ${r.why}`));
+            pending = [...pending, ...attached];
+        }
+        finally {
+            discard(clip.folder);
+        }
+        out();
+    };
     /**
      * 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.
+     * answered without looking at the thing you gave it. A file with a problem
+     * gets one line saying so and is never sent (manual 3.10).
+     *
+     * `send` is false when the line named files and said nothing else: that is
+     * a drag and drop, and the files wait for the question that follows.
      */
     const gather = async (typed) => {
-        const { currentWorkspace } = await Promise.resolve().then(() => __importStar(require('./settings')));
-        const found = attach.mentions(typed, currentWorkspace().path);
+        const { resolveProject } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+        const here = await sessionFolder();
+        const root = resolveProject(here, place.added).root;
+        completion.root = root;
+        const found = attach.mentions(typed, root, here);
+        const waiting = () => pending.map((a) => a.id);
         if (found.length === 0)
-            return { text: typed, ids: [] };
+            return { text: typed, ids: waiting(), leftOut: [], send: true };
         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)}`));
+        const problems = found.filter((m) => m.problem);
+        const readable = found.filter((m) => !m.problem);
+        const { attached, refused } = readable.length > 0
+            ? await attach.upload(conn.url, conn.workspaceKey, readable.map((m) => m.file))
+            : { attached: [], refused: [] };
+        for (const line of attach.describe(attached))
+            out(ui.c.dim(`  ${line}`));
+        for (const m of problems)
+            out(ui.c.amber(`  ${m.problem?.message}`));
         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) };
+            out(ui.c.amber(`  ${r.why}`));
+        const failed = [...problems.map((m) => m.file), ...refused.map((r) => r.file)];
+        const leftOut = failed.map((f) => path.basename(f));
+        const landed = found.filter((m) => !failed.includes(m.file));
+        const words = attach.withoutMentions(typed, found);
+        pending = [...pending, ...attached];
+        if (!words) {
+            if (pending.length > 0)
+                out(ui.c.dim('  Waiting for your question. `attached` lists what will go with it.'));
+            out();
+            return { text: '', ids: [], leftOut, send: false };
+        }
+        // Every file failed and the request was about them: nothing is sent until
+        // the person says so (manual 3.10).
+        if (attached.length === 0 && pending.length === 0) {
+            const go = await confirm('None of those files could be attached. Send the request anyway? (y/n)');
+            if (!go) {
+                out(ui.c.dim('  Nothing was sent.'));
+                out();
+                return { text: '', ids: [], leftOut, send: false };
+            }
+        }
+        return { text: attach.withoutPaths(typed, landed), ids: waiting(), leftOut, send: true };
     };
     // 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".
@@ -497,6 +1398,60 @@ async function runRepl() {
     /** 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;
+    /** Everything else a running job can be asked: pause, carry on, the queue,
+     *  the full view (manual 6.7 to 6.9). Null between jobs. */
+    let job = null;
+    // Esc pauses a running job; at the prompt it does nothing (6.7).
+    keyboard.onEscape = () => {
+        if (!job || job.isPaused())
+            return false;
+        job.pause();
+        return true;
+    };
+    // Ctrl+O, the short or the full view, from now on (6.9).
+    keyboard.onFullView = () => {
+        view.full = !view.full;
+        job?.setFull(view.full);
+        out();
+        out(ui.c.dim(view.full ? '  full view: each action\'s input and output in full' : '  short view'));
+        if (!job)
+            prompt();
+    };
+    // Ctrl+G: the request so far, in your own editor (6.6). At the prompt only.
+    keyboard.onEditor = () => {
+        if (job || working)
+            return;
+        const edit = reader;
+        const now = [...draft, edit?.line ?? ''].join('\n');
+        draft = [];
+        void editRequest(now);
+    };
+    // Ctrl+V: the clipboard's picture, as `paste` (3.4). At the prompt only;
+    // what is typed so far stays on the line.
+    keyboard.onPasteImage = () => {
+        if (job || working)
+            return;
+        void pasteImage().then(() => prompt());
+    };
+    keyboard.vi = (0, machine_1.machineSettings)().keys === 'vi';
+    // Ctrl+C: the job, then the line, then the session (6.7).
+    interrupt = () => {
+        if (job) {
+            // An approval on screen is answered no, a question as stopped.
+            takeAnswer(null);
+            job.cancel();
+            return;
+        }
+        const edit = reader;
+        if (draft.length > 0 || (edit && edit.line)) {
+            draft = [];
+            if (edit)
+                edit.line = '';
+            out();
+            return prompt();
+        }
+        leave();
+    };
     let leaving = false;
     /**
      * Ctrl-C, or `exit`.
@@ -515,13 +1470,21 @@ async function runRepl() {
         if (leaving)
             return;
         leaving = true;
-        takeAnswer('n');
+        // The portal link ends with the session (manual 8.11).
+        if (remote.session)
+            void remoteOff(session, true);
+        // A question on screen is answered as stopped, not as a word (4.3).
+        takeAnswer(null);
         cancelJob?.();
         const close = () => {
             out();
+            const said = (0, render_1.stoppedLines)((0, shell_1.stopEverything)());
+            if (said)
+                process.stdout.write(said);
             summarize(session);
             out();
             releaseTerminal();
+            earlier.finish();
             done();
         };
         if (!working)
@@ -541,7 +1504,20 @@ async function runRepl() {
         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.'));
+    const lastLine = known.lines?.[here];
+    await showProjectLine(lastLine ? Promise.resolve(lastLine) : lineAsked);
+    // The command and skill list, and whether this company lets typed requests
+    // be kept on this machine (manual 6.4, 6.5). Unknown keeps them for this
+    // session only and leaves any file alone. The last list serves until the
+    // fresh one lands.
+    if (!known.list?.ok)
+        await listAsked;
+    // `config set history off` keeps nothing at all, not even for this session.
+    const historyOff = (0, machine_1.machineSettings)().history === 'off';
+    earlier.start(historyOff ? false : listed?.ok ? listed.keepHistory : null);
+    if (historyOff)
+        earlier.disable();
+    out(ui.c.dim('  Type what you want done. / lists commands and skills, voice dictates, Ctrl+C leaves.'));
     out();
     // One line at a time, in the order they arrived.
     //
@@ -563,11 +1539,41 @@ async function runRepl() {
         }
         working = false;
     };
-    onLine = (line) => {
+    // Requests sent from the portal while `remote` is on (manual 8.11). This
+    // terminal asks the service for them every two seconds between jobs, which
+    // is also how the service knows the session is still running here; they are
+    // run here, on this machine, exactly as if typed, approvals included.
+    remote.take = (text) => {
+        out(`\n  ${ui.c.bold('from the portal:')} ${text}`);
+        queue.push(text);
+        void drain();
+    };
+    remote.idle = () => !job && !working && !leaving;
+    /** The lines of a request continued with `\\` or Alt+Enter, so far. */
+    let draft = [];
+    onLine = (typedLine) => {
+        // Up and Down start again from the newest request after every line.
+        if (reader)
+            reader.historyIndex = -1;
+        const continued = keyboard.takeContinued();
         // 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))
+        if (draft.length === 0 && takeAnswer(keyboard.expand(typedLine)))
+            return;
+        // A request on more than one line (manual 6.2). Held until a line ends
+        // without a continuation, then sent once with its line breaks.
+        if (continued || typedLine.endsWith('\\')) {
+            draft.push(continued ? typedLine : typedLine.slice(0, -1));
+            reader?.setPrompt(ui.c.dim('       ... '));
+            reader?.prompt();
             return;
+        }
+        const shown = [...draft, typedLine].join('\n');
+        draft = [];
+        // Paste labels swapped back for what was pasted (6.3).
+        const line = keyboard.expand(shown);
+        if (line.trim())
+            earlier.add(shown, line);
         // 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
@@ -575,6 +1581,38 @@ async function runRepl() {
         // conversation before the next step, which is the earliest moment it can
         // change anything.
         const said = line.trim();
+        // Paused with Esc: whatever comes next, even an empty Enter, is the answer
+        // to "carry on how" (manual 6.7).
+        if (job?.isPaused()) {
+            job.carryOn(said);
+            return;
+        }
+        // `queue`, `queue clear` and `transcript` while it runs are for the
+        // session, not notes for the agent (6.8, 6.9).
+        if (job && /^\/?queue(\s+clear)?$/i.test(said)) {
+            job.queue(/clear$/i.test(said));
+            return;
+        }
+        if (job && /^\/?transcript$/i.test(said)) {
+            void showTranscript(job.jobId());
+            return;
+        }
+        if (job && processWord(said))
+            return;
+        // `agents` and `stop h2` while helpers run (manual 5.25).
+        if (job && /^\/?agents$/i.test(said)) {
+            const running = job.helpers();
+            if (!running.length)
+                out(ui.c.dim('  No helpers are running.'));
+            for (const h of running)
+                out(`  ${ui.c.bold(h.id)}  ${h.agent ? `${h.agent}: ` : ''}${h.question}`);
+            return;
+        }
+        const helperStop = /^\/?stop\s+(h\d+)$/i.exec(said);
+        if (job && helperStop) {
+            job.stopHelper(helperStop[1].toLowerCase());
+            return;
+        }
         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.
@@ -588,13 +1626,355 @@ async function runRepl() {
     // existed printed nothing, and the session looked dead on arrival.
     takeTerminal();
     prompt();
+    // Shift+Tab moves to the next permission mode (manual 4.5). Only at the
+    // prompt: during a job the change would apply from the next job anyway, and
+    // redrawing over a running job's output is unreadable.
+    // The live list of commands and skills, redrawn after each key at the prompt,
+    // once the reader has applied the key to the line.
+    keys().on('keypress', (_s, key) => {
+        if (working || answering || leaving || key?.name === 'return' || key?.name === 'tab')
+            return;
+        setImmediate(updatePopup);
+    });
+    keys().on('keypress', (_s, key) => {
+        if (!key || key.name !== 'tab' || !key.shift || working || answering || leaving)
+            return;
+        const next = MODES[(MODES.indexOf(steering_.mode) + 1) % MODES.length];
+        steering_.mode = next;
+        out();
+        out(ui.c.dim(`  mode ${ui.c.bold(next)}, from the next job`));
+        prompt();
+    });
     async function handle(line) {
         const typed = line.trim();
         if (!typed)
             return prompt();
-        const { word, slashed } = commandWord(typed);
+        const { word, slashed: slashWord } = commandWord(typed);
+        // A dragged file starting with `/` is a path, not a slashed command
+        // (manual 3.3). Only when the whole first word is something on the disk.
+        const slashed = slashWord && !attach.startsWithPath(typed);
+        // Where the session works (manual 2.1 to 2.3). Read off the typed line, not
+        // `word`, because a path keeps its case.
+        const bare = typed.replace(/^\//, '').replace(/^comprism\s+/i, '').trim();
+        // The instructions in force, and a note for this project (manual 2.8, 2.9).
+        if (/^instructions$/i.test(bare)) {
+            const { cmdInstructions } = await Promise.resolve().then(() => __importStar(require('./instructions')));
+            await withTerminal(async () => { await cmdInstructions([]); });
+            return prompt();
+        }
+        const remember = /^remember\s+(.+)$/i.exec(bare);
+        if (remember) {
+            const { addNote } = await Promise.resolve().then(() => __importStar(require('./memory')));
+            await addNote(remember[1]);
+            out();
+            return prompt();
+        }
+        const where = /^(project|workspace)(?:\s+(.+))?$/i.exec(bare);
+        const addFolder = /^folders\s+add\s+(.+)$/i.exec(bare);
+        if (where || addFolder || /^folders$/i.test(bare)) {
+            const { checkFolder, resolveProject } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+            const named = where ? where[2] : addFolder ? addFolder[1] : undefined;
+            if (named) {
+                const found = checkFolder(named.trim());
+                if (!found.ok) {
+                    out(ui.fail(found.why));
+                    out();
+                    return prompt();
+                }
+                if (where) {
+                    place.folder = found.path;
+                    (await Promise.resolve().then(() => __importStar(require('../lib/project-ops')))).useSessionFolder(found.path);
+                }
+                else if (!place.added.includes(found.path))
+                    place.added.push(found.path);
+            }
+            if (/^folders$/i.test(bare)) {
+                const facts = resolveProject(await sessionFolder(), place.added);
+                out();
+                out(`  ${ui.c.bold(facts.root)}  ${ui.c.dim('project')}`);
+                for (const f of facts.added)
+                    out(`  ${ui.c.bold(f)}  ${ui.c.dim('added for this session')}`);
+                out();
+                return prompt();
+            }
+            out();
+            await showProjectLine();
+            // Another folder has other skills.
+            await refreshList();
+            return prompt();
+        }
+        // `pin <model>` and `effort <level>` (manual 4.17, 4.18), kept by the
+        // service for this session, so the browser shows the same pin.
+        const pinTo = /^pin\s+(\S+)$/.exec(word);
+        if (pinTo) {
+            const said = await steer({ pin: pinTo[1] });
+            if (said)
+                out(ui.c.dim(`  pinned ${ui.c.bold(said.pin_label ?? steering_.pin)} for the next requests. \`unpin\` hands the choice back.`));
+            out();
+            return prompt();
+        }
+        // `optimize on` and `optimize off <model>` (manual 4.17): the same switch
+        // as beside the model in the browser and VS Code. Off is the session pin.
+        const optimizeTo = /^optimize\s+(on|off)(?:\s+(\S+))?$/i.exec(word);
+        if (optimizeTo) {
+            const on = optimizeTo[1].toLowerCase() === 'on';
+            const hold = optimizeTo[2] ?? steering_.pin;
+            if (on) {
+                if (await steer({ pin: '' }))
+                    out(ui.c.dim('  Optimize is on: CompletionPrism picks the model for each step'));
+            }
+            else if (!hold) {
+                out(ui.fail('Name the model to keep, such as `optimize off sonnet`.'));
+            }
+            else {
+                const said = await steer({ pin: hold });
+                if (said)
+                    out(ui.c.dim(`  Optimize is off: ${ui.c.bold(said.pin_label ?? hold)} answers every request. Work is not optimized. \`optimize on\` hands the choice back.`));
+            }
+            out();
+            return prompt();
+        }
+        const effortTo = /^effort\s+(\S+)$/.exec(word);
+        if (effortTo) {
+            const level = effortTo[1];
+            if (!['low', 'medium', 'normal', 'high'].includes(level))
+                out(ui.fail('Effort is low, normal or high.'));
+            else {
+                const said = await steer({ effort: level === 'medium' ? 'normal' : level });
+                if (said) {
+                    out(ui.c.dim(`  effort ${ui.c.bold(said.effort)} for the next requests`));
+                    if (said.effort_note)
+                        out(ui.c.dim(`  ${said.effort_note}`));
+                }
+            }
+            out();
+            return prompt();
+        }
+        // `mode <name>` and `plan off` (manual 4.1, 4.5).
+        const modeTo = /^mode\s+(\S+)$/.exec(word);
+        if (modeTo) {
+            const named = modeTo[1];
+            if (!MODES.includes(named)) {
+                out(ui.fail(`${named} is not a permission mode. One of: ${MODES.join(', ')}`));
+            }
+            else {
+                steering_.mode = named;
+                out(ui.c.dim(`  mode ${ui.c.bold(named)}, from the next job`));
+            }
+            out();
+            return prompt();
+        }
+        if (word === 'plan off') {
+            steering_.plan = false;
+            out(ui.c.dim('  planning off: the next requests are carried out'));
+            out();
+            return prompt();
+        }
+        if (processWord(word))
+            return prompt();
+        if (/^\/?agents$/i.test(word)) {
+            await showHelpers();
+            return prompt();
+        }
+        if (/^\/?stop\s+h\d+$/i.test(word)) {
+            out(ui.c.dim('  No job is running, so there are no helpers to stop.'));
+            out();
+            return prompt();
+        }
+        // `output 3`: a command's whole output, kept on this machine (5.12).
+        const outputOf = /^output(?:\s+(\d+))?$/.exec(word);
+        if (outputOf) {
+            const { keptOutput } = await Promise.resolve().then(() => __importStar(require('../executor/shell')));
+            const kept = outputOf[1] ? keptOutput(Number(outputOf[1])) : undefined;
+            if (!outputOf[1])
+                out(ui.c.dim('  output N shows the whole output of command N, the number on its line.'));
+            else if (!kept)
+                out(ui.fail(`No output ${outputOf[1]} is kept in this session.`));
+            else {
+                out(ui.c.dim(`  output ${outputOf[1]}: ${kept.command}`));
+                out(kept.text.replace(/\n$/, '') || ui.c.dim('  (no output)'));
+            }
+            out();
+            return prompt();
+        }
+        // `detach 2` takes the second waiting file off the list (manual 3.6).
+        const detach = /^detach\s+(\d+)$/.exec(word);
+        if (detach) {
+            const n = Number(detach[1]);
+            const gone = pending[n - 1];
+            if (!gone) {
+                out(ui.fail(pending.length === 0
+                    ? 'Nothing is waiting to be attached.'
+                    : `There is no attachment ${n}. Type \`attached\` for the list.`));
+            }
+            else {
+                pending = pending.filter((_, i) => i !== n - 1);
+                out(ui.c.dim(`  detached ${gone.filename}`));
+            }
+            out();
+            return prompt();
+        }
+        // `changes`, `diff` and `rewind`, with what follows them (manual 7.1 to 7.6).
+        const reviewWord = /^(changes|diff|rewind)(?:\s+(.*))?$/.exec(word);
+        if (reviewWord) {
+            const w = reviewWord[1];
+            const rest = reviewWord[2] ?? '';
+            // What the agent changed in this session, its diff, and putting it
+            // back, files and conversation (manual 7.1 to 7.6).
+            if (w === 'changes' || w === 'diff') {
+                const done = session.jobs.filter((j) => j.jobId);
+                if (!done.length) {
+                    out(ui.c.dim('  Nothing has run in this session yet.'));
+                    out();
+                    return prompt();
+                }
+                const { cmdChanges, cmdDiff } = await Promise.resolve().then(() => __importStar(require('./review')));
+                for (const j of done) {
+                    if (w === 'changes')
+                        await cmdChanges([j.jobId]);
+                    else
+                        await cmdDiff([j.jobId, ...rest.split(/\s+/).filter(Boolean)]);
+                }
+                return prompt();
+            }
+            if (w === 'rewind') {
+                const done = session.jobs.filter((j) => j.jobId);
+                if (!done.length) {
+                    out(ui.c.dim('  Nothing has run in this session yet, so there is nothing to rewind.'));
+                    out();
+                    return prompt();
+                }
+                const conversation = /--conversation|--both/.test(rest);
+                const files = !/--conversation/.test(rest) || /--both/.test(rest);
+                out();
+                out(`  ${conversation ? 'Your requests in this session' : 'The steps of this session'}:`);
+                done.forEach((j, i) => out(`    ${i + 1}  ${j.request.slice(0, 70)}`));
+                const picked = await askLine(`  Go back to before which request? [1 to ${done.length}, Enter for ${done.length}] `);
+                if (picked === null) {
+                    out();
+                    return prompt();
+                }
+                const n = picked.trim() ? Number(picked.trim()) : done.length;
+                if (!Number.isInteger(n) || n < 1 || n > done.length) {
+                    out(ui.fail(`Choose a number from 1 to ${done.length}.`));
+                    out();
+                    return prompt();
+                }
+                if (files) {
+                    // The files of every job from that request on, latest first.
+                    const { cmdRewind } = await Promise.resolve().then(() => __importStar(require('./review')));
+                    const yesNo = async (q) => /^y(es)?$/i.test(((await askLine(q)) ?? '').trim());
+                    for (const j of done.slice(n - 1).reverse())
+                        await cmdRewind([j.jobId], yesNo);
+                }
+                if (conversation) {
+                    const { sessions: ask8, failure } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+                    const before = done[n - 2]?.jobId ?? '';
+                    const reply = await ask8('branch', { key: session.serverId, at_job: before });
+                    if (!reply.ok || !reply.sessions?.session_id) {
+                        out(ui.fail(failure(reply)));
+                        out();
+                        return prompt();
+                    }
+                    summarize(session);
+                    const kept = done.slice(0, n - 1);
+                    session = reopened(reply.sessions);
+                    session.jobs = kept.map((j) => ({ ...j }));
+                    history.push(session);
+                    out(ui.ok(`The conversation is back to before request ${n}, as a new branch.`));
+                    for (const line of reply.sessions.lines)
+                        out(line);
+                    out(ui.c.dim('  The original, with everything it cost, is kept and can be reopened.'));
+                    out();
+                }
+                return prompt();
+            }
+            return prompt();
+        }
         if (COMMANDS.has(word)) {
             switch (word) {
+                case 'plan':
+                    steering_.plan = true;
+                    out(ui.c.dim('  planning on: the next requests are planned first and change nothing. `plan off` stops.'));
+                    out();
+                    break;
+                case 'mode':
+                    out(`  ${ui.c.dim('mode')} ${ui.c.bold(steering_.mode)}${steering_.plan ? ui.c.dim(', planning first') : ''}`);
+                    out(ui.c.dim(`  one of ${MODES.join(', ')}. \`mode <name>\` or Shift+Tab changes it.`));
+                    out();
+                    break;
+                case 'pin': {
+                    const said = await steer({});
+                    out(said?.pin
+                        ? `  ${ui.c.dim('pinned')} ${ui.c.bold(said.pin_label ?? said.pin)}`
+                        : ui.c.dim('  Nothing is pinned; the service chooses the model for each step. `pin <model>` pins one.'));
+                    out();
+                    break;
+                }
+                case 'optimize': {
+                    const said = await steer({});
+                    out(said?.pin
+                        ? `  ${ui.c.dim('Optimize is off:')} ${ui.c.bold(said.pin_label ?? said.pin)} ${ui.c.dim('answers every request. `optimize on` turns it back on.')}`
+                        : ui.c.dim('  Optimize is on: CompletionPrism picks the model for each step. `optimize off <model>` keeps one.'));
+                    out();
+                    break;
+                }
+                case 'unpin':
+                    if (await steer({ pin: '' }))
+                        out(ui.c.dim('  unpinned: the service chooses the model for each step again'));
+                    out();
+                    break;
+                case 'effort': {
+                    const said = await steer({});
+                    out(ui.c.dim(said ? `  effort ${said.effort}` : '  effort not known.'));
+                    if (said?.effort_note)
+                        out(ui.c.dim(`  ${said.effort_note}`));
+                    out();
+                    break;
+                }
+                case 'why':
+                    if (!session.why || session.why.length === 0)
+                        out(ui.c.dim('  No step has run in this session yet.'));
+                    else
+                        for (const line of session.why)
+                            out(line);
+                    out();
+                    break;
+                case 'todo':
+                    if (!session.todos || session.todos.length === 0)
+                        out(ui.c.dim('  No checklist yet.'));
+                    else
+                        out((0, render_1.todos)(session.todos).trimEnd());
+                    out();
+                    break;
+                case 'edit':
+                    // Returns without the redraw below: the editor puts the text back at
+                    // the prompt itself.
+                    return editRequest('');
+                case 'context':
+                    await contextOf('context', session.lastJobId, '', session.serverId || session.id);
+                    break;
+                case 'compact':
+                    await contextOf('compact', session.lastJobId);
+                    break;
+                case 'queue':
+                    // Between jobs nothing can be waiting: a note typed now is a request.
+                    out(ui.c.dim('  No notes are waiting. Notes typed while a job runs join it at its next step.'));
+                    out();
+                    break;
+                case 'transcript':
+                    await showTranscript(session.lastJobId);
+                    break;
+                case 'paste':
+                    await pasteImage();
+                    break;
+                case 'attached':
+                    if (pending.length === 0)
+                        out(ui.c.dim('  Nothing is waiting to be attached.'));
+                    for (const row of attach.listing(pending))
+                        out(`  ${row}`);
+                    out();
+                    break;
                 case 'exit':
                 case 'quit':
                     return leave();
@@ -602,34 +1982,102 @@ async function runRepl() {
                     process.stdout.write('\x1b[2J\x1b[H');
                     break;
                 case 'help':
+                    // Asked again, so a skill saved a minute ago is on the list.
+                    await refreshList();
                     printHelp();
                     break;
+                // A new session from a copy of this one's conversation (manual 8.6).
+                case 'branch': {
+                    if (session.jobs.length === 0) {
+                        out(ui.c.dim('  Nothing has run in this session yet, so there is nothing to branch.'));
+                        out();
+                        break;
+                    }
+                    const { sessions: ask8, failure } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
+                    const reply = await ask8('branch', { key: session.serverId });
+                    if (!reply.ok || !reply.sessions?.session_id) {
+                        out(ui.fail(failure(reply)));
+                        out();
+                        break;
+                    }
+                    summarize(session);
+                    session = reopened(reply.sessions);
+                    history.push(session);
+                    for (const line of reply.sessions.lines)
+                        out(line);
+                    out();
+                    break;
+                }
+                case 'remote': {
+                    await remoteOn(session);
+                    break;
+                }
                 case 'new': {
+                    await remoteOff(session, true);
                     summarize(session);
                     session = newSession();
                     history.push(session);
-                    out(ui.ok(`New session ${ui.c.bold(session.id)}.`));
+                    const line = await numbered(session);
+                    out(line ? ui.c.bold(line) : ui.ok('New session.'));
                     out();
                     break;
                 }
                 case 'sessions': {
                     out();
+                    // What this account did before this window was opened, from the
+                    // service's record of sessions (manual 8.5). Kept numbered
+                    // separately so a number never means two different things.
+                    // Every session the service keeps a record of for this person, up to
+                    // its limit, when they can be moved through and picked by number; a
+                    // typed list stays short enough to read.
+                    const onTerminal = process.stdin.isTTY === true && process.stdout.isTTY === true;
+                    recent = await earlierSessions(history, onTerminal ? 200 : 10);
+                    // On a terminal, the list is picked from with the arrow keys; the
+                    // typed forms below still work everywhere, and in a pipe are the
+                    // only way.
+                    if (onTerminal && history.length + recent.length > 1) {
+                        // Names, dates and cost only. The ids are for typing a session
+                        // back, and nobody types in a list they move through with arrows.
+                        const noId = (line) => line.trimStart().replace(/^(?:srv|s)_[0-9a-f]+\s+/i, '');
+                        const rows = [
+                            ...history.map((s) => [
+                                `${s.title ?? 'this session'}${s === session ? '  (now)' : ''}`,
+                                `this window  \u00b7  ${s.jobs.length} job(s)  \u00b7  ${money(s.spentUsd)}`,
+                            ]),
+                            // The service's two lines where it sent them; its one line otherwise.
+                            ...recent.map((r) => (r.card?.length ? r.card : [noId(r.line)])),
+                        ];
+                        const { pick } = await Promise.resolve().then(() => __importStar(require('../lib/picker')));
+                        let choice = null;
+                        out(ui.c.dim('  choose a session:'));
+                        await withTerminal(async () => {
+                            choice = await pick(rows, 'Up and Down to choose, or type its number, Enter to open, Esc to stay here', history.indexOf(session), true);
+                        });
+                        out();
+                        if (choice === null)
+                            return prompt();
+                        const n = choice;
+                        if (n < history.length) {
+                            if (history[n] === session)
+                                return prompt();
+                            return handle(`sessions ${n + 1}`);
+                        }
+                        return handle(`sessions w${n - history.length + 1}`);
+                    }
                     history.forEach((s, i) => {
                         const here = s === session ? ui.c.green('  now') : '     ';
+                        // The NAME where our server has made one, and the id beside it
+                        // rather than instead of it: the id is what a person types back to
+                        // reopen the session, so it can never be replaced by the name.
+                        const named = s.title ? `  ${ui.c.text(s.title)}` : '';
                         out(`${here} ${String(i + 1).padStart(2)}. ${ui.c.bold(s.id)}`
-                            + `  ${s.jobs.length} job(s)  ${money(s.spentUsd)}`);
+                            + `  ${s.jobs.length} job(s)  ${money(s.spentUsd)}${named}`);
                     });
-                    // 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)}`));
+                        recent.forEach((r, i) => {
+                            out(`  ${ui.c.bold(`w${i + 1}`.padStart(3))}. ${r.line.trimStart()}`);
                         });
                     }
                     out();
@@ -643,6 +2091,24 @@ async function runRepl() {
                     await cmdStatus();
                     break;
                 }
+                // The session being stood in, unless an id is typed after it. Asking
+                // the server for "the newest" here would answer about a different
+                // session the moment two are open, and this one is on the screen.
+                case 'cost':
+                case 'spend': {
+                    // Nothing sent is nothing charged, and the service has no record of
+                    // a session before its first job, so it would answer "no such
+                    // session" to a person checking that a refusal cost them nothing
+                    // (manual 6.1).
+                    if (session.jobs.length === 0) {
+                        out(`  ${ui.c.dim('session')} ${ui.c.bold(session.id)}  ${ui.c.dim('nothing has run yet, so it has cost')} $0.00`);
+                        out();
+                        break;
+                    }
+                    const { cmdCost } = await Promise.resolve().then(() => __importStar(require('./cost')));
+                    await cmdCost([session.id]);
+                    break;
+                }
                 case 'model': {
                     const { cmdModel } = await Promise.resolve().then(() => __importStar(require('./settings')));
                     await withTerminal(() => cmdModel([]));
@@ -660,14 +2126,36 @@ async function runRepl() {
                 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 'history':
+                    // Every earlier question and answer in the session being stood in.
+                    out();
+                    await showConversation(session.serverId, true);
+                    break;
+                case 'login': {
+                    // Signing in again, or as somebody else, from inside a session. The
+                    // session was opened with the old sign in, so it ends and the next
+                    // `comprism` opens with the new one.
+                    const { cmdLogin } = await Promise.resolve().then(() => __importStar(require('./login')));
+                    const before = (0, connection_1.readConnection)()?.token;
+                    await withTerminal(async () => {
+                        // The Enter that sent `/login` is still in the terminal's input.
+                        // Given a moment it goes to the session, not to the email question.
+                        await new Promise((r) => setTimeout(r, 150));
+                        // Anything already typed but not yet read is thrown away, so the
+                        // first question waits for a real answer.
+                        while (process.stdin.read() !== null) { /* discard */ }
+                        await cmdLogin([]);
+                    });
+                    // Canceled or refused: nothing changed, so the session carries on.
+                    if ((0, connection_1.readConnection)()?.token === before)
+                        break;
+                    out(ui.c.dim(`  type ${ui.c.bold('comprism')} to start a session with this sign in`));
+                    out();
+                    return leave();
+                }
                 case 'logout':
                 case 'signout':
                 case 'disconnect': {
@@ -681,6 +2169,11 @@ async function runRepl() {
             }
             return prompt();
         }
+        // `remote off` ends the link (manual 8.11).
+        if (/^\/?remote\s+off$/.test(word)) {
+            await remoteOff(session);
+            return prompt();
+        }
         // `sessions 2` reopens the second one from this run.
         const reopen = /^sessions\s+(\d+)$/.exec(word);
         if (reopen) {
@@ -696,6 +2189,22 @@ async function runRepl() {
             out();
             return prompt();
         }
+        // `compact keep the requirement that ...` keeps those words exactly (6.15).
+        // Read off `typed`, because what to keep keeps its case.
+        const compactKeep = /^\/?compact\s+(.+)$/is.exec(typed);
+        if (compactKeep) {
+            await contextOf('compact', session.lastJobId, compactKeep[1].replace(/^keep\s+/i, '').trim());
+            return prompt();
+        }
+        // `cost <session>` breaks down a session other than the one being stood in.
+        // Read off `typed` rather than `word`, because `word` is lowercased so that
+        // command matching is forgiving, and a session id is not a word.
+        const costOf = /^\/?(?:cost|spend)\s+(\S+)$/i.exec(typed);
+        if (costOf) {
+            const { cmdCost } = await Promise.resolve().then(() => __importStar(require('./cost')));
+            await cmdCost([costOf[1]]);
+            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
@@ -703,27 +2212,37 @@ async function runRepl() {
         const carryOn = /^sessions\s+w(\d+)$/.exec(word);
         if (carryOn) {
             if (recent.length === 0)
-                recent = await pastWork();
+                recent = await earlierSessions(history);
             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.`));
+                out(ui.fail(`There is no earlier session w${carryOn[1]}. Type \`sessions\` for the list.`));
+                out();
+                return prompt();
             }
-            else {
-                summarize(session);
-                session = newSession();
-                session.lastJobId = target.id;
+            // The same session, resumed: its conversation and its running cost carry
+            // on, and it never becomes a new session that has lost them (8.5).
+            summarize(session);
+            const found = await opening({ resume: target.number });
+            if (found) {
+                session = found;
                 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) {
+        // A skill or saved command on the service's list is work for the agent,
+        // slash and all: the service expands it (chapter 9).
+        const isListed = () => Boolean(listed?.ok && listed.items.some((i) => i.source !== 'session' && i.name === word.split(/\s+/)[0]));
+        let offered = isListed();
+        if (slashed && !offered) {
+            // A skill written since the list was read is found by asking again,
+            // once, before the word is called a typo (manual 9.1, 9.2).
+            await refreshList();
+            offered = isListed();
+        }
+        if (slashed && !offered) {
             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();
@@ -738,14 +2257,22 @@ async function runRepl() {
         // 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);
+        const { text, ids, leftOut, send } = await gather(asked);
+        if (!send)
+            return prompt();
+        // Sent with this request, so no longer waiting for the next one.
+        pending = [];
         try {
-            await build(session, text || asked, confirm, (controls) => { cancelJob = controls.cancel; steerJob = controls.steer; }, ids);
+            await build(session, text || asked, confirm, (controls) => { job = controls; cancelJob = controls.cancel; steerJob = controls.steer; }, ids, leftOut, askLine);
         }
         finally {
+            job = null;
             cancelJob = null;
             steerJob = null;
         }
+        // A note that arrived after the last step is the next request (6.8).
+        queue.unshift(...view.late);
+        view.late = [];
         prompt();
     }
     await finished;