@bli-cockpit/cli 0.2.64 → 0.2.66

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

@@ -27,6 +27,25 @@
  * older `reply` / `thread` / `traceId` / `model` / `trace` / `latency` /
  * `clientLatency` keys are untouched, because scripts already read them and a
  * one-contract ticket that broke the contract would be a joke.
+ *
+ * ## Where `sources` comes from (BLI-3770)
+ *
+ * From the DOOR, as objects, when the door sends them: `POST /api/jarvis/cli`
+ * carries `sources` built from the citations the grounding layer minted, and
+ * the `Source:` lines inside `answer` are rendered from that same array. The
+ * older derivation — a line-anchored regex over the finished prose — could
+ * only find a citation the renderer happened to put on its own line, so QA
+ * tick 16's c9, c9b and n9 (all off `searchEverything`) ended *"…Source:
+ * issue, at /work/BLI-3706, by …"* INSIDE the final sentence and returned
+ * `"sources": []`: the person saw a citation, the machine did not.
+ *
+ * The prose derivation survives as the FALLBACK, for a dashboard deployed
+ * before that door field existed, and it is wider than it was: a whole
+ * `Sources:` line (plural, any case, bulleted) counts — that is what the
+ * server itself treats as provenance — and so does a citation that begins a
+ * sentence inside a paragraph. A `Source:` in the MIDDLE of a sentence ("the
+ * Source: field on that row was blank") is prose about a source, not a
+ * source, and is deliberately not matched.
  */
 /**
  * Every key of the envelope, in the order it is written. The literal list IS
@@ -43,8 +62,20 @@ export const JARVIS_ANSWER_ENVELOPE_KEYS = [
     "degraded",
     "degraded_reasons",
 ];
-/** A `Source:` line, as the grounding gate renders it into the answer. */
-const SOURCE_LINE = /^\s*Source:\s*\S/;
+/**
+ * A citation line, in every shape the server itself treats as one.
+ *
+ * BLI-3770 widened this from `/^\s*Source:\s*\S/` to mirror
+ * `apps/dashboard/src/lib/jarvis/chat-v2/provenance-lines.ts`, which matches
+ * `sources?` case-insensitively with an optional bullet. The narrow version
+ * meant a `Sources: …` line the server had already lifted out of the body as
+ * provenance, and put straight back under the answer, was not a source to
+ * this side: one thing, two definitions, in two packages.
+ */
+const SOURCE_LINE = /^\s*(?:[-*\u2022]\s+)?sources?\s*:\s*\S/i;
+/** The receipt's link, as `appendCitations` lays it out: `<url>` after the words. */
+const BRACKETED_LINK = /\s*<(https?:\/\/[^>\s]+)>\s*$/;
+const TRAILING_LINK = /\s+(https?:\/\/\S+)\s*$/;
 /**
  * The `Source:` lines inside an answer. Pure string work on what the server
  * already sent — this side never decides what a source IS, it only finds the
@@ -56,6 +87,90 @@ export function extractSourceLines(answer) {
         .map((line) => line.trim())
         .filter((line) => SOURCE_LINE.test(line));
 }
+/** The words and the link, kept apart, the way every surface renders them. */
+function splitLink(line) {
+    const trimmed = line.trim().replace(/^[-*\u2022]\s+/, "");
+    const bracketed = trimmed.match(BRACKETED_LINK);
+    if (bracketed)
+        return { label: trimmed.slice(0, bracketed.index).trim(), href: bracketed[1] ?? null };
+    const trailing = trimmed.match(TRAILING_LINK);
+    if (trailing)
+        return { label: trimmed.slice(0, trailing.index).trim(), href: trailing[1] ?? null };
+    return { label: trimmed, href: null };
+}
+/**
+ * A citation the model wrote INSIDE a paragraph (BLI-3770).
+ *
+ * It counts when it begins a sentence, which is the shape QA tick 16 caught
+ * three times. It deliberately does not count in the middle of one — "the
+ * Source: field on that row was blank" is a sentence about a field, and
+ * treating it as a receipt would put prose in a contract that is supposed to
+ * carry evidence.
+ */
+function inlineSourceFragments(line) {
+    return line
+        .split(/(?<=[.!?])\s+/)
+        .map((part) => part.trim())
+        .filter((part) => SOURCE_LINE.test(part));
+}
+/**
+ * The fallback derivation: what this side can tell from the answer alone.
+ *
+ * Only reached when the door sent no structured `sources` — a dashboard
+ * deployed before BLI-3770, or a turn whose citation nothing minted. Every
+ * row it produces is labelled `kind: "prose"` so a consumer can tell a
+ * recovered line from a minted receipt.
+ */
+export function sourcesFromAnswer(answer) {
+    const found = [];
+    const seen = new Set();
+    const add = (text) => {
+        const { label, href } = splitLink(text);
+        if (!label || seen.has(label))
+            return;
+        seen.add(label);
+        found.push({ kind: "prose", label, href, id: null, tool: null });
+    };
+    for (const raw of answer.split("\n")) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (SOURCE_LINE.test(line)) {
+            add(line);
+            continue;
+        }
+        for (const fragment of inlineSourceFragments(line))
+            add(fragment);
+    }
+    return found;
+}
+/**
+ * The door's own `sources`, checked rather than trusted. A field that arrives
+ * as something other than a list of labelled objects is treated as absent, so
+ * a malformed body degrades to the prose fallback instead of putting
+ * `[object Object]` in front of an agent.
+ */
+function doorSources(sent) {
+    if (!Array.isArray(sent))
+        return [];
+    const rows = [];
+    for (const entry of sent) {
+        if (!entry || typeof entry !== "object")
+            continue;
+        const row = entry;
+        const label = typeof row.label === "string" ? row.label.trim() : "";
+        if (!label)
+            continue;
+        rows.push({
+            kind: typeof row.kind === "string" && row.kind ? row.kind : "unknown",
+            label,
+            href: typeof row.href === "string" ? row.href : null,
+            id: typeof row.id === "string" ? row.id : null,
+            tool: typeof row.tool === "string" ? row.tool : null,
+        });
+    }
+    return rows;
+}
 export function buildJarvisAnswerEnvelope(input) {
     const reasons = [];
     if (input.modelFallback === true)
@@ -68,10 +183,14 @@ export function buildJarvisAnswerEnvelope(input) {
     const turnId = input.traceId ?? null;
     if (!turnId)
         reasons.push("no_turn_id");
+    const sent = doorSources(input.sources);
     return {
         ok: true,
         answer: input.reply,
-        sources: extractSourceLines(input.reply),
+        // BLI-3770: the door's own citations when it sent them, and only then the
+        // prose fallback. Never both — a turn's receipts have one origin, and
+        // merging the two would double-count the lines the door already described.
+        sources: sent.length > 0 ? sent : sourcesFromAnswer(input.reply),
         turn_id: turnId,
         thread_id: input.thread ?? null,
         trace_thread_id: input.traceThread ?? null,

package/dist/commands/jarvis-turn.js

@@ -158,6 +158,10 @@ export async function sendOneTurn(context, prompt, io) {
                 revised: body.revised,
                 trace,
                 proposalId: body.proposalId,
+                // 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,

package/dist/commands/public-root.js

@@ -15,7 +15,7 @@ export async function runCockpitCli(argv, io) {
   }
 
   if (command === "--version" || command === "-V" || command === "version") {
-    writeLine(io?.stdout ?? process.stdout, "0.2.64");
+    writeLine(io?.stdout ?? process.stdout, "0.2.66");
     return 0;
   }
 

package/dist/commands/status.js

@@ -8,6 +8,11 @@
  * pastes into Slack when something looks wrong. The `--json` payload is the
  * machine contract and is byte-for-byte unchanged — `status-json-shape.test.ts`
  * holds it to that.
+ *
+ * Two branches, one machine: a folder holding several repos prints a row each,
+ * a single repo prints the full block, and BOTH carry the setup receipt
+ * (BLI-3789) — it says whether this HOST is connected, which does not change
+ * with the folder you are standing in.
  */
 import { readdir, stat } from "node:fs/promises";
 import os from "node:os";
@@ -24,6 +29,18 @@ import { getCollectorRuntimePaths, inspectLocalCollectorStatus, readLocalCollect
 import { normalizeCollectionRoots } from "../root-normalization.js";
 export async function runStatus(command, io) {
     const backfillCursor = await inspectBackfillCursor(command.homeDir);
+    // BLI-3731: "is this machine actually connected?" belongs beside "is it
+    // collecting?", and it is read back off the host rather than remembered.
+    // Refreshing here also keeps the heartbeat's cache warm without the 15-minute
+    // tick paying for the probe.
+    //
+    // BLI-3789: read it BEFORE the branch below, not after. The receipt is a fact
+    // about the MACHINE, so it cannot depend on whether the folder you happen to
+    // stand in holds one repo or six — and the multi-repo branch, which every
+    // agent machine takes, used to return before the receipt was ever built.
+    const setupReceipt = await refreshSetupReceipt(io, {
+        ...(command.homeDir ? { homeDir: command.homeDir } : {}),
+    });
     const worktrees = await discoverCommandWorktrees(command.repoRoot, { maxDepth: command.maxDepth, maxRepos: command.maxRepos, homeDir: command.homeDir }, io);
     if (worktrees.length > 1) {
         const statuses = await Promise.all(worktrees.map(async (worktree) => ({
@@ -34,7 +51,17 @@ export async function runStatus(command, io) {
             head_sha: worktree.head_sha,
         })));
         if (command.json) {
-            writeLine(io.stdout, JSON.stringify({ mode: "multi_repo", statuses, backfill_cursor: backfillCursor }, null, 2));
+            writeLine(io.stdout, JSON.stringify({
+                mode: "multi_repo",
+                statuses,
+                backfill_cursor: backfillCursor,
+                // Beside `backfill_cursor`, and for the same reason: both are facts
+                // about this machine, so both sit at the top of the payload rather
+                // than once per repo row. Null means this run could not read the
+                // host — `refreshSetupReceipt` named the reason on stderr — never
+                // "this machine is not connected".
+                setup_receipt: setupReceipt?.receipt ?? null,
+            }, null, 2));
             return 0;
         }
         writeLine(io.stdout, "Tower status — every repo below this folder");
@@ -42,16 +69,10 @@ export async function runStatus(command, io) {
         for (const status of statuses) {
             writeLine(io.stdout, `- ${status.repo_label ?? status.repo}/${status.worktree_label ?? "worktree"} · ${status.branch} · head:${shortSha(status.head_sha)} · ${status.upload_state}`);
         }
+        writeConnectedBlock(io, setupReceipt);
         return 0;
     }
     const status = await inspectLocalCollectorStatus(command);
-    // BLI-3731: "is this machine actually connected?" belongs beside "is it
-    // collecting?", and it is read back off the host rather than remembered.
-    // Refreshing here also keeps the heartbeat's cache warm without the 15-minute
-    // tick paying for the probe.
-    const setupReceipt = await refreshSetupReceipt(io, {
-        ...(command.homeDir ? { homeDir: command.homeDir } : {}),
-    });
     if (command.json) {
         writeLine(io.stdout, JSON.stringify({
             ...status,
@@ -88,13 +109,22 @@ export async function runStatus(command, io) {
     writeLine(io.stdout, `Stuck files: ${stuckEvidenceLine(status)}`);
     for (const detail of status.details)
         writeLine(io.stdout, `- ${detail}`);
+    writeConnectedBlock(io, setupReceipt);
+    return 0;
+}
+/**
+ * The receipt block, in the words `cockpit doctor` prints, from the one reader
+ * (BLI-3789). Both branches of `status` call this: a person standing in a
+ * parent folder is asking about the same machine as a person standing in one
+ * repo, and only one of them used to be told.
+ */
+function writeConnectedBlock(io, setupReceipt) {
     writeLine(io.stdout, "Connected:");
     for (const line of setupReceipt
         ? setupReceiptBlock(setupReceipt, { indent: "  " })
         : ["  unknown — run `cockpit doctor` to read this machine."]) {
         writeLine(io.stdout, line);
     }
-    return 0;
 }
 /**
  * Done, still working, or never started — and when it is still working, how

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.64",
+  "version": "0.2.66",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.9",
-    "@bli-cockpit/mcp": "0.1.7",
+    "@bli-cockpit/mcp": "0.1.8",
     "@bli-cockpit/telemetry-core": "0.1.30"
   }
 }