@illuminis/comprism 0.1.4 → 0.1.6

package/out/commands/repl.js

@@ -80,7 +80,7 @@ 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 shell_1 = require("../machine/executor/shell");
 const voice = __importStar(require("../lib/voice"));
 const out = (s = '') => process.stdout.write(s + '\n');
 /**
@@ -127,6 +127,13 @@ function takeTerminal() {
         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', () => interrupt());
 }
@@ -136,6 +143,7 @@ function takeTerminal() {
  * 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, () => {
@@ -172,6 +180,103 @@ function complete(line, done) {
     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
@@ -180,7 +285,7 @@ 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 { resolveProject } = await Promise.resolve().then(() => __importStar(require('../machine/folder/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.
@@ -214,9 +319,10 @@ let interrupt = () => leaveSession();
 /** Words that are commands. Anything else typed is work. */
 const COMMANDS = new Set([
     'new', 'sessions', 'branch', 'remote', 'model', 'providers', 'keys', 'status',
-    'voice', 'help', 'exit', 'quit', 'clear', 'login', 'logout', 'signout',
+    '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. */
@@ -250,11 +356,12 @@ async function showHelpers() {
     out();
 }
 /** The permission modes, in the order Shift+Tab moves through them (4.5). */
+/** The modes Shift+Tab steps through, as the service last listed them. */
 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: '' };
+const steering_ = { mode: 'approve_writes', plan: false, pin: '', effort: '', modes: MODES };
 /**
  * The line as a command, with a leading slash taken off.
  *
@@ -308,9 +415,9 @@ async function withTerminal(run) {
  * request. Returns nothing when the workspace cannot be reached: a list is not
  * worth stopping a session over.
  */
-async function earlierSessions(run) {
+async function earlierSessions(run, limit = 10) {
     const { sessions } = await Promise.resolve().then(() => __importStar(require('../lib/sessions')));
-    const reply = await sessions('list', { limit: 10 });
+    const reply = await sessions('list', { limit });
     if (!reply.ok || !reply.sessions?.sessions)
         return [];
     const rows = reply.sessions.sessions;
@@ -324,7 +431,7 @@ async function earlierSessions(run) {
             here.id = r.number;
             return;
         }
-        found.push({ number: r.number, line: lines[i] ?? r.number });
+        found.push({ number: r.number, line: lines[i] ?? r.number, card: r.card });
     });
     return found;
 }
@@ -416,8 +523,100 @@ async function opening(how) {
     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();
@@ -425,7 +624,7 @@ function printHelp() {
     out();
     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(ui.c.amber('  Your organization could not be asked for its skills, so only this tool\'s own words are shown.'));
         out();
     }
     else if (listed.needsUpdate.length > 0) {
@@ -447,9 +646,42 @@ function printHelp() {
 /**
  * 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`.
+ * another. Neither changes the saved default, which is `comprism workspace`.
+ */
+const place = { folder: null, added: [], workspace: '' };
+/**
+ * One command the service runs itself (web manual 13.2, 13.3). The service says
+ * what it means and writes every line; this answers whether a folder exists on
+ * this computer when asked, prints the lines, and carries out the one action it
+ * names. True when the session's workspace or folders changed; the request to
+ * run when a next step was chosen.
  */
-const place = { folder: null, added: [] };
+async function serviceCommand(words) {
+    const { runServiceCommand } = await Promise.resolve().then(() => __importStar(require('../lib/servicecommand')));
+    const said = await runServiceCommand(words, { cwd: await sessionFolder(), current: place.workspace });
+    if (!said.reached) {
+        out(ui.fail(said.message || 'Your organization could not answer that.'));
+        return false;
+    }
+    for (const line of said.lines)
+        out(line);
+    const a = said.action;
+    if (!a)
+        return false;
+    if (a.run)
+        return a.run;
+    if (a.open_workspace)
+        place.workspace = a.open_workspace;
+    if (a.use_folder) {
+        place.folder = a.use_folder;
+        (await Promise.resolve().then(() => __importStar(require('../lib/project-ops')))).useSessionFolder(a.use_folder);
+    }
+    if (a.add_folder && !place.added.includes(a.add_folder))
+        place.added.push(a.add_folder);
+    if (a.remove_folder)
+        place.added = place.added.filter((f) => f !== a.remove_folder);
+    return true;
+}
 async function sessionFolder() {
     if (place.folder)
         return place.folder;
@@ -457,14 +689,18 @@ async function sessionFolder() {
     return currentWorkspace().path;
 }
 /** The line this session begins with, as the service wrote it (manual 2.2). */
-async function showProjectLine() {
-    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+async function projectLine() {
+    const { resolveProject, asWire } = await Promise.resolve().then(() => __importStar(require('../machine/folder/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.
-    out(ui.c.bold(reply.ok && reply.project_line ? reply.project_line : `  ${facts.root}`));
+    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();
 }
 /** Ctrl+O's choice, kept for the next job too, and notes left over from the
@@ -483,7 +719,7 @@ async function contextOf(intent, jobId, keep = '', sessionKey) {
         intent, prompt: keep, ...(jobId ? { jobId } : {}), ...(sessionKey ? { spendSession: sessionKey } : {}),
     });
     if (!reply.ok || !reply.context) {
-        out(ui.fail(reply.message || 'Your workspace could not answer that.'));
+        out(ui.fail(reply.message || 'Your organization could not answer that.'));
     }
     else {
         for (const line of reply.context.lines)
@@ -502,7 +738,7 @@ async function showTranscript(jobId) {
     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.'));
+        out(ui.fail(reply.message || 'The transcript could not be read from your organization.'));
     }
     else {
         for (const line of reply.transcript.lines)
@@ -758,10 +994,48 @@ async function runRepl(how = {}) {
     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.
     //
@@ -769,9 +1043,20 @@ async function runRepl(how = {}) {
     // 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.fail(`Your organization could not be reached, so ${ui.c.bold('nothing is known')} about your keys.`));
         out(`      ${ui.c.dim(state.why)}`);
         out(`      ${ui.c.dim('check the address with')} ${ui.c.bold('comprism status')}${ui.c.dim(', or sign in again with')} ${ui.c.bold('comprism login')}`);
         out();
@@ -808,6 +1093,14 @@ async function runRepl(how = {}) {
         }
         steering_.pin = said.pin ?? '';
         steering_.effort = said.effort === 'normal' ? '' : said.effort;
+        // Mode and plan are the service's too (CLI manual 4.1, 4.5); kept here only
+        // to send with the next job and to draw the prompt.
+        if (said.mode)
+            steering_.mode = said.mode;
+        if (typeof said.plan === 'boolean')
+            steering_.plan = said.plan;
+        if (said.modes?.length)
+            steering_.modes = said.modes;
         return said;
     };
     if (how.latest || how.resume || how.pick) {
@@ -821,7 +1114,8 @@ async function runRepl(how = {}) {
         session = found;
     }
     else {
-        await numbered(session);
+        // 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
@@ -909,6 +1203,52 @@ async function runRepl(how = {}) {
      * 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();
@@ -927,7 +1267,45 @@ async function runRepl(how = {}) {
         }
         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) {
@@ -1010,7 +1388,7 @@ async function runRepl(how = {}) {
      * a drag and drop, and the files wait for the question that follows.
      */
     const gather = async (typed) => {
-        const { resolveProject } = await Promise.resolve().then(() => __importStar(require('../lib/project')));
+        const { resolveProject } = await Promise.resolve().then(() => __importStar(require('../machine/folder/project')));
         const here = await sessionFolder();
         const root = resolveProject(here, place.added).root;
         completion.root = root;
@@ -1168,17 +1546,20 @@ async function runRepl(how = {}) {
         reader.setPrompt(`${ui.c.bold(ui.c.blue('comprism'))} ${ui.c.dim('>')} `);
         reader.prompt();
     };
-    await showProjectLine();
+    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.
-    await refreshList();
+    // 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, or help. Ctrl+C to leave.'));
+    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.
     //
@@ -1290,14 +1671,25 @@ async function runRepl(how = {}) {
     // 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;
+        // The next mode in the service's own list, set by the service.
+        const modes = steering_.modes;
+        const next = modes[(modes.indexOf(steering_.mode) + 1) % modes.length];
         out();
-        out(ui.c.dim(`  mode ${ui.c.bold(next)}, from the next job`));
-        prompt();
+        void steer({ mode: next }).then((said) => {
+            for (const line of said?.lines ?? [])
+                out(ui.c.dim(line));
+            prompt();
+        });
     });
     async function handle(line) {
         const typed = line.trim();
@@ -1323,38 +1715,27 @@ async function runRepl(how = {}) {
             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();
-            }
+        // Commands the service runs itself (web manual 13.2, 13.3): any word the
+        // service lists as its own, and `project`, the old name for `workspace`.
+        // What they mean and every line printed are the service's; this sends what
+        // was typed, answers whether a folder exists, and carries out the action.
+        const head = (bare.split(/\s+/)[0] ?? '').toLowerCase();
+        const { waitingNextSteps } = await Promise.resolve().then(() => __importStar(require('../agent/session')));
+        const serviceWord = head === 'project'
+            || (/^\d+$/.test(bare) && waitingNextSteps > 0)
+            || (listed?.items ?? []).some((i) => i.source === 'service' && i.name === head);
+        if (serviceWord) {
+            const words = head === 'project' ? bare.replace(/^project\b/i, 'workspace') : bare;
+            const acted = await serviceCommand(words);
             out();
-            await showProjectLine();
-            // Another folder has other skills.
-            await refreshList();
+            // A next step chosen: it runs as the request it stands for.
+            if (typeof acted === 'string')
+                return handle(`work ${acted}`);
+            if (acted) {
+                await showProjectLine();
+                // Another folder has other skills.
+                await refreshList();
+            }
             return prompt();
         }
         // `pin <model>` and `effort <level>` (manual 4.17, 4.18), kept by the
@@ -1367,18 +1748,35 @@ async function runRepl(how = {}) {
             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}`));
-                }
+            // The service checks the word and says what is allowed.
+            const said = await steer({ effort: effortTo[1] });
+            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();
@@ -1386,20 +1784,16 @@ async function runRepl(how = {}) {
         // `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`));
-            }
+            const said = await steer({ mode: modeTo[1] });
+            for (const line of said?.lines ?? [])
+                out(ui.c.dim(line));
             out();
             return prompt();
         }
         if (word === 'plan off') {
-            steering_.plan = false;
-            out(ui.c.dim('  planning off: the next requests are carried out'));
+            const said = await steer({ plan: false });
+            for (const line of said?.lines ?? [])
+                out(ui.c.dim(line));
             out();
             return prompt();
         }
@@ -1417,7 +1811,7 @@ async function runRepl(how = {}) {
         // `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 { keptOutput } = await Promise.resolve().then(() => __importStar(require('../machine/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.'));
@@ -1526,16 +1920,20 @@ async function runRepl(how = {}) {
         }
         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.'));
+                case 'plan': {
+                    const said = await steer({ plan: true });
+                    for (const line of said?.lines ?? [])
+                        out(ui.c.dim(line));
                     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.`));
+                }
+                case 'mode': {
+                    const said = await steer({});
+                    for (const line of said?.lines ?? [])
+                        out(ui.c.dim(line));
                     out();
                     break;
+                }
                 case 'pin': {
                     const said = await steer({});
                     out(said?.pin
@@ -1544,6 +1942,14 @@ async function runRepl(how = {}) {
                     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'));
@@ -1649,6 +2055,46 @@ async function runRepl(how = {}) {
                 }
                 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
@@ -1658,10 +2104,6 @@ async function runRepl(how = {}) {
                         out(`${here} ${String(i + 1).padStart(2)}. ${ui.c.bold(s.id)}`
                             + `  ${s.jobs.length} job(s)  ${money(s.spentUsd)}${named}`);
                     });
-                    // And 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.
-                    recent = await earlierSessions(history);
                     if (recent.length > 0) {
                         out();
                         out(ui.c.dim('  earlier work on this account:'));
@@ -1685,17 +2127,10 @@ async function runRepl(how = {}) {
                 // 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;
-                    }
+                    // Nothing sent is nothing charged: the service answers even before
+                    // the first job, so a refusal can be checked as costing nothing (6.1).
                     const { cmdCost } = await Promise.resolve().then(() => __importStar(require('./cost')));
-                    await cmdCost([session.id]);
+                    await cmdCost([session.serverId || session.id]);
                     break;
                 }
                 case 'model': {
@@ -1718,6 +2153,33 @@ async function runRepl(how = {}) {
                 // 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': {