chainlesschain 0.166.115 → 0.166.118

package/src/lib/evolution/evolution-evidence-artifact-adapter.js

@@ -15,7 +15,9 @@ import {
   EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA,
   EVOLUTION_ARTIFACT_DEFAULT_TTL_MS,
   EVOLUTION_ARTIFACT_MAX_TTL_MS,
+  captureEvolutionArtifactStoreDirectoryBoundary,
 } from "./evolution-artifact-ports.js";
+import { EVOLUTION_EVIDENCE_STORAGE_TYPES } from "./evolution-evidence-storage-layout.js";
 import { EVOLUTION_ARTIFACT_REF_SCHEMA } from "./evolution-ledger.js";
 import {
   EVOLUTION_RAW_STORAGE_RECEIPT_SCHEMA,
@@ -353,6 +355,7 @@ export class EvolutionEvidenceArtifactAdapter {
     projector,
     bundleVerifier,
     artifactPorts,
+    typedArtifactPorts,
   } = {}) {
     this.#tenantId = normalizeId(tenantId, "evidence adapter tenantId");
     this.#audience = normalizeId(audience, "evidence adapter audience");
@@ -374,11 +377,50 @@ export class EvolutionEvidenceArtifactAdapter {
       EvolutionEvidenceBundleVerifier.prototype,
       "bundleVerifier",
     );
-    assertInstance(
-      artifactPorts,
-      EvolutionArtifactPorts.prototype,
-      "artifactPorts",
-    );
+    if (typedArtifactPorts !== undefined) {
+      if (artifactPorts !== undefined)
+        throw new TypeError(
+          "Evidence adapter requires exactly one storage layout",
+        );
+      assertPlainExact(
+        typedArtifactPorts,
+        new Set(EVOLUTION_EVIDENCE_STORAGE_TYPES),
+        "typedArtifactPorts",
+      );
+      const captured = {};
+      const identities = new Set();
+      for (const type of EVOLUTION_EVIDENCE_STORAGE_TYPES) {
+        const port = typedArtifactPorts[type];
+        const boundary =
+          captureEvolutionArtifactStoreDirectoryBoundary(port).descriptor;
+        if (
+          boundary.artifactTenantId !== this.#tenantId ||
+          boundary.audience !== this.#audience
+        )
+          throw new TypeError(
+            "Typed Evidence store scope does not match its adapter",
+          );
+        for (const directory of [boundary.root, boundary.files]) {
+          const identity = `${directory.identity.dev}:${directory.identity.ino}`;
+          if (identities.has(identity))
+            throw new TypeError("Typed Evidence stores must be distinct");
+          identities.add(identity);
+        }
+        captured[type] = port;
+      }
+      this.#ports = Object.freeze(captured);
+    } else {
+      assertInstance(
+        artifactPorts,
+        EvolutionArtifactPorts.prototype,
+        "artifactPorts",
+      );
+      this.#ports = Object.freeze(
+        Object.fromEntries(
+          EVOLUTION_EVIDENCE_STORAGE_TYPES.map((type) => [type, artifactPorts]),
+        ),
+      );
+    }
     this.#ttlMs = ttlMs;
     this.#project = captureMethod(projector, "project", "projector");
     this.#projectAgentModel = captureMethod(
@@ -392,16 +434,15 @@ export class EvolutionEvidenceArtifactAdapter {
       "projector",
     );
     this.#verify = captureMethod(bundleVerifier, "verify", "bundleVerifier");
-    this.#ports = artifactPorts;
     this.#resolveManifestRef =
-      artifactPorts.createEvolutionLedgerArtifactResolver({
+      this.#ports.evidence.createEvolutionLedgerArtifactResolver({
         purpose: this.#purpose,
       });
     Object.freeze(this);
   }
 
   #put(type, value) {
-    return this.#ports.putCanonical(type, value, {
+    return this.#ports[type].putCanonical(type, value, {
       audience: this.#audience,
       purpose: this.#purpose,
       retention: "ttl",
@@ -479,12 +520,15 @@ export class EvolutionEvidenceArtifactAdapter {
     if (result.manifest.type !== "evidence") {
       throw new TypeError("evidence manifest descriptor type is invalid");
     }
-    const manifestResolved = this.#ports.resolve(result.manifest.envelope, {
-      expectedDigest: result.manifest.digest,
-      expectedType: "evidence",
-      purpose: this.#purpose,
-      tenantId: this.#tenantId,
-    });
+    const manifestResolved = this.#ports.evidence.resolve(
+      result.manifest.envelope,
+      {
+        expectedDigest: result.manifest.digest,
+        expectedType: "evidence",
+        purpose: this.#purpose,
+        tenantId: this.#tenantId,
+      },
+    );
     return this.#resolveManifest(manifestResolved.value, result.evidenceId);
   }
 
@@ -553,7 +597,7 @@ export class EvolutionEvidenceArtifactAdapter {
       if (!descriptor || descriptor.type !== type) {
         throw new Error("evidence derivation component type is invalid");
       }
-      bundle[field] = this.#ports.resolve(descriptor.envelope, {
+      bundle[field] = this.#ports[type].resolve(descriptor.envelope, {
         expectedDigest: descriptor.digest,
         expectedType: type,
         purpose: this.#purpose,

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

@@ -11,12 +11,16 @@
 
 import { createHash, randomBytes } from "node:crypto";
 import {
+  AGENT_MODEL_REQUEST_LIMITS,
+  AGENT_MODEL_IMAGE_LIMITS,
   projectAgentOpaqueTransportBlock,
   snapshotAgentModelRequest,
 } from "./agent-model-projection.js";
 import { snapshotSkillDecisionPayload } from "./skill-decision-projection.js";
 import {
   createEvidenceJsonTextBoundary,
+  AGENT_FENCED_CODE_LANGUAGES,
+  AGENT_CODE_TEXT_RESULT_TOOLS,
   EVIDENCE_JSON_POLICY,
   isAgentToolArgumentsPath,
 } from "./evidence-json-text.js";
@@ -515,13 +519,56 @@ export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V2_DIGEST = `sha256:${crea
     "utf8",
   )
   .digest("hex")}`;
-const AGENT_MODEL_RULESET = Object.freeze({
+const AGENT_MODEL_RULESET_V3 = Object.freeze({
   ...AGENT_MODEL_RULESET_V2,
   schema: "chainlesschain.evolution-agent-model-projection-rules/v3",
   version: 3,
   opaqueTransportPolicy:
     "digest-bound-base64-image-and-signed-thinking-no-plaintext-projection-v1",
 });
+export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V3_DIGEST = `sha256:${createHash(
+  "sha256",
+)
+  .update(
+    `${AGENT_MODEL_RULESET_V3.schema}\0${JSON.stringify(AGENT_MODEL_RULESET_V3)}`,
+    "utf8",
+  )
+  .digest("hex")}`;
+const AGENT_MODEL_RULESET_V4 = Object.freeze({
+  ...AGENT_MODEL_RULESET_V3,
+  schema: "chainlesschain.evolution-agent-model-projection-rules/v4",
+  version: 4,
+  codeTextPolicy: "paired-code-source-and-result-literal-scan-v1",
+  codeTextResultTools: AGENT_CODE_TEXT_RESULT_TOOLS,
+  // ArtifactPorts caps the complete durable record at 1 MiB. Reserve room for
+  // provenance/findings and the record envelope; no storage limit is relaxed.
+  maxModelBytes: AGENT_MODEL_REQUEST_LIMITS.maxBytes - 128 * 1024,
+  maxStringChars: AGENT_MODEL_REQUEST_LIMITS.maxBytes - 128 * 1024,
+  maxNodes: AGENT_MODEL_REQUEST_LIMITS.maxNodes,
+  maxDepth: AGENT_MODEL_REQUEST_LIMITS.maxDepth,
+  decodedDepthPolicy: "independent-bounded-json-depth-v1",
+  imageBudget: AGENT_MODEL_IMAGE_LIMITS,
+  jsonTextPolicy: Object.freeze({
+    ...EVIDENCE_JSON_POLICY,
+    version: 2,
+    maxNodes: AGENT_MODEL_REQUEST_LIMITS.maxNodes,
+  }),
+});
+export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V4_DIGEST = `sha256:${createHash(
+  "sha256",
+)
+  .update(
+    `${AGENT_MODEL_RULESET_V4.schema}\0${JSON.stringify(AGENT_MODEL_RULESET_V4)}`,
+    "utf8",
+  )
+  .digest("hex")}`;
+const AGENT_MODEL_RULESET = Object.freeze({
+  ...AGENT_MODEL_RULESET_V4,
+  schema: "chainlesschain.evolution-agent-model-projection-rules/v5",
+  version: 5,
+  fencedCodePolicy: "closed-message-code-fence-literal-scan-v1",
+  fencedCodeLanguages: AGENT_FENCED_CODE_LANGUAGES,
+});
 export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST = `sha256:${createHash(
   "sha256",
 )
@@ -552,6 +599,8 @@ const SUPPORTED_RULESETS = new Map([
   [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_V3_DIGEST, AGENT_MODEL_RULESET_V3],
+  [EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V4_DIGEST, AGENT_MODEL_RULESET_V4],
   [EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST, AGENT_MODEL_RULESET],
 ]);
 
@@ -627,6 +676,8 @@ const AGENT_VALUE_PATTERNS = Object.freeze([
 function valuePatterns(ruleset) {
   return ruleset === SKILL_DECISION_RULESET ||
     ruleset === AGENT_MODEL_RULESET ||
+    ruleset === AGENT_MODEL_RULESET_V4 ||
+    ruleset === AGENT_MODEL_RULESET_V3 ||
     ruleset === AGENT_MODEL_RULESET_V2 ||
     ruleset === AGENT_MODEL_RULESET_V1
     ? AGENT_VALUE_PATTERNS
@@ -690,7 +741,12 @@ function assertExactRecord(
   }
 }
 
-function canonicalJson(value, seen = new Set(), depth = 0) {
+function canonicalJson(
+  value,
+  seen = new Set(),
+  depth = 0,
+  maximumBytes = 2 * 1024 * 1024,
+) {
   if (depth > 32) {
     throw projectionError(
       EVOLUTION_PROJECTION_INVALID_CODE,
@@ -712,10 +768,12 @@ function canonicalJson(value, seen = new Set(), depth = 0) {
     output = JSON.stringify(value);
   }
   if (output !== undefined) {
-    if (Buffer.byteLength(output, "utf8") > 2 * 1024 * 1024) {
+    if (Buffer.byteLength(output, "utf8") > maximumBytes) {
       throw projectionError(
         EVOLUTION_PROJECTION_INVALID_CODE,
-        "projection exceeds the 2 MiB admission limit",
+        maximumBytes === 2 * 1024 * 1024
+          ? "projection exceeds the 2 MiB admission limit"
+          : "Agent image transport exceeds its canonical byte budget",
       );
     }
     return output;
@@ -757,7 +815,9 @@ function canonicalJson(value, seen = new Set(), depth = 0) {
           "projection arrays must use enumerable own data entries",
         );
       }
-      entries.push(canonicalJson(descriptor.value, seen, depth + 1));
+      entries.push(
+        canonicalJson(descriptor.value, seen, depth + 1, maximumBytes),
+      );
     }
     output = `[${entries.join(",")}]`;
   } else {
@@ -784,24 +844,29 @@ function canonicalJson(value, seen = new Set(), depth = 0) {
         );
       }
       fields.push(
-        `${JSON.stringify(key)}:${canonicalJson(descriptor.value, seen, depth + 1)}`,
+        `${JSON.stringify(key)}:${canonicalJson(descriptor.value, seen, depth + 1, maximumBytes)}`,
       );
     }
     output = `{${fields.join(",")}}`;
   }
   seen.delete(value);
-  if (Buffer.byteLength(output, "utf8") > 2 * 1024 * 1024) {
+  if (Buffer.byteLength(output, "utf8") > maximumBytes) {
     throw projectionError(
       EVOLUTION_PROJECTION_INVALID_CODE,
-      "projection exceeds the 2 MiB admission limit",
+      maximumBytes === 2 * 1024 * 1024
+        ? "projection exceeds the 2 MiB admission limit"
+        : "Agent image transport exceeds its canonical byte budget",
     );
   }
   return output;
 }
 
-function digest(value, domain) {
+function digest(value, domain, maximumBytes) {
   return `sha256:${createHash("sha256")
-    .update(`${domain}\0${canonicalJson(value)}`, "utf8")
+    .update(
+      `${domain}\0${canonicalJson(value, new Set(), 0, maximumBytes)}`,
+      "utf8",
+    )
     .digest("hex")}`;
 }
 
@@ -1296,6 +1361,43 @@ function sanitizeString(value, path, findings, injections, ruleset, patterns) {
   return output;
 }
 
+function isAgentCodeTextPath(payload, path, resultToolNames) {
+  if (
+    path[0] !== "messages" ||
+    !/^\d+$/u.test(path[1] ?? "") ||
+    !Array.isArray(payload?.messages)
+  ) {
+    return false;
+  }
+  const message = payload.messages[Number(path[1])];
+  if (!message || typeof message !== "object") return false;
+  if (
+    path[2] === "tool_calls" &&
+    /^\d+$/u.test(path[3] ?? "") &&
+    path[4] === "function" &&
+    path[5] === "arguments"
+  ) {
+    const call = message.tool_calls?.[Number(path[3])];
+    const fields = path.slice(6);
+    if (fields[0] === "$json") fields.shift();
+    return call?.function?.name === "run_code" && fields[0] === "code";
+  }
+  if (path[2] === "content" && message.role === "tool") {
+    const callId = message.tool_call_id;
+    return payload.messages.some(
+      (candidate) =>
+        candidate?.role === "assistant" &&
+        Array.isArray(candidate.tool_calls) &&
+        candidate.tool_calls.some(
+          (call) =>
+            call?.id === callId &&
+            resultToolNames.includes(call?.function?.name),
+        ),
+    );
+  }
+  return false;
+}
+
 function sanitizePayload(
   payload,
   ruleset = RULESET,
@@ -1306,8 +1408,10 @@ function sanitizePayload(
   let nodes = 0;
   let truncated = false;
   const jsonText = ruleset.jsonTextPolicy
-    ? createEvidenceJsonTextBoundary((message) =>
-        projectionError(EVOLUTION_PROJECTION_INVALID_CODE, message),
+    ? createEvidenceJsonTextBoundary(
+        (message) =>
+          projectionError(EVOLUTION_PROJECTION_INVALID_CODE, message),
+        ruleset.jsonTextPolicy,
       )
     : null;
   const visit = (value, path, depth, layer = 0) => {
@@ -1323,7 +1427,9 @@ function sanitizePayload(
     }
     const toolArguments = jsonText && isAgentToolArgumentsPath(path);
     const opaqueTransportBlock =
-      ruleset === AGENT_MODEL_RULESET
+      ruleset === AGENT_MODEL_RULESET ||
+      ruleset === AGENT_MODEL_RULESET_V4 ||
+      ruleset === AGENT_MODEL_RULESET_V3
         ? projectAgentOpaqueTransportBlock(value, path.join("."))
         : null;
     if (opaqueTransportBlock !== null) return opaqueTransportBlock;
@@ -1337,11 +1443,34 @@ function sanitizePayload(
       const plain = (text) =>
         sanitizeString(text, path, findings, injections, ruleset, patterns);
       if (!jsonText) return plain(value);
+      const codeText =
+        ruleset.codeTextPolicy ===
+          "paired-code-source-and-result-literal-scan-v1" &&
+        isAgentCodeTextPath(payload, path, ruleset.codeTextResultTools);
       const output = jsonText(value, {
         layer,
         objectOnly: toolArguments,
+        codeText,
+        // Only direct message text can contain Markdown code examples. Tool
+        // arguments and recursively decoded strings keep their existing rules.
+        fencedCodeLanguages:
+          path[0] === "messages" &&
+          /^\d+$/u.test(path[1] ?? "") &&
+          path[2] === "content" &&
+          (path.length === 3 || (path.length === 5 && path[4] === "text"))
+            ? ruleset.fencedCodeLanguages
+            : null,
         visit: (decoded, nextLayer) =>
-          visit(decoded, [...path, "$json"], depth + 1, nextLayer),
+          visit(
+            decoded,
+            [...path, "$json"],
+            // Serialized JSON has its own unchanged depth/layer limits. Its
+            // traversal must not charge protocol nesting as decoded depth.
+            ruleset.decodedDepthPolicy === "independent-bounded-json-depth-v1"
+              ? 0
+              : depth + 1,
+            nextLayer,
+          ),
         plain,
         equal: (left, right) => canonicalJson(left) === canonicalJson(right),
       });
@@ -3045,7 +3174,7 @@ function validateBundleIntegrity(bundle) {
   validateRedactionSummary(model.redactionSummary);
   if (
     !Array.isArray(model.injectionFindings) ||
-    model.injectionFindings.length > RULESET.maxNodes * 2
+    model.injectionFindings.length > ruleset.maxNodes * 2
   ) {
     throw projectionError(
       EVOLUTION_PROJECTION_INVALID_CODE,
@@ -3187,12 +3316,17 @@ function validateBundleIntegrity(bundle) {
     }
     if (
       ruleset === AGENT_MODEL_RULESET ||
+      ruleset === AGENT_MODEL_RULESET_V4 ||
+      ruleset === AGENT_MODEL_RULESET_V3 ||
       ruleset === AGENT_MODEL_RULESET_V2 ||
       ruleset === AGENT_MODEL_RULESET_V1
     ) {
       snapshotAgentModelRequest(model.content, {
         allowStructuredArgumentText: ruleset !== AGENT_MODEL_RULESET_V1,
-        allowOpaqueTransportBlocks: ruleset === AGENT_MODEL_RULESET,
+        allowOpaqueTransportBlocks:
+          ruleset === AGENT_MODEL_RULESET ||
+          ruleset === AGENT_MODEL_RULESET_V4 ||
+          ruleset === AGENT_MODEL_RULESET_V3,
       });
       if (
         model.truncated ||
@@ -3477,6 +3611,9 @@ export class EvolutionEvidenceProjector {
     const sourceInputDigest = digest(
       payload,
       "chainlesschain.evolution-raw-plaintext/v2",
+      ruleset === AGENT_MODEL_RULESET
+        ? AGENT_MODEL_IMAGE_LIMITS.maxCanonicalRequestBytes
+        : undefined,
     );
     const sourceEnvelopeDigest = digest(
       input.sourceEnvelope,

package/src/lib/evolution/evolution-evidence-storage-layout.js

@@ -0,0 +1,115 @@
+import fs from "node:fs";
+import path from "node:path";
+
+import { ArtifactStore } from "../artifact-store.js";
+import {
+  EvolutionArtifactPorts,
+  captureEvolutionArtifactStoreDirectoryBoundary,
+  captureEvolutionLedgerBatchReadWindow,
+} from "./evolution-artifact-ports.js";
+
+export const EVOLUTION_TYPED_EVIDENCE_LAYOUT = "typed-evidence-v1";
+export const EVOLUTION_EVIDENCE_STORAGE_TYPES = Object.freeze([
+  "source-evidence",
+  "model-projection",
+  "trusted-projection",
+  "receipt",
+  "evidence",
+]);
+
+export function validateEvidenceStorageLayout(value) {
+  if (value !== "legacy" && value !== EVOLUTION_TYPED_EVIDENCE_LAYOUT)
+    throw new TypeError("Unsupported Evidence storage layout");
+  return value;
+}
+
+// Callers must supply events freshly authenticated by the genuine Run adapter.
+// A later event, projection, or sidecar is never a layout authority.
+export function evidenceStorageLayoutForRun(events, emptyLayout = "legacy") {
+  validateEvidenceStorageLayout(emptyLayout);
+  if (events.length === 0) return emptyLayout;
+  const data = events[0].data;
+  if (!data || !Object.hasOwn(data, "evidenceStorageLayout")) return "legacy";
+  if (data.evidenceStorageLayout !== EVOLUTION_TYPED_EVIDENCE_LAYOUT)
+    throw new TypeError("Unsupported authenticated Evidence storage layout");
+  return EVOLUTION_TYPED_EVIDENCE_LAYOUT;
+}
+
+function physicalStore(directory) {
+  return [
+    directory,
+    path.join(directory, "files"),
+    path.join(directory, "index.jsonl"),
+  ].map((location, index) => {
+    const stat = fs.lstatSync(location, { bigint: true });
+    if (
+      stat.isSymbolicLink() ||
+      (index < 2 ? !stat.isDirectory() : !stat.isFile() || stat.nlink !== 1n)
+    )
+      throw new Error(
+        "Typed Evidence store must retain physical directories and a single-link index",
+      );
+    return {
+      location,
+      dev: stat.dev,
+      ino: stat.ino,
+      birthtimeNs: stat.birthtimeNs,
+    };
+  });
+}
+
+/** Separate genuine stores; no change to artifact locators or ledger authority. */
+export function createTypedEvidenceArtifactPorts({
+  rootDir,
+  tenantId,
+  audience,
+  artifactAuthority,
+  now,
+  existingRun,
+}) {
+  const directories = EVOLUTION_EVIDENCE_STORAGE_TYPES.map((type) =>
+    path.join(rootDir, type),
+  );
+  // Preflight every shard before any constructor can recreate a missing one.
+  const before = existingRun ? directories.map(physicalStore) : null;
+  const result = {};
+  const identities = new Set();
+  for (const [index, type] of EVOLUTION_EVIDENCE_STORAGE_TYPES.entries()) {
+    const port = new EvolutionArtifactPorts({
+      tenantId,
+      audience,
+      artifactStore: new ArtifactStore({ dir: directories[index], now }),
+      allowedTypes: [type],
+      envelopeSigner: artifactAuthority.envelopeSigner,
+      envelopeVerifier: artifactAuthority.envelopeVerifier,
+      currentAuthorityResolver: artifactAuthority.currentAuthorityResolver,
+      now,
+    });
+    const boundary = captureEvolutionArtifactStoreDirectoryBoundary(port);
+    const after = physicalStore(directories[index]);
+    for (const [entryIndex, entry] of after.entries()) {
+      const previous = before?.[index][entryIndex];
+      if (
+        previous &&
+        ["dev", "ino", "birthtimeNs"].some(
+          (key) => previous[key] !== entry[key],
+        )
+      )
+        throw new Error("Typed Evidence store identity changed during reopen");
+      const identity = `${entry.dev}:${entry.ino}`;
+      if (identities.has(identity))
+        throw new Error("Typed Evidence stores must be distinct");
+      identities.add(identity);
+    }
+    boundary.recheck();
+    // Authenticate bounded index structure through the original port reader.
+    // Payloads and current authority remain freshly checked on actual reads.
+    captureEvolutionLedgerBatchReadWindow(
+      port.createEvolutionLedgerArtifactResolver({
+        purpose: "evidence-projection",
+      }),
+    )(() => undefined);
+    result[type] = port;
+  }
+  return Object.freeze(result);
+}

package/src/lib/evolution/evolution-file-witness.js

@@ -4,6 +4,7 @@ import path from "node:path";
 import { types } from "node:util";
 import { ensurePrivateDirectory, ensurePrivateFile } from "../secure-fs.js";
 import { withFileLock } from "../with-file-lock.js";
+import { evolutionPrivateStorageOptions } from "./evolution-private-storage.js";
 import { createEvolutionPhysicalStateReader } from "./evolution-physical-state-reader.js";
 import {
   createEvolutionWitnessSegments,
@@ -246,7 +247,10 @@ export function createEvolutionFileWitness({
       "maximumHistoryBytes must be a safe integer of at least 4096",
     );
   }
-  const secureOptions = { deps: { fs: fsImpl }, failIfUnavailable: true };
+  const secureOptions = evolutionPrivateStorageOptions(fsImpl);
+  const secureFileOptions = evolutionPrivateStorageOptions(fsImpl, {
+    file: true,
+  });
   ensurePrivateDirectory(directory, secureOptions);
   const readerOptions = {
     fsImpl,
@@ -651,7 +655,7 @@ export function createEvolutionFileWitness({
     const bytes = reader.read(file, {
       maximumBytes: byteLimit,
       allowAbsent,
-      prepareFile: (name) => ensurePrivateFile(name, secureOptions),
+      prepareFile: (name) => ensurePrivateFile(name, secureFileOptions),
     });
     recheckStorage();
     return bytes;
@@ -723,7 +727,7 @@ export function createEvolutionFileWitness({
       fsImpl.closeSync(descriptor);
       descriptor = undefined;
       fsImpl.renameSync(temporary, file);
-      ensurePrivateFile(file, secureOptions);
+      ensurePrivateFile(file, secureFileOptions);
       descriptor = fsImpl.openSync(file, "r+");
       fsImpl.fsyncSync(descriptor);
       fsImpl.closeSync(descriptor);

package/src/lib/evolution/evolution-ledger-file-manifest-catalog.js

@@ -5,6 +5,7 @@ import { types as utilTypes } from "node:util";
 
 import { ensurePrivateDirectory, ensurePrivateFile } from "../secure-fs.js";
 import { withFileLock } from "../with-file-lock.js";
+import { evolutionPrivateStorageOptions } from "./evolution-private-storage.js";
 import {
   createEvolutionManifestStateReader,
   captureEvolutionManifestStateReaderDirectoryBoundary,
@@ -76,7 +77,10 @@ export function createEvolutionLedgerFileManifestCatalogBackend({
   }
   const directory = path.resolve(directoryPath);
   const file = path.join(directory, "manifest-catalog.json");
-  const secureOptions = { deps: { fs: fsImpl }, failIfUnavailable: true };
+  const secureOptions = evolutionPrivateStorageOptions(fsImpl);
+  const secureFileOptions = evolutionPrivateStorageOptions(fsImpl, {
+    file: true,
+  });
   ensurePrivateDirectory(directory, secureOptions);
 
   const stateReader = createEvolutionManifestStateReader({
@@ -131,7 +135,7 @@ export function createEvolutionLedgerFileManifestCatalogBackend({
       fsImpl.closeSync(descriptor);
       descriptor = undefined;
       fsImpl.renameSync(temporary, file);
-      ensurePrivateFile(file, secureOptions);
+      ensurePrivateFile(file, secureFileOptions);
       descriptor = fsImpl.openSync(file, "r+");
       fsImpl.fsyncSync(descriptor);
       fsImpl.closeSync(descriptor);

package/src/lib/evolution/evolution-ledger-file-manifest-head-store.js

@@ -5,6 +5,7 @@ import { types as utilTypes } from "node:util";
 
 import { ensurePrivateDirectory, ensurePrivateFile } from "../secure-fs.js";
 import { withFileLock } from "../with-file-lock.js";
+import { evolutionPrivateStorageOptions } from "./evolution-private-storage.js";
 import {
   createEvolutionManifestStateReader,
   captureEvolutionManifestStateReaderDirectoryBoundary,
@@ -96,7 +97,10 @@ export function createEvolutionLedgerFileManifestHeadBackend({
     throw new TypeError("manifest head maximumBytes must be at least 4096");
   }
   const file = path.join(directory, "manifest-head.json");
-  const secureOptions = { deps: { fs: fsImpl }, failIfUnavailable: true };
+  const secureOptions = evolutionPrivateStorageOptions(fsImpl);
+  const secureFileOptions = evolutionPrivateStorageOptions(fsImpl, {
+    file: true,
+  });
   ensurePrivateDirectory(directory, secureOptions);
 
   const invokeCrashHook = (phase, details) => {
@@ -158,7 +162,7 @@ export function createEvolutionLedgerFileManifestHeadBackend({
       descriptor = undefined;
       invokeCrashHook("after-stage", { file, temporary });
       fsImpl.renameSync(temporary, file);
-      ensurePrivateFile(file, secureOptions);
+      ensurePrivateFile(file, secureFileOptions);
       descriptor = fsImpl.openSync(file, "r+");
       fsImpl.fsyncSync(descriptor);
       fsImpl.closeSync(descriptor);