@bli-cockpit/cli 0.2.37 → 0.2.39

package/dist/commands/brief.js

@@ -0,0 +1,133 @@
+/**
+ * `cockpit brief` — the TODAY page, read from a terminal (BLI-3458).
+ *
+ * This file owns terminal output only. The page itself, whose it is, whether
+ * this person may open it and which version they asked for are all decided by
+ * `GET /api/jarvis/brief`, which calls the SAME `loadBriefView` the website's
+ * home page calls. There is deliberately no local rendering of a `JarvisPage`
+ * here: the dashboard hands back finished text (the serializer's
+ * `TERMINAL_FLAVOR`), so the terminal and the browser cannot drift into showing
+ * two different briefs.
+ *
+ * Identity is the existing paired device session. `--for` changes WHOSE page is
+ * asked for, never who is asking — the same rule `cockpit jarvis --as` follows.
+ */
+import { writeLine } from "./cli-io.js";
+import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const REQUEST_DEADLINE_MS = 30_000;
+export async function runBrief(command, io) {
+    const session = await loadPairedSession("brief", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const startedAt = Date.now();
+    const result = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${queryFor(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "brief",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log: (line) => writeLine(io.stderr, line),
+    });
+    if (!result.ok) {
+        // `towerJsonRequest` already turned a non-2xx into the server's own
+        // sentence, which for this route is the plain-words notice a person reads
+        // on the page ("Nothing has been written for you yet."). Relayed verbatim
+        // rather than translated into a code.
+        writeFailure(command, io, result.reason, result.detail);
+        return 1;
+    }
+    const body = result.body;
+    if (!body.ok || typeof body.text !== "string") {
+        const detail = body.reply ?? body.error ?? "Tower answered without a page.";
+        writeFailure(command, io, body.error ?? "no_page", detail);
+        return 1;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify(body));
+    }
+    else {
+        writeHuman(io, command, body);
+    }
+    writeLine(io.stderr, `[brief cli] read ${JSON.stringify({
+        text_length: body.text.length,
+        cadence: body.page?.cadence ?? null,
+        visible_because: body.visibleBecause ?? null,
+        tldr: Boolean(command.tldr),
+        pinned_version: command.version != null,
+        subject: command.subject ? "selected" : "caller",
+        version_count: body.versions?.length ?? null,
+        versions_reason: body.versionsReason ?? null,
+        claim_count: body.claims?.length ?? null,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
+function queryFor(command) {
+    const params = new URLSearchParams();
+    if (command.subject)
+        params.set("p", command.subject);
+    if (command.version)
+        params.set("v", command.version);
+    if (command.tldr)
+        params.set("tldr", "1");
+    if (command.versions)
+        params.set("versions", "1");
+    if (command.claims)
+        params.set("claims", "1");
+    const query = params.toString();
+    return query ? `?${query}` : "";
+}
+function writeHuman(io, command, body) {
+    const page = body.page ?? {};
+    // Whose page, and — when it is not the newest — that it is a record of a
+    // moment rather than something that failed to update.
+    const whose = page.displayName ? `${page.displayName}'s page` : "This page";
+    const pinned = page.olderVersionLabel ? ` · version from ${page.olderVersionLabel}` : "";
+    writeLine(io.stdout, `${DIM}${whose}${pinned}${RESET}`);
+    writeLine(io.stdout, "");
+    writeLine(io.stdout, body.text ?? "");
+    if (body.claims && body.claims.length > 0) {
+        writeLine(io.stdout, "");
+        writeLine(io.stdout, `${DIM}Claim ids — pass one to \`cockpit correct --claim\`:${RESET}`);
+        for (const claim of body.claims) {
+            writeLine(io.stdout, `${DIM}  [${claim.claimId}]${RESET} ${claim.text ?? ""}`);
+        }
+    }
+    if (body.versions) {
+        writeLine(io.stdout, "");
+        if (body.versions.length === 0) {
+            // Never "there is one version". An empty list with a reason is an
+            // answer; an empty list without one is a wrong answer.
+            writeLine(io.stdout, `${DIM}Earlier versions could not be listed (${body.versionsReason ?? "no reason given"}).${RESET}`);
+        }
+        else {
+            writeLine(io.stdout, `${DIM}Versions — pass one to \`cockpit brief --version\`:${RESET}`);
+            for (const version of body.versions) {
+                const headline = version.headline ? ` — ${version.headline}` : "";
+                writeLine(io.stdout, `${DIM}  ${version.version}/${version.of}  ${version.pageId}  ${version.asOf}${headline}${RESET}`);
+            }
+        }
+    }
+    if (!command.subject && body.people && body.people.length > 1) {
+        const others = body.people
+            .filter((person) => person.personId !== page.personId)
+            .map((person) => person.slug)
+            .filter(Boolean);
+        if (others.length > 0) {
+            writeLine(io.stdout, "");
+            writeLine(io.stdout, `${DIM}You can also open: ${others.join(", ")} (\`--for <name>\`)${RESET}`);
+        }
+    }
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(io.stderr, detail);
+    }
+    writeLine(io.stderr, `[brief cli] not read ${JSON.stringify({ reason })}`);
+}

package/dist/commands/correct.js

@@ -0,0 +1,160 @@
+/**
+ * `cockpit correct` — say that one line on the page is wrong (BLI-3458).
+ *
+ * Two requests, in this order, and the order matters:
+ *
+ *   1. `GET /api/jarvis/brief?claims=1` — resolve WHICH page and WHOSE, and
+ *      look up the line the person named. That read is also what supplies the
+ *      two facts the correction door needs and a terminal cannot know:
+ *      whether the clause rests on a machine record (`observed`, which decides
+ *      tier 2 vs tier 3) and the receipt links the live ground-truth check
+ *      mines for an identifier.
+ *   2. `POST /api/jarvis/corrections` — the same door the panel's form uses,
+ *      which checks the claim against the live record BEFORE writing, and can
+ *      answer back that the record disagrees.
+ *
+ * A claim id the page does not carry is refused HERE, before any write, with
+ * the fix named — `cockpit brief --claims` prints every id. Filing it anyway
+ * would land a correction on a clause nobody can find, which is how a ledger
+ * fills with rows that mean nothing.
+ *
+ * The push-back is the point of this command, not an error path: when JARVIS
+ * says the record disagrees, that sentence is what the person came for, and it
+ * is printed on stdout with an exit code of 0 — the correction WAS filed, with
+ * its outcome recorded. Only a failure to file at all is a non-zero exit.
+ */
+import { isInteractiveStdin, writeLine } from "./cli-io.js";
+import { loadPairedSession, towerJsonRequest } from "../tower-client.js";
+const DIM = "\x1b[2m";
+const RESET = "\x1b[0m";
+const REQUEST_DEADLINE_MS = 60_000;
+const MAX_CORRECTION_LENGTH = 4000;
+export async function runCorrect(command, io) {
+    const session = await loadPairedSession("correct", command.homeDir);
+    const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    const log = (line) => writeLine(io.stderr, line);
+    const startedAt = Date.now();
+    const text = await resolveText(command, io);
+    if (!text) {
+        writeFailure(command, io, "no_correction_text", 'Say what is wrong: `cockpit correct --claim <id> --text "..."`, or pipe it in on stdin.');
+        return 1;
+    }
+    // Step one: which page, whose, and does that line exist.
+    const read = await towerJsonRequest({
+        dashboardUrl,
+        path: `/api/jarvis/brief${briefQuery(command)}`,
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        method: "GET",
+        label: "correct:brief",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+    });
+    if (!read.ok) {
+        writeFailure(command, io, read.reason, read.detail);
+        return 1;
+    }
+    const brief = read.body;
+    const personId = brief.page?.personId;
+    if (!brief.ok || !personId) {
+        writeFailure(command, io, brief.error ?? "no_page", brief.reply ?? "There is no page to correct.");
+        return 1;
+    }
+    const claim = (brief.claims ?? []).find((candidate) => candidate.claimId === command.claimId);
+    if (!claim) {
+        writeFailure(command, io, "unknown_claim", `That page has no line called “${command.claimId}”. Run \`cockpit brief --claims\` to see the ids.`);
+        return 1;
+    }
+    // Step two: the same door the panel's form posts to.
+    const written = await towerJsonRequest({
+        dashboardUrl,
+        path: "/api/jarvis/corrections",
+        deviceToken: session.device_token,
+        fetch: io.fetch,
+        label: "correct",
+        timeoutMs: REQUEST_DEADLINE_MS,
+        log,
+        body: {
+            personId,
+            pageId: brief.page?.pageId ?? null,
+            claimId: command.claimId,
+            // The line as it reads now, so the ledger records what was disputed and
+            // the live check has the sentence to work from.
+            quotedText: claim.text ?? null,
+            correctionText: text,
+            contextLinks: claim.links ?? [],
+            clauseOnPage: true,
+            clauseIsObserved: Boolean(claim.observed),
+            ...(command.supersedes ? { supersedes: command.supersedes } : {}),
+        },
+    });
+    if (!written.ok) {
+        writeFailure(command, io, written.reason, written.detail);
+        return 1;
+    }
+    const filed = written.body;
+    if (!filed.correctionId) {
+        writeFailure(command, io, "not_filed", filed.error ?? "Tower did not record that correction.");
+        return 1;
+    }
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: true, ...filed }));
+    }
+    else {
+        writeLine(io.stdout, filed.reply ?? "Filed.");
+        if (filed.finding)
+            writeLine(io.stdout, `${DIM}The record says: ${filed.finding}${RESET}`);
+        if (filed.link)
+            writeLine(io.stdout, `${DIM}${filed.link}${RESET}`);
+    }
+    writeLine(io.stderr, `[correct cli] filed ${JSON.stringify({
+        tier: filed.tier ?? null,
+        outcome: filed.outcome ?? null,
+        pushed_back: Boolean(filed.pushBack),
+        observed_clause: Boolean(claim.observed),
+        context_links: (claim.links ?? []).length,
+        supersedes: command.supersedes != null,
+        subject: command.subject ? "selected" : "caller",
+        text_length: text.length,
+        elapsed_ms: Date.now() - startedAt,
+    })}`);
+    return 0;
+}
+function briefQuery(command) {
+    const params = new URLSearchParams({ claims: "1" });
+    if (command.subject)
+        params.set("p", command.subject);
+    if (command.version)
+        params.set("v", command.version);
+    return `?${params.toString()}`;
+}
+/** `--text`, or whatever was piped in. Never a prompt — this may run headless. */
+async function resolveText(command, io) {
+    if (command.text)
+        return command.text;
+    if (isInteractiveStdin(io))
+        return null;
+    const piped = await readAll(io.stdin);
+    const trimmed = piped.trim();
+    return trimmed.length > 0 ? trimmed : null;
+}
+async function readAll(stream) {
+    stream.setEncoding("utf8");
+    let text = "";
+    for await (const chunk of stream) {
+        text += chunk;
+        if (text.length > MAX_CORRECTION_LENGTH) {
+            throw new Error(`A correction is limited to ${MAX_CORRECTION_LENGTH} characters.`);
+        }
+    }
+    return text;
+}
+function writeFailure(command, io, reason, detail) {
+    if (command.json) {
+        writeLine(io.stdout, JSON.stringify({ ok: false, error: reason, detail }));
+    }
+    else {
+        writeLine(io.stderr, detail);
+    }
+    writeLine(io.stderr, `[correct cli] not filed ${JSON.stringify({ reason })}`);
+}

package/dist/commands/jarvis.js

@@ -5,14 +5,28 @@
  * existing paired device session, and every turn is executed by the dashboard
  * through the same JARVIS runtime used by web chat and Slack.
  */
-import { errorMessage, isInteractiveStdin, readLine, writeLine } from "./cli-io.js";
+import { isInteractiveStdin, readLine, writeLine } from "./cli-io.js";
 import { attachedFileRefusalSentence, readAttachedImage, } from "./jarvis-attachment.js";
-import { getCollectorRuntimePaths, readLocalCollectorSessionFile, } from "../local-state.js";
+import { loadPairedSession, towerFailureDetail, towerJsonRequest, towerRequest, } from "../tower-client.js";
+import { readTowerTurn, streamFailureDetail, } from "../tower-stream.js";
 const TRACE_DIM = "\x1b[2m";
 const TRACE_RESET = "\x1b[0m";
+/**
+ * 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;
 export async function runJarvis(command, io) {
-    const session = await loadPairedSession(command.homeDir);
+    const session = await loadPairedSession("jarvis", command.homeDir);
     const dashboardUrl = command.dashboardUrl ?? session.dashboard_url;
+    // BLI-3458: reading back what was already said. No turn, no model, no
+    // conversation-ledger write — and, on the server, only ever THIS device
+    // holder's own terminal rows.
+    if (command.threads || command.history) {
+        return readHistory({ command, dashboardUrl, deviceToken: session.device_token }, io);
+    }
     const oneShotPrompt = await resolveOneShotPrompt(command, io);
     if (oneShotPrompt !== null) {
         return sendOneTurn({ command, dashboardUrl, deviceToken: session.device_token }, oneShotPrompt, io);
@@ -32,17 +46,89 @@ export async function runJarvis(command, io) {
             return exitCode;
     }
 }
-async function loadPairedSession(homeDir) {
-    const paths = getCollectorRuntimePaths(homeDir);
-    try {
-        const session = await readLocalCollectorSessionFile(paths);
-        if (session.session_state !== "valid") {
-            throw new Error(`session_${session.session_state}`);
-        }
-        return session;
+/**
+ * `--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;
     }
-    catch (error) {
-        throw new Error(`JARVIS needs a valid paired Tower session. Run \`cockpit login\`, then try again (${errorMessage(error)}).`);
+    for (const thread of threads) {
+        const turns = thread.turnCount === 1 ? "1 turn" : `${thread.turnCount ?? 0} turns`;
+        writeLine(io.stdout, `${thread.name}  ${TRACE_DIM}${turns} · ${thread.lastAt ?? "unknown"}${TRACE_RESET}`);
+        if (thread.preview)
+            writeLine(io.stdout, `${TRACE_DIM}  ${thread.preview}${TRACE_RESET}`);
+    }
+    writeLine(io.stdout, "");
+    writeLine(io.stdout, `${TRACE_DIM}Replay one with \`cockpit jarvis --thread <name> --history\`.${TRACE_RESET}`);
+}
+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, `${TRACE_DIM}Showing the most recent ${messages.length}; there is more before this (\`--limit\`).${TRACE_RESET}`);
+    }
+    for (const message of messages) {
+        const speaker = message.role === "you" ? "you" : "jarvis";
+        writeLine(io.stdout, `${speaker}> ${message.text ?? ""}`);
     }
 }
 async function resolveOneShotPrompt(command, io) {
@@ -68,65 +154,100 @@ async function sendOneTurn(context, prompt, io) {
         }
         attachment = read;
     }
-    let response;
-    try {
-        response = attachment
-            ? await io.fetch(`${context.dashboardUrl}/api/jarvis/cli`, {
-                method: "POST",
-                headers: { authorization: `Bearer ${context.deviceToken}` },
-                body: buildAttachmentForm(context.command, prompt, attachment),
-            })
-            : await io.fetch(`${context.dashboardUrl}/api/jarvis/cli`, {
-                method: "POST",
-                headers: {
-                    authorization: `Bearer ${context.deviceToken}`,
-                    "content-type": "application/json",
-                },
-                body: JSON.stringify({
-                    question: prompt,
-                    thread: context.command.thread,
-                    subject: context.command.subject,
-                    model: context.command.model,
-                }),
-            });
-    }
-    catch (error) {
-        writeFailure(context.command, io, "gateway_unreachable", errorMessage(error));
+    // 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);
+    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,
+            },
+        log,
+    });
+    if (!requested.ok) {
+        writeFailure(context.command, io, requested.reason, towerFailureDetail(requested.reason, requested.detail));
+        return 1;
+    }
+    // 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.
+    let liveTraceLines = 0;
+    const turn = await readTowerTurn(requested.response, {
+        startedAt,
+        log,
+        onActivity: (event) => {
+            if (context.command.json)
+                return;
+            if (writeActivityLine(io, event))
+                liveTraceLines += 1;
+        },
+        onNote: (reason, detail) => {
+            log(`[jarvis cli] stream note ${JSON.stringify({
+                reason,
+                ...(detail && reason !== "ndjson_line_unparseable" ? { detail } : {}),
+            })}`);
+        },
+    });
+    if (!turn.ok) {
+        writeFailure(context.command, io, turn.reason, streamFailureDetail(turn.reason, turn.detail));
         return 1;
     }
-    const body = await readReply(response);
-    if (!response.ok || !body.ok || !body.reply) {
-        const reason = body.error ?? body.reply ?? `http_${response.status}`;
+    const body = turn.final;
+    const httpStatus = typeof turn.final.httpStatus === "number" ? turn.final.httpStatus : requested.response.status;
+    if (httpStatus >= 400 || !body.ok || !body.reply) {
+        const reason = body.error ?? body.reply ?? `http_${httpStatus}`;
         writeFailure(context.command, io, "turn_failed", reason);
         return 1;
     }
+    // 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);
     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: body.trace ?? [],
+            trace,
             subject: body.subject ?? null,
         }));
     }
     else {
         const subject = body.subject?.displayName ? ` (${body.subject.displayName})` : "";
         writeLine(io.stdout, `jarvis${subject}> ${body.reply}`);
-        writeTraceBlock(io, body.trace);
+        // 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: body.trace?.length ?? 0,
-        trace_failed: body.trace?.filter((step) => step.status === "failed").length ?? 0,
+        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,
     })}`);
     return 0;
 }
@@ -166,11 +287,53 @@ function writeAttachmentRefusal(command, io, refusal, filePath) {
 function writeTraceBlock(io, trace) {
     if (!trace || trace.length === 0)
         return;
-    for (const step of trace) {
-        const elapsed = typeof step.elapsedMs === "number" ? ` (${step.elapsedMs}ms)` : "";
-        const failure = step.status === "failed" ? ` — failed: ${step.detail ?? "no reason given"}` : "";
-        writeLine(io.stdout, `${TRACE_DIM}  ⏺ ${step.label}${elapsed}${failure}${TRACE_RESET}`);
+    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, `${TRACE_DIM}  ⏺ ${step.label}${elapsed}${failure}${TRACE_RESET}`);
+}
+/**
+ * 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
@@ -185,22 +348,10 @@ function writeModelReceipt(io, model) {
     const mismatched = requested !== null && answered !== null && requested !== answered;
     if (!model.fallback && !mismatched)
         return;
-    writeLine(io.stdout, `Model: ${answered ?? "an unknown model"} answered (${requested ?? "the requested model"} unavailable)`);
-}
-async function readReply(response) {
-    const text = await response.text();
-    if (!text)
-        return { ok: false, error: "empty_response" };
-    try {
-        const value = JSON.parse(text);
-        if (!value || typeof value !== "object") {
-            return { ok: false, error: "response_body_not_object" };
-        }
-        return value;
-    }
-    catch {
-        return { ok: false, error: "response_body_not_json" };
-    }
+    // 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"}`);
 }
 function writeFailure(command, io, reason, detail) {
     if (command.json) {