@bli-cockpit/cli 0.2.236 → 0.2.238

package/dist/commands/issue-show.js

@@ -91,40 +91,39 @@ export async function showIssue(command, door) {
         results.push(await fetchOneIssue(door, ref));
     // BLI-10450: one directory call for the whole batch, never one per issue.
     const directory = await resolveAssigneeDirectory(door, results.filter((result) => result.ok).map((result) => result.issue.assignee_id));
-    // A single ref keeps the pre-BLI-10450 shape and failure path exactly.
-    if (refs.length === 1) {
-        const [result] = results;
-        if (!result || !result.ok) {
-            return failAgentDoor(door, TAG, result?.reason ?? "issue_not_found_or_unreadable", result?.detail ?? "That issue does not exist, or you cannot read it.");
-        }
-        if (door.json) {
-            return emitAgentDoor(door, {
-                ok: true,
-                issue: withSizeLabel(withAssigneeIdentity(result.issue, directory)),
-                comments: result.comments,
-                ...(result.linearTicketId ? { linear_ticket_id: result.linearTicketId } : {}),
-                ...(result.commentsUnreadReason ? { comments_unread_reason: result.commentsUnreadReason } : {}),
-            });
-        }
-        renderOneIssue(door, result, directory);
-        return 0;
+    if (refs.length === 1)
+        return reportSingleIssue(door, results[0], directory);
+    return reportSeveralIssues(door, results, directory);
+}
+/** The JSON body for one issue that was read: the issue, its comments and any Linear link. */
+function readIssueJson(result, directory) {
+    return {
+        issue: withSizeLabel(withAssigneeIdentity(result.issue, directory)),
+        comments: result.comments,
+        ...(result.linearTicketId ? { linear_ticket_id: result.linearTicketId } : {}),
+        ...(result.commentsUnreadReason ? { comments_unread_reason: result.commentsUnreadReason } : {}),
+    };
+}
+// A single ref keeps the pre-BLI-10450 shape and failure path exactly.
+function reportSingleIssue(door, result, directory) {
+    if (!result || !result.ok) {
+        return failAgentDoor(door, TAG, result?.reason ?? "issue_not_found_or_unreadable", result?.detail ?? "That issue does not exist, or you cannot read it.");
     }
-    // Several refs: `{ ok, issues: [...] }`, one entry per ref in the order
-    // given, each carrying `ref` so a caller can match an answer back to what
-    // it asked for. One bad id never loses the rest of the batch.
+    if (door.json)
+        return emitAgentDoor(door, { ok: true, ...readIssueJson(result, directory) });
+    renderOneIssue(door, result, directory);
+    return 0;
+}
+// Several refs: `{ ok, issues: [...] }`, one entry per ref in the order
+// given, each carrying `ref` so a caller can match an answer back to what
+// it asked for. One bad id never loses the rest of the batch.
+function reportSeveralIssues(door, results, directory) {
     const failed = results.filter((result) => !result.ok);
     if (door.json) {
         return emitAgentDoor(door, {
             ok: failed.length === 0,
             issues: results.map((result) => result.ok
-                ? {
-                    ref: result.ref,
-                    ok: true,
-                    issue: withSizeLabel(withAssigneeIdentity(result.issue, directory)),
-                    comments: result.comments,
-                    ...(result.linearTicketId ? { linear_ticket_id: result.linearTicketId } : {}),
-                    ...(result.commentsUnreadReason ? { comments_unread_reason: result.commentsUnreadReason } : {}),
-                }
+                ? { ref: result.ref, ok: true, ...readIssueJson(result, directory) }
                 : { ref: result.ref, ok: false, error: result.reason, detail: result.detail }),
         }, failed.length === 0 ? 0 : 1);
     }

package/dist/commands/issue-write.js

@@ -1,3 +1,4 @@
+import { randomUUID } from "node:crypto";
 /**
  * The verbs that CHANGE something: `cockpit issue create|update|move|comment`
  * (BLI-3716). The reads and the router live in `issue.ts`, the shared shapes
@@ -19,12 +20,14 @@ export async function createIssue(command, door) {
     const body = await readBody(command, door.io);
     if (!body.ok)
         return failAgentDoor(door, TAG, body.reason, body.detail);
-    const answer = await askAgentDoor(door, {
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision })}`);
+    const answer = await askTicketWrite(door, {
         path: "/api/work/issues",
         method: "POST",
         label: "issue create",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: {
+        body: { request_id: requestId, expected_revision: command.expectedRevision,
             title: command.title,
             ...(body.text ? { description: body.text } : {}),
             ...(refs.projectId ? { project_id: refs.projectId } : {}),
@@ -35,11 +38,12 @@ export async function createIssue(command, door) {
         },
     });
     if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        return refuseWrite(door, answer, requestId);
     const issue = maybeWithSizeLabel(answer.body.issue);
     writeLine(door.io.stderr, `${TAG} created ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null, description_bytes: Buffer.byteLength(body.text, "utf8") })}`);
+    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(answer.body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, issue });
+        return emitAgentDoor(door, { ok: true, issue, mutation: answer.body.mutation });
     writeLine(door.io.stdout, `Created ${issue?.identifier ?? ""} — ${issue?.title ?? ""} (${issue?.id ?? ""}).`);
     return 0;
 }
@@ -55,21 +59,17 @@ export async function updateIssue(command, door) {
             return failAgentDoor(door, TAG, body.reason, body.detail);
         description = body.text;
     }
-    if (description === undefined
-        && command.title === undefined
-        && command.priority === undefined
-        && command.estimate === undefined
-        && command.assignee === undefined
-        && refs.projectId === undefined
-        && refs.parentId === undefined) {
+    if (!changesAnything(command, description, refs)) {
         return failAgentDoor(door, TAG, "invalid_body", "issue update needs at least one of --title, --priority, --size, --assignee, --project, --parent, or a description on --body-stdin/--file.");
     }
-    const answer = await askAgentDoor(door, {
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision })}`);
+    const answer = await askTicketWrite(door, {
         path: `/api/work/issues/${encodeURIComponent(ref)}`,
         method: "PATCH",
         label: "issue update",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: {
+        body: { request_id: requestId, expected_revision: command.expectedRevision,
             ...(command.title !== undefined ? { title: command.title } : {}),
             ...(description !== undefined ? { description } : {}),
             ...(command.priority === undefined ? {} : { priority: command.priority }),
@@ -80,29 +80,33 @@ export async function updateIssue(command, door) {
         },
     });
     if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        return refuseWrite(door, answer, requestId);
     const issue = maybeWithSizeLabel(answer.body.issue);
     writeLine(door.io.stderr, `${TAG} updated ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null })}`);
+    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(answer.body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, issue });
+        return emitAgentDoor(door, { ok: true, issue, mutation: answer.body.mutation });
     writeLine(door.io.stdout, `Updated ${issue?.identifier ?? ref} — ${issue?.title ?? ""}.`);
     return 0;
 }
 export async function moveIssue(command, door) {
     const ref = command.issueRef ?? "";
-    const answer = await askAgentDoor(door, {
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision })}`);
+    const answer = await askTicketWrite(door, {
         path: `/api/work/issues/${encodeURIComponent(ref)}/state`,
         method: "POST",
         label: "issue move",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: { state: command.moveState },
+        body: { request_id: requestId, expected_revision: command.expectedRevision, state: command.moveState },
     });
     if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        return refuseWrite(door, answer, requestId);
     const issue = answer.body.issue;
     writeLine(door.io.stderr, `${TAG} moved ${JSON.stringify({ issue_id: issue?.id ?? null, identifier: issue?.identifier ?? null, to_state: command.moveState })}`);
+    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(answer.body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, issue });
+        return emitAgentDoor(door, { ok: true, issue, mutation: answer.body.mutation });
     writeLine(door.io.stdout, `${issue?.identifier ?? ref} is now ${issue?.state ?? command.moveState}.`);
     return 0;
 }
@@ -114,19 +118,62 @@ export async function commentIssue(command, door) {
     if (body.text.trim() === "") {
         return failAgentDoor(door, TAG, "invalid_body", 'A comment is never taken on the command line — pipe it in: `echo "..." | cockpit issue comment BLI-3654`.');
     }
-    const answer = await askAgentDoor(door, {
+    const requestId = command.requestId ?? randomUUID();
+    writeLine(door.io.stderr, `${TAG} request ${JSON.stringify({ request_id: requestId, expected_revision: command.expectedRevision })}`);
+    const answer = await askTicketWrite(door, {
         path: `/api/work/issues/${encodeURIComponent(ref)}/comments`,
         method: "POST",
         label: "issue comment",
         timeoutMs: WRITE_DEADLINE_MS,
-        body: { body_markdown: body.text },
+        body: { request_id: requestId, expected_revision: command.expectedRevision, body_markdown: body.text },
     });
     if (!answer.ok)
-        return failAgentDoor(door, TAG, answer.reason, answer.detail);
+        return refuseWrite(door, answer, requestId);
     const comment = answer.body.comment;
     writeLine(door.io.stderr, `${TAG} commented ${JSON.stringify({ comment_id: comment?.id ?? null, byte_size: Buffer.byteLength(body.text, "utf8") })}`);
+    writeLine(door.io.stderr, `${TAG} local commit receipt ${JSON.stringify(answer.body.mutation ?? { outcome: "unknown_check_again", request_id: requestId })}`);
     if (door.json)
-        return emitAgentDoor(door, { ok: true, comment });
+        return emitAgentDoor(door, { ok: true, comment, mutation: answer.body.mutation });
     writeLine(door.io.stdout, `Commented on ${ref} (${comment?.id ?? ""}).`);
     return 0;
+}
+/** A truncated or missing response body cannot be called a successful ticket write. */
+async function askTicketWrite(door, options) {
+    try {
+        const answer = await askAgentDoor(door, options);
+        if (!answer.ok)
+            return answer;
+        const body = answer.body;
+        if (body && (body.issue || body.comment))
+            return answer;
+    }
+    catch {
+        console.error(`${TAG} response lost`, JSON.stringify({ reason: "mutation_unknown" }));
+    }
+    const requestId = options.body.request_id;
+    return { ok: false, reason: "mutation_unknown", detail: "Result unknown. Check this request ID before retrying with identical input.",
+        body: { mutation: { request_id: requestId, outcome: "unknown_check_again" } } };
+}
+/** Did the person ask for at least one field to change? */
+function changesAnything(command, description, refs) {
+    return description !== undefined
+        || command.title !== undefined
+        || command.priority !== undefined
+        || command.estimate !== undefined
+        || command.assignee !== undefined
+        || refs.projectId !== undefined
+        || refs.parentId !== undefined;
+}
+/** Says where the local commit stands, then fails with the door's own reason. */
+function refuseWrite(door, answer, requestId) {
+    writeLine(door.io.stderr, `${TAG} check local commit with cockpit ticket mutation-status ${requestId}; retry unchanged input with --request-id ${requestId}.`);
+    const mutation = answer.body?.mutation ?? { request_id: requestId, outcome: "unknown_check_again" };
+    if (door.json) {
+        writeLine(door.io.stderr, `${TAG} refused ${JSON.stringify({ reason: answer.reason, request_id: requestId })}`);
+        return emitAgentDoor(door, { ok: false, error: answer.reason, detail: answer.detail, mutation }, 1);
+    }
+    const receipt = mutation;
+    if (receipt.current)
+        writeLine(door.io.stderr, `${TAG} conflict ${JSON.stringify({ request_id: requestId, outcome: receipt.outcome, current_state: receipt.current.state, current_revision: receipt.current.revision })}`);
+    return failAgentDoor(door, TAG, answer.reason, answer.detail);
 }

package/dist/commands/issue.js

@@ -36,6 +36,16 @@ import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write
 export async function runIssue(command, io) {
     const door = await openAgentDoor("issue", command, io);
     switch (command.action) {
+        case "mutation-status": {
+            const answer = await askAgentDoor(door, { path: `/api/work/mutations/${encodeURIComponent(command.issueRef ?? "")}`,
+                method: "GET", label: "ticket mutation status", timeoutMs: READ_DEADLINE_MS });
+            if (!answer.ok)
+                return failAgentDoor(door, TAG, answer.reason, answer.detail);
+            if (door.json)
+                return emitAgentDoor(door, { ok: true, ...answer.body });
+            writeLine(door.io.stdout, JSON.stringify(answer.body));
+            return 0;
+        }
         case "board":
             return readTicketBoard(command, door);
         case "list":
@@ -92,23 +102,10 @@ export function listGapLines(body, requestedLimit) {
     return lines;
 }
 async function listIssues(command, door) {
-    const query = new URLSearchParams();
-    if (command.stateFilter)
-        query.set("state", command.stateFilter);
-    if (command.assignee)
-        query.set("assignee_id", command.assignee);
-    if (command.limit !== undefined)
-        query.set("limit", String(command.limit));
-    if (command.project) {
-        const resolved = await resolveProjectId(door, command.project);
-        if (resolved.status === "list_failed")
-            return failAgentDoor(door, TAG, resolved.reason, resolved.detail);
-        if (resolved.status === "not_found") {
-            return failAgentDoor(door, TAG, "project_not_found_or_unreadable", `No project here is called "${command.project}" — run \`cockpit project list\` for the names.`);
-        }
-        query.set("project_id", resolved.id);
-    }
-    const suffix = query.toString();
+    const built = await buildIssueListQuery(command, door);
+    if (!built.ok)
+        return built.exitCode;
+    const suffix = built.query.toString();
     // BLI-10579: the assignee directory (`/api/team/members`) is the whole org
     // roster regardless of which issues come back — it never actually depended
     // on the issue list — so start it now, alongside the issues request,
@@ -116,26 +113,7 @@ async function listIssues(command, door) {
     // `work list` p50 was exactly this serial second call).
     const directoryFetch = beginAssigneeDirectoryFetch(door);
     const listPath = `/api/work/issues${suffix ? `?${suffix}` : ""}`;
-    const answer = await readThroughCache({
-        io: door.io,
-        homeDir: door.homeDir,
-        deviceToken: door.deviceToken,
-        surface: "work",
-        label: "issue list",
-        path: listPath,
-        json: door.json,
-        ask: () => askAgentDoor(door, {
-            path: listPath,
-            method: "GET",
-            label: "issue list",
-            timeoutMs: READ_DEADLINE_MS,
-            // BLI-10746: `work list` was the slowest of the six reads measured
-            // from Vietnam (1,682 ms p50) — route it through the resident memory
-            // daemon's warm connection so this command skips a fresh TCP+TLS
-            // handshake.
-            warmRoute: true,
-        }),
-    });
+    const answer = await askIssueList(door, listPath);
     if (!answer.ok) {
         // Not awaited for its own sake — `finishAssigneeDirectory` always awaits
         // the in-flight fetch so it never leaks past this command's exit.
@@ -176,6 +154,51 @@ async function listIssues(command, door) {
     writeLine(door.io.stdout, `${issues.length} issue(s).`);
     return 0;
 }
+/** The list query for the filters given, or the exit code of the project lookup that failed. */
+async function buildIssueListQuery(command, door) {
+    const query = new URLSearchParams();
+    if (command.stateFilter)
+        query.set("state", command.stateFilter);
+    if (command.assignee)
+        query.set("assignee_id", command.assignee);
+    if (command.limit !== undefined)
+        query.set("limit", String(command.limit));
+    if (command.project) {
+        const resolved = await resolveProjectId(door, command.project);
+        if (resolved.status === "list_failed")
+            return { ok: false, exitCode: failAgentDoor(door, TAG, resolved.reason, resolved.detail) };
+        if (resolved.status === "not_found") {
+            return {
+                ok: false,
+                exitCode: failAgentDoor(door, TAG, "project_not_found_or_unreadable", `No project here is called "${command.project}" — run \`cockpit project list\` for the names.`),
+            };
+        }
+        query.set("project_id", resolved.id);
+    }
+    return { ok: true, query };
+}
+function askIssueList(door, listPath) {
+    return readThroughCache({
+        io: door.io,
+        homeDir: door.homeDir,
+        deviceToken: door.deviceToken,
+        surface: "work",
+        label: "issue list",
+        path: listPath,
+        json: door.json,
+        ask: () => askAgentDoor(door, {
+            path: listPath,
+            method: "GET",
+            label: "issue list",
+            timeoutMs: READ_DEADLINE_MS,
+            // BLI-10746: `work list` was the slowest of the six reads measured
+            // from Vietnam (1,682 ms p50) — route it through the resident memory
+            // daemon's warm connection so this command skips a fresh TCP+TLS
+            // handshake.
+            warmRoute: true,
+        }),
+    });
+}
 /**
  * What a history row actually says. A row imported from Linear's issue
  * TIMESTAMPS (created/started/completed/canceled) carries no state names at
@@ -187,6 +210,14 @@ async function listIssues(command, door) {
  * reads a real gap as a broken command.
  */
 function historyChange(row) {
+    if (row.source === "native" && row.detail?.operation) {
+        if (row.detail.operation === "create")
+            return "created the ticket";
+        if (row.detail.operation === "comment")
+            return "added a comment";
+        if (row.change_type === "other")
+            return `updated ${(row.detail.fields ?? []).join(", ")}`;
+    }
     if (row.from_value === null && row.to_value === null) {
         return `(no state names recorded — imported from ${row.source})`;
     }

package/dist/commands/jarvis-live-answer.js

@@ -0,0 +1,99 @@
+import { colorEnabled, dim, writeFragment, writeLine } from "./cli-io.js";
+import { ANSWER_REVISED_LINE, writeReply, writeReplyContinuation } from "./jarvis-render.js";
+/**
+ * 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.
+ */
+export function createLiveAnswer(command, io) {
+    const styled = colorEnabled(io);
+    const quiet = command.json === true;
+    const screen = { printed: "", opened: false };
+    return {
+        token(event) {
+            if (quiet)
+                return;
+            const text = event.text ?? "";
+            if (event.reset) {
+                if (screen.printed) {
+                    writeLine(io.stdout, "");
+                    writeLine(io.stdout, dim("  — that draft was replaced —", styled));
+                    screen.opened = false;
+                }
+                screen.printed = "";
+            }
+            if (!text)
+                return;
+            openAnswerLine(io, screen, "");
+            screen.printed += text;
+            writeFragment(io.stdout, text);
+        },
+        interrupt() {
+            if (quiet || !screen.opened)
+                return;
+            writeLine(io.stdout, "");
+            screen.opened = false;
+        },
+        settle(reply, subject, revised) {
+            if (quiet)
+                return;
+            settleLiveAnswer(io, styled, screen, { reply, subject, revised });
+        },
+        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 && screen.opened)
+                writeLine(io.stdout, "");
+        },
+    };
+}
+function openAnswerLine(io, screen, subject) {
+    if (screen.opened)
+        return;
+    screen.opened = true;
+    writeFragment(io.stdout, `jarvis${subject}> `);
+}
+function settleLiveAnswer(io, styled, screen, settled) {
+    const { reply, subject, revised } = settled;
+    const { printed } = screen;
+    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 (screen.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 (!screen.opened)
+            writeFragment(io.stdout, `jarvis${subject}> `);
+        writeReplyContinuation(io, reply.slice(printed.length));
+        return;
+    }
+    if (screen.opened)
+        writeLine(io.stdout, "");
+    writeLine(io.stdout, dim(revised ? `  — ${ANSWER_REVISED_LINE} —` : "  — corrected —", styled));
+    writeReply(io, `jarvis${subject}> `, reply);
+}

package/dist/commands/jarvis-render.js

@@ -228,7 +228,7 @@ export function writeReplyContinuation(io, tail) {
  * 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";
+export 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).
  *
@@ -251,99 +251,6 @@ const ANSWER_CORRECTED_NOTE_LINE = "The paragraph printed above is unchanged —
     "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.";
-/**
- * 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.
- */
-export 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, "");
-        },
-    };
-}
 /**
  * Print what a correction did to the answer above, once the turn has settled.
  *

package/dist/commands/jarvis-trace.js

@@ -84,28 +84,10 @@ export async function readRememberedTurn(homeDir) {
 }
 export async function runJarvisTrace(context, io) {
     const log = (line) => writeLine(io.stderr, line);
-    let traceId = context.requested;
-    let resolvedFrom = "argument";
-    if (context.requested === "last") {
-        const remembered = await readRememberedTurn(context.homeDir);
-        if (!remembered) {
-            return refuse(context, io, "no_remembered_turn", "This machine has not asked JARVIS anything since traces were turned on, so there is no last turn to open. Ask something, then run this again — or pass the trace id from the turn's receipt.");
-        }
-        if (remembered.traceId) {
-            traceId = remembered.traceId;
-            resolvedFrom = "bookmark";
-        }
-        else if (remembered.threadId) {
-            // The bookmark knew the conversation but not the turn (an older receipt).
-            // Ask the server for that conversation's newest turn rather than nothing.
-            const newest = await newestTraceForThread(context, remembered.threadId, io);
-            if (!newest) {
-                return refuse(context, io, "no_traces_in_thread", "That conversation has no recorded turns inside the 30-day retention. Pass a trace id, or ask something new.");
-            }
-            traceId = newest;
-            resolvedFrom = "thread";
-        }
-    }
+    const resolution = await resolveRequestedTrace(context, io);
+    if (!resolution.ok)
+        return resolution.exitCode;
+    const { traceId, resolvedFrom } = resolution;
     const result = await towerJsonRequest({
         dashboardUrl: context.dashboardUrl,
         path: `/api/ops/trace/${encodeURIComponent(traceId)}`,
@@ -139,6 +121,32 @@ export async function runJarvisTrace(context, io) {
     })}`);
     return 0;
 }
+/** Turns `last` into the remembered turn's trace id; any other argument is already a trace id. */
+async function resolveRequestedTrace(context, io) {
+    if (context.requested !== "last")
+        return { ok: true, traceId: context.requested, resolvedFrom: "argument" };
+    const remembered = await readRememberedTurn(context.homeDir);
+    if (!remembered) {
+        return {
+            ok: false,
+            exitCode: refuse(context, io, "no_remembered_turn", "This machine has not asked JARVIS anything since traces were turned on, so there is no last turn to open. Ask something, then run this again — or pass the trace id from the turn's receipt."),
+        };
+    }
+    if (remembered.traceId)
+        return { ok: true, traceId: remembered.traceId, resolvedFrom: "bookmark" };
+    if (!remembered.threadId)
+        return { ok: true, traceId: context.requested, resolvedFrom: "argument" };
+    // The bookmark knew the conversation but not the turn (an older receipt).
+    // Ask the server for that conversation's newest turn rather than nothing.
+    const newest = await newestTraceForThread(context, remembered.threadId, io);
+    if (!newest) {
+        return {
+            ok: false,
+            exitCode: refuse(context, io, "no_traces_in_thread", "That conversation has no recorded turns inside the 30-day retention. Pass a trace id, or ask something new."),
+        };
+    }
+    return { ok: true, traceId: newest, resolvedFrom: "thread" };
+}
 async function newestTraceForThread(context, threadId, io) {
     const result = await towerJsonRequest({
         dashboardUrl: context.dashboardUrl,