@illuminis/comprism 0.1.3 → 0.1.4

package/out/lib/stdin.js

@@ -0,0 +1,117 @@
+"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.STDIN_NAME = void 0;
+exports.readPiped = readPiped;
+exports.attachPiped = attachPiped;
+exports.openTerminal = openTerminal;
+/**
+ * Text piped in, and the keyboard behind the pipe (manual 3.9).
+ *
+ * `git diff | comprism work "write a commit message"` hands the tool two
+ * things through two doors: the diff on standard input and the person at the
+ * terminal. They are never confused. Standard input is read to its end and
+ * attached as a file called `standard input`; it is material to read, never
+ * an answer. Approval questions go to the terminal itself (`/dev/tty`, or the
+ * Windows console), so a `y` in the piped text can never approve anything.
+ * With no terminal at all, the job is unattended (manual 10.1).
+ */
+const fs = __importStar(require("node:fs"));
+const os = __importStar(require("node:os"));
+const path = __importStar(require("node:path"));
+const tty = __importStar(require("node:tty"));
+const attach = __importStar(require("./attach"));
+/** The name piped text is attached under. */
+exports.STDIN_NAME = 'standard input';
+/** How long a pipe may stay silent before the person is told it is waited on. */
+const QUIET_MS = 2000;
+/**
+ * Everything piped in, read to the end. Null when standard input is a
+ * terminal, and empty when the pipe closed with nothing on it.
+ *
+ * A pipe that stays open with nothing coming (a command still running, or one
+ * that never closes) is announced after two seconds on standard error, so the
+ * person is not left looking at a still screen. Ctrl+C ends it as usual.
+ */
+function readPiped(input = process.stdin, say = (l) => { process.stderr.write(`${l}\n`); }) {
+    if (input.isTTY)
+        return Promise.resolve(null);
+    return new Promise((resolve) => {
+        const chunks = [];
+        const quiet = setTimeout(() => say('  waiting for standard input (Ctrl+C to stop)'), QUIET_MS);
+        input.on('data', (c) => {
+            chunks.push(typeof c === 'string' ? Buffer.from(c) : c);
+        });
+        const done = () => {
+            clearTimeout(quiet);
+            resolve(Buffer.concat(chunks).toString('utf8'));
+        };
+        input.on('end', done);
+        input.on('error', done);
+    });
+}
+/**
+ * The piped text, uploaded as `standard input`. Written to a temporary file so
+ * it travels exactly like any attachment, and the file removed straight after.
+ */
+async function attachPiped(text, baseUrl, credential) {
+    const folder = fs.mkdtempSync(path.join(os.tmpdir(), 'comprism-stdin-'));
+    const file = path.join(folder, exports.STDIN_NAME);
+    try {
+        fs.writeFileSync(file, text);
+        return await attach.upload(baseUrl, credential, [file]);
+    }
+    finally {
+        fs.rmSync(folder, { recursive: true, force: true });
+    }
+}
+/**
+ * The terminal the person is sitting at, when standard input is a pipe.
+ * Null when there is none (a script, a scheduler, a container), which makes
+ * the job unattended.
+ */
+function openTerminal(platform = process.platform) {
+    try {
+        const fd = fs.openSync(platform === 'win32' ? 'CONIN$' : '/dev/tty', 'r');
+        if (!tty.isatty(fd)) {
+            fs.closeSync(fd);
+            return null;
+        }
+        return new tty.ReadStream(fd);
+    }
+    catch {
+        return null;
+    }
+}

package/out/lib/store.d.ts

@@ -0,0 +1,40 @@
+export declare const LEDGER_FILE = "ledger.jsonl";
+export declare const DECISIONS_FILE = "decisions.jsonl";
+export declare const SESSIONS_FILE = "sessions.json";
+/**
+ * Files that may never carry a supersede row and may never be resolved through
+ * `latestByKey`. Adding a file here is a promise that its rows are frozen.
+ */
+export declare const IMMUTABLE_FILES: ReadonlySet<string>;
+export declare function storePath(file: string): string;
+/**
+ * Append to a supersedable store. Refuses the immutable ones by name.
+ */
+export declare function appendRow(file: string, row: object): void;
+/**
+ * Append to an immutable store. The only write path to `decisions.jsonl`.
+ *
+ * Refuses any row carrying `supersedes`. A decision record that supersedes
+ * another is not a correction, it is a second decision, and it belongs in the
+ * file as its own row with its own id.
+ */
+export declare function appendImmutable(file: string, row: object): void;
+/**
+ * Read every parseable row.
+ *
+ * A truncated final line - the process died mid-write on a machine without the
+ * fsync guarantee, or the file was copied while being written - is skipped
+ * rather than thrown. One lost row is a gap in the evidence; an exception here
+ * would make every row after it unreadable, which is a far worse failure.
+ */
+export declare function readRows<T>(file: string): T[];
+/**
+ * Resolve supersede chains: the last row wins per key.
+ *
+ * Takes the file name rather than just the rows, so that calling it on an
+ * immutable store is an error at the call site rather than a review comment
+ * somebody has to catch.
+ */
+export declare function latestByKey<T>(file: string, rows: T[], key: (row: T) => string): Map<string, T>;
+/** Row count without parsing, for reports and the gate. */
+export declare function countRows(file: string): number;

package/out/lib/store.js

@@ -0,0 +1,138 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.IMMUTABLE_FILES = exports.SESSIONS_FILE = exports.DECISIONS_FILE = exports.LEDGER_FILE = void 0;
+exports.storePath = storePath;
+exports.appendRow = appendRow;
+exports.appendImmutable = appendImmutable;
+exports.readRows = readRows;
+exports.latestByKey = latestByKey;
+exports.countRows = countRows;
+/**
+ * The append-only store.
+ *
+ * One JSON object per line. A row is written once and never edited. There is no
+ * update path, no delete path and no rewrite path in this file, and that is the
+ * point: the discipline is structural rather than a convention someone has to
+ * remember at three in the morning.
+ *
+ * Two grades of immutability, and the difference matters:
+ *
+ *   - Ordinary stores (the ledger) are append-only with supersession. A
+ *     correction is a NEW row carrying `supersedes`, and `latestByKey` resolves
+ *     the chain at read time. Nothing is lost; the earlier belief stays on the
+ *     record.
+ *   - `decisions.jsonl` is stricter. It is never superseded, for any reason,
+ *     because it means exactly one thing forever: what the system knew and
+ *     chose at decision time. A supersede row would make it a claim about the
+ *     present instead. The fences below make that unenforceable by accident:
+ *     `appendRow` refuses the file, `appendImmutable` refuses a `supersedes`
+ *     field, and `latestByKey` refuses to run against it at all.
+ */
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const config_1 = require("./config");
+exports.LEDGER_FILE = 'ledger.jsonl';
+exports.DECISIONS_FILE = 'decisions.jsonl';
+exports.SESSIONS_FILE = 'sessions.json';
+/**
+ * Files that may never carry a supersede row and may never be resolved through
+ * `latestByKey`. Adding a file here is a promise that its rows are frozen.
+ */
+exports.IMMUTABLE_FILES = new Set([exports.DECISIONS_FILE]);
+function storePath(file) {
+    return node_path_1.default.join((0, config_1.homeDir)(), file);
+}
+/**
+ * The single write primitive. Everything that appends goes through here.
+ *
+ * `fsync` after every row is the reason a kill mid-session leaves a parseable
+ * file: the bytes are on the disk, not in a buffer that dies with the process.
+ * It costs a syscall per call, against a network round trip to a model, so the
+ * cost is not measurable and the guarantee is absolute.
+ */
+function writeLine(file, row) {
+    (0, config_1.ensureHome)();
+    const line = `${JSON.stringify(row)}\n`;
+    const fd = node_fs_1.default.openSync(storePath(file), 'a', 0o600);
+    try {
+        node_fs_1.default.writeSync(fd, line, null, 'utf8');
+        node_fs_1.default.fsyncSync(fd);
+    }
+    finally {
+        node_fs_1.default.closeSync(fd);
+    }
+}
+/**
+ * Append to a supersedable store. Refuses the immutable ones by name.
+ */
+function appendRow(file, row) {
+    if (exports.IMMUTABLE_FILES.has(file)) {
+        throw new Error(`${file} is immutable: append through appendImmutable, which forbids supersession.`);
+    }
+    writeLine(file, row);
+}
+/**
+ * Append to an immutable store. The only write path to `decisions.jsonl`.
+ *
+ * Refuses any row carrying `supersedes`. A decision record that supersedes
+ * another is not a correction, it is a second decision, and it belongs in the
+ * file as its own row with its own id.
+ */
+function appendImmutable(file, row) {
+    if (!exports.IMMUTABLE_FILES.has(file)) {
+        throw new Error(`${file} is not an immutable store: append through appendRow.`);
+    }
+    if (Object.prototype.hasOwnProperty.call(row, 'supersedes')) {
+        throw new Error(`${file} rows are never superseded. A later decision is a new record, not a correction.`);
+    }
+    writeLine(file, row);
+}
+/**
+ * Read every parseable row.
+ *
+ * A truncated final line - the process died mid-write on a machine without the
+ * fsync guarantee, or the file was copied while being written - is skipped
+ * rather than thrown. One lost row is a gap in the evidence; an exception here
+ * would make every row after it unreadable, which is a far worse failure.
+ */
+function readRows(file) {
+    const p = storePath(file);
+    if (!node_fs_1.default.existsSync(p))
+        return [];
+    const out = [];
+    for (const line of node_fs_1.default.readFileSync(p, 'utf8').split('\n')) {
+        const trimmed = line.trim();
+        if (!trimmed)
+            continue;
+        try {
+            out.push(JSON.parse(trimmed));
+        }
+        catch {
+            continue;
+        }
+    }
+    return out;
+}
+/**
+ * Resolve supersede chains: the last row wins per key.
+ *
+ * Takes the file name rather than just the rows, so that calling it on an
+ * immutable store is an error at the call site rather than a review comment
+ * somebody has to catch.
+ */
+function latestByKey(file, rows, key) {
+    if (exports.IMMUTABLE_FILES.has(file)) {
+        throw new Error(`${file} is never superseded, so resolving it through latestByKey would imply it can be.`);
+    }
+    const map = new Map();
+    for (const row of rows)
+        map.set(key(row), row);
+    return map;
+}
+/** Row count without parsing, for reports and the gate. */
+function countRows(file) {
+    return readRows(file).length;
+}

package/out/lib/sync.d.ts

@@ -0,0 +1,18 @@
+export interface SyncTarget {
+    /** Tenant base URL, e.g. https://acme.completionprism.ai */
+    url: string;
+    /** A tenant session token. Never written to any file by this command. */
+    token: string;
+    /** Only needed on localhost, where there is no subdomain to resolve. */
+    tenant?: string;
+}
+export interface SyncOutcome {
+    accepted: Record<string, number>;
+    duplicates: Record<string, number>;
+    rejected: Record<string, string[]>;
+    reconciliation: Record<string, unknown>;
+    sent: Record<string, number>;
+}
+/** Everything the local stores hold, in the shape the tenant expects. */
+export declare function collectBatch(): Record<string, unknown>;
+export declare function sync(target: SyncTarget): Promise<SyncOutcome>;

package/out/lib/sync.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectBatch = collectBatch;
+exports.sync = sync;
+/**
+ * Sync: the one thin contract between the Companion and the tenant.
+ *
+ * The Companion works standalone with no service to call - that is the wedge,
+ * and nothing here changes it. Sync is opt-in, additive, and one direction: the
+ * local stores are read, posted, and left exactly as they were. Nothing is
+ * deleted locally on success, because the local record is the primary evidence
+ * and a server round trip is not a reason to destroy it.
+ *
+ * Two properties make it safe to run on a cron:
+ *
+ *   **Idempotent.** Every record is keyed by the id the Companion assigned it,
+ *   and the server refuses a duplicate rather than inserting a second copy. A
+ *   retry after a dropped connection cannot double-count anyone's spend.
+ *
+ *   **Reconciled.** The response carries what the batch claimed and what the
+ *   tenant now holds. If the two disagree, that is visible here, in the command
+ *   the person just ran - not three weeks later in a figure someone is trying to
+ *   defend to a CFO.
+ */
+const chains_1 = require("../internal/chains");
+const config_1 = require("./config");
+const evidence_1 = require("../internal/evidence");
+const links_1 = require("../internal/links");
+const scan_1 = require("../internal/scan");
+const sessions_1 = require("../commands/sessions");
+const snapshot_1 = require("../internal/snapshot");
+const store_1 = require("./store");
+const version_1 = require("./version");
+/** Everything the local stores hold, in the shape the tenant expects. */
+function collectBatch() {
+    const sessions = (0, sessions_1.listSessions)();
+    const chains = (0, chains_1.buildChainsFromStore)(sessions);
+    return {
+        companion_version: version_1.COMPRISM_VERSION,
+        sessions,
+        ledger: (0, store_1.readRows)(store_1.LEDGER_FILE),
+        decisions: (0, snapshot_1.readSnapshots)(),
+        chains,
+        links: (0, links_1.readLinks)(),
+        executed_pairs: (0, evidence_1.readExecutedPairs)(),
+        policy_rejections: (0, evidence_1.readRejections)(),
+        exploration: (0, evidence_1.readExploration)(),
+        imported_ledger: (0, scan_1.readImportedLedger)(),
+        scan_findings: (0, scan_1.readFindings)(),
+    };
+}
+async function sync(target) {
+    const batch = collectBatch();
+    const cfg = (0, config_1.loadConfig)();
+    const headers = {
+        'content-type': 'application/json',
+        authorization: `Bearer ${target.token}`,
+    };
+    // On localhost there is no subdomain, so the tenant travels in a header.
+    // Hyphenated in the header, underscored in the schema: the single most common
+    // cause of "it cannot find the tenant".
+    if (target.tenant)
+        headers['X-Tenant-ID'] = target.tenant;
+    const res = await fetch(`${target.url.replace(/\/+$/, '')}/api/v1/completion/sync`, {
+        method: 'POST',
+        headers,
+        body: JSON.stringify(batch),
+    });
+    if (!res.ok) {
+        // The status line, never the body: a server error body can echo the payload,
+        // and the payload is the customer's record.
+        throw new Error(`sync failed: ${res.status} ${res.statusText}`);
+    }
+    const result = (await res.json());
+    const sent = {};
+    for (const [key, value] of Object.entries(batch)) {
+        if (Array.isArray(value))
+            sent[key] = value.length;
+    }
+    return { ...result, sent, ...(cfg.mode ? {} : {}) };
+}

package/out/lib/ui.d.ts

@@ -79,12 +79,10 @@ export declare function table(headers: string[], rows: string[][]): string;
  * out of the way, leaving the answer and a one-line receipt.
  */
 export declare class LiveIndicator {
-    private timer;
-    private frame;
-    private label;
-    private readonly frames;
+    private shown;
     start(label: string): void;
     update(label: string): void;
+    private draw;
     stop(): void;
 }
 export interface ReceiptData {

package/out/lib/ui.js

@@ -35,15 +35,20 @@ exports.warn = warn;
 exports.fail = fail;
 exports.info = info;
 const isTty = process.stdout.isTTY === true;
-const noColor = !!process.env.NO_COLOR || process.env.TERM === 'dumb';
-const useColor = isTty && !noColor;
+/** Decided when drawn, not when loaded, so `--plain`, `plain true` and
+ *  `theme plain` applied at start up take effect (manual 6.10, 6.12). */
+const noColor = () => !!process.env.NO_COLOR || process.env.TERM === 'dumb';
+const useColorNow = () => isTty && !noColor();
+/** Plain mode: no color and nothing redrawn; every update is a new line. */
+const plainNow = () => process.env.COMPRISM_PLAIN === '1' || !isTty;
+const light = () => process.env.COMPRISM_THEME === 'light';
 function width() {
     return Math.min(process.stdout.columns || 88, 100);
 }
 // ── palette ─────────────────────────────────────────────────────────────────
 // illuminis brand, from branding/brand.toml. Deep navy is unreadable on a dark
 // terminal, so the terminal palette leans on the two blues and the purple.
-const rgb = (r, g, b) => (s) => useColor ? `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m` : s;
+const rgb = (r, g, b) => (s) => useColorNow() ? `\x1b[38;2;${r};${g};${b}m${s}\x1b[0m` : s;
 exports.c = {
     blue: rgb(59, 111, 181), // primary_blue  #3B6FB5
     deep: rgb(31, 77, 120), // heading_blue  #1F4D78
@@ -52,9 +57,10 @@ exports.c = {
     amber: rgb(217, 119, 6), // warning       #D97706
     red: rgb(220, 38, 38), // error         #DC2626
     muted: rgb(158, 158, 158), // muted_text    #9E9E9E
-    text: rgb(214, 219, 228),
-    bold: (s) => (useColor ? `\x1b[1m${s}\x1b[0m` : s),
-    dim: (s) => (useColor ? `\x1b[2m${s}\x1b[0m` : s),
+    // Light on a dark terminal, dark on a light one (manual 6.10).
+    text: (s) => (light() ? rgb(40, 44, 52)(s) : rgb(214, 219, 228)(s)),
+    bold: (s) => (useColorNow() ? `\x1b[1m${s}\x1b[0m` : s),
+    dim: (s) => (useColorNow() ? `\x1b[2m${s}\x1b[0m` : s),
 };
 /** The prism: white light entering, a spectrum leaving. The brand in one line. */
 const SPECTRUM = [
@@ -75,13 +81,13 @@ const SPECTRUM = [
  * and the brand is the one thing a customer notices before the engine.
  */
 function spectrumAt(index, glyph) {
-    if (!useColor)
+    if (!useColorNow())
         return glyph;
     const [r, g, b] = SPECTRUM[Math.abs(index) % SPECTRUM.length];
     return `\x1b[38;2;${r};${g};${b}m${glyph}\x1b[0m`;
 }
 function prismRule(w = width()) {
-    if (!useColor)
+    if (!useColorNow())
         return '-'.repeat(w);
     const seg = Math.max(1, Math.floor(w / SPECTRUM.length));
     let out = '';
@@ -197,29 +203,29 @@ function table(headers, rows) {
  * out of the way, leaving the answer and a one-line receipt.
  */
 class LiveIndicator {
-    timer = null;
-    frame = 0;
-    label = '';
-    frames = ['◜', '◠', '◝', '◞', '◡', '◟'];
+    shown = false;
+    // No animation of its own. A glyph turning on a timer looks like work
+    // whether or not anything is happening; the line changes only when the
+    // caller has something new to say, and in plain mode each change is a new
+    // line rather than a redraw (manual 6.12).
     start(label) {
-        if (!isTty)
-            return;
-        this.label = label;
-        this.timer = setInterval(() => {
-            const glyph = this.frames[this.frame % this.frames.length];
-            this.frame += 1;
-            process.stdout.write(`\r  ${exports.c.purple(glyph)} ${exports.c.dim(this.label)}   `);
-        }, 90);
+        this.draw(label);
     }
     update(label) {
-        this.label = label;
+        this.draw(label);
+    }
+    draw(label) {
+        if (plainNow()) {
+            process.stdout.write(`  ${label}\n`);
+            return;
+        }
+        process.stdout.write(`\r  ${exports.c.purple('◠')} ${exports.c.dim(label)}   `);
+        this.shown = true;
     }
     stop() {
-        if (this.timer)
-            clearInterval(this.timer);
-        this.timer = null;
-        if (isTty)
+        if (this.shown && !plainNow())
             process.stdout.write(`\r${' '.repeat(width())}\r`);
+        this.shown = false;
     }
 }
 exports.LiveIndicator = LiveIndicator;

package/out/lib/voice.js

@@ -143,6 +143,30 @@ function start() {
         stdio: ['ignore', 'ignore', 'ignore'],
     });
     let stopped = null;
+    // The recorder never outlives the session. Closing the window or ending the
+    // process while it listens would otherwise leave a microphone recording to a
+    // file nobody knows about, the worst thing this tool could do.
+    const abandon = () => {
+        try {
+            child.kill('SIGKILL');
+        }
+        catch { /* already gone */ }
+        discard(file);
+    };
+    const onSignal = (signal) => {
+        abandon();
+        release();
+        process.kill(process.pid, signal);
+    };
+    const release = () => {
+        process.off('exit', abandon);
+        process.off('SIGHUP', onSignal);
+        process.off('SIGTERM', onSignal);
+    };
+    process.once('exit', abandon);
+    process.once('SIGHUP', onSignal);
+    process.once('SIGTERM', onSignal);
+    child.once('close', release);
     const stop = () => {
         if (stopped)
             return stopped;

package/out/postinstall.js

@@ -1,5 +1,8 @@
 #!/usr/bin/env node
 "use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 /**
  * Runs on `npm install -g @illuminis/comprism`. Rule R1.
@@ -20,8 +23,26 @@ Object.defineProperty(exports, "__esModule", { value: true });
  * swallowing its own errors. A package that fails to install because its
  * telemetry could not configure itself deserves to be uninstalled.
  */
+const node_fs_1 = __importDefault(require("node:fs"));
 const install_1 = require("./commands/install");
 const readiness_1 = require("./lib/readiness");
+/**
+ * Written to the terminal itself, not to npm. npm hides everything an install
+ * script prints unless the install fails, so the next steps a person needs
+ * right now never reached the screen (owner, 27 September 2026). Falls back to
+ * standard output where there is no terminal, such as a build server's log.
+ */
+function say(text) {
+    const tty = process.platform === 'win32' ? 'CONOUT$' : '/dev/tty';
+    try {
+        const fd = node_fs_1.default.openSync(tty, 'w');
+        node_fs_1.default.writeSync(fd, text);
+        node_fs_1.default.closeSync(fd);
+    }
+    catch {
+        process.stdout.write(text);
+    }
+}
 async function main() {
     // Local development installs (`npm install` inside the repo) should not touch
     // the developer's shell profile. Only a global install means "set me up".
@@ -44,29 +65,33 @@ async function main() {
         if (report.desktop.staleRemoved) {
             desktopLines.push('    · removed an old CompletionPrism entry from Claude Desktop (it could not answer)');
         }
-        if (report.desktop.note) {
+        // Only when Claude Desktop is on this machine: a line about an app somebody
+        // does not have is noise in a list of next steps.
+        if (report.desktop.note && report.desktop.present) {
             desktopLines.push(`    · ${report.desktop.note}`);
         }
         else if (report.desktop.present && report.baseUrl) {
             desktopLines.push(`    · Claude Desktop: add ${report.baseUrl}/mcp under Settings > Connectors`);
         }
-        process.stdout.write([
+        // A short numbered list of what to do next, and nothing a person has to
+        // decode. The setup detail (which profile got a line) is one quiet line.
+        const signIn = !(report.enrolled && report.baseUrl);
+        const steps = [
+            'Open a new terminal window.',
+            ...(signIn ? ['Sign in:              comprism login'] : []),
+            'Start working:        comprism      (or claude, already measured)',
+            ...(report.baseUrl ? [`See what it saved:    ${report.baseUrl}`] : []),
+        ];
+        say([
             '',
-            '  CompletionPrism is set up.',
-            `    · interception configured against ${report.baseUrl || 'no tenant yet - run `comprism connect`'}`,
-            ...report.profilesTouched.map((p) => `    · added one line to ${p}`),
-            ...report.profilesAlreadyHad.map((p) => `    · already configured in ${p}`),
-            ...desktopLines,
+            '  CompletionPrism is installed.',
             '',
-            '  Open a new terminal and just work:',
-            '    claude            your tools, instrumented, unchanged',
-            '    comprism          our own session',
-            '    comprism check    what this machine still needs',
+            '  Next steps',
+            ...steps.map((line, i) => `    ${i + 1}. ${line}`),
+            ...desktopLines,
             '',
-            ...(report.baseUrl
-                ? [`  What your work cost: ${report.baseUrl}`, '']
-                : []),
-            '  If our recorder is ever down your tools are unaffected. Undo with `comprism uninstall`.',
+            ...report.profilesTouched.map((p) => `  Set up in ${p}.`),
+            '  To remove it later, one command: comprism uninstall',
             '',
         ].join('\n'));
         // What this machine still needs, said at the only moment somebody is
@@ -76,7 +101,7 @@ async function main() {
         // already fine is noise on a screen somebody is about to close.
         const machine = (0, readiness_1.check)();
         if (!machine.ready) {
-            process.stdout.write([
+            say([
                 '  Two things the work itself may need on this machine:',
                 ...machine.lines,
                 '',
@@ -89,7 +114,7 @@ async function main() {
     }
     catch {
         // Never fail an install over setup. The user can run `comprism install`.
-        process.stdout.write('\n  CompletionPrism installed. Run `comprism install` to finish setup.\n\n');
+        say('\n  CompletionPrism is installed. Next step: open a new terminal and run `comprism install`.\n\n');
     }
 }
 void main();

package/out/providers/anthropic.d.ts

@@ -0,0 +1,22 @@
+/**
+ * Anthropic adapter.
+ *
+ * Deliberately dependency-free: the Messages API over `fetch`, nothing else.
+ * The Companion has to install into someone else's tool without dragging a
+ * dependency tree behind it, and a proxy that sits in front of a provider is a
+ * poor place to inherit somebody's transitive supply chain.
+ */
+import type { Message, ProviderResult } from '../lib/types';
+export interface AnthropicCall {
+    model: string;
+    messages: Message[];
+    maxTokens: number;
+    apiKey: string;
+}
+export declare function callAnthropic(call: AnthropicCall): Promise<ProviderResult>;
+/** Carries the status code so the shared retry policy can read it. */
+export declare class ProviderHttpError extends Error {
+    status: number;
+    latencyMs: number;
+    constructor(status: number, message: string);
+}