@bli-cockpit/cli 0.2.206 → 0.2.208

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.206");
+    writeLine(io?.stdout ?? process.stdout, "0.2.208");
     return 0;
   }
 

package/dist/commands/sources-check.js

@@ -1,4 +1,5 @@
 import { writeLine } from "./cli-io.js";
+import { readDescribedImageKeys } from "../image-description-state.js";
 import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
 import { fetchTranscriptObjects } from "../evidence-transcripts-client.js";
 import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConfig, readLocalCollectorSessionFile, } from "../local-state.js";
@@ -28,13 +29,14 @@ export async function runSourcesCheck(command, io, now = new Date()) {
         codex: await readRawEvidenceCursor(paths),
         claude_code: await readRawEvidenceCursor(paths, { filename: CLAUDE_CURSOR_FILENAME, sessionsOnly: true }),
     };
+    const describedKeys = new Set(await readDescribedImageKeys(paths.state_dir));
     const report = emptyReport(command, remote, local.newer_count, local.file_read_failed + local.directory_read_failed);
     for (const file of local.files) {
         const judged = await judgeSource({
             file,
             remotes: remote.files.get(file.key) ?? [],
             cursorEntry: file.kind === "claude_subagent" ? null : (cursors[file.source].sessions[file.session_id] ?? null),
-            facts: fileFacts(file),
+            facts: fileFacts(file, undefined, { describedKeys }),
         }).catch((error) => {
             report.local.unreadable += 1;
             console.error("[collector sources] a transcript could not be judged; left out of the answer", JSON.stringify({ reason: "file_unreadable", kind: file.kind, byte_size: file.byte_size, error_name: error?.name ?? "Error" }));

package/dist/commands/sources-verdict.js

@@ -30,6 +30,8 @@ import path from "node:path";
 import { RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, REDACTION_STUB_SHA256, } from "@bli-cockpit/telemetry-core";
 import { sanitizeTextEvidenceForUpload } from "../adapters/raw-evidence-sanitize.js";
 import { isSecretLikePath } from "../adapters/raw-evidence-keys.js";
+import { IMAGE_HANDLING_MODE } from "@bli-cockpit/telemetry-core";
+import { uploadFormOfTranscript } from "../image-description-session.js";
 export async function judgeSource(input) {
     const { file, remotes, cursorEntry } = input;
     if (remotes.length === 0)
@@ -79,7 +81,11 @@ export async function judgeSource(input) {
  * upload does (`raw-evidence-transcript-file.ts`): same sanitizer, same
  * secret-like-name rule, same byte cap.
  */
-export function fileFacts(file, maxBytes = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
+export function fileFacts(file, maxBytes = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES, 
+/** Tests only set `mode`. Production reads the one switch. `describedKeys` is the collector's described-image state. */
+upload = {}) {
+    const mode = upload.mode ?? IMAGE_HANDLING_MODE;
+    const describedKeys = upload.describedKeys ?? new Set();
     let bytes = null;
     const read = () => {
         bytes ??= file.byte_size > maxBytes ? Promise.resolve(null) : fs.readFile(file.file_path);
@@ -96,9 +102,11 @@ export function fileFacts(file, maxBytes = RAW_EVIDENCE_UPLOAD_MAX_FILE_BYTES) {
             sanitized ??= read().then((buffer) => {
                 if (!buffer)
                     return null;
+                // Compare against what the uploader sends: in drop mode that is the slim form, not the disk bytes.
+                const uploadText = uploadFormOfTranscript(buffer.toString("utf8"), file.source === "codex" ? "codex" : "claude_code", mode, describedKeys);
                 const result = sanitizeTextEvidenceForUpload({
-                    text: buffer.toString("utf8"),
-                    originalBytes: buffer,
+                    text: uploadText,
+                    originalBytes: uploadText === buffer.toString("utf8") ? buffer : Buffer.from(uploadText, "utf8"),
                     redactedFields: [`${file.kind === "codex_rollout" ? "codex_jsonl" : file.kind === "claude_main" ? "claude_jsonl" : "claude_jsonl_sidecar"}.body`],
                     secretLikeFileName: isSecretLikePath(path.basename(file.file_path)),
                 });

package/dist/image-description-session.js

@@ -22,8 +22,8 @@
  */
 import { IMAGE_DESCRIBE_MAX_BYTES, IMAGE_HANDLING_MODE, base64Of, findEmbeddedImages, replaceImagesWithMarkers, } from "@bli-cockpit/telemetry-core";
 import { postImageToDescribeDoor } from "./image-describe-client.js";
-import { slimOrKeep } from "./slim/slim-transcript.js";
-import { imageStateKey, readDescribedImageKeys, writeDescribedImageKeys, } from "./image-description-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). */
 export const IMAGE_DESCRIBE_MAX_PER_RUN = 100;
 /** After this long in one sync, remaining images wait for the next tick. */
@@ -35,6 +35,8 @@ export async function openImageDescriptions(options) {
     const fetchImpl = options.fetchImpl ?? globalThis.fetch;
     const described = new Set(await readDescribedImageKeys(options.stateDir));
     const orderedKeys = [...described];
+    const failedImages = await readFailedImages(options.stateDir);
+    let stateDirty = false;
     const settledThisRun = new Map();
     const now = options.now ?? Date.now;
     const startedAt = now();
@@ -59,12 +61,33 @@ export async function openImageDescriptions(options) {
             source: input.source,
             session_id: input.sessionId.slice(0, 200),
         });
+        const key = imageStateKey(image.sha256);
         if (outcome.ok) {
             markDescribed(image.sha256);
             settledThisRun.set(image.sha256, outcome.status);
+            if (failedImages[key]) {
+                delete failedImages[key];
+                stateDirty = true;
+            }
             return;
         }
         settledThisRun.set(image.sha256, `failed:${outcome.reason}`);
+        rememberFailure(key, outcome);
+    }
+    /**
+     * BLI-16979: the door answered about THIS image and could not describe it (a 4xx such as
+     * `describer_rejected_image`, or a 5xx). Wait before sending the same bytes again, instead of
+     * re-sending them every sync. A transport error, a 401 and a 429 say nothing about the image, so
+     * they are not remembered.
+     */
+    function rememberFailure(key, outcome) {
+        if (outcome.httpStatus < 400 || outcome.httpStatus === 401 || outcome.httpStatus === 429)
+            return;
+        const attempts = (failedImages[key]?.attempts ?? 0) + 1;
+        const delay = imageRetryDelayMs(attempts, outcome.permanent);
+        failedImages[key] = { reason: outcome.reason, attempts, retry_after: now() + delay };
+        stateDirty = true;
+        console.error(TAG + " image not described, will not be re-sent until later", JSON.stringify({ reason: outcome.reason, http_status: outcome.httpStatus, attempts, retry_in_hours: Math.round(delay / 3_600_000), sha256_prefix: key.slice(0, 16) }));
     }
     async function describeAndReplace(input) {
         const images = findEmbeddedImages(input.text);
@@ -74,7 +97,7 @@ export async function openImageDescriptions(options) {
         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 };
+        const counts = { already: 0, described_now: 0, known: 0, too_large: 0, over_budget: 0, failed: 0, backing_off: 0 };
         const failedReasons = {};
         const toSend = [];
         for (const image of unique.values()) {
@@ -90,6 +113,11 @@ export async function openImageDescriptions(options) {
                 counts.too_large += 1;
                 continue;
             }
+            const earlierFailure = failedImages[imageStateKey(image.sha256)];
+            if (earlierFailure && earlierFailure.retry_after > now()) {
+                counts.backing_off += 1;
+                continue;
+            }
             toSend.push(image);
         }
         let next = 0;
@@ -116,8 +144,10 @@ export async function openImageDescriptions(options) {
                 failedReasons[reason] = (failedReasons[reason] ?? 0) + 1;
             }
         }
-        if (counts.described_now + counts.known > 0)
-            await writeDescribedImageKeys(options.stateDir, orderedKeys);
+        if (counts.described_now + counts.known > 0 || stateDirty) {
+            await writeImageDescriptionState(options.stateDir, { described: orderedKeys, failed: failedImages });
+            stateDirty = false;
+        }
         const replaced = mode === "describe_and_drop"
             ? replaceImagesWithMarkers(input.text, images, (image) => described.has(imageStateKey(image.sha256)))
             : { text: input.text, replacedCount: 0, charsSaved: 0 };
@@ -151,6 +181,19 @@ export async function openImageDescriptions(options) {
         },
     };
 }
+/**
+ * What the uploader sends for this transcript text, worked out offline (BLI-17013). Keep mode: the
+ * text as it is. Drop mode: every image whose key is in `describedKeys` becomes its marker, then
+ * the slim rules run, the same two steps as `prepareTranscript` above, with no describe-door call.
+ * `cockpit sources check` uses it so a complete upload is judged against the bytes actually uploaded.
+ */
+export function uploadFormOfTranscript(text, source, mode, describedKeys) {
+    if (mode !== "describe_and_drop")
+        return text;
+    const images = findEmbeddedImages(text);
+    const replaced = replaceImagesWithMarkers(text, images, (image) => describedKeys.has(imageStateKey(image.sha256)));
+    return slimTranscript(replaced.text, source).text;
+}
 /**
  * The image step for one build of an envelope. When a sync-wide budget is shared across worktrees
  * the session lives on it (one count budget and one state file for the whole sync); otherwise this

package/dist/image-description-state.js

@@ -35,10 +35,54 @@ export async function readDescribedImageKeys(stateDir) {
         return [];
     }
 }
-export async function writeDescribedImageKeys(stateDir, keys) {
+/** Oldest failures leave first past this many. */
+export const IMAGE_FAILED_STATE_MAX_KEYS = 5_000;
+const HOUR_MS = 3_600_000;
+/** A refusal that repeats for the same bytes (a 4xx): a week, then a month. */
+const PERMANENT_BACKOFF_MS = [7 * 24 * HOUR_MS, 30 * 24 * HOUR_MS];
+/** A failure that may pass (the door or the model was down): 1 h, 6 h, 24 h, then 72 h. */
+const TRANSIENT_BACKOFF_MS = [HOUR_MS, 6 * HOUR_MS, 24 * HOUR_MS, 72 * HOUR_MS];
+/** How long to leave an image alone after its Nth failed attempt. */
+export function imageRetryDelayMs(attempts, permanent) {
+    const steps = permanent ? PERMANENT_BACKOFF_MS : TRANSIENT_BACKOFF_MS;
+    return steps[Math.min(Math.max(attempts, 1), steps.length) - 1];
+}
+/** The failures on record, key to record. A missing or unreadable file is an empty map, said out loud when unreadable. */
+export async function readFailedImages(stateDir) {
+    try {
+        const raw = (await readJsonFile(imageDescriptionStatePath(stateDir)));
+        if (!raw?.failed || typeof raw.failed !== "object" || Array.isArray(raw.failed))
+            return {};
+        const kept = {};
+        for (const [key, value] of Object.entries(raw.failed)) {
+            const record = value;
+            if (key.length !== KEY_CHARS || !record)
+                continue;
+            if (typeof record.reason !== "string" || typeof record.attempts !== "number" || typeof record.retry_after !== "number")
+                continue;
+            kept[key] = { reason: record.reason, attempts: record.attempts, retry_after: record.retry_after };
+        }
+        return kept;
+    }
+    catch (error) {
+        if (!isMissingFileFailure(error)) {
+            console.error("[image-descriptions] failed-image list unreadable, starting from an empty list", JSON.stringify({ reason: "image_failed_state_unreadable" }));
+        }
+        return {};
+    }
+}
+export async function writeImageDescriptionState(stateDir, state) {
+    const keys = state.described;
     const kept = keys.length > IMAGE_DESCRIPTION_STATE_MAX_KEYS ? keys.slice(keys.length - IMAGE_DESCRIPTION_STATE_MAX_KEYS) : keys;
+    const failedEntries = Object.entries(state.failed).sort((a, b) => a[1].retry_after - b[1].retry_after);
+    const failed = Object.fromEntries(failedEntries.slice(Math.max(0, failedEntries.length - IMAGE_FAILED_STATE_MAX_KEYS)));
     await writeJsonFile(imageDescriptionStatePath(stateDir), {
         schema_version: "cockpit-image-descriptions.v1",
         described: kept,
+        failed,
     });
+}
+/** Writes the described list and keeps whatever failures are on record. */
+export async function writeDescribedImageKeys(stateDir, keys) {
+    await writeImageDescriptionState(stateDir, { described: keys, failed: await readFailedImages(stateDir) });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.206",
+  "version": "0.2.208",
   "private": false,
   "type": "module",
   "bin": {