@bli-cockpit/cli 0.2.204 → 0.2.206

package/dist/image-description-state.js

@@ -0,0 +1,44 @@
+/**
+ * Which images this machine has already sent to the describe door (BLI-16977).
+ *
+ * One small file in the collector state directory. It is how "each distinct image is sent once"
+ * survives from one 15-minute sync to the next. A key is the first 32 hex characters of the
+ * image's sha256 (128 bits: no two images on one laptop will ever share one); the file holds keys
+ * only, never a description, never a path, never a byte. If it is lost or corrupt the worst case
+ * is the images are sent again and the server answers "known" without calling a model.
+ */
+import path from "node:path";
+import { isMissingFileFailure } from "./health-detail.js";
+import { readJsonFile, writeJsonFile } from "./local-state-files.js";
+export const IMAGE_DESCRIPTION_STATE_FILENAME = "image-descriptions.json";
+/** Oldest keys leave first past this many (about 5 MB on disk). */
+export const IMAGE_DESCRIPTION_STATE_MAX_KEYS = 150_000;
+const KEY_CHARS = 32;
+export function imageStateKey(sha256) {
+    return sha256.slice(0, KEY_CHARS);
+}
+export function imageDescriptionStatePath(stateDir) {
+    return path.join(stateDir, IMAGE_DESCRIPTION_STATE_FILENAME);
+}
+/** The keys already described, oldest first. A missing or unreadable file is an empty list, said out loud when unreadable. */
+export async function readDescribedImageKeys(stateDir) {
+    try {
+        const raw = (await readJsonFile(imageDescriptionStatePath(stateDir)));
+        if (!Array.isArray(raw?.described))
+            return [];
+        return raw.described.filter((key) => typeof key === "string" && key.length === KEY_CHARS);
+    }
+    catch (error) {
+        if (!isMissingFileFailure(error)) {
+            console.error("[image-descriptions] state file unreadable, starting from an empty list", JSON.stringify({ reason: "image_state_unreadable" }));
+        }
+        return [];
+    }
+}
+export async function writeDescribedImageKeys(stateDir, keys) {
+    const kept = keys.length > IMAGE_DESCRIPTION_STATE_MAX_KEYS ? keys.slice(keys.length - IMAGE_DESCRIPTION_STATE_MAX_KEYS) : keys;
+    await writeJsonFile(imageDescriptionStatePath(stateDir), {
+        schema_version: "cockpit-image-descriptions.v1",
+        described: kept,
+    });
+}

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));
+    }
+}