chainlesschain 0.166.21 → 0.166.24

package/src/lib/evolution/evidence-json-text.js

@@ -0,0 +1,236 @@
+// Decode data only: no evaluation, revivers, prototype setters or permissive
+// JSON repair. Budgets belong to the entire projection, including nested text.
+export const EVIDENCE_JSON_POLICY = Object.freeze({
+  version: 1,
+  maxLayers: 4,
+  maxDepth: 16,
+  maxNodes: 4096,
+  maxDecodedBytes: 4 * 1024 * 1024,
+  duplicates: "reject-decoded-keys",
+  malformed: "reject-recognized-json",
+  arguments: "object-only",
+  numbers: "finite-safe-integers-pii-to-string",
+});
+
+export function isAgentToolArgumentsPath(path) {
+  return (
+    path.length === 6 &&
+    path[0] === "messages" &&
+    /^\d+$/u.test(path[1]) &&
+    path[2] === "tool_calls" &&
+    /^\d+$/u.test(path[3]) &&
+    path[4] === "function" &&
+    path[5] === "arguments"
+  );
+}
+
+function assignmentKeyBefore(text, start, end) {
+  let index = end - 1;
+  while (index >= start && /\s/u.test(text[index])) index--;
+  if (text[index] !== ":" && text[index] !== "=") return undefined;
+  index--;
+  while (index >= start && /\s/u.test(text[index])) index--;
+  const keyEnd = index + 1;
+  while (index >= start && !/[\s"'{}[\],:=]/u.test(text[index])) index--;
+  return keyEnd > index + 1 ? text.slice(index + 1, keyEnd) : undefined;
+}
+
+export function createEvidenceJsonTextBoundary(fail) {
+  let nodes = 0;
+  let bytes = 0;
+  const reject = () => {
+    throw fail(
+      "Agent model JSON text is malformed, ambiguous or exceeds its budget",
+    );
+  };
+  const parser = (text, start) => {
+    let index = start;
+    const whitespace = () => {
+      while (/[ \t\r\n]/u.test(text[index] ?? "x")) index++;
+    };
+    const string = () => {
+      const begin = index++;
+      while (index < text.length) {
+        const char = text[index++];
+        if (char === "\\") index++;
+        else if (char === '"') {
+          try {
+            return JSON.parse(text.slice(begin, index));
+          } catch {
+            return reject();
+          }
+        }
+      }
+      return reject();
+    };
+    const value = (depth = 0) => {
+      if (
+        ++nodes > EVIDENCE_JSON_POLICY.maxNodes ||
+        depth > EVIDENCE_JSON_POLICY.maxDepth
+      )
+        reject();
+      whitespace();
+      const char = text[index];
+      if (char === '"') return string();
+      if (char === "{" || char === "[") {
+        const array = char === "[";
+        const end = array ? "]" : "}";
+        const output = array ? [] : Object.create(null);
+        index++;
+        whitespace();
+        if (text[index] === end) {
+          index++;
+          return output;
+        }
+        while (index < text.length) {
+          let key;
+          if (!array) {
+            if (text[index] !== '"') reject();
+            key = string();
+            if (Object.hasOwn(output, key)) reject();
+            whitespace();
+            if (text[index++] !== ":") reject();
+          }
+          const child = value(depth + 1);
+          if (array) output.push(child);
+          else
+            Object.defineProperty(output, key, {
+              value: child,
+              enumerable: true,
+            });
+          whitespace();
+          if (text[index] === end) {
+            index++;
+            return output;
+          }
+          if (text[index++] !== ",") reject();
+          whitespace();
+        }
+        return reject();
+      }
+      const token =
+        /^(?:true|false|null|-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?)/u.exec(
+          text.slice(index),
+        )?.[0];
+      if (!token) return reject();
+      index += token.length;
+      const parsed = JSON.parse(token);
+      if (
+        typeof parsed === "number" &&
+        (!Number.isFinite(parsed) ||
+          (Number.isInteger(parsed) && !Number.isSafeInteger(parsed)))
+      )
+        reject();
+      return parsed;
+    };
+    return {
+      value,
+      end: () => index,
+      whitespace,
+    };
+  };
+
+  return (text, { layer = 0, objectOnly = false, visit, plain, equal }) => {
+    bytes += Buffer.byteLength(text, "utf8");
+    if (bytes > EVIDENCE_JSON_POLICY.maxDecodedBytes) reject();
+    const transform = (parsed) => {
+      if (layer >= EVIDENCE_JSON_POLICY.maxLayers) reject();
+      return visit(parsed, layer + 1);
+    };
+    if (objectOnly) {
+      const reader = parser(text, 0);
+      const parsed = reader.value();
+      reader.whitespace();
+      if (
+        reader.end() !== text.length ||
+        !parsed ||
+        typeof parsed !== "object" ||
+        Array.isArray(parsed)
+      )
+        reject();
+      const safe = transform(parsed);
+      return equal(parsed, safe) ? text : JSON.stringify(safe);
+    }
+
+    // Scan once, consuming each JSON span in full. Quoted scalar fragments
+    // decode escaped secrets; quoted key/value fragments use the same key rules
+    // as objects. Ordinary code braces and projection markers are not JSON.
+    let output = "";
+    let plainStart = 0;
+    for (let index = 0; index < text.length;) {
+      const char = text[index];
+      const next =
+        char === "{" || char === "["
+          ? text.slice(index + 1).match(/^\s*(.)/u)?.[1]
+          : undefined;
+      const container =
+        (char === "{" &&
+          (next === '"' || next === "}" || next === "'" || next === "\\")) ||
+        (char === "[" &&
+          next !== undefined &&
+          (["[", "{", '"', "]"].includes(next) ||
+            /[0-9]/u.test(next) ||
+            /^\s*(?:-\d|(?:true|false|null)(?=[\s,\]]))/u.test(
+              text.slice(index + 1),
+            )));
+      if (!container && char !== '"') {
+        index++;
+        continue;
+      }
+      // A prose quotation can contain newlines/ordinary backslashes. Only a
+      // lexically valid JSON string is a candidate outside JSON containers.
+      if (
+        !container &&
+        // eslint-disable-next-line no-control-regex -- JSON strings exclude literal U+0000 through U+001F.
+        !/^"(?:[^"\\\x00-\x1f]|\\(?:["\\/bfnrt]|u[0-9a-fA-F]{4}))*"/u.test(
+          text.slice(index),
+        )
+      ) {
+        index++;
+        continue;
+      }
+      const reader = parser(text, index);
+      let parsed = reader.value();
+      const valueEnd = reader.end();
+      reader.whitespace();
+      const pair = char === '"' && text[reader.end()] === ":";
+      const assignmentKey =
+        char === '"' && !pair
+          ? // Scan backward once; an unanchored greedy key regex would retry at
+            // every offset of a long ordinary prefix before a quoted fragment.
+            assignmentKeyBefore(text, plainStart, index)
+          : undefined;
+      let end = valueEnd;
+      if (pair) {
+        const rhs = parser(text, reader.end() + 1);
+        const entry = rhs.value();
+        parsed = Object.defineProperty(Object.create(null), parsed, {
+          value: entry,
+          enumerable: true,
+        });
+        end = rhs.end();
+      } else if (assignmentKey) {
+        // Bare assignments followed by a quoted value cross a text/JSON span.
+        // Reuse decoded field rules rather than a second credential-key list.
+        parsed = Object.defineProperty(Object.create(null), assignmentKey, {
+          value: parsed,
+          enumerable: true,
+        });
+      }
+      const safe = transform(parsed);
+      let replacement = text.slice(index, end);
+      if (!equal(parsed, safe)) {
+        replacement = JSON.stringify(safe);
+        if (pair) replacement = replacement.slice(1, -1);
+        else if (assignmentKey) {
+          if (!Object.hasOwn(safe, assignmentKey)) reject();
+          replacement = JSON.stringify(safe[assignmentKey]);
+        }
+      }
+      output += plain(text.slice(plainStart, index)) + replacement;
+      index = end;
+      plainStart = index;
+    }
+    return output + plain(text.slice(plainStart));
+  };
+}

package/src/lib/evolution/evolution-artifact-ports.js

@@ -60,6 +60,7 @@ export const EVOLUTION_ARTIFACT_DEFAULT_TTL_MS = 15 * 60 * 1000;
 export const EVOLUTION_ARTIFACT_MAX_TTL_MS = 24 * 60 * 60 * 1000;
 export const EVOLUTION_ARTIFACT_RETENTIONS = Object.freeze(["ttl", "ledger"]);
 export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_TYPES = Object.freeze([
+  "controlled-skill-pilot-state",
   "skill-release-transition-intent",
   "skill-release-finalization",
   "skill-release-state-migration",
@@ -67,22 +68,43 @@ export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_TYPES = Object.freeze([
   "skill-mutation-nonce-claim",
   "skill-promotion-review-decision",
   "skill-promotion-review-packet",
+  "evolution-workbench-projection",
+  "evolution-workbench-review-preparation",
+  "evolution-workbench-review-settlement",
+  "evolution-workbench-rollback-preparation",
+  "evolution-workbench-rollback-settlement",
   "skill-registry-transition-attempt",
   "skill-registry-transition-request",
   "skill-registry-transition-settlement",
+  "skill-retrieval-revocation-state",
   "evolution-run-event",
+  "evolution-eval-child-evidence",
+  "evolution-raw-deletion-receipt",
+  "evolution-raw-deletion-tombstone",
+  "evolution-release-train-checkpoint",
+  "evolution-release-train-stage-output",
+  "evolvable-artifact-candidate",
+  "evolvable-artifact-transition",
   "evolution-workbench-metrics-receipt-retention",
   "evolution-workbench-metrics-snapshot",
   "governed-knowledge-sync-record",
   "governed-knowledge-merge-operation",
   "governed-knowledge-dependency-operation",
   "governed-knowledge-trust-record",
+  "governed-skill-marketplace-state",
   "structured-memory-authority-receipt",
   "structured-memory-event",
   "structured-memory-snapshot",
   "wiki-maintenance-request",
   "wiki-maintenance-settlement",
   "wiki-revision",
+  "wiki-pruning-journal",
+  "wiki-pruning-retrieval-projection",
+  "wiki-skill-proposal",
+  "wikiskill-benchmark-envelope-manifest",
+  "wikiskill-benchmark-execution-manifest",
+  "wikiskill-benchmark-plan",
+  "wikiskill-benchmark-report-chunk",
 ]);
 export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_PURPOSES = Object.freeze([
   "evolution-ledger",
@@ -98,6 +120,7 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "actor",
   "candidate",
   "candidate-diff",
+  "controlled-skill-pilot-state",
   "diff",
   "eval",
   "eval-policy",
@@ -106,12 +129,20 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "evaluation",
   "evaluation-result",
   "evolution-run-event",
+  "evolution-eval-child-evidence",
+  "evolution-raw-deletion-receipt",
+  "evolution-raw-deletion-tombstone",
+  "evolution-release-train-checkpoint",
+  "evolution-release-train-stage-output",
+  "evolvable-artifact-candidate",
+  "evolvable-artifact-transition",
   "evolution-workbench-metrics-receipt-retention",
   "evolution-workbench-metrics-snapshot",
   "governed-knowledge-sync-record",
   "governed-knowledge-merge-operation",
   "governed-knowledge-dependency-operation",
   "governed-knowledge-trust-record",
+  "governed-skill-marketplace-state",
   "evidence",
   "model-projection",
   "policy",
@@ -126,9 +157,15 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "skill-mutation-nonce-claim",
   "skill-promotion-review-decision",
   "skill-promotion-review-packet",
+  "evolution-workbench-projection",
+  "evolution-workbench-review-preparation",
+  "evolution-workbench-review-settlement",
+  "evolution-workbench-rollback-preparation",
+  "evolution-workbench-rollback-settlement",
   "skill-registry-transition-attempt",
   "skill-registry-transition-request",
   "skill-registry-transition-settlement",
+  "skill-retrieval-revocation-state",
   "skill-release-finalization",
   "skill-release-state-migration",
   "structured-memory-authority-receipt",
@@ -137,6 +174,13 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "wiki-maintenance-request",
   "wiki-maintenance-settlement",
   "wiki-revision",
+  "wiki-pruning-journal",
+  "wiki-pruning-retrieval-projection",
+  "wiki-skill-proposal",
+  "wikiskill-benchmark-envelope-manifest",
+  "wikiskill-benchmark-execution-manifest",
+  "wikiskill-benchmark-plan",
+  "wikiskill-benchmark-report-chunk",
   "skill-release-transition-intent",
   "source",
   "source-evidence",
@@ -292,6 +336,7 @@ const CONSTRUCTOR_REQUIRED_KEYS = new Set([
 ]);
 const LEDGER_RESOLVER_OPTION_KEYS = new Set(["purpose"]);
 const EVOLUTION_LEDGER_ARTIFACT_RESOLVERS = new WeakSet();
+const EVOLUTION_LEDGER_BATCH_RESOLVERS = new WeakMap();
 const isProxy = Object.freeze(utilTypes.isProxy.bind(utilTypes));
 const isDate = Object.freeze(utilTypes.isDate.bind(utilTypes));
 const dateGetTime = Object.freeze(
@@ -299,6 +344,7 @@ const dateGetTime = Object.freeze(
 );
 const RETENTION_SET = new Set(EVOLUTION_ARTIFACT_RETENTIONS);
 const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
+  ["controlled-skill-pilot-state", new Set(["evolution-ledger"])],
   [
     "skill-release-transition-intent",
     new Set(["evolution-ledger", "skill-release-transition"]),
@@ -315,10 +361,25 @@ const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
   ],
   ["skill-promotion-review-decision", new Set(["evolution-ledger"])],
   ["skill-promotion-review-packet", new Set(["evolution-ledger"])],
+  ["evolution-workbench-projection", new Set(["evolution-ledger"])],
+  ["evolution-workbench-review-preparation", new Set(["evolution-ledger"])],
+  ["evolution-workbench-review-settlement", new Set(["evolution-ledger"])],
+  ["evolution-workbench-rollback-preparation", new Set(["evolution-ledger"])],
+  ["evolution-workbench-rollback-settlement", new Set(["evolution-ledger"])],
   ["skill-registry-transition-attempt", new Set(["evolution-ledger"])],
   ["skill-registry-transition-request", new Set(["evolution-ledger"])],
   ["skill-registry-transition-settlement", new Set(["evolution-ledger"])],
+  ["skill-retrieval-revocation-state", new Set(["evolution-ledger"])],
+  ["wiki-pruning-journal", new Set(["evolution-ledger"])],
+  ["wiki-pruning-retrieval-projection", new Set(["evolution-ledger"])],
   ["evolution-run-event", new Set(["evolution-ledger"])],
+  ["evolution-eval-child-evidence", new Set(["evolution-ledger"])],
+  ["evolution-raw-deletion-receipt", new Set(["evolution-ledger"])],
+  ["evolution-raw-deletion-tombstone", new Set(["evolution-ledger"])],
+  ["evolution-release-train-checkpoint", new Set(["evolution-ledger"])],
+  ["evolution-release-train-stage-output", new Set(["evolution-ledger"])],
+  ["evolvable-artifact-candidate", new Set(["evolution-ledger"])],
+  ["evolvable-artifact-transition", new Set(["evolution-ledger"])],
   [
     "evolution-workbench-metrics-receipt-retention",
     new Set(["evolution-ledger"]),
@@ -328,7 +389,13 @@ const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
   ["governed-knowledge-merge-operation", new Set(["evolution-ledger"])],
   ["governed-knowledge-dependency-operation", new Set(["evolution-ledger"])],
   ["governed-knowledge-trust-record", new Set(["evolution-ledger"])],
+  ["governed-skill-marketplace-state", new Set(["evolution-ledger"])],
   ["wiki-revision", new Set(["evolution-ledger"])],
+  ["wiki-skill-proposal", new Set(["evolution-ledger"])],
+  ["wikiskill-benchmark-envelope-manifest", new Set(["evolution-ledger"])],
+  ["wikiskill-benchmark-execution-manifest", new Set(["evolution-ledger"])],
+  ["wikiskill-benchmark-plan", new Set(["evolution-ledger"])],
+  ["wikiskill-benchmark-report-chunk", new Set(["evolution-ledger"])],
   ["structured-memory-authority-receipt", new Set(["evolution-ledger"])],
   ["structured-memory-event", new Set(["evolution-ledger"])],
   ["structured-memory-snapshot", new Set(["evolution-ledger"])],
@@ -940,6 +1007,12 @@ function samePath(left, right) {
     : normalizedLeft === normalizedRight;
 }
 
+// The native implementation performs the same physical canonicalization
+// without the JS fallback's repeated ancestor lstats (especially costly on
+// Windows). Identity, containment, no-link and descriptor readback checks
+// below remain mandatory on every access; this does not cache any pathname.
+const physicalRealpath = (fs.realpathSync.native ?? fs.realpathSync).bind(fs);
+
 function isContained(root, candidate) {
   const relative = path.relative(root, candidate);
   return (
@@ -1008,7 +1081,7 @@ function inspectPhysicalDirectory(directory, label) {
   try {
     stat = fs.lstatSync(directory);
     assertDirectory(stat, label);
-    realPath = fs.realpathSync(directory);
+    realPath = physicalRealpath(directory);
   } catch (cause) {
     if (isEvolutionArtifactPortError(cause)) throw cause;
     throw artifactError(
@@ -1036,7 +1109,7 @@ function inspectPhysicalIndex(indexPath, rootRealPath) {
   try {
     pathStat = fs.lstatSync(indexPath);
     assertRegularSingleLink(pathStat, "ArtifactStore index");
-    realPath = fs.realpathSync(indexPath);
+    realPath = physicalRealpath(indexPath);
     if (
       !samePath(realPath, indexPath) ||
       !isContained(rootRealPath, realPath)
@@ -1315,7 +1388,7 @@ function readTrustedIndexSnapshot(layout) {
         "ArtifactStore index physical identity changed",
       );
     }
-    indexRealPath = fs.realpathSync(layout.indexPath);
+    indexRealPath = physicalRealpath(layout.indexPath);
     if (
       !samePath(indexRealPath, layout.indexRealPath) ||
       !samePath(indexRealPath, layout.indexPath) ||
@@ -1372,7 +1445,7 @@ function readTrustedIndexSnapshot(layout) {
     if (
       !sameFileIdentity(beforePathStat, afterPathStat) ||
       !samePhysicalIdentity(afterPathStat, layout.indexIdentity) ||
-      !samePath(fs.realpathSync(layout.indexPath), indexRealPath)
+      !samePath(physicalRealpath(layout.indexPath), indexRealPath)
     ) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -2075,9 +2148,13 @@ export class EvolutionArtifactPorts {
     }
   }
 
-  #assertUniqueRecordDigest(recordDigest, artifactId) {
+  #assertUniqueRecordDigest(
+    recordDigest,
+    artifactId,
+    entries = this.#boundedIndexEntries(),
+  ) {
     const matches = this.#entriesByDataField(
-      this.#boundedIndexEntries(),
+      entries,
       "recordDigest",
       recordDigest,
     );
@@ -2106,6 +2183,33 @@ export class EvolutionArtifactPorts {
     }
   }
 
+  #loadLedgerEntry(artifactId, recordDigest = null, snapshot = null) {
+    // Ledger resolution is read-only. Read the already attested physical index
+    // directly instead of invoking ArtifactStore.list/get (both acquire writer
+    // locks). Each read/batch obtains a fresh bounded descriptor snapshot;
+    // nothing caches index contents, signatures or current authority.
+    const { entries } =
+      snapshot ?? readTrustedIndexSnapshot(this.#store.layout);
+    const matches = this.#entriesByDataField(entries, "id", artifactId);
+    if (matches.length === 0) {
+      throw artifactError(
+        EVOLUTION_ARTIFACT_NOT_FOUND_CODE,
+        "evolution artifact index entry was removed or expired",
+        { artifactId },
+      );
+    }
+    if (matches.length !== 1) {
+      throw artifactError(
+        EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+        "evolution artifact id has duplicate index rows",
+        { artifactId },
+      );
+    }
+    if (recordDigest !== null)
+      this.#assertUniqueRecordDigest(recordDigest, artifactId, entries);
+    return matches[0];
+  }
+
   #validateLineage(value, envelope, core, envelopeDigest) {
     assertExactRecord(
       value,
@@ -2255,7 +2359,7 @@ export class EvolutionArtifactPorts {
     let afterDescriptorStat;
     let bytes;
     try {
-      rootRealPath = fs.realpathSync(filesRoot);
+      rootRealPath = physicalRealpath(filesRoot);
       if (!samePath(rootRealPath, this.#store.layout.filesRealPath)) {
         throw artifactError(
           EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -2264,7 +2368,7 @@ export class EvolutionArtifactPorts {
       }
       beforePathStat = fs.lstatSync(resolvedStoredPath);
       assertRegularSingleLink(beforePathStat, "stored artifact path");
-      targetRealPath = fs.realpathSync(resolvedStoredPath);
+      targetRealPath = physicalRealpath(resolvedStoredPath);
       if (!isContained(rootRealPath, targetRealPath)) {
         throw artifactError(
           EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -2314,7 +2418,7 @@ export class EvolutionArtifactPorts {
           "stored artifact pathname changed during readback",
         );
       }
-      const afterRealPath = fs.realpathSync(resolvedStoredPath);
+      const afterRealPath = physicalRealpath(resolvedStoredPath);
       if (!samePath(targetRealPath, afterRealPath)) {
         throw artifactError(
           EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -2789,14 +2893,21 @@ export class EvolutionArtifactPorts {
     options,
     artifactId,
     preauthenticated = null,
+    ledgerRead = false,
+    capturedLedgerEntry = null,
+    batchWindow = null,
   ) {
     const authentication =
       preauthenticated || this.#authenticateEnvelope(envelope, options);
-    this.#assertUniqueRecordDigest(
-      authentication.core.recordDigest,
-      artifactId,
-    );
-    const entry = this.#loadCurrentEntryById(artifactId);
+    if (!ledgerRead)
+      this.#assertUniqueRecordDigest(
+        authentication.core.recordDigest,
+        artifactId,
+      );
+    const entry = ledgerRead
+      ? (capturedLedgerEntry ??
+        this.#loadLedgerEntry(artifactId, authentication.core.recordDigest))
+      : this.#loadCurrentEntryById(artifactId);
     const normalizedEntry = this.#validateIndexEntry(
       entry,
       envelope,
@@ -2815,11 +2926,25 @@ export class EvolutionArtifactPorts {
       authentication.core.recordDigest,
     );
     const record = this.#parseRecordBytes(bytes, authentication.core);
-    this.#assertEntryStable(artifactId, entry);
-    this.#assertUniqueRecordDigest(
-      authentication.core.recordDigest,
-      artifactId,
-    );
+    if (ledgerRead && batchWindow === null) {
+      const after = this.#loadLedgerEntry(
+        artifactId,
+        authentication.core.recordDigest,
+      );
+      if (canonicalJson(after) !== canonicalJson(entry)) {
+        throw artifactError(
+          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+          "ArtifactStore index entry was replaced during ledger readback",
+          { artifactId },
+        );
+      }
+    } else if (!ledgerRead) {
+      this.#assertEntryStable(artifactId, entry);
+      this.#assertUniqueRecordDigest(
+        authentication.core.recordDigest,
+        artifactId,
+      );
+    }
     const releaseClock = this.#clock();
     if (
       releaseClock.milliseconds <
@@ -2859,6 +2984,13 @@ export class EvolutionArtifactPorts {
       ...receiptCore,
       receiptDigest: domainDigest(RESOLUTION_RECEIPT_DOMAIN, receiptCore),
     });
+    batchWindow?.push({
+      checkedAt: releaseClock.milliseconds,
+      expiresAt: Math.min(
+        authentication.core.expiresAtMs ?? Infinity,
+        authentication.authority.decisionExpiresAtMs,
+      ),
+    });
     return {
       artifactRef,
       authentication,
@@ -3212,7 +3344,7 @@ export class EvolutionArtifactPorts {
     });
   }
 
-  #resolveLedgerRequest(request, purpose) {
+  #resolveLedgerRequest(request, purpose, snapshot = null, batchWindow = null) {
     assertExactRecord(
       request,
       LEDGER_REQUEST_KEYS,
@@ -3239,7 +3371,7 @@ export class EvolutionArtifactPorts {
     const artifactRef = normalizeArtifactRef(
       ownData(request, "ref", "evolution ledger artifact request"),
     );
-    const entry = this.#loadCurrentEntryById(artifactRef.artifactId);
+    const entry = this.#loadLedgerEntry(artifactRef.artifactId, null, snapshot);
     assertExactRecord(
       entry,
       INDEX_ENTRY_KEYS,
@@ -3267,11 +3399,20 @@ export class EvolutionArtifactPorts {
       tenantId: this.#tenantId,
     });
     const authentication = this.#authenticateEnvelope(envelope, options);
+    if (snapshot !== null)
+      this.#assertUniqueRecordDigest(
+        authentication.core.recordDigest,
+        artifactRef.artifactId,
+        snapshot.entries,
+      );
     const resolved = this.#resolveAuthenticatedEntry(
       envelope,
       options,
       artifactRef.artifactId,
       authentication,
+      true,
+      entry,
+      batchWindow,
     );
     const ledgerReceiptCore = {
       artifactReceiptDigest: resolved.receipt.receiptDigest,
@@ -3296,6 +3437,36 @@ export class EvolutionArtifactPorts {
     });
   }
 
+  #resolveLedgerBatch(input, purpose) {
+    assertDenseDataArray(input, "ledger artifact batch", 128);
+    const requests = frozenCanonicalClone(input);
+    const snapshot = readTrustedIndexSnapshot(this.#store.layout);
+    const window = [];
+    const results = requests.map((request) =>
+      this.#resolveLedgerRequest(request, purpose, snapshot, window),
+    );
+    // One bounded synchronous read, not a cache: every envelope/current
+    // authority and payload is authenticated individually. Re-attest the full
+    // index after ALL reads, and all decision leases before releasing bytes.
+    const after = readTrustedIndexSnapshot(this.#store.layout);
+    if (after.bytesDigest !== snapshot.bytesDigest)
+      throw artifactError(
+        EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+        "ArtifactStore index changed during ledger batch readback",
+      );
+    const completed = this.#clock().milliseconds;
+    if (
+      window.some(
+        (entry) => completed < entry.checkedAt || completed >= entry.expiresAt,
+      )
+    )
+      throw artifactError(
+        EVOLUTION_ARTIFACT_EXPIRED_CODE,
+        "artifact authority expired before ledger batch release",
+      );
+    return Object.freeze(results);
+  }
+
   /** Return a frozen read-only function; it exposes no put/signing authority. */
   createEvolutionLedgerArtifactResolver(options = {}) {
     assertOptionalExactRecord(
@@ -3316,6 +3487,9 @@ export class EvolutionArtifactPorts {
     const resolveReadOnly = (request) =>
       this.#resolveLedgerRequest(request, normalizedPurpose);
     EVOLUTION_LEDGER_ARTIFACT_RESOLVERS.add(resolveReadOnly);
+    EVOLUTION_LEDGER_BATCH_RESOLVERS.set(resolveReadOnly, (requests) =>
+      this.#resolveLedgerBatch(requests, normalizedPurpose),
+    );
     return Object.freeze(resolveReadOnly);
   }
 }
@@ -3343,4 +3517,11 @@ export function isEvolutionLedgerArtifactResolver(value) {
   );
 }
 
+export function captureEvolutionLedgerBatchResolver(value) {
+  const resolve = EVOLUTION_LEDGER_BATCH_RESOLVERS.get(value);
+  if (!resolve)
+    throw new TypeError("a branded ledger artifact resolver is required");
+  return resolve;
+}
+
 Object.freeze(EvolutionArtifactPorts.prototype);