@illuminis/comprism 0.1.4 → 0.1.6

package/out/agent/command.js

@@ -56,11 +56,11 @@ exports.runAgent = runAgent;
 const fs = __importStar(require("fs"));
 const readline = __importStar(require("readline"));
 const connection_1 = require("../lib/connection");
-const project_1 = require("../lib/project");
+const project_1 = require("../machine/folder/project");
 const session_1 = require("./session");
 const ui = __importStar(require("./render"));
 const output_1 = require("../lib/output");
-const self_1 = require("../lib/self");
+const self_1 = require("../machine/runtime/self");
 /** The WebSocket the session needs is a global from Node 22.
  *
  *  Checked here with a message somebody can act on. Without it the failure is
@@ -219,7 +219,7 @@ async function runAgent(args) {
     // `--sandbox` never runs without one (manual 4.12): refused before anything
     // runs or is charged.
     if (args.sandbox) {
-        const { availability } = await Promise.resolve().then(() => __importStar(require("../executor/sandbox")));
+        const { availability } = await Promise.resolve().then(() => __importStar(require("../machine/executor/sandbox")));
         const found = availability();
         if (!found.system) {
             process.stderr.write(ui.red(`  --sandbox cannot start: ${found.why}.`)
@@ -414,7 +414,7 @@ ${ui.bold("comprism work")} — a coding agent in your terminal
   comprism work "add a test for the parser and make it pass"
 
 ${ui.bold("What it does")}
-  Reads your project, changes files, runs commands and runs your tests. It
+  Reads your workspace, changes files, runs commands and runs your tests. It
   shows you every change as it makes it, asks before deleting a file or
   running a command, and can undo the whole job. Each step is routed to whichever
   model finishes the work for least, and the receipt at the end says what it
@@ -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

@@ -1,4 +1,4 @@
-import { type ProjectFacts } from "../lib/project";
+import { type ProjectFacts } from "../machine/folder/project";
 import * as ui from "./render";
 export interface SessionOptions {
     /** Where the workspace lives, and the URL of the server that owns it. */
@@ -106,7 +106,12 @@ export interface SessionOptions {
     /** `--output stream`: handed the service's stream lines as they arrive. */
     onStream?: (items: Array<Record<string, unknown>>) => void;
 }
+/** How many next steps the last job offered (web manual 13.4), so a bare number
+ *  typed next is sent to the service to run one rather than to the agent. */
+export declare let waitingNextSteps: number;
 export interface JobResult {
+    /** The service's lines for the next steps it offered, printed as sent. */
+    nextSteps?: string[];
     outcome: string;
     detail?: string | null;
     jobId?: string;
@@ -122,6 +127,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 +176,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 +308,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.