chainlesschain 0.166.117 → 0.166.121

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

@@ -19,6 +19,7 @@ import {
 import { snapshotSkillDecisionPayload } from "./skill-decision-projection.js";
 import {
   createEvidenceJsonTextBoundary,
+  AGENT_FENCED_CODE_LANGUAGES,
   AGENT_CODE_TEXT_RESULT_TOOLS,
   EVIDENCE_JSON_POLICY,
   isAgentToolArgumentsPath,
@@ -533,7 +534,7 @@ export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_V3_DIGEST = `sha256:${crea
     "utf8",
   )
   .digest("hex")}`;
-const AGENT_MODEL_RULESET = Object.freeze({
+const AGENT_MODEL_RULESET_V4 = Object.freeze({
   ...AGENT_MODEL_RULESET_V3,
   schema: "chainlesschain.evolution-agent-model-projection-rules/v4",
   version: 4,
@@ -553,6 +554,40 @@ const AGENT_MODEL_RULESET = Object.freeze({
     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_V5 = 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_V5_DIGEST = `sha256:${createHash(
+  "sha256",
+)
+  .update(
+    `${AGENT_MODEL_RULESET_V5.schema}\0${JSON.stringify(AGENT_MODEL_RULESET_V5)}`,
+    "utf8",
+  )
+  .digest("hex")}`;
+const AGENT_MODEL_RULESET = Object.freeze({
+  ...AGENT_MODEL_RULESET_V5,
+  schema: "chainlesschain.evolution-agent-model-projection-rules/v6",
+  version: 6,
+  jsonTextPolicy: Object.freeze({
+    ...AGENT_MODEL_RULESET_V5.jsonTextPolicy,
+    version: 3,
+    bracketMarkerPolicy: "bounded-display-markers-v1",
+    proseQuotedPairPolicy: "non-sensitive-top-level-expression-v1",
+  }),
+});
 export const EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST = `sha256:${createHash(
   "sha256",
 )
@@ -584,6 +619,8 @@ const SUPPORTED_RULESETS = new Map([
   [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_V5_DIGEST, AGENT_MODEL_RULESET_V5],
   [EVOLUTION_AGENT_MODEL_PROJECTION_RULESET_DIGEST, AGENT_MODEL_RULESET],
 ]);
 
@@ -659,6 +696,8 @@ const AGENT_VALUE_PATTERNS = Object.freeze([
 function valuePatterns(ruleset) {
   return ruleset === SKILL_DECISION_RULESET ||
     ruleset === AGENT_MODEL_RULESET ||
+    ruleset === AGENT_MODEL_RULESET_V5 ||
+    ruleset === AGENT_MODEL_RULESET_V4 ||
     ruleset === AGENT_MODEL_RULESET_V3 ||
     ruleset === AGENT_MODEL_RULESET_V2 ||
     ruleset === AGENT_MODEL_RULESET_V1
@@ -1409,7 +1448,10 @@ function sanitizePayload(
     }
     const toolArguments = jsonText && isAgentToolArgumentsPath(path);
     const opaqueTransportBlock =
-      ruleset === AGENT_MODEL_RULESET || ruleset === AGENT_MODEL_RULESET_V3
+      ruleset === AGENT_MODEL_RULESET ||
+      ruleset === AGENT_MODEL_RULESET_V5 ||
+      ruleset === AGENT_MODEL_RULESET_V4 ||
+      ruleset === AGENT_MODEL_RULESET_V3
         ? projectAgentOpaqueTransportBlock(value, path.join("."))
         : null;
     if (opaqueTransportBlock !== null) return opaqueTransportBlock;
@@ -1431,6 +1473,15 @@ function sanitizePayload(
         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,
@@ -3287,6 +3338,8 @@ function validateBundleIntegrity(bundle) {
     }
     if (
       ruleset === AGENT_MODEL_RULESET ||
+      ruleset === AGENT_MODEL_RULESET_V5 ||
+      ruleset === AGENT_MODEL_RULESET_V4 ||
       ruleset === AGENT_MODEL_RULESET_V3 ||
       ruleset === AGENT_MODEL_RULESET_V2 ||
       ruleset === AGENT_MODEL_RULESET_V1
@@ -3294,7 +3347,10 @@ function validateBundleIntegrity(bundle) {
       snapshotAgentModelRequest(model.content, {
         allowStructuredArgumentText: ruleset !== AGENT_MODEL_RULESET_V1,
         allowOpaqueTransportBlocks:
-          ruleset === AGENT_MODEL_RULESET || ruleset === AGENT_MODEL_RULESET_V3,
+          ruleset === AGENT_MODEL_RULESET ||
+          ruleset === AGENT_MODEL_RULESET_V5 ||
+          ruleset === AGENT_MODEL_RULESET_V4 ||
+          ruleset === AGENT_MODEL_RULESET_V3,
       });
       if (
         model.truncated ||

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);