chainlesschain 0.166.92 → 0.166.93

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

@@ -15,11 +15,43 @@ import { types as utilTypes } from "node:util";
 import { ArtifactStore } from "../artifact-store.js";
 import { artifactPhysicalIdentity as physicalIdentity } from "./evolution-artifact-identity.js";
 import { withEvolutionFileIdentity } from "./evolution-file-identity.js";
+import { readBoundedDescriptor } from "./bounded-descriptor-read.js";
+import { readBoundedArtifactFile } from "../bounded-artifact-file-read.js";
 import {
   EVOLUTION_ARTIFACT_REF_SCHEMA,
   EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA,
 } from "./evolution-ledger.js";
 
+const ARTIFACT_STORE_DIRECTORY_BOUNDARIES = new WeakMap();
+// Only the shared identity helper's directory opens use this adapter. A POSIX
+// directory/FIFO swap must fail before reaching a potentially blocking open.
+const INDEX_DIRECTORY_FS = Object.freeze({
+  constants: fs.constants,
+  realpathSync: fs.realpathSync,
+  lstatSync: (...args) => fs.lstatSync(...args),
+  fstatSync: (...args) => fs.fstatSync(...args),
+  closeSync: (...args) => fs.closeSync(...args),
+  openSync: (target, flags) =>
+    fs.openSync(
+      target,
+      flags | (fs.constants.O_NONBLOCK || 0) | (fs.constants.O_DIRECTORY || 0),
+    ),
+});
+const INDEX_STAT_FIELDS = Object.freeze([
+  "dev",
+  "ino",
+  "mode",
+  "uid",
+  "gid",
+  "nlink",
+  "size",
+  "mtimeNs",
+  "ctimeNs",
+]);
+const INDEX_MUTATION_FIELDS = Object.freeze(
+  INDEX_STAT_FIELDS.filter((name) => name !== "dev" && name !== "ino"),
+);
+
 export const EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA =
   "chainlesschain.evolution-durable-artifact-record/v1";
 export const EVOLUTION_ARTIFACT_ENVELOPE_CORE_SCHEMA =
@@ -84,6 +116,10 @@ export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_TYPES = Object.freeze([
   "evolution-run-event",
   "rrsi-history-event",
   "skill-registry-store-policy",
+  "skill-registry-runtime-policy",
+  "rrsi-observed-text-chunk",
+  "rrsi-observed-text-manifest",
+  "rrsi-content-restriction-event",
   "pm-exploration-recovery-snapshot",
   "pm-exploration-provider-settlement",
   "evolution-eval-child-evidence",
@@ -144,6 +180,10 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "evolution-run-event",
   "rrsi-history-event",
   "skill-registry-store-policy",
+  "skill-registry-runtime-policy",
+  "rrsi-observed-text-chunk",
+  "rrsi-observed-text-manifest",
+  "rrsi-content-restriction-event",
   "pm-exploration-recovery-snapshot",
   "pm-exploration-provider-settlement",
   "evolution-eval-child-evidence",
@@ -402,6 +442,10 @@ const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
   ["evolution-run-event", new Set(["evolution-ledger"])],
   ["rrsi-history-event", new Set(["evolution-ledger"])],
   ["skill-registry-store-policy", new Set(["evolution-ledger"])],
+  ["skill-registry-runtime-policy", new Set(["evolution-ledger"])],
+  ["rrsi-observed-text-chunk", new Set(["evolution-ledger"])],
+  ["rrsi-observed-text-manifest", new Set(["evolution-ledger"])],
+  ["rrsi-content-restriction-event", new Set(["evolution-ledger"])],
   ["pm-exploration-recovery-snapshot", new Set(["evolution-ledger"])],
   ["pm-exploration-provider-settlement", new Set(["evolution-ledger"])],
   ["evolution-eval-child-evidence", new Set(["evolution-ledger"])],
@@ -1117,7 +1161,12 @@ function inspectPhysicalDirectory(directory, label) {
   let stat;
   let realPath;
   try {
-    stat = fs.lstatSync(directory);
+    stat = fs.lstatSync(directory, { bigint: true });
+    if (typeof stat.dev !== "bigint" || typeof stat.ino !== "bigint")
+      throw artifactError(
+        EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+        `${label} requires full-precision directory stat fields`,
+      );
     assertDirectory(stat, label);
     realPath = physicalRealpath(directory);
   } catch (cause) {
@@ -1141,8 +1190,11 @@ function inspectPhysicalDirectory(directory, label) {
 }
 
 function inspectPhysicalIndex(indexPath, rootRealPath) {
-  return withEvolutionFileIdentity(fs, indexPath, (samePathHandle) =>
-    inspectPhysicalIndexWithIdentity(indexPath, rootRealPath, samePathHandle),
+  return withEvolutionFileIdentity(
+    INDEX_DIRECTORY_FS,
+    indexPath,
+    (samePathHandle) =>
+      inspectPhysicalIndexWithIdentity(indexPath, rootRealPath, samePathHandle),
   );
 }
 
@@ -1155,8 +1207,8 @@ function inspectPhysicalIndexWithIdentity(
   let realPath;
   let descriptor = null;
   try {
-    pathStat = fs.lstatSync(indexPath);
-    assertRegularSingleLink(pathStat, "ArtifactStore index");
+    pathStat = fs.lstatSync(indexPath, { bigint: true });
+    assertIndexStat(pathStat, "ArtifactStore index");
     realPath = physicalRealpath(indexPath);
     if (
       !samePath(realPath, indexPath) ||
@@ -1169,16 +1221,36 @@ function inspectPhysicalIndexWithIdentity(
     }
     descriptor = fs.openSync(
       indexPath,
-      fs.constants.O_RDONLY | Number(fs.constants.O_NOFOLLOW || 0),
+      fs.constants.O_RDONLY |
+        Number(fs.constants.O_NOFOLLOW || 0) |
+        Number(fs.constants.O_NONBLOCK || 0),
     );
-    const descriptorStat = fs.fstatSync(descriptor);
-    assertRegularSingleLink(descriptorStat, "ArtifactStore index descriptor");
-    if (!samePathHandle(pathStat, descriptorStat)) {
+    const descriptorStat = fs.fstatSync(descriptor, { bigint: true });
+    assertIndexStat(descriptorStat, "ArtifactStore index descriptor");
+    if (
+      !samePathHandle(pathStat, descriptorStat) ||
+      !sameIndexMutationMetadata(pathStat, descriptorStat)
+    ) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
         "ArtifactStore index pathname and descriptor identities differ",
       );
     }
+    const afterPathStat = fs.lstatSync(indexPath, { bigint: true });
+    const afterDescriptorStat = fs.fstatSync(descriptor, { bigint: true });
+    assertIndexStat(afterPathStat, "ArtifactStore index");
+    assertIndexStat(afterDescriptorStat, "ArtifactStore index descriptor");
+    if (
+      !sameIndexStat(pathStat, afterPathStat) ||
+      !sameIndexStat(descriptorStat, afterDescriptorStat) ||
+      !samePathHandle(afterPathStat, afterDescriptorStat) ||
+      !sameIndexMutationMetadata(afterPathStat, afterDescriptorStat) ||
+      !samePath(physicalRealpath(indexPath), realPath)
+    )
+      throw artifactError(
+        EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+        "ArtifactStore index changed while its identity was captured",
+      );
   } catch (cause) {
     if (isEvolutionArtifactPortError(cause)) throw cause;
     throw artifactError(
@@ -1273,16 +1345,6 @@ function attestCapturedDirectory(directory, realPath, identity, label) {
   }
 }
 
-function sameFileIdentity(left, right) {
-  return (
-    left.dev === right.dev &&
-    left.ino === right.ino &&
-    left.size === right.size &&
-    left.mtimeMs === right.mtimeMs &&
-    left.ctimeMs === right.ctimeMs
-  );
-}
-
 function assertRegularSingleLink(stat, label) {
   if (
     !stat ||
@@ -1298,6 +1360,35 @@ function assertRegularSingleLink(stat, label) {
   }
 }
 
+function assertIndexStat(stat, label) {
+  if (INDEX_STAT_FIELDS.some((name) => typeof stat?.[name] !== "bigint"))
+    throw artifactError(
+      EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+      `${label} requires full-precision index stat fields`,
+    );
+  assertRegularSingleLink(stat, label);
+  if (stat.size < 0n || stat.size > BigInt(EVOLUTION_ARTIFACT_MAX_INDEX_BYTES))
+    throw artifactError(
+      EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
+      `${label} exceeds its bounded snapshot size`,
+    );
+}
+
+function sameIndexMutationMetadata(left, right) {
+  return (
+    INDEX_MUTATION_FIELDS.every((name) => left[name] === right[name]) &&
+    physicalIdentity(left).birthtimeMs === physicalIdentity(right).birthtimeMs
+  );
+}
+
+function sameIndexStat(left, right) {
+  return (
+    left.dev === right.dev &&
+    left.ino === right.ino &&
+    sameIndexMutationMetadata(left, right)
+  );
+}
+
 function attestStoreDirectories(layout) {
   attestCapturedDirectory(
     layout.rootDir,
@@ -1420,8 +1511,11 @@ function parseTrustedIndexBytes(bytes) {
 }
 
 function readTrustedIndexSnapshot(layout) {
-  return withEvolutionFileIdentity(fs, layout.indexPath, (samePathHandle) =>
-    readTrustedIndexSnapshotWithIdentity(layout, samePathHandle),
+  return withEvolutionFileIdentity(
+    INDEX_DIRECTORY_FS,
+    layout.indexPath,
+    (samePathHandle) =>
+      readTrustedIndexSnapshotWithIdentity(layout, samePathHandle),
   );
 }
 
@@ -1434,8 +1528,8 @@ function readTrustedIndexSnapshotWithIdentity(layout, samePathHandle) {
   let bytes;
   let indexRealPath;
   try {
-    beforePathStat = fs.lstatSync(layout.indexPath);
-    assertRegularSingleLink(beforePathStat, "ArtifactStore index");
+    beforePathStat = fs.lstatSync(layout.indexPath, { bigint: true });
+    assertIndexStat(beforePathStat, "ArtifactStore index");
     if (!samePhysicalIdentity(beforePathStat, layout.indexIdentity)) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -1455,27 +1549,32 @@ function readTrustedIndexSnapshotWithIdentity(layout, samePathHandle) {
     }
     descriptor = fs.openSync(
       layout.indexPath,
-      fs.constants.O_RDONLY | Number(fs.constants.O_NOFOLLOW || 0),
-    );
-    beforeDescriptorStat = fs.fstatSync(descriptor);
-    assertRegularSingleLink(
-      beforeDescriptorStat,
-      "ArtifactStore index descriptor",
+      fs.constants.O_RDONLY |
+        Number(fs.constants.O_NOFOLLOW || 0) |
+        Number(fs.constants.O_NONBLOCK || 0),
     );
+    beforeDescriptorStat = fs.fstatSync(descriptor, { bigint: true });
+    assertIndexStat(beforeDescriptorStat, "ArtifactStore index descriptor");
     if (
       !samePathHandle(beforePathStat, beforeDescriptorStat) ||
-      beforeDescriptorStat.size > EVOLUTION_ARTIFACT_MAX_INDEX_BYTES
+      !sameIndexMutationMetadata(beforePathStat, beforeDescriptorStat)
     ) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
         "ArtifactStore index descriptor is replaced or oversized",
       );
     }
-    bytes = fs.readFileSync(descriptor);
-    afterDescriptorStat = fs.fstatSync(descriptor);
+    bytes = readBoundedDescriptor(
+      fs,
+      descriptor,
+      Number(beforeDescriptorStat.size),
+      EVOLUTION_ARTIFACT_MAX_INDEX_BYTES,
+    );
+    afterDescriptorStat = fs.fstatSync(descriptor, { bigint: true });
+    assertIndexStat(afterDescriptorStat, "ArtifactStore index descriptor");
     if (
-      !sameFileIdentity(beforeDescriptorStat, afterDescriptorStat) ||
-      bytes.length !== beforeDescriptorStat.size
+      !sameIndexStat(beforeDescriptorStat, afterDescriptorStat) ||
+      BigInt(bytes.length) !== beforeDescriptorStat.size
     ) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -1494,10 +1593,10 @@ function readTrustedIndexSnapshotWithIdentity(layout, samePathHandle) {
   }
   let afterPathStat;
   try {
-    afterPathStat = fs.lstatSync(layout.indexPath);
-    assertRegularSingleLink(afterPathStat, "ArtifactStore index");
+    afterPathStat = fs.lstatSync(layout.indexPath, { bigint: true });
+    assertIndexStat(afterPathStat, "ArtifactStore index");
     if (
-      !sameFileIdentity(beforePathStat, afterPathStat) ||
+      !sameIndexStat(beforePathStat, afterPathStat) ||
       !samePhysicalIdentity(afterPathStat, layout.indexIdentity) ||
       !samePath(physicalRealpath(layout.indexPath), indexRealPath)
     ) {
@@ -2017,6 +2116,42 @@ export class EvolutionArtifactPorts {
       throw new TypeError("EvolutionArtifactPorts now must be a function");
     }
     this.#now = Object.freeze((...args) => now(...args));
+    const layout = this.#store.layout;
+    const directoryBoundary = deepFreeze({
+      schema: "chainlesschain.evolution-artifact-store-directory-boundary/v1",
+      artifactTenantId: this.#tenantId,
+      audience: this.#audience,
+      root: { path: layout.rootRealPath, identity: layout.rootIdentity },
+      files: { path: layout.filesRealPath, identity: layout.filesIdentity },
+      scope: "root-and-files-directories",
+      indexLocation: layout.indexRealPath,
+      indexFileIdentityVerified: false,
+      indexContentsVerified: false,
+      artifactInventoryVerified: false,
+      independentVolumeIdentityVerified: false,
+      fullPhysicalStorageGraphVerified: false,
+      rootAuthorityVerified: false,
+      generationProvenanceVerified: false,
+      tenantWideIndexAuthorityVerified: false,
+      grantsMutationOrPromotionAuthority: false,
+    });
+    const recheck = (...args) => {
+      if (args.length)
+        throw artifactError(
+          EVOLUTION_ARTIFACT_INVALID_CODE,
+          "artifact directory boundary takes no replacement context",
+        );
+      attestStoreDirectories(layout);
+      return directoryBoundary;
+    };
+    recheck();
+    ARTIFACT_STORE_DIRECTORY_BOUNDARIES.set(
+      this,
+      Object.freeze({
+        descriptor: directoryBoundary,
+        recheck: Object.freeze(recheck),
+      }),
+    );
     Object.freeze(this);
   }
 
@@ -2362,26 +2497,6 @@ export class EvolutionArtifactPorts {
   }
 
   #readStoredBytes(entry, normalizedEntry, expectedDigest) {
-    const expectedPath = path.resolve(
-      this.#store.layout.filesDir,
-      normalizedEntry.file,
-    );
-    return withEvolutionFileIdentity(fs, expectedPath, (samePathHandle) =>
-      this.#readStoredBytesWithIdentity(
-        entry,
-        normalizedEntry,
-        expectedDigest,
-        samePathHandle,
-      ),
-    );
-  }
-
-  #readStoredBytesWithIdentity(
-    entry,
-    normalizedEntry,
-    expectedDigest,
-    samePathHandle,
-  ) {
     attestStoreDirectories(this.#store.layout);
     const expectedHex = expectedDigest.slice("sha256:".length);
     let storedPath;
@@ -2413,9 +2528,13 @@ export class EvolutionArtifactPorts {
       );
     }
 
+    const readBounds = Object.freeze({
+      expectedSize: normalizedEntry.size,
+      maximumBytes: EVOLUTION_ARTIFACT_MAX_CANONICAL_BYTES,
+    });
     let integrityBefore;
     try {
-      integrityBefore = this.#store.verifyIntegrity(entry);
+      integrityBefore = this.#store.verifyIntegrity(entry, readBounds);
     } catch (cause) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -2425,53 +2544,13 @@ export class EvolutionArtifactPorts {
     }
     validateIntegrityResult(integrityBefore, expectedHex);
 
-    let rootRealPath;
-    let beforePathStat;
-    let targetRealPath;
-    let descriptor = null;
-    let beforeDescriptorStat;
-    let afterDescriptorStat;
     let bytes;
     try {
-      rootRealPath = physicalRealpath(filesRoot);
-      if (!samePath(rootRealPath, this.#store.layout.filesRealPath)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "ArtifactStore files root physical identity changed before byte read",
-        );
-      }
-      beforePathStat = fs.lstatSync(resolvedStoredPath);
-      assertRegularSingleLink(beforePathStat, "stored artifact path");
-      targetRealPath = physicalRealpath(resolvedStoredPath);
-      if (!isContained(rootRealPath, targetRealPath)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "stored artifact realpath escapes the captured files root",
-        );
-      }
-      descriptor = fs.openSync(
+      bytes = readBoundedArtifactFile(
         resolvedStoredPath,
-        fs.constants.O_RDONLY | Number(fs.constants.O_NOFOLLOW || 0),
-      );
-      beforeDescriptorStat = fs.fstatSync(descriptor);
-      assertRegularSingleLink(
-        beforeDescriptorStat,
-        "stored artifact descriptor",
+        readBounds.expectedSize,
+        readBounds.maximumBytes,
       );
-      if (!samePathHandle(beforePathStat, beforeDescriptorStat)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "stored artifact pathname and descriptor identities differ",
-        );
-      }
-      bytes = fs.readFileSync(descriptor);
-      afterDescriptorStat = fs.fstatSync(descriptor);
-      if (!sameFileIdentity(beforeDescriptorStat, afterDescriptorStat)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "stored artifact changed while it was read",
-        );
-      }
     } catch (cause) {
       if (isEvolutionArtifactPortError(cause)) throw cause;
       throw artifactError(
@@ -2479,33 +2558,6 @@ export class EvolutionArtifactPorts {
         "stored artifact could not be opened safely",
         { cause },
       );
-    } finally {
-      if (descriptor !== null) fs.closeSync(descriptor);
-    }
-    let afterPathStat;
-    try {
-      afterPathStat = fs.lstatSync(resolvedStoredPath);
-      assertRegularSingleLink(afterPathStat, "stored artifact path");
-      if (!sameFileIdentity(beforePathStat, afterPathStat)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "stored artifact pathname changed during readback",
-        );
-      }
-      const afterRealPath = physicalRealpath(resolvedStoredPath);
-      if (!samePath(targetRealPath, afterRealPath)) {
-        throw artifactError(
-          EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-          "stored artifact realpath changed during readback",
-        );
-      }
-    } catch (cause) {
-      if (isEvolutionArtifactPortError(cause)) throw cause;
-      throw artifactError(
-        EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
-        "stored artifact could not be re-attested",
-        { cause },
-      );
     }
     if (
       bytes.length !== normalizedEntry.size ||
@@ -2518,7 +2570,7 @@ export class EvolutionArtifactPorts {
     }
     let integrityAfter;
     try {
-      integrityAfter = this.#store.verifyIntegrity(entry);
+      integrityAfter = this.#store.verifyIntegrity(entry, readBounds);
     } catch (cause) {
       throw artifactError(
         EVOLUTION_ARTIFACT_INTEGRITY_FAILED_CODE,
@@ -3617,4 +3669,32 @@ export function captureEvolutionLedgerArtifactResolverBinding(value) {
   return binding;
 }
 
+/** Original root/files directory capture only; never an installer or tenant grant. */
+export function captureEvolutionArtifactStoreDirectoryBoundary(value) {
+  if (arguments.length !== 1)
+    throw new TypeError(
+      "artifact directory boundary capture takes exactly one original ports object",
+    );
+  rejectProxy(value, "EvolutionArtifactPorts directory boundary");
+  if (
+    !value ||
+    Object.getPrototypeOf(value) !== EvolutionArtifactPorts.prototype ||
+    !hasStablePrototype(
+      value,
+      EvolutionArtifactPorts.prototype,
+      "EvolutionArtifactPorts directory boundary",
+    )
+  )
+    throw new TypeError(
+      "a genuine EvolutionArtifactPorts directory boundary is required",
+    );
+  const boundary = ARTIFACT_STORE_DIRECTORY_BOUNDARIES.get(value);
+  if (!boundary)
+    throw new TypeError(
+      "a genuine EvolutionArtifactPorts directory boundary is required",
+    );
+  boundary.recheck();
+  return boundary;
+}
+
 Object.freeze(EvolutionArtifactPorts.prototype);

package/src/lib/evolution/rrsi-history-ledger-adapter.js

@@ -3230,6 +3230,31 @@ export function createRrsiHistoryLedgerAdapter(input) {
       artifactPorts: options.artifactPorts,
       ledgerArtifactResolver: options.ledgerArtifactResolver,
       resolveCampaignRoot: adapter.resolveCampaignRoot,
+      resolvePreparation(executionId) {
+        rrsiId(executionId, "preparation execution ID");
+        return withHistoryLock(() => {
+          const { state } = load();
+          const entry = state.reservations.get(executionId);
+          if (!entry || !isRrsiPreparationReservation(entry.reservation))
+            rrsiFail("preparation execution is not registered");
+          const operation = [...state.operations.values()].find(
+            (value) =>
+              value.record.kind === "reserve-preparation" &&
+              value.record.payload.executionId === executionId,
+          );
+          if (!operation) rrsiFail("preparation registration is missing");
+          return freezeRrsiData({
+            descriptor,
+            identity: state.identity,
+            reservation: entry.reservation,
+            registrationRecord: historyRegistrationRecord(operation),
+            status: entry.status,
+            dispatched: entry.dispatched,
+            historyAuthenticated: true,
+            sourceDerivationVerified: false,
+          });
+        });
+      },
       resolveNativeBatch: adapter.resolveNativeBatch,
       resolveNativeStatisticsScope: adapter.resolveNativeStatisticsScope,
       assertNativeFreshChild(response, expectedBindings) {