chainlesschain 0.166.26 → 0.166.29

package/src/lib/evolution/agent-evolution-ingress.js

@@ -1,8 +1,12 @@
 import crypto from "node:crypto";
+import { types } from "node:util";
 import evolutionRun from "@chainlesschain/session-core/evolution-run";
 
 import { EvolutionEvidenceArtifactAdapter } from "./evolution-evidence-artifact-adapter.js";
-import { EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST } from "./evolution-evidence-projector.js";
+import {
+  EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST,
+  EVOLUTION_PROJECTION_RULESET_DIGEST,
+} from "./evolution-evidence-projector.js";
 import { EvolutionRunLedgerAdapter } from "./evolution-run-ledger-adapter.js";
 import { captureEvolutionRunWikiMaintenanceProducer } from "./evolution-run-wiki-maintenance-source.js";
 import { WIKI_MAINTENANCE_TRIGGER_KIND } from "./wiki-maintenance-trigger-ledger-adapter.js";
@@ -35,7 +39,7 @@ function requiredString(value, label) {
   return value;
 }
 
-function canonical(value) {
+function canonical(value, seen = new Set()) {
   if (value === null || typeof value === "boolean") {
     return JSON.stringify(value);
   }
@@ -49,17 +53,44 @@ function canonical(value) {
   if (!value || typeof value !== "object") {
     throw new TypeError("Agent evolution evidence must be JSON-compatible");
   }
-  if (Array.isArray(value)) {
-    return `[${value.map(canonical).join(",")}]`;
+  if (types.isProxy(value) || seen.has(value)) {
+    throw new TypeError("Agent evolution evidence must be acyclic plain data");
   }
+  const array = Array.isArray(value);
   const prototype = Object.getPrototypeOf(value);
-  if (prototype !== Object.prototype && prototype !== null) {
+  if (!array && prototype !== Object.prototype && prototype !== null) {
     throw new TypeError("Agent evolution evidence must use plain objects");
   }
-  return `{${Object.keys(value)
-    .sort()
-    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
-    .join(",")}}`;
+  const keys = Reflect.ownKeys(value).filter(
+    (key) => !(array && key === "length"),
+  );
+  if (
+    array &&
+    (keys.length !== value.length ||
+      keys.some((key, index) => key !== String(index)))
+  ) {
+    throw new TypeError("Agent evolution evidence arrays must be dense data");
+  }
+  seen.add(value);
+  try {
+    const entries = (array ? keys : keys.sort()).map((key) => {
+      const property = Object.getOwnPropertyDescriptor(value, key);
+      if (
+        typeof key !== "string" ||
+        !property?.enumerable ||
+        !("value" in property)
+      ) {
+        throw new TypeError(
+          "Agent evolution evidence cannot contain accessors or symbols",
+        );
+      }
+      const encoded = canonical(property.value, seen);
+      return array ? encoded : `${JSON.stringify(key)}:${encoded}`;
+    });
+    return array ? `[${entries.join(",")}]` : `{${entries.join(",")}}`;
+  } finally {
+    seen.delete(value);
+  }
 }
 
 function clone(value) {
@@ -106,6 +137,7 @@ export function createAgentEvolutionIngress({
   evidenceAdapter,
   runAdapter,
   sourceEnvelopeAuthority,
+  openCacheSourceRun = null,
   wikiMaintenanceProducer = null,
   releaseTrain = null,
   completionTriggerKind = WIKI_MAINTENANCE_TRIGGER_KIND.SESSION_END,
@@ -144,27 +176,40 @@ export function createAgentEvolutionIngress({
     sourceEnvelopeAuthority,
   );
   const descriptor = runAdapter.descriptor;
+  if (openCacheSourceRun !== null && typeof openCacheSourceRun !== "function")
+    throw new TypeError("cache source Run opener must be a function");
   let tail = Promise.resolve();
-  let modelAdmissionFailure = null;
+  let admissionFailure = null;
+  let lastModelResponse = null;
+  let modelAdmissionPending = false;
 
-  const serialize = (operation, latchModelFailure = false) => {
-    const invoke = latchModelFailure
-      ? async () => {
-          try {
-            return await operation();
-          } catch (cause) {
-            // Latch inside the serialized operation, before releasing the queue.
-            // A complete() already queued by another caller cannot win this race.
-            modelAdmissionFailure = ingressFailure(cause);
-            throw modelAdmissionFailure;
-          }
-        }
-      : operation;
+  const serialize = (operation) => {
+    const invoke = async () => {
+      if (admissionFailure !== null) throw admissionFailure;
+      try {
+        return await operation();
+      } catch (cause) {
+        // Every evidence boundary is fail-stop, not just model admission.
+        // Latch before releasing queued requests or completion operations.
+        admissionFailure ??= ingressFailure(cause);
+        throw admissionFailure;
+      }
+    };
     const pending = tail.then(invoke, invoke);
     tail = pending.catch(() => undefined);
     return pending;
   };
 
+  const cloneEvidence = (value) => {
+    if (admissionFailure !== null) throw admissionFailure;
+    try {
+      return clone(value);
+    } catch (cause) {
+      admissionFailure = ingressFailure(cause);
+      throw admissionFailure;
+    }
+  };
+
   const currentTimestamp = () => {
     const value = now();
     const iso = value instanceof Date ? value.toISOString() : value;
@@ -190,10 +235,16 @@ export function createAgentEvolutionIngress({
     }).projection;
   };
 
-  const ingest = (kind, evidence, options = {}, modelRequest = null) =>
+  const ingest = (
+    kind,
+    evidence,
+    options = {},
+    modelRequest = null,
+    cacheRecord = false,
+  ) =>
     guardIngress(
       serialize(async () => {
-        if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
+        if (admissionFailure !== null) throw admissionFailure;
         const projection = appendStarted();
         if (projection.status === "completed") {
           throw new Error(
@@ -208,7 +259,17 @@ export function createAgentEvolutionIngress({
           options.occurredAt ?? currentTimestamp(),
           "Agent evidence occurredAt",
         );
-        const payload = modelRequest ?? clone(evidence);
+        if (cacheRecord && lastModelResponse === null)
+          throw new Error("Cache receipt requires a recorded model response");
+        const payload = cacheRecord
+          ? {
+              schema: "chainlesschain.model-response-cache/v1",
+              requestKey: evidence.requestKey,
+              sourceRunId: descriptor.runId,
+              sourceEventId: lastModelResponse.eventId,
+              responseEvent: clone(lastModelResponse.event),
+            }
+          : (modelRequest ?? clone(evidence));
         const sourceEnvelope = await issueSourceEnvelope(
           Object.freeze({
             schema: AGENT_EVOLUTION_INGRESS_SCHEMA,
@@ -259,6 +320,21 @@ export function createAgentEvolutionIngress({
             derivationManifestDigest: persisted.manifest.digest,
           },
         });
+        if (kind === "model-input") {
+          lastModelResponse = null;
+          modelAdmissionPending = true;
+        } else if (kind === "response-completed" && modelAdmissionPending) {
+          lastModelResponse = { eventId, event: clone(payload.event) };
+          modelAdmissionPending = false;
+        }
+        if (cacheRecord)
+          return clone({
+            schema: "chainlesschain.model-response-cache-receipt/v1",
+            tenantId: descriptor.tenantId,
+            runId: descriptor.runId,
+            eventId,
+            artifact: persisted,
+          });
         if (modelRequest === null) return appended;
         // Resolve the published manifest and every attested component afresh.
         // The prototype call requires the real adapter's private state; an
@@ -284,49 +360,164 @@ export function createAgentEvolutionIngress({
         ) {
           throw new Error("Agent model projection Run frontier changed");
         }
-        if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
+        if (admissionFailure !== null) throw admissionFailure;
         return buildAgentModelRequest(
           modelRequest,
           resolved.bundle.modelProjection,
         );
-      }, modelRequest !== null),
+      }),
     );
 
   const ingress = Object.freeze({
     schema: AGENT_EVOLUTION_INGRESS_SCHEMA,
     tenantId: descriptor.tenantId,
     runId: descriptor.runId,
+    createResponseCacheReceipt: async (input) => {
+      const snapshot = cloneEvidence(input);
+      const requestKey = snapshot?.requestKey;
+      if (
+        typeof requestKey !== "string" ||
+        !/^[a-f0-9]{64}$/.test(requestKey)
+      ) {
+        admissionFailure ??= ingressFailure(
+          new TypeError("Cache request key must be SHA-256"),
+        );
+        throw admissionFailure;
+      }
+      return ingest("model-response-cache", { requestKey }, {}, null, true);
+    },
+    replayResponseCache: async (input) => {
+      const snapshot = cloneEvidence(input);
+      const response = await guardIngress(
+        serialize(async () => {
+          const { receipt, requestKey } = snapshot;
+          if (
+            typeof requestKey !== "string" ||
+            !/^[a-f0-9]{64}$/.test(requestKey) ||
+            !receipt ||
+            receipt.schema !==
+              "chainlesschain.model-response-cache-receipt/v1" ||
+            receipt.tenantId !== descriptor.tenantId ||
+            !openCacheSourceRun
+          )
+            throw new Error("Invalid or cross-tenant response cache receipt");
+          const opened = openCacheSourceRun(receipt.runId);
+          const source = opened?.runAdapter;
+          if (
+            !(source instanceof EvolutionRunLedgerAdapter) ||
+            !(
+              opened.evidenceAdapter instanceof EvolutionEvidenceArtifactAdapter
+            ) ||
+            source.descriptor.tenantId !== descriptor.tenantId ||
+            source.descriptor.runId !== receipt.runId
+          )
+            throw new Error("Unbound response cache source Run");
+          const loaded = source.load();
+          const event = loaded.events.find(
+            (item) => item.eventId === receipt.eventId,
+          );
+          if (
+            loaded.projection?.status !== "completed" ||
+            event?.data?.evidenceKind !== "model-response-cache" ||
+            event.subjectId !== receipt.artifact?.evidenceId ||
+            event.artifactRef !== receipt.artifact?.manifest?.ref?.ref ||
+            event.payloadDigest !== receipt.artifact?.manifest?.digest
+          )
+            throw new Error(
+              "Cache receipt is not committed in a completed Run",
+            );
+          const resolved =
+            await EvolutionEvidenceArtifactAdapter.prototype.resolve.call(
+              opened.evidenceAdapter,
+              receipt.artifact,
+            );
+          const projection = resolved.bundle.modelProjection;
+          const record = projection.content;
+          if (
+            resolved.verification.verified !== true ||
+            resolved.verification.tenantId !== descriptor.tenantId ||
+            projection.rulesetDigest !== EVOLUTION_PROJECTION_RULESET_DIGEST ||
+            projection.visibility !== "model-visible" ||
+            projection.truncated ||
+            projection.injectionFindings.length !== 0 ||
+            record?.schema !== "chainlesschain.model-response-cache/v1" ||
+            record.requestKey !== requestKey ||
+            record.sourceRunId !== receipt.runId ||
+            record.responseEvent?.type !== "response-complete"
+          )
+            throw new Error(
+              "Cache response projection is not safe or request-bound",
+            );
+          const responseEvent = loaded.events.find(
+            (item) => item.eventId === record.sourceEventId,
+          );
+          if (
+            responseEvent?.data?.evidenceKind !== "response-completed" ||
+            responseEvent.sequence >= event.sequence
+          )
+            throw new Error("Cache receipt lacks its preceding model response");
+          // Reopen after asynchronous attestation checks; no cached Run authority.
+          if (digest(source.load()) !== digest(loaded))
+            throw new Error("Cache source Run changed during verification");
+          return clone(record.responseEvent);
+        }),
+      );
+      await ingest("model-response-cache-replayed", {
+        requestKey: snapshot.requestKey,
+        sourceReceipt: snapshot.receipt,
+        responseEvent: response,
+      });
+      return response;
+    },
     start: () => guardIngress(serialize(() => appendStarted())),
     prepareModelRequest: (request) => {
-      if (modelAdmissionFailure !== null)
-        return Promise.reject(modelAdmissionFailure);
+      if (admissionFailure !== null) return Promise.reject(admissionFailure);
       let snapshot;
       try {
         snapshot = snapshotAgentModelRequest(request);
       } catch (error) {
-        modelAdmissionFailure = ingressFailure(error);
-        return Promise.reject(modelAdmissionFailure);
+        admissionFailure = ingressFailure(error);
+        return Promise.reject(admissionFailure);
       }
       return ingest("model-input", snapshot, {}, snapshot);
     },
-    ingestUserPrompt: (input, options) =>
-      ingest("user-prompt", { input: clone(input) }, options),
-    ingestAgentEvent: (event, options) => {
-      const baseKind = CORE_EVENT_KINDS.get(event?.type);
+    ingestUserPrompt: async (input, options) =>
+      ingest("user-prompt", { input: cloneEvidence(input) }, options),
+    ingestAgentEvent: async (event, options) => {
+      if (admissionFailure !== null) throw admissionFailure;
+      let type;
+      try {
+        if (types.isProxy(event))
+          throw new TypeError("Agent event cannot be a Proxy");
+        const property =
+          event && typeof event === "object"
+            ? Object.getOwnPropertyDescriptor(event, "type")
+            : null;
+        if (property && !("value" in property))
+          throw new TypeError("Agent event type cannot be an accessor");
+        type = property?.value;
+      } catch (cause) {
+        admissionFailure = ingressFailure(cause);
+        throw admissionFailure;
+      }
+      const baseKind = CORE_EVENT_KINDS.get(type);
       if (!baseKind) {
         return Promise.resolve(Object.freeze({ ignored: true }));
       }
+      const snapshot = cloneEvidence(event);
       const kind =
-        event.type === "tool-result" &&
-        Boolean(event.error || event.result?.error || event.result?.isError)
+        type === "tool-result" &&
+        Boolean(
+          snapshot.error || snapshot.result?.error || snapshot.result?.isError,
+        )
           ? "tool-failed"
           : baseKind;
-      return ingest(kind, { event: clone(event) }, options);
+      return ingest(kind, { event: snapshot }, options);
     },
     complete: (options = {}) =>
       guardIngress(
         serialize(async () => {
-          if (modelAdmissionFailure !== null) throw modelAdmissionFailure;
+          if (admissionFailure !== null) throw admissionFailure;
           const loaded = runAdapter.load();
           let projection;
           if (loaded.projection?.status === "completed") {

package/src/lib/evolution/agent-evolution-runtime-composition.js

@@ -122,7 +122,7 @@ function normalizeClock(clock) {
   });
 }
 
-function layout(stateRootDir, tenantId, runId) {
+function layout(stateRootDir, tenantId, runId, initialize = true) {
   if (typeof stateRootDir !== "string" || stateRootDir.trim() === "") {
     throw new TypeError("stateRootDir is required");
   }
@@ -140,10 +140,11 @@ function layout(stateRootDir, tenantId, runId) {
     ledgerAuthorityRootDir: path.join(scope, "ledger-authority"),
     witnessFilePath: path.join(scope, "witness", "checkpoint.json"),
   });
-  fs.mkdirSync(path.dirname(result.witnessFilePath), {
-    recursive: true,
-    mode: 0o700,
-  });
+  if (initialize)
+    fs.mkdirSync(path.dirname(result.witnessFilePath), {
+      recursive: true,
+      mode: 0o700,
+    });
   return result;
 }
 
@@ -350,6 +351,26 @@ export function createAgentEvolutionRuntimeComposition({
     ...(witnessMaximumBytes === undefined ? {} : { witnessMaximumBytes }),
   });
   captureEvolutionLedgerFileBackend(backend);
+  const cacheSourceAuthorities = Object.freeze(
+    Object.fromEntries(
+      ["ledger", "witness"].map((kind) => [
+        kind,
+        Object.freeze({
+          trust: Object.freeze({ ...backend.descriptor[`${kind}Trust`] }),
+          signer: captureAuthority(
+            authorities[kind].signer,
+            "sign",
+            `cache ${kind} signer`,
+          ),
+          verifier: captureAuthority(
+            authorities[kind].verifier,
+            "verify",
+            `cache ${kind} verifier`,
+          ),
+        }),
+      ]),
+    ),
+  );
   const runAdapter = new EvolutionRunLedgerAdapter({
     descriptor: {
       tenantId,
@@ -459,6 +480,65 @@ export function createAgentEvolutionRuntimeComposition({
   const evolutionIngress = createAgentEvolutionIngress({
     evidenceAdapter,
     runAdapter,
+    openCacheSourceRun: (input) => {
+      const sourceRunId = identifier(input, "cache source runId");
+      const sourceStorage = layout(
+        storage.rootDir,
+        tenantId,
+        sourceRunId,
+        false,
+      );
+      if (!fs.existsSync(sourceStorage.witnessFilePath))
+        throw new Error("Cache source Run witness does not exist");
+      const sourcePorts = new EvolutionArtifactPorts({
+        tenantId,
+        audience,
+        artifactStore: new ArtifactStore({
+          dir: sourceStorage.artifactDir,
+          now: clock,
+        }),
+        envelopeSigner: ports.artifactEnvelopeSigner,
+        envelopeVerifier: ports.artifactEnvelopeVerifier,
+        currentAuthorityResolver: ports.artifactCurrentAuthorityResolver,
+        now: clock,
+      });
+      const sourceResolver = sourcePorts.createEvolutionLedgerArtifactResolver({
+        purpose: "evolution-ledger",
+      });
+      const sourceBackend = createEvolutionLedgerFileBackend({
+        rootDir: sourceStorage.ledgerRootDir,
+        authorityRootDir: sourceStorage.ledgerAuthorityRootDir,
+        witnessFilePath: sourceStorage.witnessFilePath,
+        witnessId: witnessIdInput ?? defaultWitnessId(tenantId, sourceRunId),
+        ledgerAuthority: cacheSourceAuthorities.ledger,
+        witnessAuthority: cacheSourceAuthorities.witness,
+        artifactResolver: sourceResolver,
+        secure,
+        clock,
+        ...(fsImpl === undefined ? {} : { fsImpl }),
+        ...(lock === undefined ? {} : { lock }),
+        ...(random === undefined ? {} : { random }),
+        ...(lockTimeoutMs === undefined ? {} : { lockTimeoutMs }),
+        ...(witnessMaximumBytes === undefined ? {} : { witnessMaximumBytes }),
+      });
+      return {
+        runAdapter: new EvolutionRunLedgerAdapter({
+          descriptor: { ...runAdapter.descriptor, runId: sourceRunId },
+          artifactPorts: sourcePorts,
+          ledger: sourceBackend.ledger,
+          ledgerArtifactResolver: sourceResolver,
+          now: clock,
+        }),
+        evidenceAdapter: new EvolutionEvidenceArtifactAdapter({
+          tenantId,
+          audience,
+          projector,
+          bundleVerifier,
+          artifactPorts: sourcePorts,
+          ...(evidenceTtlMs === undefined ? {} : { ttlMs: evidenceTtlMs }),
+        }),
+      };
+    },
     sourceEnvelopeAuthority: ports.sourceEnvelope,
     wikiMaintenanceProducer,
     releaseTrain,

package/src/lib/evolution/evolution-deployment-loader.js

@@ -9,9 +9,15 @@ export const EVOLUTION_DEPLOYMENT_DESCRIPTOR_SCHEMA =
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const SUPPORTED_COMMANDS = new Set([
   "agent",
+  "ask",
+  "chat",
+  "compact",
+  "complete",
+  "cowork",
   "desktop",
   "evolution",
   "marketplace",
+  "orchestrate",
   "serve",
 ]);
 
@@ -273,7 +279,17 @@ async function loadBuiltInFactories(commandName) {
         new GovernedKnowledgeQuarantineReleaseLedger(options),
     });
   }
-  if (commandName === "agent" || commandName === "serve") {
+  if (
+    commandName === "agent" ||
+    commandName === "ask" ||
+    commandName === "chat" ||
+    commandName === "compact" ||
+    commandName === "complete" ||
+    commandName === "desktop" ||
+    commandName === "cowork" ||
+    commandName === "orchestrate" ||
+    commandName === "serve"
+  ) {
     const { createAgentEvolutionRuntimeComposition } =
       await import("./agent-evolution-runtime-composition.js");
     factories.createAgentEvolutionRuntimeComposition =

package/src/lib/evolution/evolution-evidence-projector.js

@@ -457,6 +457,19 @@ const RULESET_DIGEST = `sha256:${createHash("sha256")
   )
   .digest("hex")}`;
 
+// Keep v2 and every Agent ruleset byte-identical for historical verification.
+// New raw-event projections scan finite numeric scalars as well as strings;
+// encrypted Raw remains unchanged, including the original numeric types.
+const RAW_RULESET_V3 = Object.freeze({
+  ...RULESET,
+  schema: "chainlesschain.evolution-projection-rules/v3",
+  version: 3,
+  numericScalarPolicy: "safe-integer-sensitive-text-redaction-v1",
+});
+const RAW_RULESET_V3_DIGEST = `sha256:${createHash("sha256")
+  .update(`${RAW_RULESET_V3.schema}\0${JSON.stringify(RAW_RULESET_V3)}`, "utf8")
+  .digest("hex")}`;
+
 // A separate policy keeps existing v2 artifacts readable without changing
 // their meaning/digest. Agent messages are authenticated and scanned as whole
 // fields; the existing total model-content ceiling still applies. Never scan
@@ -512,6 +525,7 @@ export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST = `sha256:${createH
   .digest("hex")}`;
 const SUPPORTED_RULESETS = new Map([
   [RULESET_DIGEST, RULESET],
+  [RAW_RULESET_V3_DIGEST, RAW_RULESET_V3],
   [AGENT_MODEL_RULESET_V1_DIGEST, AGENT_MODEL_RULESET_V1],
   [EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V2_DIGEST, AGENT_MODEL_RULESET_V2],
   [EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST, AGENT_MODEL_RULESET],
@@ -1300,7 +1314,7 @@ function sanitizePayload(
           "Raw payload contains a non-finite number",
         );
       }
-      if (jsonText) {
+      if (jsonText || ruleset.numericScalarPolicy) {
         if (Number.isInteger(value) && !Number.isSafeInteger(value)) {
           throw projectionError(
             EVOLUTION_PROJECTION_INVALID_CODE,
@@ -3107,7 +3121,7 @@ function validateBundleIntegrity(bundle) {
       }
     }
     if (
-      ruleset.jsonTextPolicy &&
+      (ruleset.jsonTextPolicy || ruleset.numericScalarPolicy) &&
       canonicalJson(sanitizePayload(model.content, ruleset).content) !==
         canonicalJson(model.content)
     ) {
@@ -3347,7 +3361,7 @@ export class EvolutionEvidenceProjector {
   }
 
   project(input) {
-    return this.#project(input, RULESET);
+    return this.#project(input, RAW_RULESET_V3);
   }
 
   projectAgentModelRequest(input) {
@@ -3615,10 +3629,14 @@ export class EvolutionEvidenceProjector {
       sanitized,
       ruleset === AGENT_MODEL_RULESET
         ? EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST
-        : RULESET_DIGEST,
+        : RAW_RULESET_V3_DIGEST,
     );
     const trustedSanitized = source.compilable
-      ? sanitizePayload(source.trustedPayload, RULESET, valuePatterns(ruleset))
+      ? sanitizePayload(
+          source.trustedPayload,
+          ruleset === RAW_RULESET_V3 ? RAW_RULESET_V3 : RULESET,
+          valuePatterns(ruleset),
+        )
       : null;
     const trustedInputStructured =
       source.compilable && isStructuredTrustedPayload(source.trustedPayload);
@@ -4077,4 +4095,5 @@ Object.freeze(EvolutionEvidenceProjector.prototype);
 Object.freeze(EvolutionEvidenceBundleVerifier.prototype);
 Object.freeze(EvolutionEvidenceReader.prototype);
 
-export const EVOLUTION_PROJECTION_RULESET_DIGEST = RULESET_DIGEST;
+export const EVOLUTION_PROJECTION_RULESET_V2_DIGEST = RULESET_DIGEST;
+export const EVOLUTION_PROJECTION_RULESET_DIGEST = RAW_RULESET_V3_DIGEST;

package/src/lib/model-failure-policy.js

@@ -1,5 +1,15 @@
 import { isAbortError } from "./abort-utils.js";
 
+export function isEvolutionIngressFailure(error) {
+  const visited = new Set();
+  for (let current = error; current; current = current.cause) {
+    if (visited.has(current) || visited.size >= 32) return true;
+    visited.add(current);
+    if (current.code === "CC_AGENT_EVOLUTION_INGRESS_FAILED") return true;
+  }
+  return false;
+}
+
 // Admission failures are not provider outages, even when their causes contain
 // HTTP status codes or retryable/authentication words.
 export function isTerminalModelFailure(error) {