chainlesschain 0.166.115 → 0.166.118

package/src/lib/evolution/evolution-windows-directory-durability.js

@@ -1,6 +1,7 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createRequire } from "node:module";
+import { randomUUID } from "node:crypto";
 
 const require = createRequire(import.meta.url);
 const DIRECTORY_ATTRIBUTE = 0x10;
@@ -18,16 +19,21 @@ function loadWindowsApi() {
   if (windowsApi !== null) return windowsApi;
   const koffi = require("koffi");
   const kernel32 = koffi.load("kernel32.dll");
+  // Koffi's named types share a process-wide registry even when this module
+  // is loaded in separate realms. Keep each API's ABI declarations private;
+  // filesystem brands and the API cache remain local to this module instance.
+  const typeScope = randomUUID().replaceAll("-", "");
+  const typeName = (name) => `${name}_${typeScope}`;
   const HANDLE = koffi.pointer(
-    "ChainlessChainEvolutionDirectoryHandle",
+    typeName("ChainlessChainEvolutionDirectoryHandle"),
     koffi.opaque(),
   );
-  const FILETIME = koffi.struct("ChainlessChainEvolutionFileTime", {
+  const FILETIME = koffi.struct(typeName("ChainlessChainEvolutionFileTime"), {
     lowDateTime: "uint32_t",
     highDateTime: "uint32_t",
   });
   const BY_HANDLE_FILE_INFORMATION = koffi.struct(
-    "ChainlessChainEvolutionDirectoryInformation",
+    typeName("ChainlessChainEvolutionDirectoryInformation"),
     {
       fileAttributes: "uint32_t",
       creationTime: FILETIME,
@@ -41,20 +47,86 @@ function loadWindowsApi() {
       fileIndexLow: "uint32_t",
     },
   );
+  const FILE_ID_128 = koffi.struct(
+    typeName("ChainlessChainEvolutionFileId128"),
+    {
+      low: "uint64_t",
+      high: "uint64_t",
+    },
+  );
+  const FILE_ID_INFO = koffi.struct(
+    typeName("ChainlessChainEvolutionFileIdInfo"),
+    {
+      volumeSerialNumber: "uint64_t",
+      fileId: FILE_ID_128,
+    },
+  );
+  const statFields = {
+    fileId: "int64_t",
+    creationTime: "int64_t",
+    lastAccessTime: "int64_t",
+    lastWriteTime: "int64_t",
+    changeTime: "int64_t",
+    allocationSize: "int64_t",
+    endOfFile: "int64_t",
+    fileAttributes: "uint32_t",
+    reparseTag: "uint32_t",
+    numberOfLinks: "uint32_t",
+  };
+  const FILE_STAT_INFORMATION = koffi.struct(
+    typeName("ChainlessChainEvolutionFileStatInformation"),
+    { ...statFields, effectiveAccess: "uint32_t" },
+  );
+  const FILE_STAT_BASIC_INFORMATION = koffi.struct(
+    typeName("ChainlessChainEvolutionFileStatBasicInformation"),
+    {
+      ...statFields,
+      deviceType: "uint32_t",
+      deviceCharacteristics: "uint32_t",
+      reserved: "uint32_t",
+      // Windows' documented layout; libuv 1.49 placed these in reverse order.
+      volumeSerialNumber: "uint64_t",
+      fileId128: FILE_ID_128,
+    },
+  );
+  const IO_STATUS_BLOCK = koffi.struct(
+    typeName("ChainlessChainEvolutionIoStatus"),
+    {
+      status: "intptr_t",
+      information: "uintptr_t",
+    },
+  );
+  let GetFileInformationByName = null;
+  try {
+    const fileApi = koffi.load("api-ms-win-core-file-l2-1-4.dll");
+    GetFileInformationByName = fileApi.func(
+      `bool __stdcall GetFileInformationByName(str16 fileName, int informationClass, _Out_ ${typeName("ChainlessChainEvolutionFileStatBasicInformation")} *information, uint32_t size)`,
+    );
+  } catch {
+    // Older Windows versions use libuv's handle-based stat path instead.
+  }
+  const ntdll = koffi.load("ntdll.dll");
   windowsApi = Object.freeze({
     koffi,
     HANDLE,
     CreateFileW: kernel32.func(
-      "ChainlessChainEvolutionDirectoryHandle __stdcall CreateFileW(str16 fileName, uint32_t desiredAccess, uint32_t shareMode, void *securityAttributes, uint32_t creationDisposition, uint32_t flagsAndAttributes, void *templateFile)",
+      `${typeName("ChainlessChainEvolutionDirectoryHandle")} __stdcall CreateFileW(str16 fileName, uint32_t desiredAccess, uint32_t shareMode, void *securityAttributes, uint32_t creationDisposition, uint32_t flagsAndAttributes, void *templateFile)`,
     ),
     FlushFileBuffers: kernel32.func(
-      "bool __stdcall FlushFileBuffers(ChainlessChainEvolutionDirectoryHandle handle)",
+      `bool __stdcall FlushFileBuffers(${typeName("ChainlessChainEvolutionDirectoryHandle")} handle)`,
     ),
     GetDriveTypeW: kernel32.func(
       "uint32_t __stdcall GetDriveTypeW(str16 rootPathName)",
     ),
     GetFileInformationByHandle: kernel32.func(
-      "bool __stdcall GetFileInformationByHandle(ChainlessChainEvolutionDirectoryHandle handle, _Out_ ChainlessChainEvolutionDirectoryInformation *information)",
+      `bool __stdcall GetFileInformationByHandle(${typeName("ChainlessChainEvolutionDirectoryHandle")} handle, _Out_ ${typeName("ChainlessChainEvolutionDirectoryInformation")} *information)`,
+    ),
+    GetFileInformationByHandleEx: kernel32.func(
+      `bool __stdcall GetFileInformationByHandleEx(${typeName("ChainlessChainEvolutionDirectoryHandle")} handle, int informationClass, _Out_ ${typeName("ChainlessChainEvolutionFileIdInfo")} *information, uint32_t size)`,
+    ),
+    GetFileInformationByName,
+    NtQueryInformationFile: ntdll.func(
+      `int32_t __stdcall NtQueryInformationFile(${typeName("ChainlessChainEvolutionDirectoryHandle")} handle, _Out_ ${typeName("ChainlessChainEvolutionIoStatus")} *ioStatus, _Out_ ${typeName("ChainlessChainEvolutionFileStatInformation")} *information, uint32_t size, int informationClass)`,
     ),
     GetLastError: kernel32.func("uint32_t __stdcall GetLastError()"),
     GetVolumeInformationW: kernel32.func(
@@ -64,9 +136,13 @@ function loadWindowsApi() {
       "bool __stdcall GetVolumePathNameW(str16 fileName, _Out_ uint16_t *volumePathName, uint32_t bufferLength)",
     ),
     CloseHandle: kernel32.func(
-      "bool __stdcall CloseHandle(ChainlessChainEvolutionDirectoryHandle handle)",
+      `bool __stdcall CloseHandle(${typeName("ChainlessChainEvolutionDirectoryHandle")} handle)`,
     ),
     BY_HANDLE_FILE_INFORMATION,
+    FILE_ID_INFO,
+    FILE_STAT_INFORMATION,
+    FILE_STAT_BASIC_INFORMATION,
+    IO_STATUS_BLOCK,
   });
   return windowsApi;
 }
@@ -137,7 +213,78 @@ function fileId(information) {
   );
 }
 
-function assertDirectoryHandleIdentity(api, handle, fsImpl, directory, expected) {
+// These Win32 APIs expose a DWORD serial. Normalize serial representations
+// only across those APIs, retaining full stat.dev for path-change checks.
+// Node 22.12's fast-stat ABI defect needs a separate, handle-bound projection.
+function windowsVolumeSerial(device) {
+  return BigInt.asUintN(32, BigInt(device));
+}
+
+function matchesFastNodeDirectoryIdentity(api, handle, directory, expected) {
+  if (!api.GetFileInformationByName) return false;
+  const handleIdentity = {};
+  requireWindowsSuccess(
+    api,
+    api.GetFileInformationByHandleEx(
+      handle,
+      18,
+      handleIdentity,
+      api.koffi.sizeof(api.FILE_ID_INFO),
+    ),
+  );
+  const handleStat = {};
+  const status = api.NtQueryInformationFile(
+    handle,
+    {},
+    handleStat,
+    api.koffi.sizeof(api.FILE_STAT_INFORMATION),
+    68,
+  );
+  if (status < 0) {
+    throw new Error("Windows local UI native directory identity unavailable");
+  }
+  const pathStat = {};
+  requireWindowsSuccess(
+    api,
+    api.GetFileInformationByName(
+      win32Path(directory),
+      3,
+      pathStat,
+      api.koffi.sizeof(api.FILE_STAT_BASIC_INFORMATION),
+    ),
+  );
+  const pathFileId = BigInt.asUintN(64, BigInt(pathStat.fileId));
+  if (
+    (Number(pathStat.fileAttributes) & DIRECTORY_ATTRIBUTE) === 0 ||
+    (Number(pathStat.fileAttributes) & REPARSE_POINT_ATTRIBUTE) !== 0 ||
+    BigInt(pathStat.volumeSerialNumber) !==
+      BigInt(handleIdentity.volumeSerialNumber) ||
+    BigInt(pathStat.fileId128.low) !== BigInt(handleIdentity.fileId.low) ||
+    BigInt(pathStat.fileId128.high) !== BigInt(handleIdentity.fileId.high) ||
+    pathFileId !== BigInt.asUintN(64, BigInt(handleStat.fileId))
+  ) {
+    throw new Error(
+      "Windows local UI path identity does not match the directory handle",
+    );
+  }
+  // Same projections as windows-sandbox.cs: pair dev and ino from one stat
+  // implementation, only after binding the correctly laid-out path result to
+  // this handle's complete volume/128-bit ID. Never treat dev === 0 as a bypass.
+  return (
+    pathFileId === BigInt(expected.stat.ino) &&
+    (BigInt(expected.stat.dev) ===
+      windowsVolumeSerial(pathStat.volumeSerialNumber) ||
+      BigInt(expected.stat.dev) === BigInt(pathStat.fileId128.high))
+  );
+}
+
+function assertDirectoryHandleIdentity(
+  api,
+  handle,
+  fsImpl,
+  directory,
+  expected,
+) {
   const information = {};
   requireWindowsSuccess(
     api,
@@ -147,9 +294,43 @@ function assertDirectoryHandleIdentity(api, handle, fsImpl, directory, expected)
   if (
     (attributes & DIRECTORY_ATTRIBUTE) === 0 ||
     (attributes & REPARSE_POINT_ATTRIBUTE) !== 0 ||
-    BigInt(information.volumeSerialNumber) !== BigInt(expected.stat.dev) ||
-    fileId(information) !== BigInt(expected.stat.ino)
+    BigInt(information.volumeSerialNumber) !== expected.volumeSerialNumber
+  ) {
+    throw new Error(
+      "Windows local UI durability handle does not match the requested directory",
+    );
+  }
+  const expectedDevice = BigInt(expected.stat.dev);
+  const matchingLegacyFileId =
+    fileId(information) === BigInt(expected.stat.ino);
+  let legacyIdentityMatches =
+    matchingLegacyFileId &&
+    BigInt(information.volumeSerialNumber) === expectedDevice;
+  if (
+    !legacyIdentityMatches &&
+    matchingLegacyFileId &&
+    expectedDevice > 0xffffffffn
   ) {
+    const fullIdentity = {};
+    requireWindowsSuccess(
+      api,
+      api.GetFileInformationByHandleEx(
+        handle,
+        18,
+        fullIdentity,
+        api.koffi.sizeof(api.FILE_ID_INFO),
+      ),
+    );
+    legacyIdentityMatches =
+      expectedDevice === BigInt(fullIdentity.volumeSerialNumber);
+  }
+  const fastIdentityMatches = matchesFastNodeDirectoryIdentity(
+    api,
+    handle,
+    expected.resolvedPath,
+    expected,
+  );
+  if (!legacyIdentityMatches && !fastIdentityMatches) {
     throw new Error(
       "Windows local UI durability handle does not match the requested directory",
     );
@@ -169,12 +350,15 @@ function assertDirectoryHandleIdentity(api, handle, fsImpl, directory, expected)
 /** Flush one verified directory on a local NTFS volume using a write handle. */
 export function flushWindowsLocalNtfsDirectory(
   directory,
-  { fsImpl = fs } = {},
+  { fsImpl = fs, nativeApi = null } = {},
 ) {
   if (process.platform !== "win32") {
     throw new Error("Windows directory flush is only available on Windows");
   }
-  const api = loadWindowsApi();
+  const api =
+    typeof nativeApi === "function"
+      ? nativeApi(loadWindowsApi())
+      : nativeApi || loadWindowsApi();
   const before = pathIdentity(fsImpl, directory);
   const volumePath = Buffer.alloc(520);
   requireWindowsSuccess(
@@ -203,18 +387,18 @@ export function flushWindowsLocalNtfsDirectory(
   );
   if (
     driveType !== DRIVE_FIXED ||
-    readWideString(fileSystemName).toLowerCase() !== "ntfs" ||
-    BigInt(volumeSerialNumber[0]) !== BigInt(before.stat.dev)
+    readWideString(fileSystemName).toLowerCase() !== "ntfs"
   ) {
     throw new Error(
       "Windows local UI durable storage requires a local NTFS directory",
     );
   }
+  const expected = {
+    ...before,
+    volumeSerialNumber: BigInt(volumeSerialNumber[0]),
+  };
 
-  const invalidHandle = BigInt.asUintN(
-    api.koffi.sizeof("intptr_t") * 8,
-    -1n,
-  );
+  const invalidHandle = BigInt.asUintN(api.koffi.sizeof("intptr_t") * 8, -1n);
   const handle = api.CreateFileW(
     win32Path(before.resolvedPath),
     GENERIC_READ_WRITE,
@@ -231,25 +415,13 @@ export function flushWindowsLocalNtfsDirectory(
 
   let operationError = null;
   try {
-    assertDirectoryHandleIdentity(
-      api,
-      handle,
-      fsImpl,
-      directory,
-      before,
-    );
+    assertDirectoryHandleIdentity(api, handle, fsImpl, directory, expected);
     const flushed = api.FlushFileBuffers(handle);
     if (!flushed) {
       const errorCode = api.GetLastError();
       throw windowsError("FlushFileBuffers", errorCode);
     }
-    assertDirectoryHandleIdentity(
-      api,
-      handle,
-      fsImpl,
-      directory,
-      before,
-    );
+    assertDirectoryHandleIdentity(api, handle, fsImpl, directory, expected);
   } catch (error) {
     operationError = error;
     throw error;
@@ -282,6 +454,17 @@ export function isLocalUiEvolutionFileSystem(fsImpl) {
   );
 }
 
+// Only the original adapter inherits every filesystem operation unchanged.
+// A branded object with injected operations must keep its dependency boundary.
+export function isUnmodifiedLocalUiEvolutionFileSystem(fsImpl) {
+  return (
+    isLocalUiEvolutionFileSystem(fsImpl) &&
+    Object.getPrototypeOf(fsImpl) === fs &&
+    Reflect.ownKeys(fsImpl).length === 1 &&
+    Object.hasOwn(fsImpl, "syncDirectorySync")
+  );
+}
+
 export function ensureDirectoryTreeDurable(fsImpl, directory) {
   if (typeof fsImpl?.syncDirectorySync !== "function") {
     fsImpl.mkdirSync(directory, { recursive: true, mode: 0o700 });

package/src/lib/evolution/local-ui-evolution-runtime.js

@@ -21,8 +21,10 @@ import {
   EVOLUTION_SOURCE_VERIFICATION_SCHEMA,
 } from "./evolution-evidence-projector.js";
 import { createAgentEvolutionRuntimeComposition } from "./agent-evolution-runtime-composition.js";
+import { EVOLUTION_TYPED_EVIDENCE_LAYOUT } from "./evolution-evidence-storage-layout.js";
 import { loadLocalUiEvolutionDeployment } from "./local-ui-evolution-deployment.js";
 import { createLocalUiEvolutionFileSystem } from "./evolution-windows-directory-durability.js";
+import { createLocalUiSigningAuthority as ed25519Authority } from "./local-ui-signing-authority.js";
 import {
   formatLocalUiTenantReferenceId,
   encodeOpaqueHexId,
@@ -104,44 +106,6 @@ function encodedMessage(message) {
   return Buffer.from(canonical(message), "utf8");
 }
 
-function ed25519Authority(label, tenantId, privateKeyPem) {
-  const privateKey = createPrivateKey(privateKeyPem);
-  const publicKey = createPublicKey(privateKey);
-  const trust = Object.freeze({
-    algorithm: "ed25519",
-    keyId: `local://${tenantId}/${label}`,
-    trustPolicyDigest: sha256(`chainlesschain.local-ui.${label}.policy/v1`),
-  });
-  return Object.freeze({
-    trust,
-    signer: Object.freeze({
-      sign({ message }) {
-        return {
-          ...trust,
-          value: sign(null, encodedMessage(message), privateKey).toString(
-            "base64url",
-          ),
-        };
-      },
-    }),
-    verifier: Object.freeze({
-      verify({ message, signature }) {
-        return (
-          signature?.algorithm === trust.algorithm &&
-          signature?.keyId === trust.keyId &&
-          signature?.trustPolicyDigest === trust.trustPolicyDigest &&
-          verify(
-            null,
-            encodedMessage(message),
-            publicKey,
-            Buffer.from(signature.value || "", "base64url"),
-          )
-        );
-      },
-    }),
-  });
-}
-
 function ed25519ArtifactAuthority(tenantId, privateKeyPem) {
   const privateKey = createPrivateKey(privateKeyPem);
   const publicKey = createPublicKey(privateKey);
@@ -608,6 +572,7 @@ export async function createLocalUiEvolutionComposition({
     audience:
       commandName === "ui" ? "local-ui-quick-ask" : `local-${commandName}`,
     stateRootDir,
+    evidenceStorageLayout: EVOLUTION_TYPED_EVIDENCE_LAYOUT,
     witnessId: `local-ui-witness-${identity.tenantId}`,
     authorities: {
       ...identity.authorities,

package/src/lib/evolution/local-ui-signing-authority.js

@@ -0,0 +1,69 @@
+import {
+  createHash,
+  createPrivateKey,
+  createPublicKey,
+  sign,
+  verify,
+} from "node:crypto";
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function encodedMessage(message) {
+  if (typeof message === "string") return Buffer.from(message, "utf8");
+  if (Buffer.isBuffer(message)) return message;
+  return Buffer.from(canonical(message), "utf8");
+}
+
+/** Process-local immutable key/policy; external revocable authorities differ. */
+export function createLocalUiSigningAuthority(label, tenantId, privateKeyPem) {
+  const privateKey = createPrivateKey(privateKeyPem);
+  const publicKey = createPublicKey(privateKey);
+  const trust = Object.freeze({
+    algorithm: "ed25519",
+    keyId: `local://${tenantId}/${label}`,
+    trustPolicyDigest: `sha256:${createHash("sha256").update(`chainlesschain.local-ui.${label}.policy/v1`).digest("hex")}`,
+  });
+  // Every verifier input is captured and immutable for this authority's entire
+  // lifetime. The existing witness cache still rehashes fresh stored bytes.
+  const trustEpoch = `sha256:${createHash("sha256")
+    .update(publicKey.export({ type: "spki", format: "der" }))
+    .update("\0")
+    .update(canonical(trust))
+    .digest("hex")}`;
+  return Object.freeze({
+    trust,
+    signer: Object.freeze({
+      sign({ message }) {
+        return {
+          ...trust,
+          value: sign(null, encodedMessage(message), privateKey).toString(
+            "base64url",
+          ),
+        };
+      },
+    }),
+    verifier: Object.freeze({
+      getTrustEpoch: () => trustEpoch,
+      verify({ message, signature }) {
+        return (
+          signature?.algorithm === trust.algorithm &&
+          signature?.keyId === trust.keyId &&
+          signature?.trustPolicyDigest === trust.trustPolicyDigest &&
+          verify(
+            null,
+            encodedMessage(message),
+            publicKey,
+            Buffer.from(signature.value || "", "base64url"),
+          )
+        );
+      },
+    }),
+  });
+}

package/src/lib/image-token-estimate.js

@@ -0,0 +1,59 @@
+// Context planning estimates vision work separately from base64 transport.
+// Providers and models meter images differently. These are planning reserves;
+// provider usage receipts remain authoritative for token and cost settlement.
+export const IMAGE_TOKEN_RESERVE = 8192;
+export const LOW_DETAIL_IMAGE_TOKEN_RESERVE = 1024;
+const BASE64_ALPHABET =
+  "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+
+export function inspectCanonicalImageDataUrl(url) {
+  if (typeof url !== "string") return null;
+  const match =
+    /^data:image\/(?:png|jpeg|gif|webp);base64,([A-Za-z0-9+/]+={0,2})$/u.exec(
+      url,
+    );
+  if (!match || match[1].length % 4 !== 0) return null;
+  const data = match[1];
+  const padding = data.endsWith("==") ? 2 : data.endsWith("=") ? 1 : 0;
+  const finalValue = BASE64_ALPHABET.indexOf(data[data.length - padding - 1]);
+  if (
+    (padding === 2 && finalValue % 16 !== 0) ||
+    (padding === 1 && finalValue % 4 !== 0)
+  )
+    return null;
+  return {
+    decodedBytes: (data.length / 4) * 3 - padding,
+    encodedBytes: data.length,
+  };
+}
+
+export function imageTransportEstimate(messages) {
+  let bytes = 0;
+  let tokens = 0;
+  for (const message of messages) {
+    if (message?.role !== "user" || !Array.isArray(message.content)) continue;
+    for (const block of message.content) {
+      if (
+        block?.type !== "image_url" ||
+        Object.keys(block).sort().join() !== "image_url,type" ||
+        !block.image_url ||
+        Object.keys(block.image_url).some(
+          (key) => !["url", "detail"].includes(key),
+        )
+      )
+        continue;
+      const { url, detail } = block.image_url;
+      if (
+        typeof url !== "string" ||
+        (detail !== undefined && !["auto", "low", "high"].includes(detail)) ||
+        !inspectCanonicalImageDataUrl(url)
+      )
+        continue;
+      // Canonical base64 data URLs are ASCII and need no JSON escaping.
+      bytes += url.length;
+      tokens +=
+        detail === "low" ? LOW_DETAIL_IMAGE_TOKEN_RESERVE : IMAGE_TOKEN_RESERVE;
+    }
+  }
+  return { bytes, tokens };
+}

package/src/lib/ollama-provider-fetch.js

@@ -0,0 +1,33 @@
+import { Agent } from "undici";
+import {
+  hasFormalBudgetProviderScope,
+  providerFetch,
+} from "./formal-budget-provider-scope.js";
+
+let dispatcher;
+
+/**
+ * Do not reuse an idle Ollama socket across agent turns. Long synchronous
+ * repository work can delay processing a peer's close until the next call.
+ * pipelining: 0 disables keep-alive in undici, giving each request a fresh
+ * connection without replaying a model call after an ambiguous failure.
+ */
+export function ollamaProviderFetch(
+  input,
+  init = {},
+  fetchImpl = globalThis.fetch,
+) {
+  // A governed transport owns its physical HTTP policy and rejects adapter
+  // transport overrides. Leave its request shape and dispatcher untouched.
+  if (hasFormalBudgetProviderScope())
+    return providerFetch(input, init, fetchImpl);
+  return providerFetch(
+    input,
+    {
+      ...init,
+      dispatcher:
+        init.dispatcher ?? (dispatcher ??= new Agent({ pipelining: 0 })),
+    },
+    fetchImpl,
+  );
+}

package/src/lib/provider-stream.js

@@ -10,6 +10,7 @@ import {
 
 import { BUILT_IN_PROVIDERS } from "./llm-providers.js";
 import { normalizeOllamaBaseUrl } from "./ollama-base-url.js";
+import { ollamaProviderFetch } from "./ollama-provider-fetch.js";
 import {
   geminiGenerateContentUrl,
   geminiRequestBody,
@@ -59,7 +60,7 @@ export async function* ollamaTokenStream({
   requireCompletion = false,
 }) {
   const normalizedBaseUrl = normalizeOllamaBaseUrl(baseUrl);
-  const res = await providerFetch(
+  const res = await ollamaProviderFetch(
     `${normalizedBaseUrl}/api/${messages ? "chat" : "generate"}`,
     {
       method: "POST",
@@ -107,18 +108,18 @@ export async function* openAIStream({
   const res = await providerFetch(
     `${normalizeProviderBaseUrl(baseUrl)}/chat/completions`,
     {
-    method: "POST",
-    headers: {
-      "Content-Type": "application/json",
-      Authorization: `Bearer ${apiKey}`,
-    },
-    body: JSON.stringify({
-      model,
-      messages: messages ?? [{ role: "user", content: prompt }],
-      stream: true,
-      ...(governed ? { stream_options: { include_usage: true } } : {}),
-    }),
-    signal,
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Authorization: `Bearer ${apiKey}`,
+      },
+      body: JSON.stringify({
+        model,
+        messages: messages ?? [{ role: "user", content: prompt }],
+        stream: true,
+        ...(governed ? { stream_options: { include_usage: true } } : {}),
+      }),
+      signal,
     },
   );
   if (!res.ok || !res.body) {

package/src/lib/read-file-loop-guard.js

@@ -1,6 +1,7 @@
 import { createHash } from "node:crypto";
 import { EXPLORATION_TOOLS } from "./task-progress-tracker.js";
 import { isToolRecoveryPaused } from "./tool-recovery-result.js";
+import { hostToolOutputIdentity } from "./tool-result-preview.js";
 const MAX_FILES = 12;
 
 function keyFor(filePath, args) {
@@ -353,14 +354,16 @@ export class ReadFileLoopGuard {
     } else if (
       (tool === "run_code" || tool === "run_shell") &&
       typeof result?.output === "string" &&
-      result.output.length >= 8000
+      (result.output.length >= 8000 ||
+        hostToolOutputIdentity(result)?.chars >= 8000)
     ) {
       // Arbitrary code may just dump the same file again. Compare returned
       // evidence, not code spelling or timings. Never cache/skip execution:
       // identical stdout does not imply identical filesystem side effects.
-      const fingerprint = createHash("sha256")
-        .update(result.output)
-        .digest("hex");
+      const identity = hostToolOutputIdentity(result);
+      const fingerprint = identity
+        ? `${identity.chars}:${identity.digest}`
+        : createHash("sha256").update(result.output).digest("hex");
       if (this.largeOutputs.has(fingerprint)) this.batch.duplicates++;
       else {
         this.largeOutputs.add(fingerprint);