@bli-cockpit/cli 0.2.237 → 0.2.238

package/dist/commands/jarvis-turn-report.js

@@ -0,0 +1,124 @@
+import { writeLine } from "./cli-io.js";
+import { buildJarvisAnswerEnvelope } from "./jarvis-answer-envelope.js";
+import { clientTimingFields, latencyFields, latencyLogFields, writeModelReceipt, writeRevision, writeTraceBlock, } from "./jarvis-render.js";
+export function printJsonTurn(settled) {
+    const { context, io, body, trace, sent, turn, startedAt, preRequestMs } = settled;
+    writeLine(io.stdout, JSON.stringify({
+        // BLI-3732: the shared envelope FIRST — `answer`, `sources`,
+        // `turn_id`, `thread_id`, `trace_thread_id`, `degraded`,
+        // `degraded_reasons` — so a script here and an agent on the
+        // `jarvis_ask` MCP tool read one contract for one turn. The keys
+        // below it are the ones this command has always printed and are
+        // untouched; `reply` and `answer` are the same string.
+        ...buildJarvisAnswerEnvelope({
+            reply: body.reply,
+            thread: body.thread ?? context.command.thread,
+            traceId: body.traceId,
+            traceThread: body.traceThread,
+            modelFallback: body.model?.fallback,
+            revised: body.revised,
+            trace,
+            proposalId: body.proposalId,
+            // BLI-3787: the sentence beside it — what a person must do next when
+            // the arm proposed something, and when it refused instead.
+            nextAction: body.nextAction,
+            // BLI-3770: the door's own structured citations. Absent from a
+            // dashboard that predates it, and the envelope falls back to
+            // reading the answer's own `Source:` lines when it is.
+            sources: body.sources,
+        }),
+        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: sent.respondedMs,
+            firstByteMs: turn.timing.firstByteMs,
+            firstFrameMs: turn.timing.firstFrameMs,
+            firstTokenMs: turn.timing.firstTokenMs,
+            elapsedMs: Date.now() - startedAt,
+        },
+        ...(body.traceId ? { traceId: body.traceId } : {}),
+    }));
+}
+export function printTerminalTurn(settled, live) {
+    const { context, io, body, trace, liveTraceLines } = settled;
+    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);
+}
+export function logAnsweredTurn(settled) {
+    const { context, io, prompt, body, trace, attachment, sent, turn, startedAt, preRequestMs, liveTraceLines } = settled;
+    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,
+        // BLI-3786: `minted` is a conversation the DOOR opened for this call
+        // because nothing named one — read off the answer rather than guessed
+        // from the name, so this side keeps no copy of the server's rule. Never
+        // the thread name itself.
+        thread: body.thread && body.thread !== context.command.thread
+            ? "minted"
+            : 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: sent.respondedMs,
+            timing: turn.timing,
+        }),
+    })}`);
+}

package/dist/commands/jarvis-turn.js

@@ -7,33 +7,20 @@
  * `jarvis-render.ts` — imported one direction only.
  */
 import { colorEnabled, dim, writeLine } from "./cli-io.js";
-import { buildJarvisAnswerEnvelope } from "./jarvis-answer-envelope.js";
 import { readAttachedImage } from "./jarvis-attachment.js";
+import { logAnsweredTurn, printJsonTurn, printTerminalTurn, } from "./jarvis-turn-report.js";
+import { createLiveAnswer } from "./jarvis-live-answer.js";
 import { rememberTurnTrace } from "./jarvis-trace.js";
 import { towerFailureDetail, towerJsonRequest, towerRequest } from "../tower-client.js";
 import { readTowerTurn, streamFailureDetail } from "../tower-stream.js";
-import { activityToTrace, agentSurface, ANSWER_UPDATING_LINE, buildAttachmentForm, clientTimingFields, createLiveAnswer, latencyFields, latencyLogFields, TURN_DEADLINE_MS, writeActivityLine, writeAttachmentRefusal, writeFailure, writeModelReceipt, writeRevision, writeTraceBlock, } from "./jarvis-render.js";
+import { activityToTrace, agentSurface, ANSWER_UPDATING_LINE, buildAttachmentForm, TURN_DEADLINE_MS, writeActivityLine, writeAttachmentRefusal, writeFailure, } from "./jarvis-render.js";
+const FAILED_TURN = { exitCode: 1, reply: null };
 export 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);
+    const attached = await readTurnAttachment(context.command, io);
+    if (!attached.ok)
+        return FAILED_TURN;
+    const { attachment } = attached;
     // 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
@@ -41,12 +28,57 @@ export async function sendOneTurn(context, prompt, io) {
     // 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 log = (line) => writeLine(io.stderr, line);
+    const sent = await postTurn(context, io, prompt, attachment, log);
+    if (!sent)
+        return FAILED_TURN;
+    const read = await readStreamedTurn(context, io, sent, startedAt, log);
+    if (!read.ok)
+        return FAILED_TURN;
+    const { turn, liveTraceLines } = read;
+    const body = turn.final;
+    const httpStatus = typeof turn.final.httpStatus === "number" ? turn.final.httpStatus : sent.response.status;
+    if (httpStatus >= 400 || !body.ok || !body.reply) {
+        read.live.abandon();
+        const reason = body.error ?? body.reply ?? `http_${httpStatus}`;
+        writeFailure(context.command, io, "turn_failed", reason);
+        return FAILED_TURN;
+    }
+    // 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);
+    const settled = {
+        context, io, prompt, body: body, trace, attachment, sent, turn,
+        startedAt, preRequestMs, liveTraceLines: liveTraceLines(),
+    };
+    if (context.command.json) {
+        printJsonTurn(settled);
+    }
+    else {
+        printTerminalTurn(settled, read.live);
+    }
+    logAnsweredTurn(settled);
+    return { exitCode: 0, reply: body.reply };
+}
+/** Posts the question to the dashboard; null (after saying why) when the request failed. */
+async function postTurn(context, io, prompt, attachment, log) {
+    // 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;
     // BLI-3755: never silently. A script that asked for the code is a script
     // that can spend a human's approval, and the one line saying so is here.
     if (context.command.json && context.command.showApprovalCode) {
         log("[jarvis] approval code requested by a --json caller (--show-approval-code)");
     }
-    const requested = await towerRequest({
+    const sent = await towerRequest({
         dashboardUrl: context.dashboardUrl,
         path: "/api/jarvis/cli",
         deviceToken: context.deviceToken,
@@ -56,40 +88,67 @@ export async function sendOneTurn(context, prompt, io) {
         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,
-                // BLI-3755: who is reading this answer. A `--json` turn is a
-                // PROGRAM's, so the coding arm withholds its approval code and
-                // answers with a proposal id instead; an interactive turn is a
-                // person's and is unchanged. `--show-approval-code` opts a script
-                // back in, and says so on stderr below.
-                surface: agentSurface(context.command) ? "agent" : undefined,
-            },
+            : buildQuestionBody(context, prompt),
         log,
     });
-    if (!requested.ok) {
-        writeFailure(context.command, io, requested.reason, towerFailureDetail(requested.reason, requested.detail));
-        return { exitCode: 1, reply: null };
+    if (!sent.ok) {
+        writeFailure(context.command, io, sent.reason, towerFailureDetail(sent.reason, sent.detail));
+        return null;
+    }
+    return sent;
+}
+/**
+ * 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.
+ */
+async function readTurnAttachment(command, io) {
+    if (!command.imagePath)
+        return { ok: true, attachment: null };
+    const read = await readAttachedImage(command.imagePath);
+    if (!read.ok) {
+        writeAttachmentRefusal(command, io, read.refusal, command.imagePath);
+        return { ok: false };
     }
+    return { ok: true, attachment: read };
+}
+function buildQuestionBody(context, prompt) {
+    return {
+        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,
+        // BLI-3755: who is reading this answer. A `--json` turn is a
+        // PROGRAM's, so the coding arm withholds its approval code and
+        // answers with a proposal id instead; an interactive turn is a
+        // person's and is unchanged. `--show-approval-code` opts a script
+        // back in, and says so on stderr below.
+        surface: agentSurface(context.command) ? "agent" : undefined,
+    };
+}
+/**
+ * Reads the turn off the wire, drawing live words and trace rows as they land.
+ * `liveTraceLines` is a function because the count keeps growing until the
+ * stream ends; it is read once, after.
+ */
+async function readStreamedTurn(context, io, sent, startedAt, log) {
     // 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, {
+    const turn = await readTowerTurn(sent.response, {
         startedAt,
         log,
         onActivity: (event) => {
@@ -122,142 +181,9 @@ export async function sendOneTurn(context, prompt, io) {
     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 };
+        return { ok: false };
     }
-    // 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({
-            // BLI-3732: the shared envelope FIRST — `answer`, `sources`,
-            // `turn_id`, `thread_id`, `trace_thread_id`, `degraded`,
-            // `degraded_reasons` — so a script here and an agent on the
-            // `jarvis_ask` MCP tool read one contract for one turn. The keys
-            // below it are the ones this command has always printed and are
-            // untouched; `reply` and `answer` are the same string.
-            ...buildJarvisAnswerEnvelope({
-                reply: body.reply,
-                thread: body.thread ?? context.command.thread,
-                traceId: body.traceId,
-                traceThread: body.traceThread,
-                modelFallback: body.model?.fallback,
-                revised: body.revised,
-                trace,
-                proposalId: body.proposalId,
-                // BLI-3787: the sentence beside it — what a person must do next when
-                // the arm proposed something, and when it refused instead.
-                nextAction: body.nextAction,
-                // BLI-3770: the door's own structured citations. Absent from a
-                // dashboard that predates it, and the envelope falls back to
-                // reading the answer's own `Source:` lines when it is.
-                sources: body.sources,
-            }),
-            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,
-        // BLI-3786: `minted` is a conversation the DOOR opened for this call
-        // because nothing named one — read off the answer rather than guessed
-        // from the name, so this side keeps no copy of the server's rule. Never
-        // the thread name itself.
-        thread: body.thread && body.thread !== context.command.thread
-            ? "minted"
-            : 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 };
+    return { ok: true, turn, live, liveTraceLines: () => liveTraceLines };
 }
 /**
  * `--threads` and `--thread <name> --history`.

package/dist/commands/jarvis.js

@@ -57,29 +57,38 @@ export async function runJarvis(command, io) {
             homeDir: command.homeDir,
         }, io);
     }
+    const connection = { dashboardUrl, deviceToken: session.device_token, bootMs, sessionMs };
     const promptStartedAt = Date.now();
     const oneShotPrompt = await resolveOneShotPrompt(command, io);
     if (oneShotPrompt !== null) {
-        // A one-shot turn has nothing above it — this process printed no earlier
-        // answer — so it sends no previous answer and nothing is ever revised. The
-        // `sent_previous_answer: false` field on the answered line says so.
-        const turn = await sendOneTurn({
-            command,
-            dashboardUrl,
-            deviceToken: session.device_token,
-            boot: {
-                bootMs,
-                sessionMs,
-                // Only meaningful when the question was piped; an argument costs
-                // nothing to read and reporting a stdin wait for it would be a lie.
-                promptMs: command.prompt ? null : Date.now() - promptStartedAt,
-            },
-        }, oneShotPrompt, io);
-        return turn.exitCode;
+        return sendOneShotTurn(command, io, connection, oneShotPrompt, promptStartedAt);
     }
     if (command.json) {
         throw new Error("cockpit jarvis --json needs --prompt, positional text, or piped stdin.");
     }
+    return chatInTerminal(command, io, connection);
+}
+async function sendOneShotTurn(command, io, connection, prompt, promptStartedAt) {
+    // A one-shot turn has nothing above it — this process printed no earlier
+    // answer — so it sends no previous answer and nothing is ever revised. The
+    // `sent_previous_answer: false` field on the answered line says so.
+    const turn = await sendOneTurn({
+        command,
+        dashboardUrl: connection.dashboardUrl,
+        deviceToken: connection.deviceToken,
+        boot: {
+            bootMs: connection.bootMs,
+            sessionMs: connection.sessionMs,
+            // Only meaningful when the question was piped; an argument costs
+            // nothing to read and reporting a stdin wait for it would be a lie.
+            promptMs: command.prompt ? null : Date.now() - promptStartedAt,
+        },
+    }, prompt, io);
+    return turn.exitCode;
+}
+/** The interactive loop: read a line, send it as a turn, repeat until `/exit`. */
+async function chatInTerminal(command, io, connection) {
+    const { dashboardUrl, deviceToken, bootMs, sessionMs } = connection;
     writeLine(io.stdout, "JARVIS terminal chat. Type /exit to leave.");
     // BLI-3567: the answer this session last printed, and the question it
     // answered. It is what a correction typed on the next line can rewrite —
@@ -97,7 +106,7 @@ export async function runJarvis(command, io) {
         const turn = await sendOneTurn({
             command,
             dashboardUrl,
-            deviceToken: session.device_token,
+            deviceToken,
             // The typing wait belongs to the person, not to the turn, so no prompt
             // span is reported for an interactive turn.
             boot: { bootMs, sessionMs, promptMs: null },