@bli-cockpit/cli 0.2.237 → 0.2.239

package/dist/commands/issue.js

@@ -33,9 +33,20 @@ import { readTicketBoard } from "./tickets-board.js";
 import { showIssue } from "./issue-show.js";
 import { READ_DEADLINE_MS, TAG, resolveProjectId, sizeForEstimate, withSizeLabel, } from "./issue-contracts.js";
 import { commentIssue, createIssue, moveIssue, updateIssue } from "./issue-write.js";
+import { listIssueVersions, restoreIssueVersion } from "./issue-versions.js";
 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":
@@ -52,6 +63,10 @@ export async function runIssue(command, io) {
             return commentIssue(command, door);
         case "history":
             return issueHistory(command, door);
+        case "versions":
+            return listIssueVersions(command, door);
+        case "restore":
+            return restoreIssueVersion(command, door);
     }
 }
 function issueLine(issue, directory) {
@@ -92,23 +107,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 +118,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 +159,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 +215,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,

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,
+        }),
+    })}`);
+}