@bli-cockpit/cli 0.2.205 → 0.2.207

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

@@ -106,13 +106,17 @@ export async function collectOneEvidenceFile(collection, options) {
 }
 /**
  * The transcript bytes after the image step. Unchanged (the very same buffer) unless this sync has
- * an image session AND the switch is `describe_and_drop` AND at least one image has a stored
- * description. Never throws: an image step that breaks hands back the original bytes and says so.
+ * an image session AND the switch is `describe_and_drop` (images become markers where a description
+ * is stored, then the slim rules run, see src/slim/). In `describe_and_keep` the bytes always come
+ * back untouched. Never throws: an image step that breaks hands back the original bytes and says so.
  */
 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 || !mightHoldEmbeddedImages(file.bytes))
+    if (!session || !source)
+        return file.bytes;
+    // 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 file.bytes;
     try {
         const prepared = await session.prepareTranscript({
@@ -120,12 +124,12 @@ async function prepareEmbeddedImages(collection, file) {
             source,
             sessionId: file.sessionId,
         });
-        if (prepared.replacedCount === 0)
+        if (!prepared.changed)
             return file.bytes;
         return Buffer.from(prepared.text, "utf8");
     }
     catch (error) {
-        console.error("[raw-evidence] image step failed, uploading the transcript with its images", JSON.stringify({ reason: "image_step_failed", kind: file.kind, ...describeError(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 file.bytes;
     }
 }

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.205");
+    writeLine(io?.stdout ?? process.stdout, "0.2.207");
     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

@@ -1,7 +1,7 @@
 /**
  * One sync's handling of the images inside transcripts (BLI-16977).
  *
- * `prepareTranscript` takes a transcript's text just before it is masked and staged and does three
+ * `prepareTranscript` takes a transcript's text just before it is masked and staged and does four
  * things, in this order:
  *
  *  1. FIND every embedded image (`transcript-images.ts` in telemetry-core) and group them by sha256.
@@ -13,12 +13,16 @@
  *     `describe_and_drop`: every image whose description is stored becomes its short marker. An
  *     image with no stored description is KEPT. In `describe_and_keep` (the default) the text
  *     comes back byte for byte as it went in.
+ *  4. SLIM, only in `describe_and_drop`: the slim transcript (src/slim/): the duplicate copies and
+ *     the bookkeeping go, every line stays. In `describe_and_keep` the slim form is not computed
+ *     and not uploaded.
  *
  * Metadata only in the logs: counts, sizes, hashes, reason labels. Never image bytes, never a
  * description.
  */
 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, slimTranscript } from "./slim/slim-transcript.js";
 import { imageStateKey, readDescribedImageKeys, writeDescribedImageKeys, } 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;
@@ -62,84 +66,104 @@ export async function openImageDescriptions(options) {
         }
         settledThisRun.set(image.sha256, `failed:${outcome.reason}`);
     }
-    return {
-        mode,
-        async prepareTranscript(input) {
-            const images = findEmbeddedImages(input.text);
-            if (images.length === 0)
-                return { text: input.text, imageCount: 0, uniqueCount: 0, replacedCount: 0, charsSaved: 0 };
-            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 };
-            const failedReasons = {};
-            const toSend = [];
-            for (const image of unique.values()) {
-                if (described.has(imageStateKey(image.sha256))) {
-                    counts.already += 1;
-                    continue;
-                }
-                const earlier = settledThisRun.get(image.sha256);
-                if (earlier)
-                    continue;
-                if (image.byteSize > IMAGE_DESCRIBE_MAX_BYTES) {
-                    settledThisRun.set(image.sha256, "too_large");
-                    counts.too_large += 1;
+    async function describeAndReplace(input) {
+        const images = findEmbeddedImages(input.text);
+        if (images.length === 0)
+            return { text: input.text, imageCount: 0, uniqueCount: 0, replacedCount: 0, charsSaved: 0 };
+        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 };
+        const failedReasons = {};
+        const toSend = [];
+        for (const image of unique.values()) {
+            if (described.has(imageStateKey(image.sha256))) {
+                counts.already += 1;
+                continue;
+            }
+            const earlier = settledThisRun.get(image.sha256);
+            if (earlier)
+                continue;
+            if (image.byteSize > IMAGE_DESCRIBE_MAX_BYTES) {
+                settledThisRun.set(image.sha256, "too_large");
+                counts.too_large += 1;
+                continue;
+            }
+            toSend.push(image);
+        }
+        let next = 0;
+        const worker = async () => {
+            while (next < toSend.length) {
+                const image = toSend[next++];
+                if (sentThisRun >= maxPerRun || now() - startedAt > maxRunMs) {
+                    counts.over_budget += 1;
                     continue;
                 }
-                toSend.push(image);
+                await sendOne(image, input.text, input);
             }
-            let next = 0;
-            const worker = async () => {
-                while (next < toSend.length) {
-                    const image = toSend[next++];
-                    if (sentThisRun >= maxPerRun || now() - startedAt > maxRunMs) {
-                        counts.over_budget += 1;
-                        continue;
-                    }
-                    await sendOne(image, input.text, input);
-                }
-            };
-            await Promise.all(Array.from({ length: Math.min(CONCURRENCY, toSend.length) }, worker));
-            for (const image of toSend) {
-                const settled = settledThisRun.get(image.sha256);
-                if (settled === "described")
-                    counts.described_now += 1;
-                else if (settled === "known")
-                    counts.known += 1;
-                else if (settled?.startsWith("failed:")) {
-                    counts.failed += 1;
-                    const reason = settled.slice("failed:".length);
-                    failedReasons[reason] = (failedReasons[reason] ?? 0) + 1;
-                }
+        };
+        await Promise.all(Array.from({ length: Math.min(CONCURRENCY, toSend.length) }, worker));
+        for (const image of toSend) {
+            const settled = settledThisRun.get(image.sha256);
+            if (settled === "described")
+                counts.described_now += 1;
+            else if (settled === "known")
+                counts.known += 1;
+            else if (settled?.startsWith("failed:")) {
+                counts.failed += 1;
+                const reason = settled.slice("failed:".length);
+                failedReasons[reason] = (failedReasons[reason] ?? 0) + 1;
             }
-            if (counts.described_now + counts.known > 0)
-                await writeDescribedImageKeys(options.stateDir, orderedKeys);
-            const replaced = mode === "describe_and_drop"
-                ? replaceImagesWithMarkers(input.text, images, (image) => described.has(imageStateKey(image.sha256)))
-                : { text: input.text, replacedCount: 0, charsSaved: 0 };
-            console.error(TAG + " transcript prepared", JSON.stringify({
-                mode,
-                source: input.source,
-                images: images.length,
-                unique: unique.size,
-                ...counts,
-                failed_reasons: failedReasons,
-                replaced: replaced.replacedCount,
-                chars_saved: replaced.charsSaved,
-                kept_without_description: mode === "describe_and_drop" ? images.length - replaced.replacedCount : 0,
-            }));
-            return {
-                text: replaced.text,
-                imageCount: images.length,
-                uniqueCount: unique.size,
-                replacedCount: replaced.replacedCount,
-                charsSaved: replaced.charsSaved,
-            };
+        }
+        if (counts.described_now + counts.known > 0)
+            await writeDescribedImageKeys(options.stateDir, orderedKeys);
+        const replaced = mode === "describe_and_drop"
+            ? replaceImagesWithMarkers(input.text, images, (image) => described.has(imageStateKey(image.sha256)))
+            : { text: input.text, replacedCount: 0, charsSaved: 0 };
+        console.error(TAG + " transcript prepared", JSON.stringify({
+            mode,
+            source: input.source,
+            images: images.length,
+            unique: unique.size,
+            ...counts,
+            failed_reasons: failedReasons,
+            replaced: replaced.replacedCount,
+            chars_saved: replaced.charsSaved,
+            kept_without_description: mode === "describe_and_drop" ? images.length - replaced.replacedCount : 0,
+        }));
+        return {
+            text: replaced.text,
+            imageCount: images.length,
+            uniqueCount: unique.size,
+            replacedCount: replaced.replacedCount,
+            charsSaved: replaced.charsSaved,
+        };
+    }
+    return {
+        mode,
+        async prepareTranscript(input) {
+            const afterImages = await describeAndReplace(input);
+            if (mode !== "describe_and_drop")
+                return { ...afterImages, text: input.text, changed: false, slim: null };
+            const slim = slimOrKeep(afterImages.text, input.source, { sessionId: input.sessionId });
+            return { ...afterImages, text: slim.text, changed: slim.text !== input.text, slim: slim.stats };
         },
     };
 }
+/**
+ * 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/slim/claude-attachments.js

@@ -0,0 +1,96 @@
+/**
+ * Claude Code `attachment` lines: the harness's bookkeeping, re-saved every few turns (BLI-16977).
+ * On one laptop attachment lines are 30% of Claude transcript bytes and almost none of it is
+ * conversation. The line always stays (Tower counts lines and reads every timestamp); what goes is
+ * the payload that is a second copy, an exact repeat of an earlier block, or text nobody reads.
+ *
+ * Three kinds of change, by attachment type:
+ *
+ *  - PAYLOAD dropped: `hook_success` (except SessionStart, whose output is context the model saw),
+ *    `total_tokens_reminder`, `deferred_tools_record`.
+ *  - REPEATS become a reference after the first copy: the system prompt and tool list
+ *    (`prompt_snapshot`), CLAUDE.md files (`instructions`), the skill listing, session context,
+ *    nested memory, MCP and agent listings, the deferred-tools delta's description lines, invoked
+ *    skills, hook-injected context.
+ *  - The `rendered` and `renderedInHumanTurn` copies (the same attachment as the model saw it)
+ *    are dropped for every type measured to be a template around fields that stay.
+ *
+ * Kept whole: `queued_command` (what the person typed while the agent was busy, often found
+ * nowhere else), `edited_text_file` snippets, SessionStart hook output, `hook_additional_context`
+ * (once per distinct text), `deferred_tools_delta` names (added AND removed), and every attachment
+ * type this file does not name.
+ */
+import { isJsonObject, stripKey } from "./slim-support.js";
+/** Fields dropped from the attachment, by type. */
+const PAYLOAD_FIELDS_DROPPED = {
+    total_tokens_reminder: ["text"],
+    deferred_tools_record: ["entries", "toolInputCopies"],
+};
+/** Fields kept once per distinct text, by type. */
+const REPEATED_FIELDS = {
+    prompt_snapshot: ["systemPrompt", "tools"],
+    skill_listing: ["content"],
+    session_context: ["context"],
+    nested_memory: ["content"],
+    mcp_instructions_delta: ["addedBlocks"],
+    agent_listing_delta: ["addedLines"],
+    deferred_tools_delta: ["addedLines", "surfacedDefinitions"],
+    invoked_skills: ["skills"],
+    hook_additional_context: ["content"],
+};
+/**
+ * Types whose `rendered` copy is a template around fields that stay, or around nothing that
+ * matters. `environment` is deliberately absent: its rendered text had 622 distinct versions in the
+ * survey and nobody proved they hold nothing else.
+ */
+const RENDERED_IS_A_COPY = new Set([
+    "hook_success", "hook_additional_context", "hook_system_message", "instructions", "skill_listing",
+    "queued_command", "total_tokens_reminder", "mcp_instructions_delta", "agent_listing_delta",
+    "deferred_tools_delta", "deferred_tools_record", "session_context", "nested_memory", "invoked_skills",
+    "edited_text_file", "file", "bash_output_audience_note", "remote_session_change", "model",
+    "batching_reminder_sent", "date", "auto_mode", "credential_org", "silent_turn_reminder",
+    "thinking_drop", "read_truncation_notice", "structured_output",
+]);
+export function slimAttachmentLine(record, seen, edits) {
+    const attachment = record["attachment"];
+    if (!isJsonObject(attachment))
+        return;
+    const type = typeof attachment["type"] === "string" ? attachment["type"] : "";
+    if (type === "hook_success")
+        dropHookOutput(attachment, edits);
+    for (const field of PAYLOAD_FIELDS_DROPPED[type] ?? [])
+        stripKey(attachment, field, `attachment.${type}.${field}`, edits);
+    for (const field of REPEATED_FIELDS[type] ?? [])
+        seen.dedupeKey(attachment, field, `attachment.${type}.repeat`, edits);
+    if (type === "instructions" && Array.isArray(attachment["files"])) {
+        for (const file of attachment["files"]) {
+            if (isJsonObject(file))
+                seen.dedupeKey(file, "content", "attachment.instructions.repeat", edits);
+        }
+    }
+    if (RENDERED_IS_A_COPY.has(type)) {
+        for (const copy of ["rendered", "renderedInHumanTurn"])
+            stripKey(record, copy, "attachment.rendered", edits);
+    }
+}
+/** A hook that ran fine and printed something: its output is bookkeeping unless it was the SessionStart hook. */
+function dropHookOutput(attachment, edits) {
+    if (attachment["hookEvent"] === "SessionStart")
+        return;
+    const exitCode = attachment["exitCode"];
+    if (exitCode !== undefined && exitCode !== 0)
+        return;
+    for (const field of ["command", "content", "stderr", "stdout"]) {
+        stripKey(attachment, field, "attachment.hook_success.output", edits);
+    }
+}
+/** A `stop_hook_summary` system line with no error and no stop request: the per-hook list is bookkeeping. */
+export function slimStopHookSummary(record, edits) {
+    if (record["subtype"] !== "stop_hook_summary")
+        return;
+    const errors = record["hookErrors"];
+    const hadErrors = Array.isArray(errors) ? errors.length > 0 : errors !== undefined && errors !== null && errors !== false;
+    if (hadErrors || record["preventedContinuation"] === true || record["stopReason"])
+        return;
+    stripKey(record, "hookInfos", "system.stop_hook_summary.hookInfos", edits);
+}

package/dist/slim/claude-rules.js

@@ -0,0 +1,48 @@
+/**
+ * The slim rules for one Claude Code transcript line (BLI-16977). Entry point: `slimClaudeRecord`.
+ *
+ * The line's skeleton is never touched: type, timestamp, uuid, parentUuid, sessionId, cwd,
+ * gitBranch, isSidechain, requestId, version and the rest of the envelope stay, because Tower reads
+ * the timestamp and the working folder of every line. `message.usage` stays whole too (the 1-hour
+ * versus 5-minute cache-write split is what the cost is priced on). Only payload goes.
+ *
+ * What goes, and why it is safe (measured on 160 local files; the per-rule table is in
+ * docs/architecture/image-descriptions.md):
+ *
+ *  - `wireToolInputs`: a second copy of each tool call's input, keyed by tool_use id.
+ *  - `message.input_transformations`: a list of "thinking was dropped here" pointers, re-listed on
+ *    every assistant line, holding no content.
+ *  - `toolUseResult` fields that repeat the tool_result or the tool input (claude-tool-results.ts).
+ *  - Attachment bookkeeping (claude-attachments.ts).
+ *
+ * Unknown shapes pass through untouched.
+ */
+import { slimAttachmentLine, slimStopHookSummary } from "./claude-attachments.js";
+import { rememberToolInputs, slimToolUseResult, } from "./claude-tool-results.js";
+import { isJsonObject, stripKey } from "./slim-support.js";
+export function newClaudeSlimState() {
+    return { toolInputs: new Map() };
+}
+export function slimClaudeRecord(record, state, seen, edits) {
+    stripKey(record, "wireToolInputs", "wireToolInputs", edits);
+    switch (record["type"]) {
+        case "assistant": {
+            rememberToolInputs(record, state.toolInputs);
+            const message = record["message"];
+            if (isJsonObject(message))
+                stripKey(message, "input_transformations", "message.input_transformations", edits);
+            return;
+        }
+        case "user":
+            slimToolUseResult(record, state.toolInputs, edits);
+            return;
+        case "attachment":
+            slimAttachmentLine(record, seen, edits);
+            return;
+        case "system":
+            slimStopHookSummary(record, edits);
+            return;
+        default:
+            return;
+    }
+}

package/dist/slim/claude-tool-results.js

@@ -0,0 +1,178 @@
+/**
+ * Claude Code `toolUseResult`: the structured copy of what a tool returned, written next to the
+ * `tool_result` block that holds the same thing for the model (BLI-16977).
+ *
+ * Measured on one laptop (80 largest plus 80 random files), 92% of `toolUseResult` bytes repeat
+ * something already on the same line (the tool_result text) or on the tool call's own input. This
+ * file strips exactly those repeats, and only after PROVING each one is a repeat:
+ *
+ *  - Read `file.content`: the first and last non-blank lines of the file text appear in the
+ *    tool_result. (A truncated tool_result fails the check and the field stays.)
+ *  - Bash `stdout` and `stderr`: the text appears in the tool_result, and no `persistedOutputPath`
+ *    says the tool_result is only a preview of a longer output.
+ *  - Write `content`, Edit `oldString` and `newString`, Agent and Task `prompt` and `description`:
+ *    the same sha256 as the tool call's input, which an earlier assistant line carried.
+ *  - A string or list result (MCP tools): every long string in it appears in the tool_result.
+ *
+ * Kept on purpose, because each holds something found nowhere else: Bash `bashEditDiff`, the
+ * `originalFile` and `structuredPatch` of an Edit or a Write, full output behind a
+ * `persistedOutputPath`, Read `totalLines`, `originalSize` and `dimensions`, and every flag
+ * (`interrupted`, `isImage`, `userModified`, ...). The harvest extractor reads
+ * `toolUseResult.interrupted`; it is never touched.
+ */
+import { canonicalText, contentHash, isJsonObject, stripKey, } from "./slim-support.js";
+/** Tools whose result repeats a field of the tool call's input, and which input fields. */
+const COPIED_INPUT_FIELDS = {
+    Write: ["content"],
+    Edit: ["old_string", "new_string"],
+    Agent: ["prompt", "description"],
+    Task: ["prompt", "description"],
+};
+/** Which result field repeats which input field. */
+const RESULT_FIELD_FOR_INPUT = {
+    Write: { content: "content" },
+    Edit: { oldString: "old_string", newString: "new_string" },
+    Agent: { prompt: "prompt", description: "description" },
+    Task: { prompt: "prompt", description: "description" },
+};
+/** Tool calls remembered so a result can be matched to its input. Oldest dropped first. */
+const MAX_REMEMBERED_TOOL_CALLS = 50_000;
+/** A string shorter than this is not checked as a copy (it costs nothing to keep). */
+const MIN_COPY_CHARS = 40;
+/** Called for each assistant line: remember what the Write, Edit and Agent calls carried. */
+export function rememberToolInputs(record, inputs) {
+    const message = record["message"];
+    const content = isJsonObject(message) ? message["content"] : undefined;
+    if (!Array.isArray(content))
+        return;
+    for (const block of content) {
+        if (!isJsonObject(block) || block["type"] !== "tool_use")
+            continue;
+        const id = block["id"];
+        const tool = block["name"];
+        const input = block["input"];
+        if (typeof id !== "string" || typeof tool !== "string" || !isJsonObject(input))
+            continue;
+        const fields = COPIED_INPUT_FIELDS[tool];
+        if (!fields)
+            continue;
+        const hashes = {};
+        for (const field of fields) {
+            const text = input[field];
+            if (typeof text === "string")
+                hashes[field] = contentHash(text);
+        }
+        inputs.set(id, { tool, hashes });
+        if (inputs.size > MAX_REMEMBERED_TOOL_CALLS) {
+            const oldest = inputs.keys().next().value;
+            if (oldest !== undefined)
+                inputs.delete(oldest);
+        }
+    }
+}
+/** Called for each user line that carries a `toolUseResult`. */
+export function slimToolUseResult(record, inputs, edits) {
+    const result = record["toolUseResult"];
+    if (result === undefined)
+        return;
+    const blocks = toolResultBlocks(record);
+    // Several results on one line is not a shape we have seen; leave the line alone rather than guess which is which.
+    if (blocks.length !== 1)
+        return;
+    const block = blocks[0];
+    const toolUseId = block["tool_use_id"];
+    const digest = typeof toolUseId === "string" ? inputs.get(toolUseId) : undefined;
+    if (typeof toolUseId === "string")
+        inputs.delete(toolUseId);
+    if (isJsonObject(result)) {
+        stripCopiedFields(result, digest, toolResultText(block), edits);
+        return;
+    }
+    if (typeof result === "string" || Array.isArray(result)) {
+        if (everyLongStringAppearsIn(result, block["content"])) {
+            edits.strip("toolUseResult.copy_of_tool_result", canonicalText(result).length);
+            delete record["toolUseResult"];
+        }
+    }
+}
+function stripCopiedFields(result, digest, resultText, edits) {
+    const file = result["file"];
+    if (isJsonObject(file) && typeof file["content"] === "string" && fileLinesAppearIn(file["content"], resultText)) {
+        stripKey(file, "content", "toolUseResult.file.content", edits);
+    }
+    if (typeof result["stdout"] === "string" && result["persistedOutputPath"] === undefined && result["isImage"] !== true) {
+        for (const field of ["stdout", "stderr"]) {
+            const text = result[field];
+            if (typeof text === "string" && text.length >= MIN_COPY_CHARS && resultText.includes(text)) {
+                stripKey(result, field, `toolUseResult.${field}`, edits);
+            }
+        }
+    }
+    const fieldMap = digest ? RESULT_FIELD_FOR_INPUT[digest.tool] : undefined;
+    if (!digest || !fieldMap)
+        return;
+    for (const [resultField, inputField] of Object.entries(fieldMap)) {
+        const text = result[resultField];
+        // Same hash as the call's input is an exact repeat at any length, so no minimum here.
+        if (typeof text !== "string" || text.length === 0)
+            continue;
+        if (digest.hashes[inputField] === contentHash(text)) {
+            stripKey(result, resultField, `toolUseResult.${resultField}`, edits);
+        }
+    }
+}
+function toolResultBlocks(record) {
+    const message = record["message"];
+    const content = isJsonObject(message) ? message["content"] : undefined;
+    if (!Array.isArray(content))
+        return [];
+    return content.filter((block) => isJsonObject(block) && block["type"] === "tool_result");
+}
+/** The text of a tool_result block: a string as it is, a list of blocks as their text parts joined. */
+function toolResultText(block) {
+    const content = block["content"];
+    if (typeof content === "string")
+        return content;
+    if (!Array.isArray(content))
+        return "";
+    const parts = [];
+    for (const part of content) {
+        if (isJsonObject(part) && typeof part["text"] === "string")
+            parts.push(part["text"]);
+    }
+    return parts.join("\n");
+}
+/** A Read puts `cat -n` numbering in front of each line, so compare by the first and last non-blank line. */
+function fileLinesAppearIn(fileText, resultText) {
+    if (resultText.length === 0)
+        return false;
+    const lines = fileText.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+    if (lines.length === 0)
+        return false;
+    return resultText.includes(lines[0]) && resultText.includes(lines[lines.length - 1]);
+}
+/** Every string of 40 or more characters in `value` appears (JSON-escaped) inside the tool_result content. */
+function everyLongStringAppearsIn(value, toolResultContent) {
+    const haystack = JSON.stringify(toolResultContent) ?? "";
+    const longStrings = [];
+    collectLongStrings(value, longStrings, 0);
+    if (longStrings.length === 0)
+        return false;
+    return longStrings.every((text) => haystack.includes(JSON.stringify(text).slice(1, -1)));
+}
+function collectLongStrings(value, into, depth) {
+    if (depth > 6 || into.length > 200)
+        return;
+    if (typeof value === "string") {
+        if (value.length >= MIN_COPY_CHARS)
+            into.push(value);
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value)
+            collectLongStrings(item, into, depth + 1);
+    }
+    else if (isJsonObject(value)) {
+        for (const item of Object.values(value))
+            collectLongStrings(item, into, depth + 1);
+    }
+}

package/dist/slim/codex-rules.js

@@ -0,0 +1,179 @@
+/**
+ * The slim rules for one Codex rollout line (BLI-16977). Entry point: `slimCodexRecord`.
+ *
+ * A Codex line is `{timestamp, type, payload}`. The envelope never changes; only payload goes.
+ * Measured on 80 local rollouts, almost all the bulk is images (turned into markers before this
+ * runs) and a second copy of each finished item (`event_msg` `item_completed`) next to the
+ * `response_item` the model saw. The survey and its skeptic agree on what is a copy:
+ *
+ *  - `item_completed` CommandExecution: `formatted_output` and `parsed_cmd` go, and `stdout` goes
+ *    when it equals `aggregated_output`. `aggregated_output` and `command` STAY: they are the only
+ *    full copy of what the shell printed.
+ *  - `item_completed` UserMessage, AgentMessage, Reasoning: any long string identical to one in an
+ *    EARLIER `response_item` becomes a reference. A copy that came first in the file is kept.
+ *  - McpToolCall results, FileChange contents, `compacted.replacement_history`, image generations:
+ *    kept (their images are markers by now). `compacted.guardian_history` keeps only what an
+ *    earlier `response_item` did not already hold.
+ *  - `token_count`: `last_token_usage` and `rate_limits` go; `total_token_usage` and
+ *    `model_context_window` stay (the session facts read them).
+ *  - `token_usage_record`: payload emptied (17,964 of 18,109 were byte-equal to a `token_count`).
+ *  - `thread_settings_applied`: reduced to `service_tier`.
+ *  - `response_item`: `internal_chat_message_metadata_passthrough` goes; a developer message, the
+ *    `session_meta` `base_instructions` and each `world_state` block are kept once per distinct
+ *    text and become references after.
+ *  - `task_complete.last_agent_message`: a reference when an earlier message holds the same text.
+ *
+ * `task_started`/`task_complete` durations, `session_meta.forked_from_id` and every unnamed shape
+ * pass through untouched.
+ */
+import { SLIM_COPY_MIN_CHARS, canonicalText, contentHash, isJsonObject, isSlimRef, slimRefFor, stripKey, } from "./slim-support.js";
+/** Strings from `response_item` lines remembered for comparison. Past this, new strings are not added. */
+const MAX_REMEMBERED_STRINGS = 300_000;
+/** Item types whose event copy is a pure repeat of a `response_item`. */
+const ITEM_TYPES_THAT_REPEAT = new Set(["UserMessage", "AgentMessage", "Reasoning"]);
+export function newCodexSlimState() {
+    return { earlierStrings: new Set() };
+}
+export function slimCodexRecord(record, state, seen, edits) {
+    const payload = record["payload"];
+    if (!isJsonObject(payload))
+        return;
+    switch (record["type"]) {
+        case "response_item":
+            rememberLongStrings(payload, state, 0);
+            stripKey(payload, "internal_chat_message_metadata_passthrough", "codex.response_item.passthrough", edits);
+            if (payload["type"] === "message" && payload["role"] === "developer") {
+                seen.dedupeKey(payload, "content", "codex.developer_message.repeat", edits);
+            }
+            return;
+        case "session_meta":
+            seen.dedupeKey(payload, "base_instructions", "codex.session_meta.base_instructions.repeat", edits);
+            return;
+        case "world_state": {
+            const blocks = payload["state"];
+            if (isJsonObject(blocks))
+                for (const key of Object.keys(blocks))
+                    seen.dedupeKey(blocks, key, "codex.world_state.repeat", edits);
+            return;
+        }
+        case "compacted": {
+            // guardian_history re-saves earlier turns; replacement_history is kept whole (part of it is found nowhere else).
+            const guardian = payload["guardian_history"];
+            if (Array.isArray(guardian))
+                refEarlierCopiesIn(guardian, state, "codex.compacted.guardian_history.copy_of_response_item", edits, 0);
+            return;
+        }
+        case "token_usage_record":
+            emptyPayload(record, payload, "codex.token_usage_record", edits);
+            return;
+        case "event_msg":
+            slimEvent(payload, state, edits);
+            return;
+        default:
+            return;
+    }
+}
+function slimEvent(payload, state, edits) {
+    switch (payload["type"]) {
+        case "token_count": {
+            const info = payload["info"];
+            if (isJsonObject(info))
+                stripKey(info, "last_token_usage", "codex.token_count.last_token_usage", edits);
+            stripKey(payload, "rate_limits", "codex.token_count.rate_limits", edits);
+            return;
+        }
+        case "thread_settings_applied":
+            keepOnlyServiceTier(payload, edits);
+            return;
+        case "task_complete":
+            refIfEarlierCopy(payload, "last_agent_message", state, "codex.task_complete.last_agent_message", edits);
+            return;
+        case "item_completed":
+            slimFinishedItem(payload["item"], state, edits);
+            return;
+        default:
+            return;
+    }
+}
+function slimFinishedItem(item, state, edits) {
+    if (!isJsonObject(item))
+        return;
+    const type = item["type"];
+    if (type === "CommandExecution") {
+        stripKey(item, "formatted_output", "codex.item.command.formatted_output", edits);
+        stripKey(item, "parsed_cmd", "codex.item.command.parsed_cmd", edits);
+        const stdout = item["stdout"];
+        if (typeof stdout === "string" && stdout.length >= SLIM_COPY_MIN_CHARS && stdout === item["aggregated_output"]) {
+            stripKey(item, "stdout", "codex.item.command.stdout", edits);
+        }
+        return;
+    }
+    if (typeof type === "string" && ITEM_TYPES_THAT_REPEAT.has(type)) {
+        refEarlierCopiesIn(item, state, `codex.item.${type}.copy_of_response_item`, edits, 0);
+    }
+}
+/** The payload emptied, once. */
+function emptyPayload(record, payload, rule, edits) {
+    if (Object.keys(payload).length === 0)
+        return;
+    edits.strip(rule, canonicalText(payload).length);
+    record["payload"] = {};
+}
+function keepOnlyServiceTier(payload, edits) {
+    const settings = payload["thread_settings"];
+    if (!isJsonObject(settings))
+        return;
+    const others = Object.keys(settings).filter((key) => key !== "service_tier");
+    if (others.length === 0)
+        return;
+    edits.strip("codex.thread_settings_applied", canonicalText(settings).length);
+    payload["thread_settings"] = settings["service_tier"] === undefined ? {} : { service_tier: settings["service_tier"] };
+}
+/** Walks a `response_item` payload and remembers each long string (reasoning ciphertext excluded). */
+function rememberLongStrings(value, state, depth) {
+    if (depth > 8 || state.earlierStrings.size >= MAX_REMEMBERED_STRINGS)
+        return;
+    if (typeof value === "string") {
+        if (value.length >= SLIM_COPY_MIN_CHARS)
+            state.earlierStrings.add(contentHash(value));
+    }
+    else if (Array.isArray(value)) {
+        for (const item of value)
+            rememberLongStrings(item, state, depth + 1);
+    }
+    else if (isJsonObject(value)) {
+        for (const [key, item] of Object.entries(value)) {
+            if (key !== "encrypted_content")
+                rememberLongStrings(item, state, depth + 1);
+        }
+    }
+}
+function refIfEarlierCopy(holder, key, state, rule, edits) {
+    const value = holder[key];
+    if (typeof value !== "string" || value.length < SLIM_COPY_MIN_CHARS)
+        return;
+    const hash = contentHash(value);
+    if (!state.earlierStrings.has(hash))
+        return;
+    holder[key] = slimRefFor(hash);
+    edits.strip(rule, value.length);
+}
+/** Every long string in `node` that an earlier `response_item` already held becomes a reference. */
+function refEarlierCopiesIn(node, state, rule, edits, depth) {
+    if (depth > 8)
+        return;
+    const keys = Array.isArray(node) ? node.map((_, index) => index) : Object.keys(node);
+    for (const key of keys) {
+        const holder = node;
+        const child = holder[key];
+        if (typeof child === "string") {
+            if (child.length >= SLIM_COPY_MIN_CHARS && state.earlierStrings.has(contentHash(child))) {
+                holder[key] = slimRefFor(contentHash(child));
+                edits.strip(rule, child.length);
+            }
+        }
+        else if ((Array.isArray(child) || isJsonObject(child)) && !isSlimRef(child)) {
+            refEarlierCopiesIn(child, state, rule, edits, depth + 1);
+        }
+    }
+}

package/dist/slim/slim-support.js

@@ -0,0 +1,90 @@
+/**
+ * Shared pieces of the slim transcript (BLI-16977): what a rule records, how a repeated block is
+ * swapped for a short reference, and the few JSON helpers every rule uses.
+ *
+ * The slim transcript is built one line at a time, in order, and each line may depend only on the
+ * lines before it and itself. That is the whole contract: it is why a growing transcript's slim
+ * form extends its earlier slim form byte for byte (the BLI-11088 prefix rule), and why the same
+ * code can slim a 700 MB file without holding it in memory.
+ *
+ * Nothing here reads a file, the network or the environment. Rules record sizes and rule names,
+ * never content.
+ */
+import { createHash } from "node:crypto";
+/** A block shorter than this is never worth swapping for a reference (the reference is about 40 characters). */
+export const SLIM_REF_MIN_CHARS = 300;
+/** A string shorter than this is not looked up against earlier copies. */
+export const SLIM_COPY_MIN_CHARS = 80;
+export function isJsonObject(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+export function isSlimRef(value) {
+    return isJsonObject(value) && typeof value["slim_ref"] === "string" && Object.keys(value).length === 1;
+}
+/** `sha256:` plus the first 16 hex characters of the sha256 of the value's text (a string as it is, anything else as compact JSON). */
+export function contentHash(canonicalText) {
+    return createHash("sha256").update(canonicalText).digest("hex").slice(0, 16);
+}
+export function slimRefFor(hash) {
+    return { slim_ref: `sha256:${hash}` };
+}
+/** The text a value is hashed and measured by. */
+export function canonicalText(value) {
+    if (typeof value === "string")
+        return value;
+    return JSON.stringify(value) ?? "";
+}
+/** What one line lost, by rule, in characters. A line with no entries was not touched. */
+export class LineEdits {
+    charsByRule = new Map();
+    strip(rule, chars) {
+        this.charsByRule.set(rule, (this.charsByRule.get(rule) ?? 0) + chars);
+    }
+    get rules() {
+        return [...this.charsByRule.keys()];
+    }
+    get entries() {
+        return this.charsByRule.entries();
+    }
+    get isEmpty() {
+        return this.charsByRule.size === 0;
+    }
+}
+/** Remove `key` from `holder`, recording the rule and the characters it held. */
+export function stripKey(holder, key, rule, edits) {
+    if (!(key in holder))
+        return false;
+    edits.strip(rule, canonicalText(holder[key]).length);
+    delete holder[key];
+    return true;
+}
+/**
+ * The one copy per transcript. The first time a block is seen it stays in the line; every time
+ * after, the block is replaced by `{"slim_ref":"sha256:<16 hex>"}` naming the earlier copy. The
+ * hash is of the block's text (a string as it is, anything else as compact JSON).
+ */
+export class SeenBlocks {
+    hashes = new Set();
+    /** True when this block was seen before in the transcript; remembers it otherwise. */
+    seenBefore(hash) {
+        if (this.hashes.has(hash))
+            return true;
+        this.hashes.add(hash);
+        return false;
+    }
+    /** Swap `holder[key]` for a reference when an identical block came earlier. */
+    dedupeKey(holder, key, rule, edits) {
+        const value = holder[key];
+        if (value === undefined || isSlimRef(value))
+            return;
+        const text = canonicalText(value);
+        if (text.length < SLIM_REF_MIN_CHARS)
+            return;
+        const hash = contentHash(text);
+        if (!this.seenBefore(hash))
+            return;
+        const ref = slimRefFor(hash);
+        holder[key] = ref;
+        edits.strip(rule, Math.max(0, text.length - JSON.stringify(ref).length));
+    }
+}

package/dist/slim/slim-transcript.js

@@ -0,0 +1,133 @@
+/**
+ * The slim transcript (BLI-16977): the transcript the collector uploads when
+ * `IMAGE_HANDLING_MODE` in telemetry-core is `describe_and_drop`. Images are already markers by the
+ * time this runs; this strips the duplicate copies and the bookkeeping that remain.
+ *
+ * The contract, in the order Edward and the skeptic pass set it:
+ *
+ *  1. ONE OUTPUT LINE PER INPUT LINE, same order. Tower counts lines and reads every line's
+ *     timestamp, so a line is never dropped; its payload is. A blank line, a line that is not JSON,
+ *     and a JSON value that is not an object are emitted as they came.
+ *  2. A LINE NO RULE TOUCHES IS EMITTED AS ITS ORIGINAL TEXT, never re-serialised. Only a modified
+ *     line is re-written, and it gains a compact top-level `"_slim":["rule", ...]` naming what was
+ *     stripped, so a reader can tell.
+ *  3. PREFIX STABLE. A line's slim form depends only on that line and the lines before it (no
+ *     look-ahead, no global pass). So the slim form of a growing transcript extends the slim form
+ *     of the shorter one byte for byte, and the BLI-11088 prefix supersede rule keeps working.
+ *     The one honest exception is a last line still being written: a half-written JSON line is
+ *     emitted as it is and becomes a slim line once it is whole.
+ *  4. NEVER FAIL A TRANSCRIPT. A line whose rules throw is emitted as it came and counted; any other
+ *     failure hands back the text it was given (`slimOrKeep`) and says why.
+ *
+ * What each rule keeps and drops: claude-rules.ts and codex-rules.ts. The table for people:
+ * docs/architecture/image-descriptions.md.
+ */
+import { newClaudeSlimState, slimClaudeRecord } from "./claude-rules.js";
+import { newCodexSlimState, slimCodexRecord } from "./codex-rules.js";
+import { LineEdits, SeenBlocks, isJsonObject } from "./slim-support.js";
+/** The text an image marker starts with; a line carrying one is a modified line (an image became a marker). */
+const IMAGE_MARKER_START = "[image sha256:";
+export function createSlimmer(kind, rulesForTests) {
+    const seen = new SeenBlocks();
+    const claude = newClaudeSlimState();
+    const codex = newCodexSlimState();
+    const stats = {
+        lines: 0, linesModified: 0, linesFailed: 0, bytesBefore: 0, bytesAfter: 0, charsByRule: {}, linesByRule: {},
+    };
+    const applyRules = rulesForTests ?? ((record, edits) => {
+        if (kind === "claude_code")
+            slimClaudeRecord(record, claude, seen, edits);
+        else
+            slimCodexRecord(record, codex, seen, edits);
+    });
+    return {
+        slimLine(line) {
+            stats.lines += 1;
+            const before = Buffer.byteLength(line);
+            stats.bytesBefore += before;
+            let out = line;
+            try {
+                out = slimOneLine(line, applyRules, stats);
+            }
+            catch {
+                stats.linesFailed += 1;
+                out = line;
+            }
+            stats.bytesAfter += out === line ? before : Buffer.byteLength(out);
+            return out;
+        },
+        stats: () => stats,
+    };
+}
+function slimOneLine(line, applyRules, stats) {
+    const body = line.endsWith("\r") ? line.slice(0, -1) : line;
+    const first = body.trimStart().charCodeAt(0);
+    if (first !== 0x7b /* { */)
+        return line;
+    let record;
+    try {
+        record = JSON.parse(body);
+    }
+    catch {
+        return line;
+    }
+    if (!isJsonObject(record))
+        return line;
+    const edits = new LineEdits();
+    applyRules(record, edits);
+    const rules = edits.rules;
+    if (line.includes(IMAGE_MARKER_START))
+        rules.push("images");
+    const already = Array.isArray(record["_slim"]) ? record["_slim"] : [];
+    const fresh = rules.filter((rule) => !already.includes(rule));
+    if (fresh.length === 0)
+        return line;
+    record["_slim"] = [...already, ...fresh];
+    for (const [rule, chars] of edits.entries) {
+        stats.charsByRule[rule] = (stats.charsByRule[rule] ?? 0) + chars;
+        stats.linesByRule[rule] = (stats.linesByRule[rule] ?? 0) + 1;
+    }
+    if (fresh.includes("images"))
+        stats.linesByRule["images"] = (stats.linesByRule["images"] ?? 0) + 1;
+    stats.linesModified += 1;
+    return JSON.stringify(record) + (line.endsWith("\r") ? "\r" : "");
+}
+/** The slim form of a whole transcript's text, line for line. */
+export function slimTranscript(text, kind) {
+    const slimmer = createSlimmer(kind);
+    const lines = text.split("\n");
+    const out = new Array(lines.length);
+    for (let index = 0; index < lines.length; index += 1)
+        out[index] = slimmer.slimLine(lines[index]);
+    const stats = slimmer.stats();
+    return { text: stats.linesModified === 0 ? text : out.join("\n"), stats };
+}
+const TAG = "[slim-transcript]";
+/**
+ * `slimTranscript` that can never fail a transcript: any exception returns the text it was given and
+ * logs the reason. Metadata only: counts, sizes, rule names. Never a line, never a field value.
+ */
+export function slimOrKeep(text, kind, label) {
+    const startedAt = Date.now();
+    try {
+        const slim = slimTranscript(text, kind);
+        const stats = slim.stats;
+        console.error(TAG + (stats.linesModified === 0 ? " nothing to strip" : " transcript slimmed"), JSON.stringify({
+            source: kind,
+            session_id: label.sessionId.slice(0, 80),
+            lines: stats.lines,
+            lines_modified: stats.linesModified,
+            lines_failed: stats.linesFailed,
+            bytes_before: stats.bytesBefore,
+            bytes_after: stats.bytesAfter,
+            chars_by_rule: stats.charsByRule,
+            lines_by_rule: stats.linesByRule,
+            elapsed_ms: Date.now() - startedAt,
+        }));
+        return { text: slim.text, stats };
+    }
+    catch (error) {
+        console.error(TAG + " failed, uploading the transcript as it was", JSON.stringify({ reason: "slim_failed", source: kind, error_name: error instanceof Error ? error.name : typeof error, bytes: typeof text === "string" ? text.length : 0 }));
+        return { text, stats: null };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.205",
+  "version": "0.2.207",
   "private": false,
   "type": "module",
   "bin": {
@@ -27,9 +27,9 @@
     "test": "node dist/cli.js --help && node ../../scripts/assert-public-cli-routing.mjs && node ../../scripts/assert-public-cli-verb-help.mjs && node ../../scripts/assert-public-cli-surface-doors.mjs && node ../../scripts/assert-public-cli-runtime-files.mjs && node ../../scripts/assert-public-cli-exit-contract.mjs && node ../../scripts/assert-public-cli-no-fleet-posts.mjs && node ../../scripts/assert-public-cli-doctor-json.mjs && node ../../scripts/assert-public-package-pack.mjs --workspace=@bli-cockpit/cli"
   },
   "dependencies": {
-    "@bli-cockpit/memory-mcp": "0.1.62",
-    "@bli-cockpit/mcp": "0.1.117",
-    "@bli-cockpit/telemetry-core": "0.1.71"
+    "@bli-cockpit/memory-mcp": "0.1.63",
+    "@bli-cockpit/mcp": "0.1.118",
+    "@bli-cockpit/telemetry-core": "0.1.72"
   },
   "repository": {
     "type": "git",