@bli-cockpit/cli 0.2.250 → 0.2.251

package/dist/adapters/raw-evidence-prepare-memo.js

@@ -61,19 +61,23 @@ export function prepareRecipe(options) {
 export function prepareMemoPath(stateDir) {
     return path.join(stateDir, PREPARE_MEMO_FILENAME);
 }
-const EMPTY_COUNTS = { skipped_count: 0, skipped_bytes: 0, rebuilt_count: 0, rebuilt_bytes: 0, volatile_count: 0 };
+const EMPTY_COUNTS = { skipped_count: 0, skipped_bytes: 0, rebuilt_count: 0, rebuilt_bytes: 0, volatile_count: 0, volatile_reused_count: 0, volatile_reused_bytes: 0 };
 export async function openPrepareMemo(stateDir) {
     const entries = await readMemoEntries(stateDir);
     let dirty = false;
     let counts = { ...EMPTY_COUNTS };
     /** Sources recalled since the last `settle`: only these have their `seen_ms` refreshed. */
     const recalled = new Set();
+    /** In-memory only, never persisted: see `rememberForThisRun`. */
+    const thisRun = new Map();
     return {
         recall(sourceKey, stamp, recipe) {
             const entry = entries.get(sourceKey);
             if (!entry)
-                return null;
-            if (entry.volatile || entry.recipe !== recipe)
+                return recallThisRun(thisRun, sourceKey, stamp, recipe);
+            if (entry.volatile)
+                return recallThisRun(thisRun, sourceKey, stamp, recipe);
+            if (entry.recipe !== recipe)
                 return null;
             if (entry.size !== stamp.size || entry.identity !== stamp.identity)
                 return null;
@@ -82,9 +86,18 @@ export async function openPrepareMemo(stateDir) {
         },
         remember(sourceKey, entry, now = Date.now()) {
             entries.set(sourceKey, { ...entry, seen_ms: now });
+            thisRun.delete(sourceKey);
             dirty = true;
         },
+        rememberForThisRun(sourceKey, entry) {
+            thisRun.set(sourceKey, { ...entry, volatile: true, seen_ms: Date.now() });
+        },
         count(outcome, bytes) {
+            if (outcome === "volatile_reused") {
+                counts.volatile_reused_count += 1;
+                counts.volatile_reused_bytes += bytes;
+                return;
+            }
             if (outcome === "skipped") {
                 counts.skipped_count += 1;
                 counts.skipped_bytes += bytes;
@@ -114,6 +127,14 @@ export async function openPrepareMemo(stateDir) {
         },
     };
 }
+function recallThisRun(thisRun, sourceKey, stamp, recipe) {
+    const entry = thisRun.get(sourceKey);
+    if (!entry || entry.recipe !== recipe)
+        return null;
+    if (entry.size !== stamp.size || entry.identity !== stamp.identity)
+        return null;
+    return entry;
+}
 /**
  * Entries recalled this pass keep their `seen_ms` fresh, lazily, so they are not forgotten while in
  * use. Only those: an entry nobody recalls (a deleted or rotated session) ages out after

package/dist/adapters/raw-evidence-transcript-file.js

@@ -63,9 +63,9 @@ export async function collectOneEvidenceFile(collection, options) {
         markCapApplied(collection, options.kind, "max_file_bytes");
         return skip("file_too_large");
     }
-    const { sanitized, contentHash, stubClaim, volatile, redactedEntry } = await prepareTranscriptForUpload(collection, options, names, read.bytes);
+    const { sanitized, contentHash, stubClaim, volatile, deferredOnly, redactedEntry } = await prepareTranscriptForUpload(collection, options, names, read.bytes);
     await rememberPreparedTranscript(collection, options, names, {
-        stamp, recipe, readBytes: read.bytes.byteLength, contentHash, byteSize: sanitized.bytes.byteLength, volatile, redactedEntry,
+        stamp, recipe, readBytes: read.bytes.byteLength, contentHash, byteSize: sanitized.bytes.byteLength, volatile, deferredOnly, redactedEntry,
     });
     if (collection.skipContentHashes.has(contentHash) && !stubClaim) {
         collection.reused.push({
@@ -121,7 +121,7 @@ async function prepareTranscriptForUpload(collection, options, names, bytes) {
         byteSize: sanitized.bytes.byteLength,
         alreadyDurable: collection.skipContentHashes.has(contentHash),
     });
-    return { sanitized, contentHash, stubClaim, volatile: images.volatile, redactedEntry };
+    return { sanitized, contentHash, stubClaim, volatile: images.volatile, deferredOnly: images.deferredOnly, redactedEntry };
 }
 /**
  * The transcript bytes after the image step. Unchanged (the very same buffer) unless this sync has
@@ -133,10 +133,10 @@ async function prepareEmbeddedImages(collection, file) {
     const session = collection.budget.images;
     const source = file.kind.startsWith("codex") ? "codex" : file.kind.startsWith("claude") ? "claude_code" : null;
     if (!session || !source)
-        return { bytes: file.bytes, volatile: false };
+        return { bytes: file.bytes, volatile: false, deferredOnly: false };
     // Drop mode slims every transcript, image-bearing or not; keep mode only describes the ones that can hold an image.
     if (session.mode !== "describe_and_drop" && !mightHoldEmbeddedImages(file.bytes))
-        return { bytes: file.bytes, volatile: false };
+        return { bytes: file.bytes, volatile: false, deferredOnly: false };
     try {
         const prepared = await session.prepareTranscript({
             text: file.bytes.toString("utf8"),
@@ -151,13 +151,15 @@ async function prepareEmbeddedImages(collection, file) {
             : prepared.imageCount > 0;
         const slimFailed = session.mode === "describe_and_drop" && prepared.slim === null;
         const volatile = imagesPending || slimFailed;
+        // BLI-22785: volatile ONLY because the budget or a backoff held images back, and the slim step held up.
+        const deferredOnly = volatile && prepared.deferredOnly && !slimFailed;
         if (!prepared.changed)
-            return { bytes: file.bytes, volatile };
-        return { bytes: Buffer.from(prepared.text, "utf8"), volatile };
+            return { bytes: file.bytes, volatile, deferredOnly };
+        return { bytes: Buffer.from(prepared.text, "utf8"), volatile, deferredOnly };
     }
     catch (error) {
         console.error("[raw-evidence] image or slim step failed, uploading the transcript as it was", JSON.stringify({ reason: "image_step_failed", kind: file.kind, ...describeError(error) }));
-        return { bytes: file.bytes, volatile: true };
+        return { bytes: file.bytes, volatile: true, deferredOnly: false };
     }
 }
 /**
@@ -178,8 +180,13 @@ async function reuseUnchangedTranscript(collection, options, names, stamp, recip
     if (options.maxFileBytes && stamp.size > options.maxFileBytes)
         return false;
     const known = memo.recall(names.sourceKey, stamp, recipe);
-    if (!known || !collection.skipContentHashes.has(known.content_hash))
+    if (!known)
         return false;
+    if (!collection.skipContentHashes.has(known.content_hash)) {
+        if (known.volatile)
+            logVolatileReuse(options.kind, names.sourceKey, known.content_hash, "hash_not_durable_full_path");
+        return false;
+    }
     if (known.redacted) {
         collection.redacted.push({
             kind: options.kind,
@@ -194,16 +201,25 @@ async function reuseUnchangedTranscript(collection, options, names, stamp, recip
         content_hash_sha256: known.content_hash,
         codex_session_id: options.sessionId,
     });
+    if (known.volatile) {
+        // BLI-22785: images held back by this run's budget or a backoff; rebuilding gives the same bytes.
+        memo.count("volatile_reused", stamp.size);
+        logVolatileReuse(options.kind, names.sourceKey, known.content_hash, "images_deferred_budget_cannot_refill_this_run");
+        return true;
+    }
     memo.count("skipped", stamp.size);
     return true;
 }
+function logVolatileReuse(kind, sourceKey, contentHash, reason) {
+    console.error("[raw-evidence] volatile transcript " + (reason === "hash_not_durable_full_path" ? "rebuilt" : "reused this run"), JSON.stringify({ reason, kind, source_key: sourceKey, hash_prefix: contentHash.slice(0, 12) }));
+}
 /** Remember what this transcript became, but only if the file stayed put while it was built. */
 async function rememberPreparedTranscript(collection, options, names, built) {
     const memo = collection.budget.prepareMemo;
     if (!memo)
         return;
     memo.count(built.volatile ? "volatile" : "rebuilt", built.readBytes);
-    if (built.volatile || !built.stamp)
+    if ((built.volatile && !built.deferredOnly) || !built.stamp)
         return;
     const after = await statSourceForMemo(options.filePath);
     const stable = after !== null
@@ -212,10 +228,7 @@ async function rememberPreparedTranscript(collection, options, names, built) {
         && built.readBytes === built.stamp.size;
     if (!stable)
         return;
-    const known = memo.recall(names.sourceKey, built.stamp, built.recipe);
-    if (known?.content_hash === built.contentHash)
-        return;
-    memo.remember(names.sourceKey, {
+    const entry = {
         ...built.stamp,
         recipe: built.recipe,
         content_hash: built.contentHash,
@@ -223,8 +236,16 @@ async function rememberPreparedTranscript(collection, options, names, built) {
         redacted: built.redactedEntry
             ? { redaction: built.redactedEntry.redaction, completenessLabel: built.redactedEntry.completenessLabel }
             : null,
-        volatile: false,
-    });
+    };
+    if (built.volatile) {
+        // BLI-22785: in memory for this process only; the memo file keeps no volatile entry.
+        memo.rememberForThisRun(names.sourceKey, entry);
+        return;
+    }
+    const known = memo.recall(names.sourceKey, built.stamp, built.recipe);
+    if (known && !known.volatile && known.content_hash === built.contentHash)
+        return;
+    memo.remember(names.sourceKey, { ...entry, volatile: false });
 }
 function nameEvidenceFile(options) {
     const fileName = path.basename(options.filePath);

package/dist/adapters/raw-evidence.js

@@ -107,15 +107,17 @@ export async function collectRawEvidencePack(context, options) {
  */
 async function reportPrepareMemo(collection) {
     const counts = await collection.budget.prepareMemo?.settle();
-    if (!counts || counts.skipped_count + counts.rebuilt_count === 0)
+    if (!counts || counts.skipped_count + counts.rebuilt_count + counts.volatile_reused_count === 0)
         return;
-    console.error(counts.skipped_count > 0 ? "[raw-evidence] slim skipped unchanged" : "[raw-evidence] no unchanged transcripts to skip", JSON.stringify({
+    console.error(counts.skipped_count + counts.volatile_reused_count > 0 ? "[raw-evidence] slim skipped unchanged" : "[raw-evidence] no unchanged transcripts to skip", JSON.stringify({
         reason: "source_unchanged_since_last_prepare",
         count: counts.skipped_count,
         bytes: counts.skipped_bytes,
         rebuilt_count: counts.rebuilt_count,
         rebuilt_bytes: counts.rebuilt_bytes,
         rebuilt_volatile_count: counts.volatile_count,
+        rebuilt_volatile_reused_count: counts.volatile_reused_count,
+        rebuilt_volatile_reused_bytes: counts.volatile_reused_bytes,
     }));
 }
 /**

package/dist/commands/backfill-live-window.js

@@ -0,0 +1,41 @@
+/**
+ * BLI-22790: backfill is history. A session file modified inside the live window belongs to the
+ * normal sync tick, which collects the same `DEFAULT_SINCE_MINUTES` (24 h) every ~15 minutes and
+ * already uploads these sessions (`riding_already_durable`). Re-preparing a live, still-growing
+ * session in backfill held the collection lock for 232 s per tick and kept the run "partial"
+ * forever, so doctor re-ran the backfill on every tick.
+ */
+import { DEFAULT_SINCE_MINUTES } from "../adapters/raw-evidence-collection-state.js";
+import { stubSessionKey } from "../evidence-stubs-client.js";
+export const BACKFILL_LIVE_WINDOW_MS = DEFAULT_SINCE_MINUTES * 60 * 1000;
+/** The window this run uses: none for a stub pass (it names its sessions), else the test seam or the default. */
+export function liveWindowMsFor(command) {
+    return command.stubPass ? 0 : (command.liveWindowMs ?? BACKFILL_LIVE_WINDOW_MS);
+}
+/** `onlySessions` (`codex:<id>` / `claude_code:<id>`) when set, then the live window. */
+export function scopeBackfillCandidates(candidates, options) {
+    const key = (c) => stubSessionKey(c.source, c.session_id);
+    const scoped = options.onlySessions ? candidates.filter((c) => options.onlySessions.has(key(c))) : candidates;
+    return leaveLiveSessionsToTheTick(scoped, options.live);
+}
+/**
+ * Drop the candidates the tick owns: modified within `liveWindowMs` (0 keeps all), unless the
+ * server names the session a redaction stub (BLI-11102), which is re-offered even while live.
+ * Logs the count either way.
+ */
+export function leaveLiveSessionsToTheTick(candidates, options) {
+    let liveExcluded = 0;
+    const kept = options.liveWindowMs <= 0 ? candidates : candidates.filter((candidate) => {
+        const live = options.now.getTime() - candidate.session_file_mtime_ms < options.liveWindowMs
+            && !options.stubbedSessions.has(stubSessionKey(candidate.source, candidate.session_id));
+        if (live)
+            liveExcluded += 1;
+        return !live;
+    });
+    console.error("[backfill] live sessions left to the tick", JSON.stringify({
+        reason: liveExcluded > 0 ? "live_owned_by_tick" : "no_live_sessions",
+        live_excluded: liveExcluded,
+        live_window_minutes: Math.round(options.liveWindowMs / 60_000),
+    }));
+    return { kept, liveExcluded };
+}

package/dist/commands/backfill-report.js

@@ -228,7 +228,17 @@ function countRemainingHistory(options) {
 async function writeAllHistoryCompletionMarker(ctx) {
     const { paths, cursor, sources, scopedCursor, scan, oversizedCandidateKeys, now } = ctx;
     const cappedSidecars = cappedSidecarCount(scan.candidates);
-    recordBackfillScanCoverage(cursor, sources, now, now);
+    // BLI-22790: sessions left to the tick were NOT covered here. Mark coverage only up to the
+    // start of the live window, so once they age out a later backfill still sees them.
+    const coveredThrough = scan.live_excluded_count > 0
+        ? new Date(now.getTime() - scan.live_window_ms)
+        : now;
+    console.error("[backfill] history coverage recorded", JSON.stringify({
+        reason: scan.live_excluded_count > 0 ? "covered_through_live_window_start" : "covered_through_now",
+        live_excluded: scan.live_excluded_count,
+        live_window_minutes: Math.round(scan.live_window_ms / 60_000),
+    }));
+    recordBackfillScanCoverage(cursor, sources, coveredThrough, now);
     await writeBackfillCursor(paths, cursor);
     const oversizedCandidates = scan.candidates.filter((candidate) => oversizedCandidateKeys.has(candidateCursorKey(candidate)));
     await writeBackfillCompletionMarker(paths, {

package/dist/commands/backfill-scan.js

@@ -14,6 +14,7 @@ import { scanAndAttributeClaudeSessions, } from "../adapters/claude-attribution.
 import { defaultCodexSessionDirs, scanAndAttributeCodexSessions, } from "../adapters/codex-attribution.js";
 import { emptyBackfillCursorState, prepareBackfillCursorForScope, readBackfillCursor, } from "../cursors/backfill-cursor.js";
 import { CLAUDE_CURSOR_FILENAME, readRawEvidenceCursor, } from "../cursors/raw-evidence-cursor.js";
+import { liveWindowMsFor, scopeBackfillCandidates } from "./backfill-live-window.js";
 import { getCollectorRuntimePaths } from "../local-state.js";
 import { candidateCursorKey, compareBackfillCandidates, isAfterCursor, } from "./backfill-candidates.js";
 import { addReadOnlyGuardIssues, addRepoDiscoveryIssues, backfillScanIssues, countReadOnlyGuards, deterministicSkipCandidateKeys, oversizedBackfillCandidateKeys, retryableCandidateKeys, sortScanIssuesByPriority, } from "./backfill-issues.js";
@@ -23,7 +24,6 @@ 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";
 /**
  * SCAN: is this machine paired, what roots/sources/window apply, and what did
  * the archived Codex + Claude session stores actually contain. Returns either
@@ -149,11 +149,13 @@ async function scanBackfillSessions(options) {
         cursorHashes: options.stubCursorHashes,
         sinceMinutes: options.window.since_minutes,
     });
+    const liveWindowMs = liveWindowMsFor(options.command);
     const selection = selectBackfillCandidates({
         scanned,
         cursor: options.cursor,
         pointerlessTerminalSessions: options.pointerlessTerminalSessions,
         maxFiles: options.command.maxFiles,
+        live: { liveWindowMs, now: options.now, stubbedSessions: options.stubReoffer.sessions },
         onlySessions: options.command.stubPass
             ? new Set(options.command.stubPass.plan.sessions.keys())
             : undefined,
@@ -177,6 +179,8 @@ async function scanBackfillSessions(options) {
         issues,
         retryable_candidate_keys: retryableCandidateKeys(candidates),
         omitted_candidate_count: selection.omittedCandidateCount,
+        live_excluded_count: selection.liveExcluded,
+        live_window_ms: liveWindowMs,
     };
 }
 /**
@@ -220,9 +224,8 @@ 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.scanned
-        .filter((candidate) => !options.onlySessions ||
-        options.onlySessions.has(stubSessionKey(candidate.source, candidate.session_id)))
+    const { kept, liveExcluded } = scopeBackfillCandidates(options.scanned, options);
+    const allCandidates = kept
         .filter((candidate) => isAfterCursor(candidate, options.cursor) ||
         isPointerlessTerminalRetry(candidate, options.pointerlessTerminalSessions))
         .sort((a, b) => compareBackfillCandidatesForRetry(a, b, options.pointerlessTerminalSessions));
@@ -230,6 +233,7 @@ function selectBackfillCandidates(options) {
     return {
         candidates,
         omittedCandidateCount: allCandidates.length - candidates.length,
+        liveExcluded,
     };
 }
 async function loadPointerlessTerminalSessions(paths, sources) {

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

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/package.json

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