chainlesschain 0.166.114 → 0.166.117

package/src/data/changelog.json

@@ -1,6 +1,32 @@
 {
   "source": "CHANGELOG.md",
   "releases": [
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.117",
+      "cliVersions": ["0.166.117"],
+      "date": "2026-10-23",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.117: code literals at Evolution ingress and completed tool recovery (2026-10-23)",
+          "body": "- Recognize Python and JavaScript literals in `run_code` source and results without treating ordinary code as malformed JSON. Continue decoding quoted sensitive keys and values for redaction.\n- Keep genuine JSON validation, duplicate-key rejection, numeric limits and projection budgets; distinguish malformed JSON errors from actual JSON budget failures.\n- Preserve historical Agent projection rulesets while using a new versioned code-text policy for new requests.\n- Coordinate the bounded Agent projection and decoded-JSON node budgets with model-request capacity, and trigger canonical compaction on text byte pressure before the ingress ceiling is reached.\n- Account for image transport separately from text: retain the existing eight-image / 20 MiB message allowance, bound historical request images, and commit image digests in small evidence and context-planning records. Estimate vision tokens separately from base64 bytes.\n- Preview oversized tool results as complete JSON trees and omit incomplete host-created excerpts, retaining status fields, pagination cursors and duplicate-output recovery guards.\n- Settle completed tool rounds before terminating an Agent Run on Evolution ingress failure, retaining verified session prefix checks and removing unanswered calls from replay.\n- Preserve completed rounds on caller cancellation, session-budget exhaustion, unknown compaction usage and independent runtime-ledger failure.\n- Persist large image context bundles as private references bound to the current saved-session generation; verify bytes on restart and clean them up with session deletion. Unsaved sessions do not create persistent image bundles.\n- Publish CLI first; follow with IDE releases recommending CLI 0.166.117 after public npm readback.\n- Align Session Core 0.3.22 and Personal Data Hub 0.4.66 with their changed source trees before publishing the CLI. Candidate 0.166.116 was not published; its immutable tag remains unchanged."
+        }
+      ]
+    },
+    {
+      "productVersion": null,
+      "cliVersion": "0.166.115",
+      "cliVersions": ["0.166.115"],
+      "date": "2026-10-22",
+      "title": "",
+      "sections": [
+        {
+          "heading": "Fixed - cc CLI 0.166.115: JSON-compatible Agent tool evidence (published, 2026-10-22)",
+          "body": "- Resolve built-in tool descriptor categories from their telemetry metadata and use explicit null for missing optional descriptor values, so successful Git and shell tools do not terminate the Agent's signed Evolution ingress.\n- Omit absent slash-command descriptions, warnings and non-persistent code script paths; represent unknown process exit codes as null. Preserve strict evidence validation.\n- Omit unavailable ranges from repeated-file read recovery and represent missing cell IDs from legacy notebooks as null, keeping successful file tools compatible with signed evidence.\n- Encode new local signing tenant, run and evidence IDs without digits while preserving their entropy, preventing accidental payment-card matches during first use. Retain existing deployment identities and sensitive-content scanning.\n- Prepare VS Code 0.37.157 and JetBrains 0.4.174 to recommend CLI 0.166.115 after exact-source gates and public npm verification."
+        }
+      ]
+    },
     {
       "productVersion": null,
       "cliVersion": "0.166.114",
@@ -9,8 +35,8 @@
       "title": "",
       "sections": [
         {
-          "heading": "Fixed - cc CLI 0.166.114: Quick Ask streaming and local Evolution setup (candidate, 2026-10-22)",
-          "body": "- Surface provider waiting status, credential errors, and terminal streaming failures in Quick Ask; bound governed chat initialization and completion to 60 seconds and support cancellation of active requests.\n- Migrate a supported signed UI-only local Evolution host to admit `agent`, `ask`, `chat`, and `ui`, retaining its signing identity and detecting concurrent profile changes.\n- Prepare VS Code 0.37.156 and JetBrains 0.4.173 to recommend CLI 0.166.114. These versions are unreleased candidates; publication still requires the exact release commit's GitHub Actions gates, OIDC npm publication and public readback before IDE publication."
+          "heading": "Fixed - cc CLI 0.166.114: Quick Ask streaming and local Evolution setup (published, 2026-10-22)",
+          "body": "- Surface provider waiting status, credential errors, and terminal streaming failures in Quick Ask; bound governed chat initialization and completion to 60 seconds and support cancellation of active requests.\n- Migrate a supported signed UI-only local Evolution host to admit `agent`, `ask`, `chat`, and `ui`, retaining its signing identity and detecting concurrent profile changes.\n- CLI 0.166.114 and Open VSX 0.37.156 were published with verified public archives. JetBrains 0.4.173 upload succeeded before cancellation; its public download was not verified. A subsequently reported Agent tool-evidence JSON error is addressed in the .115 candidate."
         }
       ]
     },

package/src/harness/jsonl-session-store.js

@@ -71,6 +71,7 @@ import {
 } from "./session-list-index.js";
 import { createSessionPersistenceFailure } from "../lib/session-persistence-failure.js";
 import { withSessionHostWriteAuthority } from "../lib/session-host-lease.js";
+import { withSessionMessageBundleDeletion } from "../lib/context-memory-kernel/message-bundle-store.js";
 import { createSessionTranscriptStructureProjection } from "../lib/session-transcript-structure.js";
 import {
   TOOL_ROUND_EVENT,
@@ -6240,18 +6241,20 @@ export function deleteJsonlSession(sessionId) {
               Number(existingMeta.updated_at_ms) ||
               Date.now(),
           ) || Date.now();
-        const tombstone = recordSessionDeleted(
-          getSessionsDir(),
-          sessionId,
-          timestamp,
-        );
-        publishSessionAntiRollbackWitness(
-          sessionId,
-          tombstone,
-          filePath,
-          "deleted",
-        );
-        return externalAnchor?.status !== "deleted";
+        return withSessionMessageBundleDeletion(sessionId, () => {
+          const tombstone = recordSessionDeleted(
+            getSessionsDir(),
+            sessionId,
+            timestamp,
+          );
+          publishSessionAntiRollbackWitness(
+            sessionId,
+            tombstone,
+            filePath,
+            "deleted",
+          );
+          return externalAnchor?.status !== "deleted";
+        });
       }
       if (!transcriptExists && existingMeta === null) {
         return false;
@@ -6276,70 +6279,72 @@ export function deleteJsonlSession(sessionId) {
         rebuildSessionMetaUnlocked(getSessionsDir(), sessionId, filePath);
         existingMeta = readSessionPersistenceWitness(sessionId);
       }
-      if (deletionWitness === null) {
-        assertSessionAntiRollbackBeforeWrite(
-          sessionId,
-          existingMeta,
-          filePath,
-          "live",
-        );
-      } else if (existingMeta?.deleted !== true) {
-        existingMeta = replaceSessionMeta(getSessionsDir(), {
-          ...emptySessionMeta(sessionId),
-          id: sessionId,
-          generation: deletionWitness.generation || null,
-          last_hash: deletionWitness.last_hash || null,
-          event_count: Math.max(0, Number(deletionWitness.event_count) || 0),
-          updated_at_ms: Math.max(
-            0,
-            Number(deletionWitness.deleted_at_ms) || Date.now(),
-          ),
-          deleted_at_ms: Math.max(
-            0,
-            Number(deletionWitness.deleted_at_ms) || Date.now(),
-          ),
-          deleted: true,
-          transcript: null,
-        });
-      }
-      if (transcriptExists) rmSync(filePath, { force: true });
-      // The external tombstone is published only after the absent transcript
-      // directory entry is durable. A retry after an interrupted unlink must
-      // repeat this barrier even though the path is already absent in memory.
-      fsyncParentDirectory(
-        filePath,
-        Object.freeze({ sessionId, filePath, operation: "delete" }),
-        "beforeDeleteDirectoryFsync",
-        "afterDeleteDirectoryFsync",
-      );
-      try {
-        const tombstone = recordSessionDeleted(getSessionsDir(), sessionId);
-        publishSessionAntiRollbackWitness(
-          sessionId,
-          tombstone,
-          filePath,
-          "deleted",
-        );
-      } catch (error) {
-        // A complete anti-rollback record is readable before its fsync. If
-        // rollback also fails, readback alone cannot prove durability. Only
-        // swallow a post-meta failure after an exact replay has settled the
-        // deleted record through the production persistence path.
-        const tombstone = readSessionMeta(getSessionsDir(), sessionId);
-        if (
-          tombstone?.deleted !== true ||
-          readSessionAntiRollbackAnchor(sessionId)?.status !== "deleted"
-        ) {
-          throw error;
+      return withSessionMessageBundleDeletion(sessionId, () => {
+        if (deletionWitness === null) {
+          assertSessionAntiRollbackBeforeWrite(
+            sessionId,
+            existingMeta,
+            filePath,
+            "live",
+          );
+        } else if (existingMeta?.deleted !== true) {
+          existingMeta = replaceSessionMeta(getSessionsDir(), {
+            ...emptySessionMeta(sessionId),
+            id: sessionId,
+            generation: deletionWitness.generation || null,
+            last_hash: deletionWitness.last_hash || null,
+            event_count: Math.max(0, Number(deletionWitness.event_count) || 0),
+            updated_at_ms: Math.max(
+              0,
+              Number(deletionWitness.deleted_at_ms) || Date.now(),
+            ),
+            deleted_at_ms: Math.max(
+              0,
+              Number(deletionWitness.deleted_at_ms) || Date.now(),
+            ),
+            deleted: true,
+            transcript: null,
+          });
         }
-        publishSessionAntiRollbackWitness(
-          sessionId,
-          tombstone,
+        if (transcriptExists) rmSync(filePath, { force: true });
+        // The external tombstone is published only after the absent transcript
+        // directory entry is durable. A retry after an interrupted unlink must
+        // repeat this barrier even though the path is already absent in memory.
+        fsyncParentDirectory(
           filePath,
-          "deleted",
+          Object.freeze({ sessionId, filePath, operation: "delete" }),
+          "beforeDeleteDirectoryFsync",
+          "afterDeleteDirectoryFsync",
         );
-      }
-      return true;
+        try {
+          const tombstone = recordSessionDeleted(getSessionsDir(), sessionId);
+          publishSessionAntiRollbackWitness(
+            sessionId,
+            tombstone,
+            filePath,
+            "deleted",
+          );
+        } catch (error) {
+          // A complete anti-rollback record is readable before its fsync. If
+          // rollback also fails, readback alone cannot prove durability. Only
+          // swallow a post-meta failure after an exact replay has settled the
+          // deleted record through the production persistence path.
+          const tombstone = readSessionMeta(getSessionsDir(), sessionId);
+          if (
+            tombstone?.deleted !== true ||
+            readSessionAntiRollbackAnchor(sessionId)?.status !== "deleted"
+          ) {
+            throw error;
+          }
+          publishSessionAntiRollbackWitness(
+            sessionId,
+            tombstone,
+            filePath,
+            "deleted",
+          );
+        }
+        return true;
+      });
     },
     {
       failIfUnavailable: true,

package/src/harness/prompt-compressor.js

@@ -10,6 +10,7 @@
  */
 
 import { createHash } from "node:crypto";
+import { imageTransportEstimate } from "../lib/image-token-estimate.js";
 import {
   collectFileReadProgress,
   FILE_READ_PROGRESS_PREFIX,
@@ -183,7 +184,25 @@ export function estimateMessagesTokens(messages) {
       typeof msg.content === "string"
         ? msg.content
         : JSON.stringify(msg.content || "");
-    return sum + estimateTokens(content);
+    const image = imageTransportEstimate([msg]);
+    // Base64 is transport, not language tokens. The remaining serialized
+    // content is still charged, including captions and image metadata.
+    return (
+      sum + estimateTokens(content) - Math.ceil(image.bytes / 4) + image.tokens
+    );
+  }, 0);
+}
+
+// Leave space for tool definitions, protocol metadata and projection records
+// before the bounded Evolution input/projected-content ceilings are reached.
+export const AUTO_COMPACT_TEXT_BYTES = 768 * 1024;
+
+export function estimateMessagesTextBytes(messages) {
+  return messages.reduce((sum, message) => {
+    const image = imageTransportEstimate([message]);
+    return (
+      sum + Buffer.byteLength(JSON.stringify(message), "utf8") - image.bytes
+    );
   }, 0);
 }
 
@@ -406,7 +425,9 @@ export class PromptCompressor {
     const currentTokens = estimateMessagesTokens(result);
     if (
       this.llmQuery &&
-      (currentTokens > this.maxTokens || result.length > this.maxMessages) &&
+      (currentTokens > this.maxTokens ||
+        result.length > this.maxMessages ||
+        estimateMessagesTextBytes(result) > AUTO_COMPACT_TEXT_BYTES) &&
       messages.length > 4
     ) {
       const summarized = await this._summarize(result, messages);
@@ -494,7 +515,40 @@ export class PromptCompressor {
     return (
       ((!this._adaptive || this._contextWindow < 128000) &&
         messages.length > this.maxMessages) ||
-      estimateMessagesTokens(messages) > this.maxTokens
+      estimateMessagesTokens(messages) > this.maxTokens ||
+      estimateMessagesTextBytes(messages) > AUTO_COMPACT_TEXT_BYTES
+    );
+  }
+
+  getCompactionTokenBudget(messages) {
+    const textBytes = estimateMessagesTextBytes(messages);
+    if (textBytes <= AUTO_COMPACT_TEXT_BYTES) return this.maxTokens;
+    const imageTokens = imageTransportEstimate(messages).tokens;
+    const lastUser = messages.findLast((message) => message.role === "user");
+    // Historical images may be dropped by the planner. Reserving all of them
+    // would let it satisfy this target by deleting images while retaining the
+    // text that caused the byte overflow.
+    const protectedImageTokens = imageTransportEstimate(
+      messages.filter(
+        (message) =>
+          message === lastUser ||
+          message.pinned === true ||
+          message._pin === true,
+      ),
+    ).tokens;
+    const textTokens = Math.max(
+      0,
+      estimateMessagesTokens(messages) - imageTokens,
+    );
+    return Math.max(
+      1,
+      Math.min(
+        this.maxTokens,
+        Math.floor(
+          protectedImageTokens +
+            textTokens * (AUTO_COMPACT_TEXT_BYTES / textBytes) * 0.75,
+        ),
+      ),
     );
   }
 

package/src/lib/context-memory-kernel/context-image-transport.js

@@ -0,0 +1,248 @@
+import { createHash, randomBytes } from "node:crypto";
+import { normalizeContextItem } from "@chainlesschain/context-memory-kernel";
+import { AGENT_MODEL_IMAGE_LIMITS } from "../evolution/agent-model-projection.js";
+import {
+  IMAGE_TOKEN_RESERVE,
+  LOW_DETAIL_IMAGE_TOKEN_RESERVE,
+  inspectCanonicalImageDataUrl,
+} from "../image-token-estimate.js";
+
+export const CONTEXT_IMAGE_TRANSPORT_PREFIX = "cc-context-image://v1/";
+const CONTEXT_IMAGE_TRANSPORT_MARKER = "cc-context-image";
+
+const PLACEHOLDER_URL =
+  /^cc-context-image:\/\/v1\/([a-f0-9]{32})\/(sha256-[a-f0-9]{64})$/u;
+
+function sha256(value) {
+  return `sha256-${createHash("sha256").update(value, "ascii").digest("hex")}`;
+}
+
+function supportedImageUrlBlock(message, block) {
+  if (
+    message?.role !== "user" ||
+    !Array.isArray(message.content) ||
+    !block ||
+    typeof block !== "object" ||
+    Array.isArray(block) ||
+    Object.keys(block).sort().join() !== "image_url,type" ||
+    block.type !== "image_url" ||
+    !block.image_url ||
+    typeof block.image_url !== "object" ||
+    Array.isArray(block.image_url) ||
+    Object.keys(block.image_url).some((key) => !["url", "detail"].includes(key))
+  )
+    return null;
+
+  const { url, detail } = block.image_url;
+  if (
+    typeof url !== "string" ||
+    (detail !== undefined && !["auto", "low", "high"].includes(detail))
+  )
+    return null;
+  if (
+    url.length >
+    Math.ceil(AGENT_MODEL_IMAGE_LIMITS.maxImageBytes / 3) * 4 + 128
+  )
+    throw codedTransportError(
+      "Image transport exceeds its per-image byte budget",
+    );
+  const image = inspectCanonicalImageDataUrl(url);
+  return image ? { url, detail, bytes: image.decodedBytes } : null;
+}
+
+function codedTransportError(message) {
+  const error = new Error(message);
+  error.code = "CC_CONTEXT_IMAGE_TRANSPORT_INVALID";
+  return error;
+}
+
+/** Replace supported user image data URLs with request-local digest commitments. */
+export function captureContextImageTransport(messagesInput) {
+  const messages = Array.isArray(messagesInput) ? messagesInput : [];
+  const captures = new Map();
+  let requestImageBytes = 0;
+  let changed = false;
+  const transportedMessages = messages.map((message) => {
+    if (message?.role !== "user" || !Array.isArray(message.content)) {
+      return message;
+    }
+
+    let contentChanged = false;
+    let messageImageBytes = 0;
+    let messageImageCount = 0;
+    const content = message.content.map((block) => {
+      const image = supportedImageUrlBlock(message, block);
+      if (!image) return block;
+
+      messageImageCount++;
+      messageImageBytes += image.bytes;
+      requestImageBytes += image.bytes;
+      if (
+        image.bytes > AGENT_MODEL_IMAGE_LIMITS.maxImageBytes ||
+        messageImageCount > AGENT_MODEL_IMAGE_LIMITS.maxMessageImages ||
+        messageImageBytes > AGENT_MODEL_IMAGE_LIMITS.maxMessageImageBytes ||
+        requestImageBytes > AGENT_MODEL_IMAGE_LIMITS.maxRequestImageBytes
+      )
+        throw codedTransportError(
+          "Images exceed the bounded message or request image budget",
+        );
+
+      const digest = sha256(image.url);
+      const nonce = randomBytes(16).toString("hex");
+      const placeholder = `${CONTEXT_IMAGE_TRANSPORT_PREFIX}${nonce}/${digest}`;
+      captures.set(placeholder, {
+        url: image.url,
+        digest,
+        detail: image.detail,
+        hasDetail: Object.hasOwn(block.image_url, "detail"),
+        reserveTokens:
+          image.detail === "low"
+            ? LOW_DETAIL_IMAGE_TOKEN_RESERVE
+            : IMAGE_TOKEN_RESERVE,
+      });
+      contentChanged = true;
+      changed = true;
+      return {
+        ...block,
+        image_url: { ...block.image_url, url: placeholder },
+      };
+    });
+    return contentChanged ? { ...message, content } : message;
+  });
+
+  return {
+    messages: changed ? transportedMessages : messages,
+    captures,
+  };
+}
+
+/** Preserve image token reserves while removing transport placeholders from item digests. */
+export function adjustContextImageTokenEstimates(itemsInput, captures) {
+  const items = Array.isArray(itemsInput) ? itemsInput : [];
+  if (!(captures instanceof Map) || captures.size === 0) return items;
+
+  return items.map((item) => {
+    if (typeof item?.content !== "string") return item;
+    let placeholderBytes = 0;
+    let reserveTokens = 0;
+    for (const [placeholder, capture] of captures) {
+      const first = item.content.indexOf(placeholder);
+      if (first < 0) continue;
+      if (item.content.indexOf(placeholder, first + placeholder.length) >= 0) {
+        throw codedTransportError(
+          "A context image transport placeholder was duplicated during planning",
+        );
+      }
+      placeholderBytes += Buffer.byteLength(placeholder, "utf8");
+      reserveTokens += capture.reserveTokens;
+    }
+    if (placeholderBytes === 0) return item;
+
+    const { digest: _previousDigest, ...withoutDigest } = item;
+    return normalizeContextItem({
+      ...withoutDigest,
+      tokenEstimate: Math.max(
+        1,
+        Math.ceil(
+          (Buffer.byteLength(item.content, "utf8") - placeholderBytes) / 4,
+        ) + reserveTokens,
+      ),
+    });
+  });
+}
+
+function containsTransportImageUrl(messages) {
+  return messages.some(
+    (message) =>
+      Array.isArray(message?.content) &&
+      message.content.some(
+        (block) =>
+          block?.type === "image_url" &&
+          typeof block.image_url?.url === "string" &&
+          block.image_url.url.includes(CONTEXT_IMAGE_TRANSPORT_MARKER),
+      ),
+  );
+}
+
+function containsCapturedPlaceholder(value, captures, seen = new Set()) {
+  if (typeof value === "string") {
+    for (const match of value.matchAll(
+      /cc-context-image:\/\/v1\/[a-f0-9]{32}\/sha256-[a-f0-9]{64}/gu,
+    )) {
+      if (captures.has(match[0])) return true;
+    }
+    return false;
+  }
+  if (!value || typeof value !== "object" || seen.has(value)) return false;
+  seen.add(value);
+  return Object.values(value).some((entry) =>
+    containsCapturedPlaceholder(entry, captures, seen),
+  );
+}
+
+/** Restore captured image data URLs and reject every unrecognized or altered placeholder. */
+export function restoreContextImageTransport(messagesInput, captures) {
+  const messages = Array.isArray(messagesInput) ? messagesInput : [];
+  const captured = captures instanceof Map ? captures : new Map();
+  const seenPlaceholders = new Set();
+  const restored = messages.map((message) => {
+    if (message?.role !== "user" || !Array.isArray(message.content)) {
+      return message;
+    }
+    let contentChanged = false;
+    const content = message.content.map((block) => {
+      if (
+        !block ||
+        typeof block !== "object" ||
+        Array.isArray(block) ||
+        block.type !== "image_url" ||
+        !block.image_url ||
+        typeof block.image_url !== "object" ||
+        Array.isArray(block.image_url) ||
+        typeof block.image_url.url !== "string" ||
+        !block.image_url.url.includes(CONTEXT_IMAGE_TRANSPORT_MARKER)
+      )
+        return block;
+
+      const placeholder = block.image_url.url;
+      const match = PLACEHOLDER_URL.exec(placeholder);
+      const capture = captured.get(placeholder);
+      if (
+        Object.keys(block).sort().join() !== "image_url,type" ||
+        Object.keys(block.image_url).some(
+          (key) => !["url", "detail"].includes(key),
+        ) ||
+        (block.image_url.detail !== undefined &&
+          !["auto", "low", "high"].includes(block.image_url.detail)) ||
+        !match ||
+        !capture ||
+        capture.hasDetail !== Object.hasOwn(block.image_url, "detail") ||
+        capture.detail !== block.image_url.detail ||
+        match[2] !== capture.digest ||
+        sha256(capture.url) !== capture.digest ||
+        seenPlaceholders.has(placeholder)
+      ) {
+        throw codedTransportError(
+          "A context image transport placeholder is unknown, altered, or duplicated",
+        );
+      }
+      seenPlaceholders.add(placeholder);
+      contentChanged = true;
+      return {
+        ...block,
+        image_url: { ...block.image_url, url: capture.url },
+      };
+    });
+    return contentChanged ? { ...message, content } : message;
+  });
+
+  if (
+    containsTransportImageUrl(restored) ||
+    containsCapturedPlaceholder(restored, captured)
+  ) {
+    throw codedTransportError(
+      "An unrecognized context image transport placeholder reached provider context",
+    );
+  }
+  return restored;
+}

package/src/lib/context-memory-kernel/jsonl-session-context-port.js

@@ -120,6 +120,7 @@ export class JsonlSessionContextPort {
           items: messagesToContextItems(authority.readMessages(), {
             sessionId,
             allowedSinks: this.allowedSinks,
+            allowExternalization: true,
           }),
         }),
       };
@@ -215,7 +216,9 @@ export class JsonlSessionContextPort {
 
   async appendCompaction(event, expectedHead) {
     this._assertSession(event.sessionId);
-    const messages = contextItemsToMessages(event.outputItems);
+    const messages = contextItemsToMessages(event.outputItems, {
+      sessionId: this.sessionId,
+    });
     const stats = compactStats(event, messages);
     const appendHead = this._appendHead(event.operationId, expectedHead);
     try {