@bli-cockpit/cli 0.2.268 → 0.2.270

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

package/dist/evidence-upload-direct.js

@@ -1,11 +1,11 @@
-import { encodeEvidenceBytes } from "@bli-cockpit/telemetry-core/evidence-storage-encoding";
+import { encodeChunkForStorage } from "./evidence-upload-encoding.js";
 import { fetchWithDeadline, isUploadDeadlineError, uploadDeadlineMs } from "./evidence-upload-deadline.js";
 import { noteSyncProgress } from "./sync-lock.js";
-export async function putSignedChunk(options, signedUrl, bytes, uploadId, index) {
-    // Identical manifest + gzip framing to the server chunk route staging write.
-    const encoded = encodeEvidenceBytes(bytes);
+export async function putSignedChunk(options, signedUrl, bytes, uploadId, index, codec = "gzip") {
+    // Identical manifest + codec framing to the server chunk route staging write (gzip unless the server listed more).
+    const encoded = encodeChunkForStorage(bytes, codec);
     console.error("[evidence-upload] chunk encoded for storage", JSON.stringify({
-        upload_id: uploadId, chunk_index: index, chunk_encoding: "gzip",
+        upload_id: uploadId, chunk_index: index, chunk_encoding: codec,
         bytes_before: bytes.length, bytes_after: encoded.length,
     }));
     const deadlineMs = uploadDeadlineMs(encoded.length);

package/dist/evidence-upload-encoding.js

@@ -0,0 +1,23 @@
+import { EVIDENCE_CODEC_PREFERENCE, EVIDENCE_MANIFESTS, compressEvidenceBytes, zstdAvailable, } from "@bli-cockpit/telemetry-core/evidence-storage-encoding";
+/** What this Node can write, most preferred first. Sent on `begin`. */
+export function localEncodings(zstd = zstdAvailable()) {
+    return EVIDENCE_CODEC_PREFERENCE.filter(codec => codec !== "zstd" || zstd);
+}
+/**
+ * zstd when this Node has it and the server lists it, else brotli when listed, else gzip.
+ * A reply with no list (an old server) means gzip, which every server has always decoded.
+ */
+export function chooseUploadEncoding(accepted, zstd = zstdAvailable()) {
+    if (!accepted || accepted.length === 0)
+        return { codec: "gzip", reason: "server_did_not_advertise" };
+    if (accepted.includes("zstd") && zstd)
+        return { codec: "zstd", reason: "server_accepts_zstd" };
+    if (accepted.includes("br")) {
+        return { codec: "br", reason: accepted.includes("zstd") ? "node_without_zstd" : "server_accepts_brotli_only" };
+    }
+    return { codec: "gzip", reason: accepted.includes("zstd") ? "node_without_zstd" : "server_did_not_advertise" };
+}
+/** The bytes the server stages for one chunk: the codec's manifest, then its stream. */
+export function encodeChunkForStorage(bytes, codec) {
+    return Buffer.concat([EVIDENCE_MANIFESTS[codec], compressEvidenceBytes(bytes, codec)]);
+}

package/dist/evidence-upload-object.js

@@ -1,5 +1,6 @@
 import { putSignedChunk } from "./evidence-upload-direct.js";
-import { gzipSync } from "node:zlib";
+import { compressEvidenceBytes } from "@bli-cockpit/telemetry-core/evidence-storage-encoding";
+import { chooseUploadEncoding } from "./evidence-upload-encoding.js";
 import { COMMIT_CRASHED_PLATFORM, RawEvidenceUploadCommitResponseSchema, isPermanentUploadFailure, } from "@bli-cockpit/telemetry-core";
 import { StagedFileError, readVerifiedChunk } from "./evidence-upload-staged.js";
 import { beginOneObject } from "./evidence-upload-terminal.js";
@@ -41,6 +42,12 @@ async function uploadObjectChunks(options, entry, disposition, chunkSizeBytes, o
     if (disposition.disposition === "already_committed" || disposition.commit_ready) {
         return { ok: true, uploadedChunks };
     }
+    // BLI-23334: the server listed what it decodes; an older one lists nothing and gets gzip.
+    const encoding = chooseUploadEncoding(disposition.accepted_encodings);
+    console.error("[evidence-upload] encoding chosen", JSON.stringify({
+        upload_id: disposition.upload_id, chunk_encoding: encoding.codec, reason: encoding.reason,
+        server_listed: disposition.accepted_encodings?.join(",") ?? "none",
+    }));
     for (let index = 0; index < entry.chunkCount; index += 1) {
         if (received.has(index))
             continue;
@@ -60,7 +67,7 @@ async function uploadObjectChunks(options, entry, disposition, chunkSizeBytes, o
         }
         const offer = disposition.signed_uploads?.find(upload => upload.chunk_index === index);
         const direct = offer
-            ? await putSignedChunk(options, offer.signed_url, chunk, disposition.upload_id, index)
+            ? await putSignedChunk(options, offer.signed_url, chunk, disposition.upload_id, index, encoding.codec)
             : "refused";
         if (direct === "deadline") {
             // BLI-22801: the chunk route would push the same bytes over the same slow link.
@@ -75,26 +82,26 @@ async function uploadObjectChunks(options, entry, disposition, chunkSizeBytes, o
             uploadedChunks += 1;
             continue;
         }
-        const failure = await uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, Boolean(offer));
+        const failure = await uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, Boolean(offer), encoding.codec);
         if (failure)
             return failure;
         uploadedChunks += 1;
     }
     return { ok: true, uploadedChunks };
 }
-async function uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, hadSignedOffer) {
+async function uploadChunkThroughEndpoint(options, entry, disposition, objectKey, index, chunk, uploadedChunks, hadSignedOffer, codec) {
     console.error("[evidence-upload] using chunk route", JSON.stringify({
         reason: hadSignedOffer ? "signed_upload_refused_fallback" : "signed_upload_not_offered",
         upload_id: disposition.upload_id, chunk_index: index,
     }));
-    const encodedChunk = gzipSync(chunk);
+    const encodedChunk = compressEvidenceBytes(chunk, codec);
     console.error("[evidence-upload] chunk encoded", JSON.stringify({
-        upload_id: disposition.upload_id, chunk_index: index, chunk_encoding: "gzip",
+        upload_id: disposition.upload_id, chunk_index: index, chunk_encoding: codec,
         bytes_before: chunk.length, bytes_after: encodedChunk.length,
     }));
     const chunkResponse = await requestJson(options, "/api/ambient/evidence/upload/chunk", {
         schema_version: "ambient-raw-evidence-upload-chunk.v2",
-        encoding: "gzip",
+        encoding: codec,
         generated_at: options.generatedAt,
         provenance: options.provenance,
         upload_id: disposition.upload_id,

package/dist/evidence-upload-plan.js

@@ -243,6 +243,7 @@ export function readBeginDispositions(body) {
             signed_uploads: entry.signed_uploads,
             reason: entry.reason ?? null,
             raw_evidence_pointer_id: entry.raw_evidence_pointer_id,
+            ...(entry.accepted_encodings ? { accepted_encodings: entry.accepted_encodings } : {}),
         });
     }
     return map;

package/dist/evidence-upload-transport.js

@@ -1,4 +1,6 @@
 import crypto from "node:crypto";
+import { EVIDENCE_CODECS_HEADER } from "@bli-cockpit/telemetry-core";
+import { localEncodings } from "./evidence-upload-encoding.js";
 import { describeError } from "./health-detail.js";
 import { fetchWithDeadline, isUploadDeadlineError, uploadDeadlineMs } from "./evidence-upload-deadline.js";
 import { noteSyncProgress } from "./sync-lock.js";
@@ -26,7 +28,7 @@ export async function requestJson(options, routePath, body) {
                     "Authorization": `Bearer ${options.deviceToken}`,
                     "Content-Type": "application/json",
                     ...(routePath.endsWith("/evidence/upload/begin")
-                        ? { "x-tower-evidence-direct": "staged-gzip-v1" } : {}),
+                        ? { "x-tower-evidence-direct": "staged-gzip-v1", [EVIDENCE_CODECS_HEADER]: localEncodings().join(",") } : {}),
                 },
                 body: serialized,
             }, deadlineMs);

package/dist/slim/claude-rules.js

@@ -14,17 +14,19 @@
  *    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).
+ *  - A thinking block's encrypted `signature`, replaced by a marker with its length (BLI-23334).
  *
  * 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";
+import { dropCiphertext, 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);
+    dropThinkingSignatures(record["message"], edits);
     switch (record["type"]) {
         case "assistant": {
             rememberToolInputs(record, state.toolInputs);
@@ -45,4 +47,20 @@ export function slimClaudeRecord(record, state, seen, edits) {
         default:
             return;
     }
+}
+/**
+ * BLI-23334: a thinking block's `signature` is a base64 blob Anthropic signs the block with; it
+ * compresses to about 75 percent and nothing in Tower reads it. The block, its `thinking` text and
+ * every other key stay. Assistant lines and `api-request-blob` lines carry the same blocks, so the
+ * rule keys on `message.content[]`, not on the line type. `redacted_thinking.data` is not touched:
+ * that block has no readable text, its data is all it is.
+ */
+function dropThinkingSignatures(message, edits) {
+    if (!isJsonObject(message) || !Array.isArray(message["content"]))
+        return;
+    for (const block of message["content"]) {
+        if (isJsonObject(block) && block["type"] === "thinking") {
+            dropCiphertext(block, "signature", "claude.thinking.signature", edits);
+        }
+    }
 }

package/dist/slim/codex-rules.js

@@ -8,7 +8,20 @@
  * Guardian history and task_complete messages deduplicate only against earlier
  * response items; a copy appearing first is retained.
  */
-import { SLIM_COPY_MIN_CHARS, canonicalText, contentHash, isJsonObject, isSlimRef, slimRefFor, stripKey, } from "./slim-support.js";
+import { SLIM_COPY_MIN_CHARS, canonicalText, contentHash, dropCiphertext, isJsonObject, isSlimRef, slimRefFor, stripKey, } from "./slim-support.js";
+/**
+ * BLI-23334: `encrypted_content` on a reasoning or compaction item is ciphertext only OpenAI can
+ * read (it compresses to about 75 percent). It becomes a marker with its length; the item and its
+ * readable `summary` stay. Exactly two places carry it: a `response_item` payload of those types,
+ * and the same item types inside a `compacted` line's `replacement_history`. No other key and no
+ * other item type is touched, so nothing outside this contract can lose a field.
+ */
+const CIPHERTEXT_ITEM_TYPES = new Set(["reasoning", "compaction"]);
+function dropItemCiphertext(item, edits) {
+    if (isJsonObject(item) && typeof item["type"] === "string" && CIPHERTEXT_ITEM_TYPES.has(item["type"])) {
+        dropCiphertext(item, "encrypted_content", "codex.encrypted_content", edits);
+    }
+}
 /** 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`. */
@@ -23,6 +36,7 @@ export function slimCodexRecord(record, state, seen, edits) {
     switch (record["type"]) {
         case "response_item":
             rememberLongStrings(payload, state, 0);
+            dropItemCiphertext(payload, edits);
             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);
@@ -39,6 +53,10 @@ export function slimCodexRecord(record, state, seen, edits) {
             return;
         }
         case "compacted": {
+            const history = payload["replacement_history"];
+            if (Array.isArray(history))
+                for (const item of history)
+                    dropItemCiphertext(item, edits);
             // 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))

package/dist/slim/slim-support.js

@@ -58,6 +58,28 @@ export function stripKey(holder, key, rule, edits) {
     delete holder[key];
     return true;
 }
+/** What an encrypted value becomes (BLI-23334): `[encrypted signature dropped, 1624 chars]`. Idempotent, prefix-stable. */
+const CIPHERTEXT_MARKER_START = "[encrypted signature dropped, ";
+export function ciphertextMarker(chars) {
+    return `${CIPHERTEXT_MARKER_START}${chars} chars]`;
+}
+/**
+ * Replace `holder[key]`, an opaque encrypted string nothing downstream can read (a Claude thinking
+ * `signature`, a Codex `encrypted_content`), with a marker that keeps its length. The surrounding
+ * block and its readable text are never touched. Shorter than its own marker, or already a marker,
+ * means no change.
+ */
+export function dropCiphertext(holder, key, rule, edits) {
+    const value = holder[key];
+    if (typeof value !== "string" || value.startsWith(CIPHERTEXT_MARKER_START))
+        return false;
+    const marker = ciphertextMarker(value.length);
+    if (value.length <= marker.length)
+        return false;
+    holder[key] = marker;
+    edits.strip(rule, value.length - marker.length);
+    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

package/dist/slim/slim-transcript.js

@@ -36,7 +36,7 @@ import { LineEdits, SeenBlocks, isJsonObject } from "./slim-support.js";
  * once, which is intended: the stored bytes are no longer what the new rules would produce.
  * `slim-rules-version.test.ts` fails when a rule changes without this moving.
  */
-export const SLIM_RULES_VERSION = "slim-rules.v1";
+export const SLIM_RULES_VERSION = "slim-rules.v2";
 /** 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) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@bli-cockpit/cli",
-  "version": "0.2.268",
+  "version": "0.2.270",
   "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.79",
-    "@bli-cockpit/mcp": "0.1.163",
-    "@bli-cockpit/telemetry-core": "0.1.86"
+    "@bli-cockpit/memory-mcp": "0.1.81",
+    "@bli-cockpit/mcp": "0.1.165",
+    "@bli-cockpit/telemetry-core": "0.1.88"
   },
   "repository": {
     "type": "git",