@illuminis/comprism 0.1.4 → 0.1.5

package/out/agent/command.js

@@ -428,7 +428,7 @@ ${ui.bold("Options")}
                      being asked about one at a time; commands still ask
   --model <id>       tell it which model you are running, so the receipt can
                      price the saving against it. It may still move you up
-  --pin              run --model and nothing else, whatever it would prefer
+  --no-optimize      Optimize off: run --model and nothing else (also --pin)
   --max-spend <usd>  stop at this much rather than running on
   --max-steps <n>    stop after this many steps
   --max-minutes <n>  start no new step after this many minutes

package/out/agent/render.d.ts

@@ -77,6 +77,24 @@ export declare function stoppedLines(stopped: string[]): string;
 export declare function ending(line: string, detail: string | null | undefined): string;
 /** How the job ended, in the words a person reads. */
 export declare function outcome(o: string, detail: string | null | undefined): string;
+/**
+ * A link a person can click, where the terminal supports one.
+ *
+ * Modern terminals understand an escape that carries an address behind a piece
+ * of text; older ones print it as ordinary characters, so the address is shown
+ * in words there instead. Never a bare escape with no fallback: a receipt whose
+ * proof is unreachable is not proof.
+ */
+export declare function link(text: string, url: string): string;
+/**
+ * A file the agent made, as a link that opens it, with where it lives beneath.
+ *
+ * The name alone is not enough: somebody who asked from their home folder for a
+ * diagram cannot tell which folder "saved diagram.png" means. So the full path
+ * is written out underneath in gray, where it can be copied into Finder or a
+ * terminal, and the name above it opens the file on a click.
+ */
+export declare function savedFile(name: string, fullPath: string, bytes: string): string;
 /** One model's share of a job, as our server reported it. */
 export interface ModelShare {
     model: string | null;
@@ -84,6 +102,18 @@ export interface ModelShare {
     usd: number | null;
     unpriced?: number;
 }
+/** The receipt card, exactly as the server words it for every client. */
+export interface ReceiptCard {
+    model: string | null;
+    title: string | null;
+    vs: string | null;
+    amount: string | null;
+    saved: boolean;
+    /** The label of the link to the whole record. */
+    details?: string | null;
+    badge: string | null;
+    warning: string | null;
+}
 /**
  * The receipt under a finished job.
  *
@@ -100,13 +130,16 @@ export interface ModelShare {
  * it, quieten it, and turn the address in it into something clickable. That is
  * formatting, which belongs to the client, and it is the only part that does.
  */
-export declare function receipt(text: string, models?: ModelShare[], testsPassed?: boolean): string;
+export declare function receipt(text: string, models?: ModelShare[], testsPassed?: boolean, card?: ReceiptCard | null): string;
 /**
- * Plain text, from a model that writes markdown.
+ * An answer, laid out for reading in a terminal (manual 6.17).
  *
- * A terminal has no bold and no bullet glyphs, so `**like this**` arrives on
- * screen as literal asterisks and a heading looks like a typing mistake. The
- * emphasis is real, so it is kept as terminal bold rather than thrown away;
- * everything that only exists to be rendered by a browser is removed.
+ * The approved design (docs/product/design/cli-answer, option B): the whole
+ * answer on one left margin behind a violet rail, so where the question ends
+ * and the answer begins is never in doubt; words wrapped at a reading width
+ * and never split by the window edge; a blank line between every block;
+ * headings in the brand violet; code in its own color; wrapped list items
+ * continuing under their own text. Piped to a file or another program, the
+ * same answer comes out without the rail or the color, as a log wants it.
  */
 export declare function plain(text: string): string;

package/out/agent/render.js

@@ -36,10 +36,13 @@ exports.diff = diff;
 exports.stoppedLines = stoppedLines;
 exports.ending = ending;
 exports.outcome = outcome;
+exports.link = link;
+exports.savedFile = savedFile;
 exports.receipt = receipt;
 exports.plain = plain;
 /** Built from a character code rather than written as a literal escape, so this
  *  file contains no control characters and stays safe to grep, diff and paste. */
+const url_1 = require("url");
 const CSI = String.fromCharCode(27) + "[";
 /** Decided when drawn, so plain mode set at start up applies (manual 6.12). */
 const supportsColour = () => process.stdout.isTTY && !process.env.NO_COLOR;
@@ -260,6 +263,32 @@ function link(text, url) {
         return `${text} (${url})`;
     return `]8;;${url}${text}]8;;`;
 }
+/**
+ * A file the agent made, as a link that opens it, with where it lives beneath.
+ *
+ * The name alone is not enough: somebody who asked from their home folder for a
+ * diagram cannot tell which folder "saved diagram.png" means. So the full path
+ * is written out underneath in gray, where it can be copied into Finder or a
+ * terminal, and the name above it opens the file on a click.
+ */
+function savedFile(name, fullPath, bytes) {
+    const href = (0, url_1.pathToFileURL)(fullPath).href;
+    return `${(0, exports.green)("  saved  ")}${link(name, href)}${(0, exports.dim)(`  ${bytes} bytes`)}\n`
+        + `${(0, exports.gray)(`         ${fullPath}`)}\n`;
+}
+/** The card's two lines, as the approved look draws them. */
+function cardRows(card) {
+    const rows = [];
+    const head = [card.title ? (0, exports.bold)(card.title) : "", card.badge ? (0, exports.violet)(card.badge) : "",
+        card.vs ? (0, exports.dim)(card.vs) : ""].filter(Boolean).join(" ");
+    if (head)
+        rows.push(head);
+    if (card.amount)
+        rows.push(card.saved ? (0, exports.bold)((0, exports.green)(card.amount)) : (0, exports.dim)(card.amount));
+    if (card.warning)
+        rows.push((0, exports.dim)(card.warning));
+    return rows;
+}
 /**
  * The receipt under a finished job.
  *
@@ -276,9 +305,9 @@ function link(text, url) {
  * it, quieten it, and turn the address in it into something clickable. That is
  * formatting, which belongs to the client, and it is the only part that does.
  */
-function receipt(text, models = [], testsPassed) {
-    const lines = [];
-    for (const line of String(text || "").split("\n")) {
+function receipt(text, models = [], testsPassed, card) {
+    const lines = card ? cardRows(card).map((r) => `  ${r}`) : [];
+    for (const line of card ? [] : String(text || "").split("\n")) {
         if (!line.trim())
             continue;
         // The address our server put in the sentence becomes a real link, and the
@@ -309,7 +338,13 @@ function receipt(text, models = [], testsPassed) {
         return "";
     // On a screen, the receipt is a highlighted box, as on the website. Piped to
     // a file or another program it stays plain lines, which is what a log wants.
-    return process.stdout.isTTY ? boxed(text, models, testsPassed) : `${lines.join("\n")}\n`;
+    if (card) {
+        // The link the server put in its sentence still goes last.
+        const found = /\[([^\]]+)\]\(([^)]+)\)/.exec(String(text || ""));
+        if (found)
+            lines.push((0, exports.dim)(`  ${link(String(card.details || found[1]), String(found[2]))}`));
+    }
+    return process.stdout.isTTY ? boxed(text, models, testsPassed, card) : `${lines.join("\n")}\n`;
 }
 /** Words wrapped to a width, never breaking a word. */
 function wrap(text, room) {
@@ -332,12 +367,20 @@ function wrap(text, room) {
  * everything else quiet. The server's words are unchanged; each clause it
  * separated with `|` gets its own line, and its link goes last, clickable.
  */
-function boxed(text, models, testsPassed) {
+function boxed(text, models, testsPassed, card) {
     // Room for the border, the padding and the `receipt` label on the first line.
     const inner = width() - 16;
-    const rows = [];
+    const rows = card ? cardRows(card) : [];
     const links = [];
     for (const raw of String(text || "").split("\n")) {
+        if (card) {
+            // The card carries the words; only the sentence's link is kept.
+            raw.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => {
+                links.push({ label: String(card.details || label), url: String(url) });
+                return "";
+            });
+            continue;
+        }
         const withoutLinks = raw.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, label, url) => {
             links.push({ label: String(label), url: String(url) });
             return "";
@@ -369,30 +412,246 @@ function boxed(text, models, testsPassed) {
     const body = rows.map((r) => `  ${(0, exports.violet)("\u2502")} ${r}${" ".repeat(widest - visible(r).length)} ${(0, exports.violet)("\u2502")}`);
     return [`  ${(0, exports.violet)(`\u256d${bar}\u256e`)}`, ...body, `  ${(0, exports.violet)(`\u2570${bar}\u256f`)}`].join("\n") + "\n";
 }
+/** A markdown table's cells, with emphasis and code marks taken off and a
+ *  `<br>` kept as a line break inside the cell. */
+function cells(row) {
+    return row.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((c) => c.trim()
+        .replace(/\*\*([^*]+)\*\*/g, "$1").replace(/__([^_]+)__/g, "$1").replace(/`([^`]+)`/g, "$1")
+        .replace(/<br\s*\/?>/gi, "\n"));
+}
+/** Widths that fit the terminal: each column its natural width when they all
+ *  fit, otherwise the narrow ones keep theirs and the wide ones share the rest. */
+function fitWidths(natural, room) {
+    const out = natural.map(() => 0);
+    let left = room;
+    let open = natural.map((_, i) => i).sort((a, b) => natural[a] - natural[b]);
+    while (open.length) {
+        const share = Math.floor(left / open.length);
+        const i = open[0];
+        if (natural[i] <= share) {
+            out[i] = natural[i];
+            left -= natural[i];
+            open = open.slice(1);
+            continue;
+        }
+        for (const j of open)
+            out[j] = Math.max(6, share);
+        break;
+    }
+    return out;
+}
+/** One cell's text as lines no wider than its column. */
+function cellLines(text, w) {
+    const lines = [];
+    for (const part of text.split("\n")) {
+        const words = wrap(part, w);
+        for (const l of words.length ? words : [""]) {
+            // A single word longer than the column is cut, never allowed to push the border.
+            for (let k = 0; k < Math.max(1, l.length); k += w)
+                lines.push(l.slice(k, k + w));
+        }
+    }
+    return lines;
+}
+/**
+ * Markdown tables drawn as terminal tables.
+ *
+ * A model asked for "a summary table" writes pipes and dashes, which a browser
+ * draws and a terminal shows as raw markup. Each block of `|` rows with a
+ * `|---|` line under its header becomes a boxed table, with long cells wrapped
+ * inside their column so the table always fits the window.
+ */
+function tables(text) {
+    const lines = text.split("\n");
+    const out = [];
+    const isRow = (l) => l !== undefined && /^\s*\|.*\|\s*$/.test(l);
+    const isRule = (l) => l !== undefined && /^\s*\|?\s*:?-{2,}:?\s*(\|\s*:?-{2,}:?\s*)*\|?\s*$/.test(l);
+    for (let i = 0; i < lines.length; i++) {
+        if (!(isRow(lines[i]) && isRule(lines[i + 1]))) {
+            out.push(lines[i]);
+            continue;
+        }
+        const head = cells(lines[i]);
+        const body = [];
+        i += 2;
+        while (isRow(lines[i]))
+            body.push(cells(lines[i++]));
+        i--;
+        const cols = head.length;
+        const rows = [head, ...body].map((r) => Array.from({ length: cols }, (_, k) => r[k] ?? ""));
+        const natural = Array.from({ length: cols }, (_, k) => Math.max(3, ...rows.map((r) => Math.max(...r[k].split("\n").map((s) => s.length)))));
+        const w = fitWidths(natural, width() - 4 - (3 * cols + 1));
+        const bar = (l, m, r) => (0, exports.dim)(`  ${l}${w.map((n) => "─".repeat(n + 2)).join(m)}${r}`);
+        const draw = (r, strong) => {
+            const wrapped = r.map((c, k) => cellLines(c, w[k]));
+            const height = Math.max(...wrapped.map((c) => c.length));
+            for (let h = 0; h < height; h++) {
+                out.push(`  ${(0, exports.dim)("│")}${wrapped.map((c, k) => {
+                    const s = (c[h] ?? "").padEnd(w[k]);
+                    return ` ${strong ? (0, exports.bold)(s) : s} `;
+                }).join((0, exports.dim)("│"))}${(0, exports.dim)("│")}`);
+            }
+        };
+        out.push(bar("┌", "┬", "┐"));
+        draw(rows[0], true);
+        out.push(bar("├", "┼", "┤"));
+        rows.slice(1).forEach((r, n) => {
+            draw(r, false);
+            if (n < rows.length - 2)
+                out.push(bar("├", "┼", "┤"));
+        });
+        out.push(bar("└", "┴", "┘"));
+    }
+    return out.join("\n");
+}
+/** The answer's two accents, one pair per terminal background (manual 6.10):
+ *  the brand violet and amber on a dark terminal, the brand purple and deep
+ *  blue on a light one, each above 4.5 to 1 against its background. */
+const onLight = () => process.env.COMPRISM_THEME === "light";
+const headingPaint = (t) => paint(onLight() ? "1;38;2;107;91;167" : "1;38;5;141", t);
+const codePaint = (t) => paint(onLight() ? "38;2;31;77;120" : "38;2;217;119;6", t);
+/** Characters of text per line, the width Glow and Claude Code read at. */
+const READING_WIDTH = 80;
+const same = (t) => t;
+/** A line of markdown as words, each piece carrying its own emphasis, so a
+ *  wrapped line never starts inside a color it cannot see the start of. */
+function words(text) {
+    const linked = text.replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} (${u})`);
+    const parts = [];
+    const re = /(\*\*[^*]+\*\*|__[^_]+__|`[^`]+`|\*[^*\s][^*]*\*)/g;
+    let last = 0;
+    for (let m = re.exec(linked); m; m = re.exec(linked)) {
+        parts.push({ t: linked.slice(last, m.index), p: same });
+        const s = m[0];
+        parts.push(s.startsWith("`") ? { t: s.slice(1, -1), p: codePaint }
+            : s.startsWith("**") || s.startsWith("__") ? { t: s.slice(2, -2), p: exports.bold }
+                : { t: s.slice(1, -1), p: (t) => paint("3", t) });
+        last = m.index + s.length;
+    }
+    parts.push({ t: linked.slice(last), p: same });
+    const out = [];
+    let cur = [];
+    for (const part of parts) {
+        for (const piece of part.t.split(/(\s+)/)) {
+            if (!piece)
+                continue;
+            if (/^\s+$/.test(piece)) {
+                if (cur.length) {
+                    out.push(cur);
+                    cur = [];
+                }
+            }
+            else
+                cur.push({ t: piece, p: part.p });
+        }
+    }
+    if (cur.length)
+        out.push(cur);
+    return out;
+}
+const show = (w) => w.map((x) => x.p(x.t)).join("");
+const size = (w) => w.reduce((n, x) => n + x.t.length, 0);
+/** Words filled into lines no wider than `room`, a word never split, every
+ *  line after the first starting under the first line's text. */
+function fill(text, lead, hang, room) {
+    const lines = [];
+    let line = lead, used = visible(lead).length, empty = true;
+    for (const w of words(text)) {
+        if (!empty && used + 1 + size(w) > room) {
+            lines.push(line);
+            line = hang;
+            used = visible(hang).length;
+            empty = true;
+        }
+        line += (empty ? "" : " ") + show(w);
+        used += (empty ? 0 : 1) + size(w);
+        empty = false;
+    }
+    lines.push(line);
+    return lines;
+}
 /**
- * Plain text, from a model that writes markdown.
+ * An answer, laid out for reading in a terminal (manual 6.17).
  *
- * A terminal has no bold and no bullet glyphs, so `**like this**` arrives on
- * screen as literal asterisks and a heading looks like a typing mistake. The
- * emphasis is real, so it is kept as terminal bold rather than thrown away;
- * everything that only exists to be rendered by a browser is removed.
+ * The approved design (docs/product/design/cli-answer, option B): the whole
+ * answer on one left margin behind a violet rail, so where the question ends
+ * and the answer begins is never in doubt; words wrapped at a reading width
+ * and never split by the window edge; a blank line between every block;
+ * headings in the brand violet; code in its own color; wrapped list items
+ * continuing under their own text. Piped to a file or another program, the
+ * same answer comes out without the rail or the color, as a log wants it.
  */
 function plain(text) {
-    return text
-        // Fenced code keeps its content and loses its fence markers.
-        .replace(/^```[a-zA-Z0-9]*\n?/gm, '')
-        .replace(/^```$/gm, '')
-        // Headings become their own words, emphasized.
-        .replace(/^#{1,6}\s+(.+)$/gm, (_m, t) => (0, exports.bold)(String(t)))
-        // Bold and italic become the terminal's own emphasis.
-        .replace(/\*\*([^*]+)\*\*/g, (_m, t) => (0, exports.bold)(String(t)))
-        .replace(/__([^_]+)__/g, (_m, t) => (0, exports.bold)(String(t)))
-        .replace(/(^|[^*])\*([^*\n]+)\*/g, (_m, pre, t) => pre + String(t))
-        // A bullet is a bullet, not an asterisk.
-        .replace(/^\s*[*-]\s+/gm, '  . ')
-        // Inline code keeps its text; the backticks were never for a terminal.
-        .replace(/`([^`]+)`/g, (_m, t) => String(t))
-        // A link reads as its words, with the address after it.
-        .replace(/\[([^\]]+)\]\(([^)]+)\)/g, (_m, t, u) => `${t} (${u})`)
-        .replace(/\n{3,}/g, '\n\n');
+    const screen = supportsColour();
+    const lead = screen ? `  ${paint(onLight() ? "38;2;107;91;167" : "38;5;141", "│")} ` : "  ";
+    const railOnly = screen ? lead.trimEnd() : "";
+    const room = Math.min(width() - 1, visible(lead).length + READING_WIDTH);
+    const src = text.replace(/\r\n/g, "\n").split("\n");
+    const out = [];
+    const gap = () => { if (out.length && out[out.length - 1] !== railOnly)
+        out.push(railOnly); };
+    const isTableRow = (l) => l !== undefined && /^\s*\|.*\|\s*$/.test(l);
+    const startsBlock = (l) => /^\s*([-*+•]\s|\d+[.)]\s|#{1,6}\s|```|>|\|)/.test(l) || /^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(l);
+    for (let i = 0; i < src.length; i++) {
+        const l = src[i];
+        if (!l.trim())
+            continue;
+        if (/^\s*```/.test(l)) {
+            gap();
+            for (i++; i < src.length && !/^\s*```/.test(src[i]); i++)
+                out.push(`${lead}  ${codePaint(src[i])}`);
+            continue;
+        }
+        const h = /^\s*#{1,6}\s+(.+?)\s*#*\s*$/.exec(l);
+        if (h) {
+            gap();
+            out.push(lead + headingPaint(h[1].replace(/\*\*/g, "")));
+            gap();
+            continue;
+        }
+        if (/^\s*([-*_])\s*\1\s*\1[\s\-*_]*$/.test(l)) {
+            gap();
+            continue;
+        }
+        if (isTableRow(l)) {
+            const block = [];
+            while (isTableRow(src[i]))
+                block.push(src[i++]);
+            i--;
+            gap();
+            // The table's own two space indent gives way to the rail, whether or
+            // not a color code comes before it.
+            const indent = new RegExp(`^((?:${String.fromCharCode(27)}\\[[0-9;]*m)*) {2}`);
+            for (const row of tables(block.join("\n")).split("\n"))
+                out.push(lead + row.replace(indent, "$1"));
+            gap();
+            continue;
+        }
+        const bullet = /^(\s*)([-*+•]|\d+[.)])\s+(.*)$/.exec(l);
+        if (bullet) {
+            if (out.length && !/^\s*([-*+•]|\d+[.)])\s/.test(src[i - 1] ?? ""))
+                gap();
+            const depth = Math.floor(bullet[1].replace(/\t/g, "  ").length / 2);
+            const mark = /\d/.test(bullet[2]) ? `${bullet[2].replace(")", ".")} ` : "• ";
+            let body = bullet[3];
+            // A list item that runs onto an indented next line is one item.
+            while (i + 1 < src.length && src[i + 1].trim() && /^\s{2,}\S/.test(src[i + 1]) && !startsBlock(src[i + 1]))
+                body += " " + src[++i].trim();
+            const indent = "  ".repeat(depth);
+            out.push(...fill(body, lead + indent + (0, exports.dim)(mark), lead + indent + " ".repeat(mark.length), room));
+            if (i + 1 < src.length && !/^\s*([-*+•]|\d+[.)])\s/.test(src[i + 1]))
+                gap();
+            continue;
+        }
+        // A paragraph is every line up to the next blank line or block.
+        let para = l.trim().replace(/^>\s?/, "");
+        while (i + 1 < src.length && src[i + 1].trim() && !startsBlock(src[i + 1]))
+            para += " " + src[++i].trim();
+        gap();
+        out.push(...fill(para, lead, lead, room));
+        gap();
+    }
+    while (out.length && out[out.length - 1] === railOnly)
+        out.pop();
+    return out.join("\n");
 }

package/out/agent/session.d.ts

@@ -122,6 +122,8 @@ export interface JobResult {
      *  model and the arithmetic are all on the server, so a client that wrote its
      *  own wording would be a second answer to the same question. */
     receipt: string;
+    /** The receipt card, worded by the server. Drawn as sent. */
+    card?: ui.ReceiptCard | null;
     /** Which models did the work, and each one's share, as the server reported
      *  it. Taken as sent, never recalculated here. */
     models: ui.ModelShare[];
@@ -169,6 +171,15 @@ export declare class TerminalSession {
      *  with nothing between the copies. */
     private lastSaid;
     private canceled;
+    /** The live "thinking 12s" line while the model works on a step. Drawn in
+     *  place and erased before anything else prints, so it never lands in the
+     *  answer. Without it a step is a blank screen for as long as the model takes,
+     *  and "thinking" and "hung" look identical. */
+    private working;
+    /** When the current wait began, kept across the line being redrawn. Cleared
+     *  when a step finishes, so the next step counts from its own start. */
+    private workFrom;
+    private readonly write;
     constructor(opts: SessionOptions, write?: (s: string) => void);
     /** Where the socket lives, derived from the workspace URL.
      *
@@ -292,6 +303,10 @@ export declare class TerminalSession {
     /** An action as approved: its name, its arguments and the real folder it
      *  runs in, so a changed argument or a moved folder is caught. */
     private fingerprint;
+    /** Starts the working line with the service's own words. Only on a real
+     *  terminal: a piped or unattended run gets the answer and nothing else. */
+    private startWorking;
+    private stopWorking;
     private narrate;
     private targetOf;
     /** Put a change in front of the person and wait.

package/out/agent/session.js

@@ -97,9 +97,19 @@ class TerminalSession {
      *  with nothing between the copies. */
     lastSaid = "";
     canceled = false;
+    /** The live "thinking 12s" line while the model works on a step. Drawn in
+     *  place and erased before anything else prints, so it never lands in the
+     *  answer. Without it a step is a blank screen for as long as the model takes,
+     *  and "thinking" and "hung" look identical. */
+    working = null;
+    /** When the current wait began, kept across the line being redrawn. Cleared
+     *  when a step finishes, so the next step counts from its own start. */
+    workFrom = null;
+    write;
     constructor(opts, write = (s) => process.stdout.write(s)) {
         this.opts = opts;
-        this.out = write;
+        this.write = write;
+        this.out = (s) => { this.stopWorking(); write(s); };
         this.executor = new executor_1.NativeExecutor({
             root: opts.root,
             added: opts.project?.added ?? [],
@@ -335,6 +345,13 @@ class TerminalSession {
                 request += selectionText(await this.editor.context());
             }
         }
+        // Working from the moment the request leaves, not from the moment the
+        // model starts. The pass, the stream and the service's own preparation
+        // take several seconds before the first step, and a blank screen for that
+        // long reads as nothing happening. The service's words replace this as
+        // soon as its first step starts.
+        this.workFrom = null;
+        this.startWorking("thinking");
         const granted = await this.pass(request);
         if (this.olderWorkspace) {
             // Straight on to the stream with the credential, silently. A person does
@@ -621,6 +638,7 @@ class TerminalSession {
                         // The sentence the server wrote. Everything a reader is told about
                         // cost and saving comes from here.
                         result.receipt = String(frame.receipt ?? "");
+                        result.card = frame.card ?? null;
                         result.reusedPct = ui.reusePct(0, frame.cached_tokens, Math.max(0, Number(frame.context_tokens ?? 0) - Number(frame.cached_tokens ?? 0)));
                         result.text = String(frame.text ?? "");
                         result.why = this.lastWhy;
@@ -685,6 +703,7 @@ class TerminalSession {
                 socket.onclose = () => {
                     if (socket !== this.socket)
                         return;
+                    this.stopWorking();
                     if (finished || this.canceled || !this.jobId) {
                         // One job on its own is its session, so what it started ends with it
                         // and is listed (manual 5.13). Inside a session they carry on.
@@ -882,8 +901,35 @@ class TerminalSession {
             : v);
         return JSON.stringify([name, sorted(input), folder]);
     }
+    /** Starts the working line with the service's own words. Only on a real
+     *  terminal: a piped or unattended run gets the answer and nothing else. */
+    startWorking(line) {
+        this.stopWorking();
+        if (!line || this.opts.headless || !process.stdout.isTTY)
+            return;
+        // One count for one wait: the service's words taking over from the
+        // request's own do not start the clock again.
+        const started = this.workFrom ??= Date.now();
+        const draw = () => this.write(`\r\x1b[2K  ${ui.dim(`${line}  ${ui.duration(Date.now() - started)}`)}`);
+        draw();
+        const timer = setInterval(draw, 1000);
+        timer.unref?.();
+        this.working = { timer };
+    }
+    stopWorking() {
+        if (!this.working)
+            return;
+        clearInterval(this.working.timer);
+        this.working = null;
+        this.write("\r\x1b[2K");
+    }
     narrate(frame) {
         switch (frame.kind) {
+            // The model is working on a step. Shown at once, so the wait is visibly
+            // work (the web app draws the same moment as its "thinking" row).
+            case "step_started":
+                this.startWorking(String(frame.line ?? ""));
+                break;
             // Helpers, in the service's words (manual 5.23, 5.25).
             case "helper_started":
                 this.helpers.set(String(frame.id), {
@@ -927,6 +973,8 @@ class TerminalSession {
                 if (this.allowanceLine)
                     this.out(this.allowanceLine);
                 this.allowanceLine = "";
+                // Still working: the first step has not started yet.
+                this.startWorking("thinking");
                 break;
             // Planning and plan approval, in the service's words (manual 4.1, 4.2).
             case "planning":
@@ -940,6 +988,7 @@ class TerminalSession {
                 this.out(ui.dim(`  ${String(frame.reason ?? "")}\n`));
                 break;
             case "step_finished": {
+                this.workFrom = null;
                 this.out(ui.step(Number(frame.index ?? 0), String(frame.model ?? ""), frame.usd, frame.latency_ms, ui.reusePct(frame.tokens_in, frame.cache_read_tokens, frame.cache_write_tokens), String(frame.reason ?? "")) + "\n");
                 if (Array.isArray(frame.why_lines))
                     this.lastWhy = frame.why_lines;
@@ -947,8 +996,8 @@ class TerminalSession {
                 // Markdown is for a browser. A terminal shows the asterisks.
                 if (said) {
                     // The plan is titled so it reads as the plan (manual 4.1).
-                    const plain = ui.plain(said).replace(/^\s*plan\s*\n/i, "");
-                    this.out(frame.plan ? `  ${ui.bold("Plan")}\n${plain}\n` : `\n${ui.plain(said)}\n`);
+                    const plan = ui.plain(said.replace(/^\s*(#+\s*)?\**plan\**:?\s*\n/i, ""));
+                    this.out(frame.plan ? `  ${ui.bold("Plan")}\n${plan}\n` : `\n${ui.plain(said)}\n`);
                     this.lastSaid = said;
                 }
                 break;
@@ -994,10 +1043,16 @@ class TerminalSession {
             case "document_made": {
                 const saved = frame.saved_to ? String(frame.saved_to) : "";
                 const bytes = Number(frame.bytes ?? 0).toLocaleString();
-                this.out(saved
-                    ? ui.green(`  saved  ${saved}`) + ui.dim(`  ${bytes} bytes\n`)
-                    : ui.yellow(`  made  ${String(frame.filename ?? "a file")}`)
-                        + ui.dim(`  ${bytes} bytes, not saved here\n`));
+                const name = String(frame.filename ?? "a file");
+                if (saved) {
+                    this.out(ui.savedFile(saved, path.resolve(this.opts.root, saved), bytes));
+                }
+                else {
+                    // Not written here, so the stored copy is the only way to it.
+                    const url = frame.url ? String(frame.url) : "";
+                    this.out(ui.yellow(`  made  `) + (url ? ui.link(name, url) : name)
+                        + ui.dim(`  ${bytes} bytes, not saved here${url ? ", click to download" : ""}\n`));
+                }
                 break;
             }
             case "compacting":
@@ -1141,13 +1196,13 @@ class TerminalSession {
             this.out(ui.ending(r.ending.line, r.detail));
             for (const line of r.ending.proof)
                 this.out(ui.dim(`  ${line}\n`));
-            this.out(ui.receipt(r.receipt, r.models));
+            this.out(ui.receipt(r.receipt, r.models, undefined, r.card));
         }
         else {
             this.out(ui.outcome(r.outcome, r.detail));
             for (const line of r.ending?.proof ?? [])
                 this.out(ui.dim(`  ${line}\n`));
-            this.out(ui.receipt(r.receipt, r.models, r.ending ? undefined : r.testsPassed));
+            this.out(ui.receipt(r.receipt, r.models, r.ending ? undefined : r.testsPassed, r.card));
         }
         if (r.jobId) {
             // The job's own reference, so a person can quote it. The link to the

package/out/commands/ask.js

@@ -50,6 +50,7 @@ const gateway_1 = require("../lib/gateway");
 const connection_1 = require("../lib/connection");
 const config_1 = require("../lib/config");
 const ui = __importStar(require("../lib/ui"));
+const render_1 = require("../agent/render");
 const prompt_1 = require("../lib/prompt");
 const output_1 = require("../lib/output");
 const stdout = (s = '') => process.stdout.write(s + '\n');
@@ -177,10 +178,18 @@ async function cmdAsk(args) {
         return 0;
     }
     out();
-    // The answer itself always reaches standard output (manual 10.2).
-    stdout(toErr ? reply.answer.trim() : reply.answer.trim());
+    // The answer itself always reaches standard output (manual 10.2). On a
+    // screen it is laid out for reading (manual 6.17); piped, it stays exactly
+    // as the model wrote it, for the program reading it.
+    const answer = reply.answer.trim();
+    stdout(process.stdout.isTTY ? (0, render_1.plain)(answer) : answer);
     out();
-    if (reply.receipt) {
+    if (reply.card) {
+        // The server's card, drawn as the approved look draws it.
+        out((0, render_1.receipt)(reply.receipt ?? '', [], undefined, reply.card).trimEnd());
+        out();
+    }
+    else if (reply.receipt) {
         out(ui.c.dim('  ' + reply.receipt.split('\n').join('\n  ')));
         out();
     }