@illuminis/comprism 0.1.4 → 0.1.5

package/out/commands/repl.js

@@ -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
@@ -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. */
@@ -308,9 +414,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 +430,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 +522,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();
@@ -457,14 +655,18 @@ async function sessionFolder() {
     return currentWorkspace().path;
 }
 /** The line this session begins with, as the service wrote it (manual 2.2). */
-async function showProjectLine() {
+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.
-    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
@@ -758,10 +960,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,7 +1009,18 @@ 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.c.dim(state.why)}`);
@@ -821,7 +1072,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 +1161,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 +1225,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) {
@@ -1168,17 +1504,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,6 +1629,13 @@ 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;
@@ -1367,6 +1713,27 @@ 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];
@@ -1544,6 +1911,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 +2024,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 +2073,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:'));
@@ -1718,6 +2129,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': {

package/out/commands/welcome.d.ts

@@ -1 +1,25 @@
-export declare function showWelcome(): Promise<void>;
+import type { SessionOut } from '../lib/gateway';
+/**
+ * Who this machine is signed in as, and everything else the header prints.
+ *
+ * ── One call, to the one service ──────────────────────────────────────────
+ *
+ * This used to call the platform's own `whoami` for the identity, and the
+ * header then had no way at all to say how many vendor keys the account held.
+ * Two questions, two addresses, and the header could show a person facts that
+ * disagreed with each other. On 17 September 2026 it did exactly that: "User
+ * unknown" beside a company name, and a session that then announced no provider
+ * key was stored while four were stored and active.
+ *
+ * Every line below now comes from one request to the single service, so the
+ * header either shows a consistent picture or says plainly that it could not
+ * reach the workspace. There is no third state in which half of it is true.
+ *
+ * Null rather than an error when it cannot be reached. A header is the wrong
+ * place to fail: somebody on a plane still gets the local facts, and the lines
+ * needing the server say so.
+ */
+export declare function session(): Promise<SessionOut | null>;
+/** `known` is who this machine is, when the caller already has it (the last
+ *  answer, drawn at once while a fresh one is asked for). */
+export declare function showWelcome(known?: SessionOut | null, signingIn?: boolean, withMark?: boolean): Promise<void>;