@bli-cockpit/cli 0.2.249 → 0.2.251

package/dist/commands/manager-meetings.js

@@ -0,0 +1,184 @@
+/**
+ * `cockpit manager meetings | tie | decide-tie` (BLI-22192): meetings tied to Tower Manager clients, from the terminal.
+ *
+ *   cockpit manager meetings [--client <client>] [--event <id> | --note <id>] [--page-size <n>] [--cursor <c>]
+ *   cockpit manager tie <client> (--event <id> [--occurrence <timestamp>] | --note <id>) [--request-id <uuid>]
+ *   cockpit manager decide-tie <tie-id> accept|dismiss|remove --version <v>
+ *
+ * A tie made here goes through the `/api/manager` door, which marks it as this person's agent's: it is a SUGGESTION until a
+ * person accepts or dismisses it (on the manager page, here, or with the MCP twins). A meeting is a calendar event (one
+ * occurrence of a recurring one with `--occurrence`) or a meeting note, by its Tower id (`cockpit cal` and `cockpit notes`
+ * print them). The door shows each tied meeting's title and time only when THIS caller can open that event or note; any
+ * other reads "a meeting you cannot open". One page at a time; the next page is the printed `--cursor`.
+ */
+import { dim } from "./cli-io.js";
+import { optionalNonEmpty } from "./local-arg-values.js";
+import { managerTime } from "./manager-render-home.js";
+const ID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const TIMESTAMP = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(\.\d+)?(Z|[+-]\d{2}:\d{2})$/;
+const BASE = "/api/manager";
+const enc = encodeURIComponent;
+/** A copy of the server's `TOWER_MANAGER_MEETING_TIE_LIMITS.pageMax` (held to it by `manager-cli-mcp-rules.test.ts`). */
+export const MEETING_TIE_PAGE_MAX = 200;
+export const TIE_DECISIONS = ["accept", "dismiss", "remove"];
+/** Where a tie stands, in words; held to the server's `TOWER_MANAGER_TIE_STATES` by `manager-enum-words.test.ts`. */
+export const TIE_STATE = {
+    suggested: "suggested by an agent, waiting for a person",
+    confirmed: "confirmed",
+    dismissed: "dismissed (not suggested again)",
+    removed: "removed",
+};
+/** Which meeting `--event`/`--note` name: one of them, as an id. */
+function readMeeting(values, verb, required) {
+    const event = optionalNonEmpty(values.flags.get("--event"));
+    const note = optionalNonEmpty(values.flags.get("--note"));
+    if (event && note)
+        throw new Error("--event and --note name two meetings. Give one.");
+    const raw = event ?? note;
+    if (!raw) {
+        if (required)
+            throw new Error(`\`cockpit manager ${verb}\` needs --event <id> (a calendar event: \`cockpit cal\` prints ids) or --note <id> (a meeting note: \`cockpit notes list\`).`);
+        return undefined;
+    }
+    if (!ID.test(raw))
+        throw new Error(`${event ? "--event" : "--note"} is the ${event ? "event's" : "note's"} Tower id, like 8f14e45f-ceea-467a-9575-1d3a4e7b2c10.`);
+    return { meetingKind: event ? "event" : "note", meetingId: raw };
+}
+/** `decide-tie`'s tie id: a uuid, refused with where tie ids come from. */
+export function readTieId(value) {
+    if (!ID.test(value))
+        throw new Error("A tie id looks like 8f14e45f-ceea-467a-9575-1d3a4e7b2c10 (`cockpit manager meetings` prints them).");
+    return value;
+}
+/** `meetings`, `tie`, `decide-tie`: the flags and words each takes, into the command. */
+export function readMeetingTieArgs(verb, values, rest, shape) {
+    if (verb === "meetings") {
+        const client = optionalNonEmpty(values.flags.get("--client"));
+        if (client)
+            shape.client = client;
+        const meeting = readMeeting(values, verb, false);
+        if (meeting)
+            Object.assign(shape, meeting);
+        const size = values.flags.get("--page-size");
+        if (size !== undefined) {
+            if (!/^\d{1,4}$/.test(size) || Number(size) < 1 || Number(size) > MEETING_TIE_PAGE_MAX)
+                throw new Error(`--page-size is a whole number from 1 to ${MEETING_TIE_PAGE_MAX}.`);
+            shape.pageSize = Number(size);
+        }
+        const cursor = optionalNonEmpty(values.flags.get("--cursor"));
+        if (cursor) {
+            if (!/^[A-Za-z0-9_-]{1,400}$/.test(cursor))
+                throw new Error("--cursor is a page's nextCursor exactly as `cockpit manager meetings --json` printed it, with the same --client, --event or --note.");
+            shape.cursor = cursor;
+        }
+        return;
+    }
+    if (verb === "tie") {
+        Object.assign(shape, readMeeting(values, verb, true));
+        const occurrence = values.flags.get("--occurrence");
+        if (occurrence !== undefined) {
+            if (shape.meetingKind !== "event")
+                throw new Error("--occurrence is one occurrence of a recurring calendar event: it goes with --event, not --note.");
+            if (!TIMESTAMP.test(occurrence) || Number.isNaN(Date.parse(occurrence)))
+                throw new Error("--occurrence is that occurrence's start with its offset, like 2026-10-20T09:00:00-07:00.");
+            shape.occurrenceStart = occurrence;
+        }
+        const requestId = values.flags.get("--request-id");
+        if (requestId !== undefined) {
+            if (!ID.test(requestId))
+                throw new Error("--request-id is the uuid an earlier `tie` printed.");
+            shape.requestId = requestId;
+        }
+        return;
+    }
+    const decision = rest[1];
+    if (!TIE_DECISIONS.includes(decision))
+        throw new Error("The last word of `cockpit manager decide-tie` is accept, dismiss or remove.");
+    shape.tieDecision = decision;
+}
+/** The request each verb sends: the page read, the tie, the decision. */
+export function meetingTiePlan(command, clientId, newRequestId) {
+    if (command.action === "meetings") {
+        const query = new URLSearchParams();
+        // Only a client the person named (`--client`): with none, the read is every client's.
+        if (command.client && clientId)
+            query.set("clientId", clientId);
+        if (command.meetingKind && command.meetingId) {
+            query.set("meetingKind", command.meetingKind);
+            query.set("meetingId", command.meetingId);
+        }
+        if (command.cursor)
+            query.set("cursor", command.cursor);
+        if (command.pageSize !== undefined)
+            query.set("limit", String(command.pageSize));
+        const text = query.toString();
+        return { method: "GET", path: `${BASE}/meeting-ties${text ? `?${text}` : ""}`, logFields: pageLog };
+    }
+    if (command.action === "tie") {
+        const requestId = command.requestId ?? newRequestId();
+        const body = { meetingKind: command.meetingKind, meetingId: command.meetingId, requestId };
+        if (command.occurrenceStart)
+            body["occurrenceStart"] = command.occurrenceStart;
+        return { method: "POST", path: `${BASE}/clients/${enc(clientId ?? "")}/meeting-ties`, body, requestId, logFields: tieLog };
+    }
+    return {
+        method: "POST",
+        path: `${BASE}/meeting-ties/${enc(command.id ?? "")}/decision`,
+        body: { decision: command.tieDecision, expectedUpdatedAt: command.version },
+        logFields: tieLog,
+    };
+}
+function pageLog(answer) {
+    const page = answer && typeof answer === "object" ? answer : {};
+    return { returned: Array.isArray(page.ties) ? page.ties.length : null, total: typeof page.total === "number" ? page.total : null, more: typeof page.nextCursor === "string" };
+}
+function tieLog(answer) {
+    const tie = answer && typeof answer === "object" ? answer : {};
+    return { tie_id: tie.id ?? null, state: tie.state ?? null, ...(typeof tie.created === "boolean" ? { created: tie.created } : {}), ...(tie.unchanged === true ? { unchanged: true } : {}) };
+}
+/** "Weekly sync, Oct 20, 9:00 AM PDT" or, for a meeting this caller cannot open, never its title. */
+function meetingWords(tie) {
+    const what = tie.meetingKind === "event" ? "calendar event" : "meeting note";
+    if (tie.meeting?.state !== "open")
+        return `a ${what} you cannot open`;
+    const when = tie.occurrenceStart ?? tie.meeting.start;
+    return `${tie.meeting.title}${when ? `, ${managerTime(when)}` : ""} (${what})`;
+}
+/** One tie on two lines: the meeting and its client, then where it stands, who tied it, and the ids a decision needs. */
+export function tieLines(tie, color) {
+    const state = TIE_STATE[tie.state] ?? tie.state;
+    const who = tie.addedBy === "agent" ? `${tie.createdByName ?? "a teammate"}'s agent` : tie.createdByName ?? "a teammate";
+    return [
+        `${meetingWords(tie)}  →  ${tie.clientName}`,
+        `  ${state}; tied by ${who} ${managerTime(tie.createdAt)}${dim(`  tie ${tie.id}  version ${tie.updatedAt}${tie.meetingId ? `  ${tie.meetingKind} ${tie.meetingId}` : ""}${tie.occurrenceStart ? ` occurrence ${tie.occurrenceStart}` : ""}`, color)}`,
+    ];
+}
+export function meetingTiePageLines(page, command, color) {
+    const scope = command.client ? `tied to ${command.client}` : command.meetingId ? "of this meeting" : "across every client";
+    const head = `Meetings ${scope}: ${page.total}${page.ties.length < page.total ? ` (showing ${page.ties.length})` : ""}`;
+    if (page.ties.length === 0)
+        return [head, "  No meetings are tied here yet. `cockpit manager tie <client> --event <id>` ties one."];
+    const lines = [head, ...page.ties.flatMap((tie) => tieLines(tie, color).map((line) => `  ${line}`))];
+    if (page.nextCursor) {
+        const again = [command.client ? `--client ${/\s/.test(command.client) ? `"${command.client}"` : command.client}` : "", command.meetingId ? `--${command.meetingKind} ${command.meetingId}` : ""].filter(Boolean).join(" ");
+        lines.push(`More: \`cockpit manager meetings ${again ? `${again} ` : ""}--cursor ${page.nextCursor}\` for the next page.`);
+    }
+    return lines;
+}
+/** What a tie or a decision did, in one sentence, then the tie. */
+export function tieWrittenLines(command, tie, color) {
+    const sentence = command.action === "tie"
+        ? tie.created === false
+            ? tie.state === "confirmed" && tie.addedBy === "agent"
+                ? "Already tied (an agent's suggestion a person has confirmed); nothing new was written."
+                : "Already tied; nothing new was written."
+            : "Tied as a suggestion: a person accepts or dismisses it on the manager page, or with `cockpit manager decide-tie`."
+        : tie.unchanged === true
+            ? "No change; it already stood that way."
+            : command.tieDecision === "accept"
+                ? "Accepted: the tie is confirmed."
+                : command.tieDecision === "dismiss"
+                    ? "Dismissed: it will not be suggested again."
+                    : "Removed: the meeting is no longer tied to this client.";
+    return [sentence, ...tieLines(tie, color)];
+}

package/dist/commands/manager-requests.js

@@ -1,3 +1,5 @@
+import { meetingTiePlan } from "./manager-meetings.js";
+import { decisionRequest } from "./manager-decisions.js";
 const BASE = "/api/manager";
 const enc = encodeURIComponent;
 export function planManagerRequest(command, clientId, newRequestId) {
@@ -77,6 +79,14 @@ export function planManagerRequest(command, clientId, newRequestId) {
         case "proposal": return write("POST", `${item}/proposal`, { ...seen, decision: command.decision, proposalId: command.proposalId });
         case "archive": return write("POST", `${item}/archive`, seen);
         case "unarchive": return write("POST", `${item}/unarchive`, seen);
+        // BLI-22192: meetings tied to clients (`manager-meetings.ts`).
+        case "meetings":
+        case "tie":
+        case "decide-tie": return meetingTiePlan(command, clientId, newRequestId);
+        // BLI-22187: decisions, their own kind (`manager-decisions.ts`).
+        case "decisions": return { ...decisionRequest(command, clientId, newRequestId), logFields: (a) => ({ returned: arrayLength(a, "items"), total: numberField(a, "total") }) };
+        case "add-decision":
+        case "decide": return { ...decisionRequest(command, clientId, newRequestId), logFields: decisionLog };
     }
 }
 function listQuery(command) {
@@ -110,6 +120,11 @@ function itemLog(table) {
         return { table, item_id: item?.id ?? null, review_status: item?.reviewStatus ?? null, ...(typeof body?.created === "boolean" ? { created: body.created } : {}) };
     };
 }
+/** A decision write's log line: its id, status and whether it wrote, never its words. */
+function decisionLog(answer) {
+    const body = answer && typeof answer === "object" ? answer : undefined;
+    return { decision_id: body?.item?.id ?? null, status: body?.item?.status ?? null, ...(typeof body?.created === "boolean" ? { created: body.created } : {}), ...(body?.unchanged === true ? { unchanged: true } : {}) };
+}
 /** Home's log line: which parts it holds and their sizes, never their words. */
 function homeLog(answer) {
     const home = answer && typeof answer === "object" ? answer : {};

package/dist/commands/manager.js

@@ -5,7 +5,7 @@
  * them, adds and edits them, ticks them off, links an action to the meeting it came from, and
  * decides the AI's suggestions, the same things the manager page does.
  *
- * Nineteen verbs (`home` and `summary`, BLI-5698: a client's Home and its "Where we are" card), each one `/api/manager` door on this machine's device token, the same door the MCP
+ * Twenty-five verbs (`meetings`, `tie` and `decide-tie`, BLI-22192: meetings tied to clients, `manager-meetings.ts`; `decisions`, `add-decision` and `decide`, BLI-22187: a client's decisions, `manager-decisions.ts`; `home` and `summary`, BLI-5698: a client's Home and its "Where we are" card), each one `/api/manager` door on this machine's device token, the same door the MCP
  * twins (`manager_*`) use; the door passes Railway's answer through unchanged. Every write on an
  * existing item carries `--version`, the item's `updatedAt` as `list`/`show` print it: a stale one is
  * refused with the door's own sentence and nothing is written. `approve`, `dismiss` and `proposal`
@@ -20,8 +20,10 @@ import { savedTextLines, clientDetailLines, clientLines, itemDetailLines, itemRo
 import { homeLines, summaryWrittenLines } from "./manager-render-home.js";
 import { parseManagerArgs } from "./local-args-tower-manager.js";
 import { READ_ONLY_HINTS, RESEEN_REFUSALS, itemHints, summaryHints } from "./manager-hints.js";
+import { decisionListLines, decisionNextStep, decisionWriteLines } from "./manager-decisions.js";
 import { readFieldsText } from "./manager-fields-file.js";
 import { planManagerRequest } from "./manager-requests.js";
+import { meetingTiePageLines, tieWrittenLines } from "./manager-meetings.js";
 const TAG = "[manager cli]";
 /**
  * Longer than the door waits for the manager server (50 s, `MANAGER_DOOR_TIMEOUT_MS`) and than the door's own
@@ -30,7 +32,7 @@ const TAG = "[manager cli]";
  */
 export const MANAGER_DEADLINE_MS = 65_000;
 /** The verbs that change an existing item. */
-const WRITES = new Set(["summary", "edit", "done", "drop", "reopen", "link", "approve", "dismiss", "proposal", "archive", "unarchive"]);
+const WRITES = new Set(["summary", "edit", "done", "drop", "reopen", "link", "approve", "dismiss", "proposal", "archive", "unarchive", "decide-tie", "decide"]);
 /**
  * `--fields-file`: the parser left the fields unread. Read the file (or stdin), and parse the same args again with its text,
  * so the file's values get exactly the flags' checks. Nothing has touched the network yet, so a bad file costs nothing.
@@ -138,7 +140,13 @@ function renderAnswer(command, body, color) {
         case "run": return runLines(body);
         case "list": return listLines(body, timeline, color, new Date(), command.archived !== true && command.review !== "rejected", command.ownerFilter !== undefined || command.noOwner === true);
         case "queue": return queueLines(body, color);
+        case "meetings": return meetingTiePageLines(body, command, color);
+        case "tie":
+        case "decide-tie": return tieWrittenLines(command, body, color);
         case "show": return itemDetailLines(body, timeline, color);
+        case "decisions": return decisionListLines(body, color);
+        case "add-decision":
+        case "decide": return decisionWriteLines(command, body, color);
         default: return [...writeSentence(command, body), ...itemRowLines(body.item, timeline, color), ...(command.action === "add" ? savedTextLines(body) : [])];
     }
 }
@@ -242,6 +250,12 @@ function refuse(door, answer, command, requestId) {
             ? `This client already has a card: pass its version (\`cockpit manager home ${clientWord(command)}\` shows it).`
             : text(body["message"]) ?? (text(body["reason"]) ? text(body["error"]) : undefined) ?? answer.detail;
     const reseen = answer.reason === "invalid_state" && (refusal === undefined || RESEEN_REFUSALS.has(refusal));
+    // BLI-22187: a decision's next steps name `decisions <client>`, never `show` (decisions have no show); an add keeps the generic retry.
+    const decisionStep = command ? decisionNextStep(command, answer.reason, refusal, requestId === undefined && (answer.httpStatus === undefined || answer.httpStatus >= 500)) : undefined;
+    if (decisionStep !== undefined) {
+        const end = /[.!?]$/.test(sentence) ? "" : ".";
+        return failAgentDoor(door, TAG, answer.reason, `${sentence}${end}${decisionStep}`, { ...(refusal ? { refusal } : {}) });
+    }
     const hint = cardExists || noDrop ? "" : reseen && command?.id
         ? ` ${itemHints(command.id, command.timeline ? " --timeline" : "").item_changed}`
         : nextStep(answer.reason, refusal, command);

package/dist/commands/notes-accounts.js

@@ -84,6 +84,7 @@ function writeHowToConnect(door) {
     writeLine(door.io.stdout, "");
     writeLine(door.io.stdout, 'Connect one:  printf "%s" "<your fellow api key>" | cockpit notes connect --provider fellow --workspace <subdomain> --key-stdin');
     writeLine(door.io.stdout, '          or:  printf "%s" "<your circleback api key>" | cockpit notes connect --provider circleback --key-stdin');
+    writeLine(door.io.stdout, '          or:  printf "%s" "<your fireflies api key>" | cockpit notes connect --provider fireflies --key-stdin');
     writeLine(door.io.stdout, "          or:  cockpit notes connect --provider wisprflow   (opens Wispr's sign-in in your browser and waits; no key)");
 }
 function writeAccountRows(door, accounts) {

package/dist/commands/public-root.js

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

package/dist/commands/settings.js

@@ -123,7 +123,7 @@ async function setSwitch(command, tower, io) {
         writeLine(io.stdout, JSON.stringify({ ok: true, ...body }));
         return 0;
     }
-    writeLine(io.stdout, `Switch ${String(body.key)} is now ${String(body.value)}.`);
+    writeLine(io.stdout, `Switch ${String(body.key)} is now ${String(body.value) === "" ? "empty" : String(body.value)}.`);
     return 0;
 }
 // ── the fleet CLI floor ───────────────────────────────────────────────

package/dist/evidence-upload-terminal.js

@@ -1,4 +1,5 @@
-import { RawEvidenceLegacyUploadResponseSchema, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadBeginResponseSchema, isRekeyableUploadConflict, } from "@bli-cockpit/telemetry-core";
+import { RAW_EVIDENCE_UPLOAD_MAX_CHUNK_BYTES, RawEvidenceLegacyUploadResponseSchema, RawEvidenceRedactionMetadataSchema, RawEvidenceUploadBeginResponseSchema, isRekeyableUploadConflict, } from "@bli-cockpit/telemetry-core";
+import { isLocalDashboardUrl } from "./dev-build.js";
 import { readBeginDispositions } from "./evidence-upload-plan.js";
 import { failedOutcome } from "./evidence-upload-object.js";
 import { rekeyedEvidencePointer } from "./evidence-upload-rekey.js";
@@ -184,17 +185,49 @@ function conformReasonLabel(reason) {
     const conformed = reason.replace(/[^a-z0-9_:.-]/gi, "_").slice(0, 120);
     return conformed.length > 0 ? conformed : "upload_failed_unlabelled";
 }
+/**
+ * The most raw bytes the legacy single-shot route is offered on a hosted dashboard (BLI-3936).
+ *
+ * The route carries the file as base64 inside one JSON body, and Vercel refuses a body over about
+ * 4.5 MB before our code runs (a 93-byte `text/plain` 413). 3 MiB of raw bytes is 4 MiB of base64
+ * plus a few KB of pointer: the exact size the chunk route already sends in every chunk body, so
+ * it is proven to pass. Above it the request cannot succeed, only cost a full upload of the object
+ * to be told so (14 MB, every backoff window, on the reference Mac).
+ */
+export const LEGACY_SINGLE_SHOT_MAX_BYTES = RAW_EVIDENCE_UPLOAD_MAX_CHUNK_BYTES;
+/** A 413 from the legacy route: the host's body limit refused bytes we expected to fit. Terminal for those bytes. */
+export const EVIDENCE_TOO_LARGE_HTTP_413_REASON = "evidence_too_large_http_413";
+/** The reason an object too big for the legacy route carries while the chunk route is down. Retryable: `begin` recovering delivers it. */
+export const LEGACY_SINGLE_SHOT_TOO_LARGE_REASON = "legacy_single_shot_too_large_chunk_route_unavailable";
 /**
  * Older dashboards predate the chunk endpoints. Fall back to one legacy
  * request per file so an oversized or already-existing object fails (or
- * reuses) individually instead of dragging the whole batch down. Large files
- * are attempted rather than pre-failed: a non-serverless dashboard (the
- * default localhost deployment) accepts them like the old CLI could, and a
- * platform body-limit rejection comes back as a labeled per-file failure.
+ * reuses) individually instead of dragging the whole batch down. On a hosted
+ * dashboard an object over `LEGACY_SINGLE_SHOT_MAX_BYTES` is not sent at all
+ * (BLI-3936): the host's body limit refuses it for certain. A non-serverless
+ * dashboard (the default localhost deployment) is still attempted at any size,
+ * like the old CLI, and a platform refusal comes back as a labeled per-file
+ * failure; a 413 there is `evidence_too_large_http_413`, terminal (`terminalDeliveryReason`).
  */
 export async function uploadWithLegacyFallback(options, loaded, outcomes) {
     for (const entry of loaded) {
         let outcome;
+        if (legacyRouteCannotCarry(options, entry.bytes.byteLength)) {
+            // Said out loud, with the numbers: this object was NOT sent, because the route would refuse it.
+            console.error("[evidence-upload] legacy single-shot upload not attempted; the object is too large for it and the chunk route is unavailable", JSON.stringify({
+                reason: LEGACY_SINGLE_SHOT_TOO_LARGE_REASON,
+                kind: entry.file.kind ?? "unknown",
+                byte_size: entry.bytes.byteLength,
+                limit_bytes: LEGACY_SINGLE_SHOT_MAX_BYTES,
+                content_hash_prefix: (entry.file.pointer.content_hash_sha256 ?? "none").slice(0, 12),
+                next: "retried through the chunk route once `begin` answers again",
+            }));
+            outcome = failedOutcome(entry.file, LEGACY_SINGLE_SHOT_TOO_LARGE_REASON);
+            outcomes.push(outcome);
+            for (const duplicate of entry.duplicates)
+                outcomes.push(duplicateOutcome(outcome, duplicate));
+            continue;
+        }
         const response = await requestJson(options, "/api/ambient/evidence/upload", {
             schema_version: "ambient-raw-evidence-upload.v1",
             generated_at: options.generatedAt,
@@ -214,6 +247,10 @@ export async function uploadWithLegacyFallback(options, loaded, outcomes) {
     }
     return summarizeOutcomes(outcomes, true);
 }
+/** True when sending this many raw bytes to the legacy route is certain to be refused by the host's body limit. */
+function legacyRouteCannotCarry(options, byteSize) {
+    return byteSize > LEGACY_SINGLE_SHOT_MAX_BYTES && !isLocalDashboardUrl(options.dashboardUrl);
+}
 function legacyUploadOutcome(file, response) {
     let outcome;
     if (response.ok) {
@@ -250,6 +287,11 @@ function legacyUploadOutcome(file, response) {
         // unverified pointer.
         outcome = failedOutcome(file, "legacy_upload_conflict_http_409");
     }
+    else if (response.status === 413) {
+        // BLI-3936: the host refused this body for its size. The same bytes meet the same limit on
+        // every retry, so this is terminal (`terminalDeliveryReason`) and says what it is.
+        outcome = failedOutcome(file, EVIDENCE_TOO_LARGE_HTTP_413_REASON);
+    }
     else {
         outcome = failedOutcome(file, `legacy_upload_failed_http_${response.status}`);
     }

package/dist/image-description-session.js

@@ -10,9 +10,13 @@ import { postImageToDescribeDoor } from "./image-describe-client.js";
 import { resolveImageHandlingMode } from "./image-mode-state.js";
 import { slimOrKeep, slimTranscript } from "./slim/slim-transcript.js";
 import { imageStateKey, imageRetryDelayMs, readDescribedImageKeys, readFailedImages, writeImageDescriptionState, } from "./image-description-state.js";
-/** New images sent to the door in one sync (all worktrees together). */
+/** New images sent to the door in one sync (all worktrees together); the count never refills within a tick. */
 export const IMAGE_DESCRIBE_MAX_PER_RUN = 100;
-/** After this long in one sync, remaining images wait for the next tick. */
+/**
+ * After this long spent DESCRIBING (the clock starts at the first image sent, not when the session
+ * opens: collection can reach image-bearing transcripts minutes into a tick), remaining images
+ * wait for the next tick.
+ */
 export const IMAGE_DESCRIBE_MAX_RUN_MS = 120_000;
 const CONCURRENCY = 3;
 const TAG = "[image-descriptions]";
@@ -25,11 +29,10 @@ export async function openImageDescriptions(options) {
     const stateDirty = false;
     const settledThisRun = new Map();
     const now = options.now ?? Date.now;
-    const startedAt = now();
     const maxPerRun = options.maxPerRun ?? IMAGE_DESCRIBE_MAX_PER_RUN;
     const maxRunMs = options.maxRunMs ?? IMAGE_DESCRIBE_MAX_RUN_MS;
     const sentThisRun = 0;
-    const run = { options, mode, fetchImpl, described, orderedKeys, failedImages, stateDirty, settledThisRun, now, startedAt, maxPerRun, maxRunMs, sentThisRun };
+    const run = { options, mode, fetchImpl, described, orderedKeys, failedImages, stateDirty, settledThisRun, now, firstSendAt: null, maxPerRun, maxRunMs, sentThisRun };
     return {
         mode,
         async prepareTranscript(input) {
@@ -52,6 +55,7 @@ function markDescribed(run, sha256) {
 async function sendOne(run, image, text, input) {
     const { options, fetchImpl, settledThisRun, failedImages } = run;
     run.sentThisRun += 1;
+    run.firstSendAt ??= run.now();
     const outcome = await postImageToDescribeDoor({ fetchImpl, dashboardUrl: options.dashboardUrl, deviceToken: options.deviceToken, sleep: options.sleep }, {
         schema_version: "image-describe.v1",
         sha256: image.sha256,
@@ -92,12 +96,12 @@ async function describeAndReplace(run, input) {
     const { mode, described, options, orderedKeys, failedImages } = run;
     const images = findEmbeddedImages(input.text);
     if (images.length === 0)
-        return { text: input.text, imageCount: 0, uniqueCount: 0, replacedCount: 0, charsSaved: 0 };
+        return { text: input.text, imageCount: 0, uniqueCount: 0, replacedCount: 0, charsSaved: 0, deferredOnly: false };
     const unique = new Map();
     for (const image of images)
         if (!unique.has(image.sha256))
             unique.set(image.sha256, image);
-    const counts = { already: 0, described_now: 0, known: 0, too_large: 0, over_budget: 0, failed: 0, backing_off: 0 };
+    const counts = { settled_earlier: 0, already: 0, described_now: 0, known: 0, too_large: 0, over_budget: 0, failed: 0, backing_off: 0 };
     const toSend = selectImagesToDescribe(run, unique, counts);
     await sendPendingImages(run, toSend, counts, input);
     const failedReasons = countImageOutcomes(run, toSend, counts);
@@ -105,6 +109,8 @@ async function describeAndReplace(run, input) {
         await writeImageDescriptionState(options.stateDir, { described: orderedKeys, failed: failedImages });
         run.stateDirty = false;
     }
+    const deferredOnly = counts.over_budget + counts.backing_off > 0
+        && counts.described_now + counts.known + counts.failed + counts.too_large + counts.settled_earlier === 0;
     const replaced = mode === "describe_and_drop"
         ? replaceImagesWithMarkers(input.text, images, (image) => described.has(imageStateKey(image.sha256)))
         : { text: input.text, replacedCount: 0, charsSaved: 0 };
@@ -114,6 +120,7 @@ async function describeAndReplace(run, input) {
         images: images.length,
         unique: unique.size,
         ...counts,
+        deferred_only: deferredOnly,
         failed_reasons: failedReasons,
         replaced: replaced.replacedCount,
         chars_saved: replaced.charsSaved,
@@ -125,6 +132,7 @@ async function describeAndReplace(run, input) {
         uniqueCount: unique.size,
         replacedCount: replaced.replacedCount,
         charsSaved: replaced.charsSaved,
+        deferredOnly,
     };
 }
 function selectImagesToDescribe(run, unique, counts) {
@@ -136,8 +144,10 @@ function selectImagesToDescribe(run, unique, counts) {
             continue;
         }
         const earlier = settledThisRun.get(image.sha256);
-        if (earlier)
+        if (earlier) {
+            counts.settled_earlier += 1;
             continue;
+        }
         if (image.byteSize > IMAGE_DESCRIBE_MAX_BYTES) {
             settledThisRun.set(image.sha256, "too_large");
             counts.too_large += 1;
@@ -153,12 +163,13 @@ function selectImagesToDescribe(run, unique, counts) {
     return toSend;
 }
 async function sendPendingImages(run, toSend, counts, input) {
-    const { now, maxPerRun, startedAt, maxRunMs } = run;
+    const { now, maxPerRun, maxRunMs } = run;
     let next = 0;
     const worker = async () => {
         while (next < toSend.length) {
             const image = toSend[next++];
-            if (run.sentThisRun >= maxPerRun || now() - startedAt > maxRunMs) {
+            const timeUp = run.firstSendAt !== null && now() - run.firstSendAt > maxRunMs;
+            if (run.sentThisRun >= maxPerRun || timeUp) {
                 counts.over_budget += 1;
                 continue;
             }

package/dist/raw-evidence-staging.js

@@ -184,7 +184,8 @@ export function clearDeliveryAttempt(state, contentHash) {
 export function terminalDeliveryReason(reason) {
     return Boolean(reason && (reason.startsWith("staging_restage_failed:") ||
         ["staging_missing_after_restage", "secret_guard_rejected", "storage_rejected_object_too_large", "storage_rejected_media_type"].includes(reason) ||
-        /^(?:begin|commit|chunk_\d+)_failed_http_413(?:_|$)/u.test(reason)));
+        /^(?:begin|commit|chunk_\d+)_failed_http_413(?:_|$)/u.test(reason) ||
+        reason === "evidence_too_large_http_413"));
 }
 export function deliveryHold(state, contentHash, now) {
     if (!contentHash)

package/dist/upload-evidence-delivery-offer.js

@@ -120,6 +120,9 @@ export async function persistDeliveryAttempts(stateDir, staging, outcomes, attem
                 first_failed_at: entry.first_failed_at,
                 next_attempt_at: entry.next_attempt_at,
                 byte_size: entry.byte_size,
+                // BLI-3936: a refusal that cannot succeed on retry (a 413) says so here, with the object's id.
+                terminal: entry.terminal_reason !== undefined,
+                content_hash_prefix: contentHash.slice(0, 12),
             }));
             continue;
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.249",
+  "version": "0.2.251",
   "private": false,
   "type": "module",
   "bin": {
@@ -28,7 +28,7 @@
   },
   "dependencies": {
     "@bli-cockpit/memory-mcp": "0.1.73",
-    "@bli-cockpit/mcp": "0.1.153",
+    "@bli-cockpit/mcp": "0.1.154",
     "@bli-cockpit/telemetry-core": "0.1.80"
   },
   "repository": {