@illuminis/comprism 0.1.4 → 0.1.5

package/out/commands/welcome.js

@@ -33,6 +33,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.session = session;
 exports.showWelcome = showWelcome;
 /**
  * The first thing anybody sees.
@@ -95,33 +96,46 @@ async function session() {
     return reply.session;
 }
 /**
- * The mark: a prism splitting light.
+ * The mark: the app icon as a terminal can draw it cleanly. A five layer prism,
+ * each layer two blocks wider than the one above and a shade deeper, with
+ * three beams leaving its right side (up, level and down) and a ring of the
+ * icon's cyan to purple around it (owner, 28 September 2026).
  *
- * A four row pyramid, drawn only in the full block glyph. The first attempt
- * used quarter blocks and came out looking like a rendering fault, because
- * those glyphs sit differently in every terminal font and a mark cannot depend
- * on a font. A full block renders identically everywhere, so the only thing
- * carrying the design is the color, which is the point of a prism.
+ * Solid blocks only, no blended edges and no white, because a terminal draws a
+ * solid block sharply in any font and a white one vanishes on a white screen.
+ * Drawn two pixels to a character, so it is nine lines tall.
  *
- * Color is taken by COLUMN, not by row. The apex sits on the middle of the
- * spectrum and each row down widens to one more color on either side, so the
- * base carries all eight. That is a prism doing its job: one input at the top,
- * the whole spectrum at the bottom. Banding it by row would have shown four of
- * the eight and read as a striped triangle instead.
- *
- * The eight values come from the same helper as the rule beneath it, so the
- * mark and the rule can never drift apart.
+ * Without color the picture cannot be drawn, so the four row block pyramid
+ * stands in: full blocks only, which render the same in every font.
  */
-const MARK_BASE = 8;
+const ICON = [
+    '..........................................53a6ed51a1ed509cee4f98ee4d93ee4c8eee4a89ee..................................................................',
+    '..............................54abed53a6ed51a1ed..............................4984ef477fef467bef......................................................',
+    '........................54abed53a6ed......................................................4476ef4371ef................................................',
+    '..................54abed53a6ed..................................................................426cf04067f0..........................................',
+    '..................53a6ed....................................a8d8f7a8d8f7..............................3f62f0..........................................',
+    '............53a6ed51a1ed....................................a8d8f7a8d8f7..............................3f5ff0425ef0..................4292f23f8af43b82f6',
+    '............51a1ed....................................74aef074aef074aef074aef0..............................455cf0......49a2ee469af0..................',
+    '............509cee....................................74aef074aef074aef074aef0........................54bbe851b3ea4daaec..............................',
+    '............4f98ee..............................4f86e64f86e64f86e64f86e64f86e64f86e6......5bcbe458c3e6......4b59f1....................................',
+    '............4d93ee..............................4f86e64f86e64f86e64f86e64f86e64f86e6f07a36f0e35befe25aeee259ece158eae057e9df56e8de55e6de54e4dd53e3dc52',
+    '............4c8eee........................3e60d83e60d83e60d83e60d83e60d83e60d83e60d83e60d8ed7435ea6e34......5056f1....................................',
+    '............4a89ee........................3e60d83e60d83e60d83e60d83e60d83e60d83e60d83e60d8............e76932e46331e15d30..............................',
+    '............4984ef477fef............2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a......5355f15653f2......de572fdb512e..................',
+    '..................467bef............2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a2e3a9a......5653f2........................d84c2cd5462bd2402a',
+    '..................4476ef4371ef..................................................................5653f25952f2..........................................',
+    '........................426cf04067f0......................................................5653f25952f2................................................',
+    '..............................3f62f03f5ff0425ef0..............................5355f15653f25952f2......................................................',
+    '..........................................455cf0485bf14b59f14e58f15056f15355f15653f2..................................................................',
+];
 function mark() {
+    const picture = ui.pixelArt(ICON);
+    if (picture.length)
+        return picture;
     const rows = [];
     for (let r = 1; r <= 4; r++) {
-        const blocks = r * 2;
-        const left = (MARK_BASE - blocks) / 2;
-        let line = ' '.repeat(left);
-        for (let i = 0; i < blocks; i++)
-            line += ui.spectrumAt(left + i, '\u2588');
-        rows.push(line + ' '.repeat(left));
+        const left = 4 - r;
+        rows.push(' '.repeat(left) + '\u2588'.repeat(r * 2) + ' '.repeat(left));
     }
     return rows;
 }
@@ -133,19 +147,31 @@ function row(label, value) {
 function readable(name) {
     return name.replace(/[-_]/g, ' ').replace(/\b\w/g, (m) => m.toUpperCase());
 }
-async function showWelcome() {
+/** `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). */
+async function showWelcome(known, signingIn = false, withMark = true) {
     const conn = (0, connection_1.readConnection)();
     const cfg = (0, config_1.loadConfig)();
     const folder = (0, settings_1.currentWorkspace)();
-    const me = await session();
-    const [m1, m2, m3, m4] = mark();
-    out();
-    out(`  ${m1}   ${ui.c.bold('CompletionPrism')} ${ui.c.dim(`v${version_1.COMPRISM_VERSION}`)}`);
-    out(`  ${m2}   ${ui.c.muted('Optimize AI completion economics by optimizing work.')}`);
-    out(`  ${m3}`);
-    out(`  ${m4}`);
-    out(ui.prismRule());
-    out();
+    const me = known !== undefined ? known : await session();
+    // The mark once per start. Signing in first draws it; the session that
+    // follows draws only the account, so nobody sees the same screen twice.
+    if (withMark) {
+        const art = mark();
+        // The name and the line under it sit beside the middle of the mark.
+        const at = Math.max(0, Math.floor(art.length / 2) - 1);
+        const beside = {
+            [at]: `${ui.c.bold('CompletionPrism')} ${ui.c.dim(`v${version_1.COMPRISM_VERSION}`)}`,
+            [at + 1]: ui.c.muted('Optimize AI completion economics by optimizing work.'),
+        };
+        out();
+        art.forEach((line, i) => out(beside[i] ? `  ${line}   ${beside[i]}` : `  ${line}`));
+        out(ui.prismRule());
+        out();
+    }
+    // Signing in comes next and says everything else itself.
+    if (signingIn && !conn?.url)
+        return;
     if (!conn?.url) {
         // Nothing else here is knowable yet, and the one useful thing to say is the
         // single command that changes that.
@@ -153,8 +179,12 @@ async function showWelcome() {
         out(row('Comparing', cfg.defaultModel || 'not set'));
         out(row('Workspace', `${folder.path}  ${ui.c.dim('(where you are)')}`));
         out();
-        out(`  ${ui.c.dim('start with')}  ${ui.c.bold('comprism login')}`);
-        out();
+        // Not said when signing in follows at once: naming a command to type, just
+        // above the sign in it would start, reads as a second step.
+        if (!signingIn) {
+            out(`  ${ui.c.dim('start with')}  ${ui.c.bold('comprism login')}`);
+            out();
+        }
         return;
     }
     const company = me?.company || readable(conn.tenant || 'unknown');
@@ -165,10 +195,16 @@ async function showWelcome() {
     // machine happens to hold. A client that can only echo its own stored address
     // can never tell a person that the address is the thing that is wrong, which
     // is exactly what happened when a machine sat pointed at a dead laptop port.
-    const address = (me?.workspace_url || conn.url).replace(/^https?:\/\//, '');
+    // Except on this laptop: there the server names its public address, which is
+    // not where this machine is talking, and "you are on production" is the
+    // single most confusing thing a developer testing locally can be told.
+    const local = (0, connection_1.isLocalAddress)(conn.url);
+    const address = local
+        ? `${conn.url.replace(/^https?:\/\//, '')} ${ui.c.dim('(this laptop)')}`
+        : (me?.workspace_url || conn.url).replace(/^https?:\/\//, '');
     out(row('User', who));
     out(row('Company', company));
-    out(row('Server', ui.c.dim(address)));
+    out(row('Server', local ? address : ui.c.dim(address)));
     out(row('Comparing', `${cfg.defaultModel || ui.c.amber('not set')}  ${ui.c.dim('change with `comprism model`')}`));
     out(row('Workspace', `${folder.path}  ${ui.c.dim(folder.source === 'cwd' ? '(where you are)' : '(saved)')}`));
     if (plan) {

package/out/lib/gateway.d.ts

@@ -68,6 +68,8 @@ export interface GatewayReply {
     answer: string | null;
     /** The receipt, already worded by the server. Clients never compose one. */
     receipt: string | null;
+    /** The receipt card, worded by the server for every client. */
+    card?: import('../agent/render').ReceiptCard | null;
     /** The model that actually answered. */
     ran_on: string | null;
     /** What this job cost to finish, on the model we ran. */
@@ -262,6 +264,8 @@ export interface SessionRecord {
     conversation_kept?: boolean;
     cost_usd: number;
     jobs: number;
+    /** The session as a list entry, in the service's words: name, then where and when. */
+    card?: string[];
 }
 export interface SessionsReply extends Partial<SessionRecord> {
     lines: string[];

package/out/lib/keyboard.d.ts

@@ -47,6 +47,9 @@ export declare class Keyboard {
     /** Esc on its own (manual 6.7). Returns true when it was used, so the key
      *  goes no further; false passes it to the reader as before. */
     onEscape: (() => boolean) | null;
+    /** The command list under the prompt (manual 6.4): Up, Down, Enter and Tab
+     *  go to it while it is showing. Returns true when it used the key. */
+    onMenuKey: ((key: 'up' | 'down' | 'enter' | 'tab') => boolean) | null;
     /** Ctrl+O, the short or full view (manual 6.9). */
     onFullView: (() => void) | null;
     /** Ctrl+G, the request in your own editor (manual 6.6). */

package/out/lib/keyboard.js

@@ -57,6 +57,9 @@ class Keyboard {
     /** Esc on its own (manual 6.7). Returns true when it was used, so the key
      *  goes no further; false passes it to the reader as before. */
     onEscape = null;
+    /** The command list under the prompt (manual 6.4): Up, Down, Enter and Tab
+     *  go to it while it is showing. Returns true when it used the key. */
+    onMenuKey = null;
     /** Ctrl+O, the short or full view (manual 6.9). */
     onFullView = null;
     /** Ctrl+G, the request in your own editor (manual 6.6). */
@@ -167,6 +170,10 @@ class Keyboard {
         // arrow or another sequence and goes to the reader.
         if (s === '\x1b' && this.onEscape?.())
             return;
+        const menu = { '\x1b[A': 'up', '\x1bOA': 'up', '\x1b[B': 'down', '\x1bOB': 'down',
+            '\r': 'enter', '\t': 'tab' }[s];
+        if (menu && this.onMenuKey?.(menu))
+            return;
         if (this.vi) {
             if (s === '\x1b') {
                 this.normal = true;

package/out/lib/lastlogin.d.ts

@@ -0,0 +1,14 @@
+export interface LastLogin {
+    email: string;
+    /** Exactly what was typed or found as the workspace, so a local one stays local. */
+    workspace: string;
+    /** Whether that workspace was typed by the person (only then may it be local). */
+    typed: boolean;
+}
+export declare function readLast(): LastLogin | null;
+export declare function saveLast(last: LastLogin): void;
+export declare function forgetLast(): void;
+export declare const keychainAvailable: () => boolean;
+export declare function savedPassword(email: string, workspace: string): string | null;
+export declare function savePassword(email: string, workspace: string, password: string): boolean;
+export declare function forgetPassword(email: string, workspace: string): void;

package/out/lib/lastlogin.js

@@ -0,0 +1,105 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.keychainAvailable = void 0;
+exports.readLast = readLast;
+exports.saveLast = saveLast;
+exports.forgetLast = forgetLast;
+exports.savedPassword = savedPassword;
+exports.savePassword = savePassword;
+exports.forgetPassword = forgetPassword;
+/**
+ * Who signed in last on this machine, so signing in again is one key.
+ *
+ * The email and the workspace address are kept in a small file. The password
+ * is never written to that file or anywhere else this tool controls: on a Mac,
+ * and only when the person says yes, it goes into their own login keychain,
+ * the same place Safari and git keep theirs, and it is read back from there.
+ * Signing out leaves both, so the next `login` is Enter; `login --forget`
+ * removes both.
+ */
+const node_child_process_1 = require("node:child_process");
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+function file() {
+    return path.join((0, config_1.ensureHome)(), 'last-login.json');
+}
+function readLast() {
+    try {
+        const got = JSON.parse(fs.readFileSync(file(), 'utf8'));
+        return got.email && got.workspace ? got : null;
+    }
+    catch {
+        return null;
+    }
+}
+function saveLast(last) {
+    try {
+        fs.writeFileSync(file(), JSON.stringify(last), { mode: 0o600 });
+    }
+    catch { /* next login asks */ }
+}
+function forgetLast() {
+    const last = readLast();
+    if (last)
+        forgetPassword(last.email, last.workspace);
+    try {
+        fs.rmSync(file(), { force: true });
+    }
+    catch { /* nothing to remove */ }
+}
+/** The keychain entry's name: one per workspace, so two workspaces never mix. */
+const service = (workspace) => `CompletionPrism ${workspace}`;
+const keychainAvailable = () => process.platform === 'darwin';
+exports.keychainAvailable = keychainAvailable;
+function savedPassword(email, workspace) {
+    if (!(0, exports.keychainAvailable)() || !email || !workspace)
+        return null;
+    const r = (0, node_child_process_1.spawnSync)('security', ['find-generic-password', '-a', email, '-s', service(workspace), '-w'], { encoding: 'utf8' });
+    return r.status === 0 ? r.stdout.replace(/\n$/, '') : null;
+}
+function savePassword(email, workspace, password) {
+    if (!(0, exports.keychainAvailable)())
+        return false;
+    const r = (0, node_child_process_1.spawnSync)('security', ['add-generic-password', '-U', '-a', email, '-s', service(workspace),
+        '-l', service(workspace), '-w', password], { stdio: 'ignore' });
+    return r.status === 0;
+}
+function forgetPassword(email, workspace) {
+    if (!(0, exports.keychainAvailable)())
+        return;
+    (0, node_child_process_1.spawnSync)('security', ['delete-generic-password', '-a', email, '-s', service(workspace)], { stdio: 'ignore' });
+}

package/out/lib/picker.d.ts

@@ -0,0 +1 @@
+export declare function pick(entries: Array<string | string[]>, hint: string, start?: number, numbered?: boolean): Promise<number | null>;

package/out/lib/picker.js

@@ -0,0 +1,158 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pick = pick;
+/**
+ * Choosing one thing from a list with the arrow keys.
+ *
+ * Each entry is one or more lines: the first is its name, the rest are quieter
+ * detail. Entries are separated by a blank line so each reads as its own item.
+ * Up and Down move, Enter picks, Esc (or Ctrl+C) leaves without picking.
+ *
+ * Only as many entries as fit the window are drawn, and the view follows the
+ * marker, so a long list scrolls instead of running off the screen (which would
+ * leave the redraw writing over lines it can no longer reach). Every line is
+ * cut to the window's width for the same reason: a wrapped line throws the
+ * redraw off by one. Off a terminal there is nothing to move through, so it
+ * returns null and the caller falls back to its typed form.
+ *
+ * With `numbered`, every entry carries its number, and typing a number moves
+ * the marker straight to it. A list of two hundred sessions is not something
+ * anybody should have to arrow through to reach the one they can already see.
+ */
+const node_readline_1 = __importDefault(require("node:readline"));
+const ui = __importStar(require("./ui"));
+const CSI = `${String.fromCharCode(27)}[`;
+function pick(entries, hint, start = 0, numbered = false) {
+    if (!process.stdin.isTTY || !process.stdout.isTTY || entries.length === 0)
+        return Promise.resolve(null);
+    const items = entries.map((e) => (Array.isArray(e) ? e : [e]));
+    const width = Math.max(20, (process.stdout.columns || 100) - 6);
+    const cut = (s) => (s.length > width ? `${s.slice(0, width - 3)}...` : s);
+    const tall = Math.max(...items.map((i) => i.length)) + 1;
+    // Room for the entries, the hint and a line either side.
+    const fits = Math.max(1, Math.floor(((process.stdout.rows || 24) - 4) / tall));
+    let at = Math.min(Math.max(0, start), items.length - 1);
+    let top = 0;
+    let drawn = 0;
+    // The number typed so far, when the entries are numbered.
+    let typed = '';
+    const digits = String(items.length).length;
+    const label = (i, line) => (numbered ? `${String(i + 1).padStart(digits)}. ${line}` : line);
+    const draw = () => {
+        if (at < top)
+            top = at;
+        if (at >= top + fits)
+            top = at - fits + 1;
+        if (drawn)
+            process.stdout.write(`${CSI}${drawn}A\r`);
+        const lines = [];
+        if (top > 0)
+            lines.push(ui.c.dim(`    ${top} more above`));
+        items.slice(top, top + fits).forEach((item, k) => {
+            const i = top + k;
+            const chosen = i === at;
+            item.forEach((line, n) => {
+                if (n === 0) {
+                    const name = cut(label(i, line));
+                    lines.push(chosen ? `  ${ui.c.bold(ui.c.blue(`▸ ${name}`))}` : `    ${ui.c.bold(name)}`);
+                }
+                else
+                    lines.push(`    ${ui.c.dim(cut(numbered ? `${' '.repeat(digits + 2)}${line}` : line))}`);
+            });
+            lines.push('');
+        });
+        const below = items.length - (top + fits);
+        if (below > 0)
+            lines.push(ui.c.dim(`    ${below} more below`));
+        lines.push(`  ${ui.c.dim(hint)}${typed ? `   ${ui.c.bold(`number ${typed}`)}` : ''}`);
+        // The same height every time, so the next redraw lands exactly on this one.
+        while (lines.length < drawn)
+            lines.push('');
+        process.stdout.write(`${lines.map((l) => `${CSI}2K${l}`).join('\n')}\n`);
+        drawn = lines.length;
+    };
+    return new Promise((resolve) => {
+        node_readline_1.default.emitKeypressEvents(process.stdin);
+        const wasRaw = process.stdin.isRaw;
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        const done = (choice) => {
+            process.stdin.off('keypress', onKey);
+            process.stdin.setRawMode(wasRaw);
+            process.stdin.pause();
+            resolve(choice);
+        };
+        const onKey = (s, key) => {
+            if (!key && !(numbered && /^[0-9]$/.test(s ?? '')))
+                return;
+            if (numbered && /^[0-9]$/.test(s ?? '')) {
+                // A number past the end starts again from this digit, so a mistyped
+                // number is corrected by typing the right one, not by clearing first.
+                const next = Number(typed + s) <= items.length ? typed + s : s;
+                const n = Number(next);
+                typed = n >= 1 && n <= items.length ? next : '';
+                if (typed)
+                    at = n - 1;
+                draw();
+            }
+            else if (numbered && key.name === 'backspace' && typed) {
+                typed = typed.slice(0, -1);
+                if (typed)
+                    at = Number(typed) - 1;
+                draw();
+            }
+            else if (key.name === 'up' || key.name === 'k') {
+                typed = '';
+                at = Math.max(0, at - 1);
+                draw();
+            }
+            else if (key.name === 'down' || key.name === 'j') {
+                typed = '';
+                at = Math.min(items.length - 1, at + 1);
+                draw();
+            }
+            else if (key.name === 'return')
+                done(at);
+            else if (key.name === 'escape' || key.name === 'q' || (key.ctrl && key.name === 'c'))
+                done(null);
+        };
+        process.stdin.on('keypress', onKey);
+        draw();
+    });
+}

package/out/lib/prompt.d.ts

@@ -2,6 +2,9 @@
 export declare function closePrompt(): void;
 /** Ask a question and wait for the answer. */
 export declare function ask(prompt: string): Promise<string>;
+/** Ask, telling a cancel (Ctrl+C, input closed) apart from an empty answer:
+ *  null is "never mind", "" is Enter. */
+export declare function askOrCancel(prompt: string): Promise<string | null>;
 /**
  * Ask for a secret, and do not put it on the screen.
  *

package/out/lib/prompt.js

@@ -5,6 +5,7 @@ var __importDefault = (this && this.__importDefault) || function (mod) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.closePrompt = closePrompt;
 exports.ask = ask;
+exports.askOrCancel = askOrCancel;
 exports.askHidden = askHidden;
 exports.freeText = freeText;
 exports.subject = subject;
@@ -24,6 +25,11 @@ function open() {
             output: process.stdout,
             terminal: process.stdin.isTTY === true,
         });
+        // Ctrl+C closes it. The next question then opens a new one instead of
+        // asking a closed reader, which threw and ended the whole program.
+        const mine = reader;
+        mine.once('close', () => { if (reader === mine)
+            reader = null; });
     }
     return reader;
 }
@@ -51,6 +57,19 @@ function ask(prompt) {
         });
     });
 }
+/** Ask, telling a cancel (Ctrl+C, input closed) apart from an empty answer:
+ *  null is "never mind", "" is Enter. */
+function askOrCancel(prompt) {
+    return new Promise((resolve) => {
+        const r = open();
+        const closed = () => resolve(null);
+        r.once('close', closed);
+        r.question(prompt, (answer) => {
+            r.off('close', closed);
+            resolve(answer.trim());
+        });
+    });
+}
 /**
  * Ask for a secret, and do not put it on the screen.
  *
@@ -86,6 +105,8 @@ function askHidden(prompt) {
         process.stdout.write(`\r${prompt}${"\u2022".repeat(inner.line.length)}`);
     };
     return new Promise((resolve) => {
+        // Ctrl+C at the password is "never mind", answered as nothing, never a crash.
+        reader.once('close', () => { inner._writeToOutput = asItWas; resolve(''); });
         reader.question(prompt, (answer) => {
             // Put readline back the way it was, whatever happened, or every later
             // question on this reader would come out as dots.

package/out/lib/startcache.d.ts

@@ -0,0 +1,13 @@
+import type { SessionOut } from './gateway';
+import type { CommandList } from './commandlist';
+export interface StartCache {
+    /** Which workspace these answers came from; another workspace's are never used. */
+    url?: string;
+    me?: SessionOut | null;
+    hasKey?: boolean;
+    /** The project line, by project folder. */
+    lines?: Record<string, string>;
+    list?: CommandList | null;
+}
+export declare function readStart(url: string): StartCache;
+export declare function saveStart(url: string, change: Partial<StartCache>): void;

package/out/lib/startcache.js

@@ -0,0 +1,78 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readStart = readStart;
+exports.saveStart = saveStart;
+/**
+ * What the service said the last time a session opened, kept so the next one
+ * can open at once.
+ *
+ * Opening a session asks the service four things (who you are, whether a key
+ * is stored, the project line, the command list). Asked from a laptop whose
+ * database is a region away, each takes seconds, and the prompt waited for all
+ * of them. Now the last answers are drawn immediately and the same questions
+ * are asked again in the background; the fresh answers are kept for next time,
+ * and a change that matters (no key any more) is said as soon as it is known.
+ *
+ * Only the service's own answers are kept, exactly as sent. Nothing here is
+ * decided on this machine, and a missing or unreadable file simply means the
+ * session waits for the service, as it always did.
+ */
+const fs = __importStar(require("node:fs"));
+const path = __importStar(require("node:path"));
+const config_1 = require("./config");
+function file() {
+    return path.join((0, config_1.ensureHome)(), 'start-cache.json');
+}
+function readStart(url) {
+    try {
+        const got = JSON.parse(fs.readFileSync(file(), 'utf8'));
+        return got.url === url ? got : { url };
+    }
+    catch {
+        return { url };
+    }
+}
+function saveStart(url, change) {
+    try {
+        const now = readStart(url);
+        const next = {
+            ...now, ...change, url,
+            lines: { ...(now.lines ?? {}), ...(change.lines ?? {}) },
+        };
+        fs.writeFileSync(file(), JSON.stringify(next), { mode: 0o600 });
+    }
+    catch { /* a cache that cannot be written only means the next start waits */ }
+}

package/out/lib/ui.d.ts

@@ -35,6 +35,14 @@ export declare const c: {
  * and the brand is the one thing a customer notices before the engine.
  */
 export declare function spectrumAt(index: number, glyph: string): string;
+/**
+ * A small picture, drawn two pixels to a character with the half block glyph:
+ * the top pixel is the glyph's color and the bottom one its background, which
+ * makes each pixel square in an ordinary terminal font. Each row of `pixels`
+ * is six hex digits per pixel, `......` for a clear one, and two rows make one
+ * line. Returns nothing without color, because the picture is only color.
+ */
+export declare function pixelArt(pixels: string[]): string[];
 export declare function prismRule(w?: number): string;
 export declare function banner(subtitle?: string): string;
 export declare function money(v: number | null): string;