@bli-cockpit/cli 0.2.53 → 0.2.55

package/dist/commands/jarvis.js

@@ -4,76 +4,31 @@
  * This file owns terminal input and output only. Identity comes from the
  * existing paired device session, and every turn is executed by the dashboard
  * through the same JARVIS runtime used by web chat and Slack.
- */
-import { colorEnabled, dim, isInteractiveStdin, readLine, readPipedText, writeFragment, writeLine, } from "./cli-io.js";
-import { attachedFileRefusalSentence, readAttachedImage, } from "./jarvis-attachment.js";
-import { rememberTurnTrace, runJarvisTrace } from "./jarvis-trace.js";
-import { loadPairedSession, towerFailureDetail, towerJsonRequest, towerRequest, } from "../tower-client.js";
-import { readTowerTurn, streamFailureDetail, turnTimingFields, } from "../tower-stream.js";
-/**
- * A citation line's link, as the dashboard mints it (BLI-3570):
- * `Source: BLI-1234 — Judge outage <https://linear.app/…>`. The words are the
- * receipt; the link is not part of the sentence, so the terminal prints it
- * underneath, dim, rather than dragging a 118-character URL through the answer.
- */
-const CITATION_LINK = /^(\s*(?:Source|Receipt)s?:.*?)\s*<(https?:\/\/[^>\s]+)>\s*$/i;
-/**
- * The answer, one line at a time, so a receipt's link gets its own dim line.
- * Every other line is printed exactly as it arrived — this never rewrites the
- * words, only where the link sits.
- */
-function writeReply(io, prefix, reply) {
-    const styled = colorEnabled(io);
-    const lines = reply.split("\n");
-    lines.forEach((line, index) => {
-        const head = index === 0 ? prefix : "";
-        const citation = line.match(CITATION_LINK);
-        if (!citation) {
-            writeLine(io.stdout, `${head}${line}`);
-            return;
-        }
-        writeLine(io.stdout, `${head}${citation[1]}`);
-        writeLine(io.stdout, dim(`  ${citation[2]}`, styled));
-    });
-}
-/**
- * The same link rule, applied to text that CONTINUES a line already on screen
- * (BLI-3517 + BLI-3570).
  *
- * When the answer streamed, the citation block arrives after the last token,
- * so `settle` has a tail to print rather than a whole reply. The first fragment
- * is deliberately never tested against `CITATION_LINK`: it is the rest of a
- * sentence the person is already reading, not a line of its own, and a regex
- * anchored at `^` would be matching against a boundary that is not there.
- * Every COMPLETE line after it gets the dim link treatment as usual.
+ * `runJarvis` below is the whole entry point and nothing else. Each
+ * responsibility lives in a named sibling, all still reachable only through
+ * this file (`./jarvis.js` is the address `local.ts` and the suites use):
  *
- * A citation that was already streamed inline cannot be split — a terminal
- * cannot unprint — and that is the honest limit of this, not a bug to chase.
- */
-function writeReplyContinuation(io, tail) {
-    const styled = colorEnabled(io);
-    const [first = "", ...rest] = tail.split("\n");
-    writeFragment(io.stdout, first);
-    for (const line of rest) {
-        writeLine(io.stdout, "");
-        const citation = line.match(CITATION_LINK);
-        if (!citation) {
-            writeFragment(io.stdout, line);
-            continue;
-        }
-        writeFragment(io.stdout, citation[1]);
-        writeLine(io.stdout, "");
-        writeFragment(io.stdout, dim(`  ${citation[2]}`, styled));
-    }
-    writeLine(io.stdout, "");
-}
-/**
- * The dashboard route caps a turn at 120s (`maxDuration = 120`). The client
- * waits slightly longer so the server's own named failure wins the race
- * whenever it manages to send one; past that, the terminal names the timeout
- * itself rather than sitting there.
- */
-const TURN_DEADLINE_MS = 125_000;
+ * - `jarvis-contracts.ts` — the parsed `cockpit jarvis` command type, and the
+ *   loose reply shapes read off `/api/jarvis/cli`, `--threads` and
+ *   `--history`.
+ * - `jarvis-turn.ts` — the turn engine: `sendOneTurn` (attach, request,
+ *   stream, settle, print, log — the one send for both a one-shot invocation
+ *   and the interactive loop below) and `readHistory` (`--threads` /
+ *   `--thread <name> --history`, the same class of act with no model call).
+ * - `jarvis-render.ts` — everything around a turn that is not the network
+ *   call: getting it ready to send (the question, the attachment multipart
+ *   body), reporting what it did (the failure sentence, the fallback-model
+ *   receipt, the latency fields), and drawing the answer and its "how I got
+ *   there" trace in a terminal, live and settled — a terminal cannot
+ *   unprint, which is why a reset or a correction says so on its own line
+ *   instead of erasing anything.
+ */
+import { readLine, writeLine } from "./cli-io.js";
+import { runJarvisTrace } from "./jarvis-trace.js";
+import { loadPairedSession } from "../tower-client.js";
+import { readHistory, sendOneTurn } from "./jarvis-turn.js";
+import { resolveOneShotPrompt } from "./jarvis-render.js";
 export async function runJarvis(command, io) {
     // Milliseconds since this process started (`performance.now()` counts from
     // `timeOrigin`), captured before this command does anything of its own.
@@ -150,634 +105,4 @@ export async function runJarvis(command, io) {
         if (turn.reply)
             previous = { answer: turn.reply, question: prompt };
     }
-}
-/**
- * `--threads` and `--thread <name> --history`.
- *
- * The whole conversation lives on the server; nothing is cached locally, so a
- * person who moves between machines sees the same history on both. The server
- * scopes it to the device holder's own account — this command cannot ask for
- * anybody else's, and there is no flag that would let it.
- */
-async function readHistory(context, io) {
-    const { command } = context;
-    const params = new URLSearchParams();
-    if (command.history) {
-        params.set("thread", command.thread);
-        if (command.limit)
-            params.set("limit", String(command.limit));
-    }
-    else {
-        params.set("threads", "1");
-    }
-    const result = await towerJsonRequest({
-        dashboardUrl: context.dashboardUrl,
-        path: `/api/jarvis/cli?${params.toString()}`,
-        deviceToken: context.deviceToken,
-        fetch: io.fetch,
-        method: "GET",
-        label: command.history ? "jarvis:thread" : "jarvis:threads",
-        timeoutMs: 30_000,
-        log: (line) => writeLine(io.stderr, line),
-    });
-    if (!result.ok) {
-        writeFailure(command, io, result.reason, result.detail);
-        return 1;
-    }
-    const body = result.body;
-    if (body.ok === false) {
-        writeFailure(command, io, "history_unavailable", body.reply ?? "Tower had nothing to show.");
-        return 1;
-    }
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify(body));
-    }
-    else if (command.history) {
-        writeThreadHistory(io, body);
-    }
-    else {
-        writeThreadList(io, body.threads ?? []);
-    }
-    writeLine(io.stderr, `[jarvis cli] history read ${JSON.stringify({
-        mode: command.history ? "thread" : "threads",
-        thread_count: body.threads?.length ?? null,
-        message_count: body.messages?.length ?? null,
-        truncated: body.truncated ?? null,
-    })}`);
-    return 0;
-}
-function writeThreadList(io, threads) {
-    if (threads.length === 0) {
-        // A real answer, not a blank. Nothing here means nothing was ever asked
-        // from this terminal, which is worth saying rather than implying.
-        writeLine(io.stdout, "No terminal conversations yet. Ask something with `cockpit jarvis`.");
-        return;
-    }
-    const styled = colorEnabled(io);
-    for (const thread of threads) {
-        const turns = thread.turnCount === 1 ? "1 turn" : `${thread.turnCount ?? 0} turns`;
-        writeLine(io.stdout, `${thread.name}  ${dim(`${turns} · ${thread.lastAt ?? "unknown"}`, styled)}`);
-        if (thread.preview)
-            writeLine(io.stdout, dim(`  ${thread.preview}`, styled));
-    }
-    writeLine(io.stdout, "");
-    writeLine(io.stdout, dim("Replay one with `cockpit jarvis --thread <name> --history`.", styled));
-}
-function writeThreadHistory(io, body) {
-    const messages = body.messages ?? [];
-    if (messages.length === 0) {
-        writeLine(io.stdout, `Nothing has been said in “${body.thread ?? "that thread"}” yet.`);
-        return;
-    }
-    if (body.truncated) {
-        writeLine(io.stdout, dim(`Showing the most recent ${messages.length}; there is more before this (\`--limit\`).`, colorEnabled(io)));
-    }
-    for (const message of messages) {
-        const speaker = message.role === "you" ? "you" : "jarvis";
-        writeLine(io.stdout, `${speaker}> ${message.text ?? ""}`);
-    }
-}
-async function resolveOneShotPrompt(command, io) {
-    if (command.prompt)
-        return validatePrompt(command.prompt);
-    if (isInteractiveStdin(io))
-        return null;
-    const piped = await readPipedText(io.stdin, { maxChars: 4000, overflowMessage: "JARVIS questions are limited to 4000 characters." });
-    return validatePrompt(piped);
-}
-async function sendOneTurn(context, prompt, io) {
-    const startedAt = Date.now();
-    // BLI-3414: an attached file is read and locally screened (exists,
-    // readable, a supported extension, under the byte ceiling) BEFORE any
-    // network call — a refusal here never reaches the dashboard and is
-    // terminal, same discipline as the panel's own attached-image gate.
-    let attachment = null;
-    if (context.command.imagePath) {
-        const read = await readAttachedImage(context.command.imagePath);
-        if (!read.ok) {
-            writeAttachmentRefusal(context.command, io, read.refusal, context.command.imagePath);
-            return { exitCode: 1, reply: null };
-        }
-        attachment = read;
-    }
-    // BLI-3457: streaming is the default. A dashboard that has not shipped the
-    // NDJSON half yet answers `application/json`, which the reader takes as a
-    // single final event and names `stream_not_available` — so the terminal
-    // works against both server versions with no flag.
-    const wantsStream = context.command.stream !== false;
-    const log = (line) => writeLine(io.stderr, line);
-    // BLI-3591: everything this turn did before the question left the machine.
-    // There is no self-update probe, no floor check and no settings fetch on
-    // this path — the ONLY awaits between the command starting and the POST are
-    // the paired-session read, the piped-prompt read and an attached image, and
-    // all three are named. If this number is ever large, the step that made it
-    // large is on the same line.
-    const preRequestMs = Date.now() - startedAt;
-    const requested = await towerRequest({
-        dashboardUrl: context.dashboardUrl,
-        path: "/api/jarvis/cli",
-        deviceToken: context.deviceToken,
-        fetch: io.fetch,
-        label: "jarvis",
-        timeoutMs: TURN_DEADLINE_MS,
-        headers: wantsStream ? { accept: "application/x-ndjson" } : {},
-        body: attachment
-            ? buildAttachmentForm(context.command, prompt, attachment)
-            : {
-                question: prompt,
-                thread: context.command.thread,
-                subject: context.command.subject,
-                model: context.command.model,
-                // BLI-3484: which day's page this turn is about. Sent verbatim — the
-                // dashboard decides what counts as a date and whose day it is.
-                date: context.command.date,
-                // BLI-3567: the answer this session last printed, so a correction can
-                // rewrite the paragraph it contradicts. Absent on a one-shot turn and
-                // on the first turn of a session, which is how the dashboard knows
-                // there is nothing above to revise.
-                previousAnswer: context.previous?.answer,
-                previousQuestion: context.previous?.question,
-            },
-        log,
-    });
-    if (!requested.ok) {
-        writeFailure(context.command, io, requested.reason, towerFailureDetail(requested.reason, requested.detail));
-        return { exitCode: 1, reply: null };
-    }
-    // Live trace lines go to a person as they land, never to a `--json`
-    // consumer: that contract is exactly one object on stdout, so the events are
-    // buffered and folded into the final payload instead. The same rule governs
-    // the answer's own words (BLI-3517): `--json` stays exactly one object.
-    let liveTraceLines = 0;
-    const live = createLiveAnswer(context.command, io);
-    const turn = await readTowerTurn(requested.response, {
-        startedAt,
-        log,
-        onActivity: (event) => {
-            if (context.command.json)
-                return;
-            // A trace row must never land in the middle of a half-written sentence.
-            live.interrupt();
-            if (writeActivityLine(io, event))
-                liveTraceLines += 1;
-        },
-        onToken: (event) => live.token(event),
-        // BLI-3567: the paragraph being rewritten says so while it happens. The
-        // terminal cannot mark the paragraph itself — it printed it turns ago — so
-        // the pending state is one dim line, in the same words the browsers use.
-        onRevision: (event) => {
-            if (context.command.json)
-                return;
-            if (event.revision?.status !== "pending")
-                return;
-            live.interrupt();
-            writeLine(io.stdout, dim(`  ${ANSWER_UPDATING_LINE}`, colorEnabled(io)));
-        },
-        onNote: (reason, detail) => {
-            log(`[jarvis cli] stream note ${JSON.stringify({
-                reason,
-                ...(detail && reason !== "ndjson_line_unparseable" ? { detail } : {}),
-            })}`);
-        },
-    });
-    if (!turn.ok) {
-        live.abandon();
-        writeFailure(context.command, io, turn.reason, streamFailureDetail(turn.reason, turn.detail));
-        return { exitCode: 1, reply: null };
-    }
-    const body = turn.final;
-    const httpStatus = typeof turn.final.httpStatus === "number" ? turn.final.httpStatus : requested.response.status;
-    if (httpStatus >= 400 || !body.ok || !body.reply) {
-        live.abandon();
-        const reason = body.error ?? body.reply ?? `http_${httpStatus}`;
-        writeFailure(context.command, io, "turn_failed", reason);
-        return { exitCode: 1, reply: null };
-    }
-    // A streaming server may leave the settled trace out of the final event
-    // because it already sent every step live; the activity we collected is that
-    // same trace, so `--json` still gets one.
-    const trace = body.trace ?? activityToTrace(turn.activity);
-    // BLI-3560: bookmark this turn so `cockpit jarvis --trace last` can open its
-    // step tree. Written before the reply is printed for no reason other than
-    // keeping the failure — which is only ever a stderr line — above the answer
-    // rather than after it.
-    await rememberTurnTrace({ traceId: body.traceId ?? null, threadId: body.traceThread ?? null }, io, context.command.homeDir);
-    if (context.command.json) {
-        writeLine(io.stdout, JSON.stringify({
-            ok: true,
-            reply: body.reply,
-            thread: body.thread ?? context.command.thread,
-            model: body.model ?? null,
-            trace,
-            subject: body.subject ?? null,
-            // BLI-3582: the server's own split of the wait. `null` from a
-            // dashboard that does not measure it yet.
-            latency: latencyFields(body.latency),
-            // BLI-3591: this side's own half of the same wait, so a consumer can
-            // put the whole journey together without a stopwatch of its own.
-            clientLatency: {
-                bootMs: context.boot.bootMs,
-                sessionMs: context.boot.sessionMs,
-                promptMs: context.boot.promptMs,
-                preRequestMs,
-                respondedMs: requested.respondedMs,
-                firstByteMs: turn.timing.firstByteMs,
-                firstFrameMs: turn.timing.firstFrameMs,
-                firstTokenMs: turn.timing.firstTokenMs,
-                elapsedMs: Date.now() - startedAt,
-            },
-            ...(body.traceId ? { traceId: body.traceId } : {}),
-        }));
-    }
-    else {
-        const subject = body.subject?.displayName ? ` (${body.subject.displayName})` : "";
-        // BLI-3517: when the answer streamed, `settle` prints only what the live
-        // words did not already say — and says so out loud when the grounding gate
-        // took some of them back. When nothing streamed it prints the whole reply
-        // through `writeReply`, which is byte-for-byte what this command printed
-        // before, BLI-3570's dim link line included.
-        live.settle(body.reply, subject, body.revised === true);
-        // BLI-3567: what the correction did to the answer above, printed under
-        // this turn's reply because that is the only place a terminal has.
-        if (body.revision)
-            writeRevision(context.command, io, body.revision);
-        // Only when nothing was drawn live — otherwise every tool would print twice.
-        if (liveTraceLines === 0)
-            writeTraceBlock(io, trace);
-        writeModelReceipt(io, body.model);
-    }
-    writeLine(io.stderr, `[jarvis cli] answered ${JSON.stringify({
-        prompt_length: prompt.length,
-        reply_length: body.reply.length,
-        trace_steps: trace?.length ?? 0,
-        trace_failed: trace?.filter((step) => step.status === "failed").length ?? 0,
-        model_requested: context.command.model ?? null,
-        elapsed_ms: Date.now() - startedAt,
-        thread: context.command.thread === "main" ? "default" : "named",
-        subject: context.command.subject ? "selected" : "caller",
-        image_attached: attachment !== null,
-        image_byte_size: attachment?.bytes.byteLength ?? null,
-        streamed: turn.streamed,
-        live_trace_lines: liveTraceLines,
-        // BLI-3517: whether the words arrived live, and whether the settled
-        // answer superseded them. `streamed_chars: 0` against a streaming
-        // dashboard means the answer landed all at once.
-        streamed_chars: turn.draft.length,
-        revised: body.revised === true,
-        // BLI-3567: whether this turn was told there was an answer above it, and
-        // what the correction did to it. `sent_previous_answer: false` is a
-        // one-shot turn; a status with no revision at all is a dashboard that
-        // predates the step.
-        sent_previous_answer: Boolean(context.previous),
-        revision: body.revision?.status ?? null,
-        revision_reason: body.revision?.reason ?? null,
-        // BLI-3582: `elapsed_ms` above is the whole wait as this side felt it;
-        // these three say which part of it was the dashboard's prep, which was
-        // the model's first token, and how long the socket stayed silent before
-        // the first byte. All null against a dashboard that does not send them.
-        ...latencyLogFields(body.latency),
-        // BLI-3591: the terminal's own half, on the same line, so the gap
-        // between the dashboard's first token and the first character a person
-        // sees stops being a mystery with nobody's name on it. `boot_ms` and
-        // `session_ms` are process facts (identical on every turn of an
-        // interactive session); the rest are this turn's, measured from the
-        // moment the turn started.
-        ...clientTimingFields(context.boot, {
-            preRequestMs,
-            respondedMs: requested.respondedMs,
-            timing: turn.timing,
-        }),
-    })}`);
-    return { exitCode: 0, reply: body.reply };
-}
-/**
- * The terminal's own spans as log fields (BLI-3591).
- *
- * Deliberately snake_case beside the dashboard's three, and deliberately
- * distinct names: `model_ttft_ms` is the dashboard's clock, `first_token_ms`
- * is this one, and confusing them is how a latency line stops being
- * answerable.
- */
-function clientTimingFields(boot, turn) {
-    return {
-        boot_ms: boot.bootMs,
-        session_ms: boot.sessionMs,
-        prompt_ms: boot.promptMs,
-        pre_request_ms: turn.preRequestMs,
-        responded_ms: turn.respondedMs,
-        ...turnTimingFields(turn.timing),
-    };
-}
-/**
- * The answer as it is written, in a terminal (BLI-3517).
- *
- * A terminal cannot unprint. That single fact decides everything here:
- *
- * - The words stream out under the usual `jarvis> ` prefix, printed the moment
- *   they arrive rather than after the whole turn (a measured 4-16 s of nothing
- *   before this ticket).
- * - A `reset` — the server taking back a draft the model wrote before deciding
- *   to call a tool — cannot erase what is on screen, so it SAYS so on its own
- *   line and the replacement follows. Never a retracted sentence left standing
- *   with nothing marking it.
- * - The settled reply is the authority. The grounding gate runs on the whole
- *   text once the stream ends, so the answer can grow (citations, a fallback
- *   notice) or change. A pure continuation is printed as the remainder; a
- *   genuine change is reprinted whole under a line saying it was revised.
- * - `--json` never streams a fragment: that contract is exactly one object on
- *   stdout, and every method here is a no-op for it.
- */
-function createLiveAnswer(command, io) {
-    const styled = colorEnabled(io);
-    const quiet = command.json === true;
-    let printed = "";
-    let opened = false;
-    const open = (subject) => {
-        if (opened)
-            return;
-        opened = true;
-        writeFragment(io.stdout, `jarvis${subject}> `);
-    };
-    return {
-        token(event) {
-            if (quiet)
-                return;
-            const text = event.text ?? "";
-            if (event.reset) {
-                if (printed) {
-                    writeLine(io.stdout, "");
-                    writeLine(io.stdout, dim("  — that draft was replaced —", styled));
-                    opened = false;
-                }
-                printed = "";
-            }
-            if (!text)
-                return;
-            open("");
-            printed += text;
-            writeFragment(io.stdout, text);
-        },
-        interrupt() {
-            if (quiet || !opened)
-                return;
-            writeLine(io.stdout, "");
-            opened = false;
-        },
-        settle(reply, subject, revised) {
-            if (quiet)
-                return;
-            if (!printed) {
-                // Nothing streamed: a non-streaming dashboard, `--no-stream`, or a
-                // turn whose words never arrived. Exactly the pre-ticket line, dim
-                // citation link and all (BLI-3570).
-                writeReply(io, `jarvis${subject}> `, reply);
-                return;
-            }
-            if (reply === printed) {
-                if (opened)
-                    writeLine(io.stdout, "");
-                return;
-            }
-            if (reply.startsWith(printed)) {
-                // The gate only ADDED — citations going back under the answer, a
-                // fallback notice. Print the tail and leave the words alone; the
-                // citation block is exactly the thing BLI-3570 puts its link under, and
-                // it is arriving here rather than in the stream.
-                if (!opened)
-                    writeFragment(io.stdout, `jarvis${subject}> `);
-                writeReplyContinuation(io, reply.slice(printed.length));
-                return;
-            }
-            if (opened)
-                writeLine(io.stdout, "");
-            writeLine(io.stdout, dim(revised ? `  — ${ANSWER_REVISED_LINE} —` : "  — corrected —", styled));
-            writeReply(io, `jarvis${subject}> `, reply);
-        },
-        abandon() {
-            // The turn died with words already on screen. End the line so the
-            // failure sentence does not run on from a half-written answer.
-            if (!quiet && opened)
-                writeLine(io.stdout, "");
-        },
-    };
-}
-/**
- * What the terminal says when the grounding gate changed an answer it had
- * already printed. The browser's own mark says the same thing in one word
- * (`ANSWER_REVISED_NOTE`, `apps/dashboard/src/lib/webchat/tool-trace.ts`);
- * this package cannot import from the dashboard, so the sentence is written
- * here in the same register rather than shared through a dependency that does
- * not exist.
- */
-const ANSWER_REVISED_LINE = "revised: I checked that against its sources and changed what they did not back up";
-/**
- * The three lines a correction's rewrite prints (BLI-3567).
- *
- * The browsers replace the paragraph where it stands. A terminal cannot —
- * stdout is a river — so it says the same three things in sequence instead:
- * that a rewrite is under way, what the paragraph now says, and that the
- * printed one above it did not change. The last of those is the honest half:
- * without it a person would have two versions on screen and no idea which one
- * JARVIS believes.
- *
- * `ANSWER_UPDATING_LINE` is the terminal's copy of the browsers'
- * `ANSWER_UPDATING_LABEL` (`apps/dashboard/src/lib/webchat/tool-trace.ts`),
- * word for word. This package cannot import from the dashboard, so it is
- * written out here rather than shared through a dependency that does not exist
- * — the same arrangement `ANSWER_REVISED_LINE` above already has.
- */
-const ANSWER_UPDATING_LINE = "(updating...)";
-const ANSWER_CORRECTED_LINE = "revised after your correction";
-const ANSWER_CORRECTED_NOTE_LINE = "The paragraph printed above is unchanged — a terminal cannot rewrite what it already " +
-    "printed. This is what it says now.";
-const ANSWER_REWRITE_UNVERIFIED_LINE = "Your correction is recorded. I could not verify a rewrite of that paragraph against its " +
-    "sources, so it stays as it was.";
-/**
- * Print what a correction did to the answer above, once the turn has settled.
- *
- * `--json` prints nothing: that contract is exactly one object on stdout, and
- * the revision rides it as a field. Every branch either prints or is a
- * deliberate no-op with a stderr line behind it in `sendOneTurn`.
- */
-function writeRevision(command, io, revision) {
-    if (command.json)
-        return;
-    const styled = colorEnabled(io);
-    if (revision.status === "unverified") {
-        writeLine(io.stdout, "");
-        writeLine(io.stdout, dim(`  — ${ANSWER_REWRITE_UNVERIFIED_LINE}`, styled));
-        return;
-    }
-    if (revision.status !== "revised")
-        return;
-    const paragraphs = Array.isArray(revision.paragraphs) ? revision.paragraphs : [];
-    const written = paragraphs.filter((one) => typeof one === "object" && one !== null && typeof one.text === "string");
-    if (written.length === 0)
-        return;
-    writeLine(io.stdout, "");
-    writeLine(io.stdout, dim(`  — ${ANSWER_CORRECTED_LINE} —`, styled));
-    for (const paragraph of written)
-        writeLine(io.stdout, paragraph.text);
-    writeLine(io.stdout, dim(`  ${ANSWER_CORRECTED_NOTE_LINE}`, styled));
-}
-/**
- * The multipart body `/api/jarvis/cli` reads when a file is attached
- * (BLI-3414) — same field names the request handler parses, mirroring the
- * JSON body's fields plus one `image` file field.
- */
-function buildAttachmentForm(command, prompt, attachment) {
-    const form = new FormData();
-    form.set("question", prompt);
-    form.set("thread", command.thread);
-    if (command.subject)
-        form.set("subject", command.subject);
-    if (command.model)
-        form.set("model", command.model);
-    if (command.date)
-        form.set("date", command.date);
-    form.set("image", new File([attachment.bytes], attachment.fileName, { type: attachment.mimeType }));
-    return form;
-}
-/** A refusal caught locally, before any request went out — never a stack trace. */
-function writeAttachmentRefusal(command, io, refusal, filePath) {
-    const message = attachedFileRefusalSentence(refusal, filePath);
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify({ ok: false, error: refusal, detail: message }));
-    }
-    else {
-        writeLine(io.stderr, `JARVIS could not attach that file: ${message}`);
-    }
-    writeLine(io.stderr, `[jarvis cli] attachment refused ${JSON.stringify({ reason: refusal })}`);
-}
-/**
- * One dim line per tool the turn called (BLI-3381): what it was, how long it
- * took, and — for a failure — the reason, matching what the web thinking
- * trace shows (`describeToolTraceEvent` on the server side built these
- * labels; this only renders them). Silent when no tool ran.
- */
-function writeTraceBlock(io, trace) {
-    if (!trace || trace.length === 0)
-        return;
-    for (const step of trace)
-        writeTraceLine(io, step);
-}
-/** The one dim trace line, drawn identically live (BLI-3457) and after the fact. */
-function writeTraceLine(io, step) {
-    const elapsed = typeof step.elapsedMs === "number" ? ` (${step.elapsedMs}ms)` : "";
-    const failure = step.status === "failed" ? ` — failed: ${step.detail ?? "no reason given"}` : "";
-    writeLine(io.stdout, dim(`  ⏺ ${step.label}${elapsed}${failure}`, colorEnabled(io)));
-}
-/**
- * Draws one streamed tool call, and says whether it drew anything.
- *
- * Only settled steps print: a `running` event is the same tool arriving a
- * second time, and printing both would double every line in a terminal that
- * cannot rewrite the one above it.
- */
-function writeActivityLine(io, event) {
-    if (event.status !== "done" && event.status !== "failed")
-        return false;
-    const step = activityToStep(event);
-    if (!step)
-        return false;
-    writeTraceLine(io, step);
-    return true;
-}
-/** The settled steps of a streamed turn, in the shape `--json` already promises. */
-function activityToTrace(activity) {
-    const steps = [];
-    for (const event of activity) {
-        if (event.status !== "done" && event.status !== "failed")
-            continue;
-        const step = activityToStep(event);
-        if (step)
-            steps.push(step);
-    }
-    return steps;
-}
-function activityToStep(event) {
-    if (event.status !== "done" && event.status !== "failed")
-        return null;
-    return {
-        tool: event.tool ?? "unknown_tool",
-        label: event.label ?? event.tool ?? "A tool ran",
-        status: event.status,
-        ...(typeof event.elapsedMs === "number" ? { elapsedMs: event.elapsedMs } : {}),
-        ...(event.detail ? { detail: event.detail } : {}),
-    };
-}
-/**
- * One line, only when the answer did not come from what was requested — a
- * fallback, or an explicit `--model` that landed on a different model
- * (BLI-3381). Silent otherwise, matching the web panel's own fallback notice.
- */
-function writeModelReceipt(io, model) {
-    if (!model)
-        return;
-    const requested = typeof model.requestedModel === "string" ? model.requestedModel : null;
-    const answered = namedModel(model.model);
-    const mismatched = requested !== null && answered !== null && requested !== answered;
-    if (!model.fallback && !mismatched)
-        return;
-    // BLI-3467: never the word "unavailable" — this side cannot know why, and
-    // on 2026-09-01 the real cause was a healthy provider refusing our own tool
-    // schema. Say what the receipt actually reports.
-    writeLine(io.stdout, `Model: ${answered ?? "an unknown model"} answered instead of ${requested ?? "the requested model"}`);
-}
-/** One millisecond span off the wire, or null for anything that is not a number. */
-function latencyMs(value) {
-    return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-/** The latency split for `--json`, always the same three keys so a consumer can rely on them. */
-function latencyFields(latency) {
-    return {
-        wireMs: latencyMs(latency?.wireMs),
-        prepMs: latencyMs(latency?.prepMs),
-        modelTtftMs: latencyMs(latency?.modelTtftMs),
-    };
-}
-/** The same three spans as log fields, snake_case like everything else on that line. */
-function latencyLogFields(latency) {
-    const split = latencyFields(latency);
-    return {
-        wire_ms: split.wireMs,
-        prep_ms: split.prepMs,
-        model_ttft_ms: split.modelTtftMs,
-    };
-}
-/**
- * The receipt's `model` field, unless it is the server's own "I could not tell"
- * sentinel (BLI-3582).
- *
- * `modelReceipt` on the dashboard writes the literal string `"unknown"` when
- * the run reported no model, and this side used to read that as a model NAME —
- * so a turn whose model was simply unnamed printed
- * `Model: unknown answered instead of gpt-5.6-terra`, a fallback notice for a
- * fallback that never happened. Every streamed turn hit it. The dashboard fix
- * makes the streamed path name the model again; this one makes the sentinel
- * unable to invent a fallback on any dashboard version, old or new.
- */
-function namedModel(value) {
-    if (typeof value !== "string")
-        return null;
-    const trimmed = value.trim();
-    if (!trimmed || trimmed.toLowerCase() === "unknown")
-        return null;
-    return trimmed;
-}
-function writeFailure(command, io, reason, detail) {
-    if (command.json) {
-        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
-        return;
-    }
-    writeLine(io.stderr, `JARVIS could not answer: ${detail}`);
-}
-function validatePrompt(raw) {
-    const prompt = raw.trim();
-    if (!prompt)
-        throw new Error("JARVIS needs a non-empty question.");
-    if (prompt.length > 4000) {
-        throw new Error("JARVIS questions are limited to 4000 characters.");
-    }
-    return prompt;
 }