@bli-cockpit/cli 0.2.157 → 0.2.158

package/dist/adapters/codex-attribution.js

@@ -167,6 +167,7 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
         file_path: file.file,
         file_name: fileName,
         codex_session_id: sessionIdFromFileName(fileName) ?? shortHash(file.file),
+        session_id_source: sessionIdFromFileName(fileName) ? "file_name" : "path_hash",
         cwd_basename: null,
         cwd_hash: null,
         session_file_mtime: new Date(file.mtimeMs).toISOString(),
@@ -197,6 +198,7 @@ async function attributeOneSession(file, worktrees, collectionRoots) {
     const metaSessionId = sanitizeSessionId(signals.session_ids[0]);
     if (metaSessionId) {
         base.codex_session_id = metaSessionId;
+        base.session_id_source = "session_meta";
     }
     const primaryCwd = signals.cwds[0] ?? null;
     if (primaryCwd) {

package/dist/commands/backfill-checkpoint.js

@@ -10,6 +10,7 @@
  */
 import { recordBackfillCursorObservations, } from "../cursors/backfill-cursor.js";
 import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { isRedactionStubObjectKey, markCursorEntryStubbed } from "../cursors/raw-evidence-stub-entry.js";
 import { isRawEvidenceUploadableAttributionState } from "../raw-evidence-attribution-policy.js";
 import { candidateCursorKey, compareBackfillCandidates, isAfterCursor, } from "./backfill-candidates.js";
 import { indexDurableMainObjectKeys } from "./backfill-evidence-outcomes.js";
@@ -34,10 +35,11 @@ export async function recordBackfillDurableSessionPointers(options) {
             // No pointer, no prior entry, or already pointed: nothing this pass owes.
             // BLI-11102: a pointer the server named a redaction stub is not a
             // delivery, so a real pointer replaces it and the mark clears.
-            const replacesStub = Boolean(prior?.stub_reoffer) && prior?.uploaded_object_key !== objectKey;
+            // BLI-11119: an entry the cursor itself knows is `stubbed` counts too.
+            const replacesStub = Boolean(prior?.stub_reoffer || prior?.stubbed) && prior?.uploaded_object_key !== objectKey;
             if (!objectKey || !prior || (prior.uploaded_object_key && !replacesStub))
                 continue;
-            if (replacesStub)
+            if (replacesStub && !isRedactionStubObjectKey(objectKey))
                 stubsReplaced += 1;
             cursor.sessions[candidate.session_id] = deliveredCursorEntry(prior, candidate, objectKey, options.now);
             changed = true;
@@ -71,8 +73,15 @@ function deliveredCursorEntry(prior, candidate, objectKey, now) {
         uploaded_byte_size: candidate.byte_size,
         last_seen_at: now.toISOString(),
     };
+    // BLI-11119: a re-offer that stubbed again earned another marker, not the
+    // transcript. The entry says so and keeps its mark for the next pass.
+    if (isRedactionStubObjectKey(objectKey)) {
+        markCursorEntryStubbed(entry);
+        return entry;
+    }
     // The mark says "this pointer is a stub"; the pointer written above is not.
     delete entry.stub_reoffer;
+    delete entry.stubbed;
     return entry;
 }
 export function advanceBackfillCursorThroughResolvedPrefix(options) {

package/dist/commands/backfill-scan.js

@@ -21,6 +21,7 @@ import { labelOutsideRootCandidates, outsideRootsWorkspace, } from "./backfill-o
 import { reasonCountsFor } from "./backfill-reasons.js";
 import { blockedBackfillResult } from "./backfill-result.js";
 import { emptyStubReofferPlan, loadStubReofferPlan, reopenStubbedSessions, } from "./backfill-stub-reoffer.js";
+import { loadStubCursorHashes, locateStubbedSessions } from "./backfill-stub-locate.js";
 import { resolveBackfillScope } from "./backfill-scope.js";
 import { stubSessionKey } from "../evidence-stubs-client.js";
 /**
@@ -64,6 +65,7 @@ export async function scanBackfillRun(command, io, now) {
                 fetchImpl: io.fetch,
             });
     reopenStubbedSessions(pointerlessTerminalSessions, stubReoffer);
+    const stubCursorHashes = await loadStubCursorHashes(paths, stubReoffer);
     const scan = await scanBackfillSessions({
         command,
         homeDir: command.homeDir ?? os.homedir(),
@@ -73,6 +75,8 @@ export async function scanBackfillRun(command, io, now) {
         window: scope.window,
         cursor,
         pointerlessTerminalSessions,
+        stubReoffer,
+        stubCursorHashes,
         now,
     });
     const reasonCounts = await auditScannedCandidates(scan, worktreeDiscovery.incomplete_reasons);
@@ -129,9 +133,19 @@ async function scanBackfillSessions(options) {
     const claudeAttribution = options.sources.includes("claude_code")
         ? await scanClaudeHistory(options, claudeProjectsDir, scanLimit)
         : null;
+    // BLI-11119: a stubbed session is found by the id in its content or by the
+    // file hash its cursor entry recorded, across every root the scan walked.
+    const scanned = locateStubbedSessions({
+        plan: options.stubReoffer,
+        candidates: [
+            ...(codexAttribution?.results.map(normalizeCodexCandidate) ?? []),
+            ...(claudeAttribution?.results.map(normalizeClaudeCandidate) ?? []),
+        ],
+        cursorHashes: options.stubCursorHashes,
+        sinceMinutes: options.window.since_minutes,
+    });
     const selection = selectBackfillCandidates({
-        codexAttribution,
-        claudeAttribution,
+        scanned,
         cursor: options.cursor,
         pointerlessTerminalSessions: options.pointerlessTerminalSessions,
         maxFiles: options.command.maxFiles,
@@ -201,10 +215,7 @@ async function scanClaudeHistory(request, projectsDir, scanLimit) {
  * so a `--max-files` cap spends its budget on them before newer history.
  */
 function selectBackfillCandidates(options) {
-    const allCandidates = [
-        ...(options.codexAttribution?.results.map(normalizeCodexCandidate) ?? []),
-        ...(options.claudeAttribution?.results.map(normalizeClaudeCandidate) ?? []),
-    ]
+    const allCandidates = options.scanned
         .filter((candidate) => !options.onlySessions ||
         options.onlySessions.has(stubSessionKey(candidate.source, candidate.session_id)))
         .filter((candidate) => isAfterCursor(candidate, options.cursor) ||
@@ -266,6 +277,7 @@ function normalizeCodexCandidate(result) {
     return {
         source: "codex",
         session_id: result.codex_session_id,
+        session_id_source: result.session_id_source,
         file_path: result.file_path,
         state: result.state,
         reason: result.reason,

package/dist/commands/backfill-stub-locate.js

@@ -0,0 +1,104 @@
+/**
+ * Where on this machine is the transcript behind a stub? (BLI-11119)
+ *
+ * The stubs door names a session by the id inside its object key, and the
+ * collector wrote that key with the id it read from the transcript's CONTENT
+ * (`session_meta.id` for Codex). A rollout's file name does not always carry
+ * that id: a resumed or forked session is filed as
+ * `rollout-<time>-<parent>_<child>.jsonl` while its first line names another
+ * id, and Codex moves files from `sessions/` into `archived_sessions/`. So a
+ * stubbed session is located the way it was keyed, across every root the scan
+ * walked, never by file name alone:
+ *
+ * 1. a scanned session whose id matches (`found_by: session_meta`, or
+ *    `file_name` when the file's first line gave no id and the scan fell back
+ *    to the name, which is then the id the key used too);
+ * 2. otherwise a scanned file whose sha256 equals the cursor entry's
+ *    `file_hash_sha256` for that session (`found_by: file_hash`); it is offered
+ *    under the STUBBED session's id, because the server retires a stub only for
+ *    a successor that names the same session;
+ * 3. otherwise `not_found`, recorded on the cursor so the scheduled sync stops
+ *    rescanning history for it every tick (see `sync-stub-heal.ts`).
+ */
+import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { stubSessionKey } from "../evidence-stubs-client.js";
+/** How many per-session lines the locate log carries; the counts cover the rest. */
+const LOGGED_SESSION_LIMIT = 25;
+/** `codex:<id>` -> the file hash the cursor last recorded for that stubbed session. */
+export async function loadStubCursorHashes(paths, plan) {
+    const hashes = new Map();
+    if (plan.sessions.size === 0)
+        return hashes;
+    for (const source of ["codex", "claude_code"]) {
+        const filename = source === "claude_code" ? CLAUDE_CURSOR_FILENAME : undefined;
+        const cursor = await readRawEvidenceCursor(paths, { filename }).catch(() => null);
+        if (!cursor)
+            continue;
+        for (const key of plan.sessions.keys()) {
+            if (!key.startsWith(`${source}:`))
+                continue;
+            const hash = cursor.sessions[key.slice(source.length + 1)]?.file_hash_sha256;
+            if (hash)
+                hashes.set(key, hash);
+        }
+    }
+    return hashes;
+}
+/**
+ * Match every stubbed session to a scanned file, record how on `plan.found_by`,
+ * and return the scanned candidates plus one candidate per hash match, carrying
+ * the stubbed session's id. Logs the outcome, found or not.
+ */
+export function locateStubbedSessions(options) {
+    const { plan } = options;
+    if (plan.sessions.size === 0)
+        return options.candidates;
+    const byKey = new Map();
+    const byHash = new Map();
+    for (const candidate of options.candidates) {
+        byKey.set(stubSessionKey(candidate.source, candidate.session_id), candidate);
+        if (candidate.content_hash_sha256) {
+            const hashKey = `${candidate.source}:${candidate.content_hash_sha256}`;
+            if (!byHash.has(hashKey))
+                byHash.set(hashKey, candidate);
+        }
+    }
+    const extra = [];
+    const sessions = [];
+    for (const key of plan.sessions.keys()) {
+        const found = locateOne(key, byKey, byHash, options.cursorHashes);
+        plan.found_by.set(key, found.foundBy);
+        if (found.candidate)
+            extra.push(found.candidate);
+        sessions.push({ session: key, found_by: found.foundBy });
+    }
+    const counts = { session_meta: 0, file_name: 0, file_hash: 0, not_found: 0 };
+    for (const session of sessions)
+        counts[session.found_by] += 1;
+    console.error("[backfill] stubbed sessions located", JSON.stringify({
+        reason: counts.not_found === sessions.length ? "stub_sessions_not_found" : "stub_sessions_located",
+        sessions: sessions.length,
+        ...counts,
+        scanned_candidates: options.candidates.length,
+        since_minutes: options.sinceMinutes,
+        found_by: sessions.slice(0, LOGGED_SESSION_LIMIT),
+    }));
+    return extra.length > 0 ? [...options.candidates, ...extra] : options.candidates;
+}
+function locateOne(key, byKey, byHash, cursorHashes) {
+    const byId = byKey.get(key);
+    if (byId) {
+        const fromContent = byId.source === "codex" && byId.session_id_source === "session_meta";
+        return { foundBy: fromContent ? "session_meta" : "file_name" };
+    }
+    const at = key.indexOf(":");
+    const source = key.slice(0, at);
+    const hash = cursorHashes.get(key);
+    const byContent = hash ? byHash.get(`${source}:${hash}`) : undefined;
+    if (!byContent)
+        return { foundBy: "not_found" };
+    return {
+        foundBy: "file_hash",
+        candidate: { ...byContent, session_id: key.slice(at + 1), session_id_source: undefined },
+    };
+}

package/dist/commands/backfill-stub-reoffer.js

@@ -1,10 +1,18 @@
 import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { markCursorEntryStubbed } from "../cursors/raw-evidence-stub-entry.js";
 import { fetchStubbedSessions, stubSessionKey } from "../evidence-stubs-client.js";
 import { describeError } from "../health-detail.js";
 import { readLocalCollectorSessionFile } from "../local-state.js";
 import { candidateCursorKey } from "./backfill-candidates.js";
 export function emptyStubReofferPlan(reason) {
-    return { status: "skipped", reason, sessions: new Map(), stub_count: 0, marked_local_sessions: 0 };
+    return {
+        status: "skipped",
+        reason,
+        sessions: new Map(),
+        stub_count: 0,
+        marked_local_sessions: 0,
+        found_by: new Map(),
+    };
 }
 /** Ask the server which of this operator's pointers are stubs. Never throws; writes nothing. */
 export async function loadStubReofferPlan(options) {
@@ -25,6 +33,7 @@ export async function loadStubReofferPlan(options) {
         sessions,
         stub_count: answer.unique_stub_count,
         marked_local_sessions: 0,
+        found_by: new Map(),
     };
 }
 /**
@@ -34,7 +43,7 @@ export async function loadStubReofferPlan(options) {
 export async function markStubReoffers(paths, plan, now) {
     if (plan.sessions.size === 0)
         return;
-    plan.marked_local_sessions = await markStubbedSessions(paths, plan.sessions, now);
+    plan.marked_local_sessions = await markStubbedSessions(paths, plan, now);
 }
 /** Reopen stubbed sessions exactly like pointer-less ones: selected past the cursor, sorted first. */
 export function reopenStubbedSessions(reopen, plan) {
@@ -67,6 +76,7 @@ export function summarizeStubReoffer(plan, candidates, durableCandidateKeys = ne
         reoffered_sessions: reoffered,
         reoffered_stubs: stubsOf(offered.filter((candidate) => attempted.includes(candidate))),
         replaced_stubs: stubsOf(offered.filter((candidate) => durableCandidateKeys.has(candidateCursorKey(candidate)))),
+        found_by: countFoundBy(plan),
     };
     if (plan.sessions.size > 0) {
         console.error("[backfill] redaction-stubbed sessions re-offered", JSON.stringify({
@@ -79,20 +89,43 @@ export function summarizeStubReoffer(plan, candidates, durableCandidateKeys = ne
     }
     return summary;
 }
-async function markStubbedSessions(paths, sessions, now) {
+function countFoundBy(plan) {
+    const counts = { session_meta: 0, file_name: 0, file_hash: 0, not_found: 0 };
+    for (const method of plan.found_by.values())
+        counts[method] += 1;
+    return counts;
+}
+/**
+ * Mark every door-named session this cursor tracks, and make its entry tell
+ * the truth (BLI-11119): an entry written before the stub rule existed claimed
+ * the full file as uploaded. The door is the source of truth, so each such
+ * entry is reconciled to `stubbed: true` with the marker's bytes, counted and
+ * logged as `stub_cursor_reconciled`. A session the scan could not find in any
+ * root keeps `not_found_at`, so the scheduled sync waits before looking again.
+ */
+async function markStubbedSessions(paths, plan, now) {
     let marked = 0;
+    let reconciled = 0;
     for (const source of ["codex", "claude_code"]) {
         const filename = source === "claude_code" ? CLAUDE_CURSOR_FILENAME : undefined;
         try {
             const cursor = await readRawEvidenceCursor(paths, { filename });
             let changed = false;
-            for (const [key, pointerIds] of sessions) {
+            for (const [key, pointerIds] of plan.sessions) {
                 if (!key.startsWith(`${source}:`))
                     continue;
                 const entry = cursor.sessions[key.slice(source.length + 1)];
                 if (!entry)
                     continue;
-                entry.stub_reoffer = { reason: "stub_reoffered", stub_pointer_ids: pointerIds, marked_at: now.toISOString() };
+                const notFound = plan.found_by.get(key) === "not_found";
+                entry.stub_reoffer = {
+                    reason: "stub_reoffered",
+                    stub_pointer_ids: pointerIds,
+                    marked_at: now.toISOString(),
+                    ...(notFound ? { not_found_at: now.toISOString() } : {}),
+                };
+                if (markCursorEntryStubbed(entry))
+                    reconciled += 1;
                 changed = true;
                 marked += 1;
             }
@@ -105,5 +138,6 @@ async function markStubbedSessions(paths, sessions, now) {
             console.error("[backfill] stub mark not written to the cursor", JSON.stringify({ reason: "stub_mark_write_failed", source, ...describeError(error) }));
         }
     }
+    console.error("[backfill] stubbed sessions' cursor entries reconciled with the stubs door", JSON.stringify({ reason: "stub_cursor_reconciled", count: reconciled, marked_local_sessions: marked }));
     return marked;
 }

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

package/dist/commands/session-sync-record.js

@@ -11,6 +11,7 @@ import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConf
 import { normalizeDashboardUrl } from "../upload-http.js";
 import { flushPendingCodexSessionReports, queueCodexSessionReport, } from "../upload.js";
 import { CLAUDE_CURSOR_FILENAME, countStaleSessions, readRawEvidenceCursor, recordSessionObservation, writeRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { isRedactionStubObjectKey, markCursorEntryStubbed } from "../cursors/raw-evidence-stub-entry.js";
 import { claudeAttributionReadFailureCount, codexAttributionReadFailureCount, } from "./agent-session-report.js";
 import { liveSyncCursorEntryRequiresRetry } from "./session-sync-attribution.js";
 /**
@@ -331,5 +332,16 @@ function recordSourceObservation(options, result) {
         uploaded_byte_size: uploadedByteSize,
         last_seen_at: options.now.toISOString(),
     };
+    // BLI-11119: a pointer that is the redaction-crash marker is not a delivery.
+    // The entry records the marker's bytes, and keeps the re-offer mark while
+    // the stub still stands.
+    if (isRedactionStubObjectKey(uploadedObjectKey)) {
+        markCursorEntryStubbed(entry);
+        if (prior?.stub_reoffer)
+            entry.stub_reoffer = prior.stub_reoffer;
+        if (uploadedThisSync) {
+            console.error("[collector sync] session delivered only as a redaction-crash stub", JSON.stringify({ reason: "stub_cursor_recorded", source: options.source, byte_size: result.byte_size }));
+        }
+    }
     recordSessionObservation(options.cursor, sessionId, entry);
 }

package/dist/commands/sync-stub-heal.js

@@ -8,6 +8,13 @@ import { DEFAULT_DASHBOARD_URL, getCollectorRuntimePaths, readLocalCollectorConf
 /** At most this many stubbed sessions are re-offered per tick (one backfill batch). */
 export const SYNC_STUB_SESSIONS_PER_TICK = 25;
 const DAY_MS = 24 * 60 * 60_000;
+/**
+ * BLI-11119: a stubbed session a re-offer could not find in any root, by
+ * content id or file hash, is looked for again after this long. Without it
+ * every tick rescanned (and hashed) every transcript back to the session's
+ * date for a file that is gone.
+ */
+export const STUB_NOT_FOUND_RETRY_MS = DAY_MS;
 const DEFAULT_DEPS = { runBackfill, loadPlan: loadStubReofferPlan };
 export async function healStubsDuringTick(command, io, deps = DEFAULT_DEPS, now = new Date()) {
     const summary = {
@@ -17,6 +24,7 @@ export async function healStubsDuringTick(command, io, deps = DEFAULT_DEPS, now
         stubs_remaining: 0,
         sessions_local: 0,
         sessions_selected: 0,
+        sessions_not_found_recently: 0,
     };
     try {
         summary.reason = await runStubPass(command, io, deps, now, summary);
@@ -54,13 +62,18 @@ async function runStubPass(command, io, deps, now, summary) {
     summary.sessions_local = local.length;
     if (local.length === 0)
         return "stubs_not_on_this_machine";
-    const selected = local.slice(0, SYNC_STUB_SESSIONS_PER_TICK);
+    const lookable = local.filter((session) => !notFoundRecently(session.notFoundAt, now));
+    summary.sessions_not_found_recently = local.length - lookable.length;
+    if (lookable.length === 0)
+        return "stubs_not_found_recently";
+    const selected = lookable.slice(0, SYNC_STUB_SESSIONS_PER_TICK);
     summary.sessions_selected = selected.length;
     const trimmed = {
         ...plan,
         sessions: new Map(selected.map((session) => [session.key, session.pointerIds])),
         stub_count: selected.reduce((total, session) => total + session.pointerIds.length, 0),
         marked_local_sessions: 0,
+        found_by: new Map(),
     };
     const window = stubWindow(selected, sessionFile.paired_at, now);
     const result = await deps.runBackfill({
@@ -90,11 +103,18 @@ async function locallyTrackedStubSessions(paths, plan) {
         const at = key.indexOf(":");
         const source = key.slice(0, at);
         const entry = cursors[source]?.sessions[key.slice(at + 1)];
-        if (entry)
-            local.push({ key, pointerIds, mtimeMs: entry.file_mtime_ms });
+        if (entry) {
+            local.push({ key, pointerIds, mtimeMs: entry.file_mtime_ms, notFoundAt: entry.stub_reoffer?.not_found_at ?? null });
+        }
     }
     return local;
 }
+function notFoundRecently(notFoundAt, now) {
+    if (!notFoundAt)
+        return false;
+    const at = Date.parse(notFoundAt);
+    return Number.isFinite(at) && now.getTime() - at < STUB_NOT_FOUND_RETRY_MS;
+}
 /**
  * The narrowest backfill window that still reaches every selected session:
  * back to the oldest one's file time plus a day. A backfill window never

package/dist/cursors/raw-evidence-cursor.js

@@ -196,6 +196,7 @@ function parseSessionEntry(value) {
         uploaded_byte_size: optionalNumberOrNull(record["uploaded_byte_size"]),
         last_seen_at: lastSeenAt,
         ...parseStubReoffer(record["stub_reoffer"]),
+        ...(record["stubbed"] === true ? { stubbed: true } : {}),
     };
 }
 function parseStubReoffer(value) {
@@ -208,7 +209,15 @@ function parseStubReoffer(value) {
         : [];
     if (record["reason"] !== "stub_reoffered" || !markedAt || ids.length === 0)
         return {};
-    return { stub_reoffer: { reason: "stub_reoffered", stub_pointer_ids: ids, marked_at: markedAt } };
+    const notFoundAt = optionalString(record["not_found_at"]);
+    return {
+        stub_reoffer: {
+            reason: "stub_reoffered",
+            stub_pointer_ids: ids,
+            marked_at: markedAt,
+            ...(notFoundAt ? { not_found_at: notFoundAt } : {}),
+        },
+    };
 }
 function parseCheckpoints(value) {
     if (!value || typeof value !== "object")

package/dist/cursors/raw-evidence-stub-entry.js

@@ -0,0 +1,39 @@
+/**
+ * A redaction-crash stub is a promise to come back, not a delivery (BLI-11119).
+ *
+ * When the redactor crashed, the collector uploaded the 42-byte marker
+ * `REDACTION_STUB_TEXT` in place of the transcript, and the cursor entry then
+ * recorded the ORIGINAL file size as uploaded. Nothing local ever considered
+ * the session undelivered. This module is the one place a cursor entry is told
+ * the truth about a stub: `stubbed: true`, `uploaded_byte_size` the marker's
+ * 42 bytes, and `byte_offset` 0 because no session byte is durable.
+ *
+ * Two ways a stub is recognised, both deterministic:
+ * - at write time, by the object key: every transcript key's last segment
+ *   starts with the first 16 hex of its content hash (a re-keyed pointer keeps
+ *   that prefix), and the marker always hashes to `REDACTION_STUB_SHA256`;
+ * - after the fact, by the stubs door's answer, which is the source of truth
+ *   for every entry written before this rule existed.
+ */
+import { REDACTION_STUB_BYTE_SIZE, REDACTION_STUB_SHA256, } from "@bli-cockpit/telemetry-core";
+const STUB_KEY_PREFIX = REDACTION_STUB_SHA256.slice(0, 16);
+/** True when this object key names the redaction-crash marker, not a transcript. */
+export function isRedactionStubObjectKey(objectKey) {
+    if (!objectKey)
+        return false;
+    const segment = objectKey.slice(objectKey.lastIndexOf("/") + 1);
+    return segment.startsWith(STUB_KEY_PREFIX);
+}
+/**
+ * Make the entry say what the server holds: a stub. Returns whether anything
+ * changed, so a caller reconciling old entries can count what it corrected.
+ */
+export function markCursorEntryStubbed(entry) {
+    const changed = entry.stubbed !== true ||
+        entry.uploaded_byte_size !== REDACTION_STUB_BYTE_SIZE ||
+        entry.byte_offset !== 0;
+    entry.stubbed = true;
+    entry.uploaded_byte_size = REDACTION_STUB_BYTE_SIZE;
+    entry.byte_offset = 0;
+    return changed;
+}

package/package.json

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