chainlesschain 0.166.46 → 0.166.47

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

@@ -78,6 +78,8 @@ export const EVOLUTION_ARTIFACT_LEDGER_RETENTION_TYPES = Object.freeze([
   "skill-registry-transition-request",
   "skill-registry-transition-settlement",
   "skill-retrieval-revocation-state",
+  "skill-runtime-revalidation-state",
+  "evolution-ledger-v2-journal",
   "evolution-run-event",
   "evolution-eval-child-evidence",
   "evolution-raw-deletion-receipt",
@@ -177,6 +179,8 @@ export const EVOLUTION_ARTIFACT_TYPES = Object.freeze([
   "skill-registry-transition-request",
   "skill-registry-transition-settlement",
   "skill-retrieval-revocation-state",
+  "skill-runtime-revalidation-state",
+  "evolution-ledger-v2-journal",
   "skill-release-finalization",
   "skill-release-state-migration",
   "structured-memory-authority-receipt",
@@ -381,6 +385,8 @@ const LEDGER_RETENTION_PURPOSES_BY_TYPE = new Map([
   ["skill-registry-transition-request", new Set(["evolution-ledger"])],
   ["skill-registry-transition-settlement", new Set(["evolution-ledger"])],
   ["skill-retrieval-revocation-state", new Set(["evolution-ledger"])],
+  ["skill-runtime-revalidation-state", new Set(["evolution-ledger"])],
+  ["evolution-ledger-v2-journal", 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"])],

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

@@ -27,6 +27,7 @@ const SUPPORTED_COMMANDS = new Set([
   "marketplace",
   "orchestrate",
   "serve",
+  "skill",
   "stream",
   "ui",
 ]);
@@ -128,7 +129,12 @@ function dependencies(value, commandName) {
     throw new TypeError(
       `evolution deployment returned invalid dependencies for ${commandName}`,
     );
-  return Object.freeze({ ...value });
+  return Object.freeze({
+    ...value,
+    ...(["agent", "skill", "chat", "serve"].includes(commandName)
+      ? { skillRuntimeAdmissionRequired: true }
+      : {}),
+  });
 }
 
 function deniedAgentDependencies(commandName, code, message, source = null) {
@@ -204,6 +210,48 @@ function authenticatedDependencies(value, commandName) {
 
 async function loadBuiltInFactories(commandName) {
   const factories = {};
+  if (
+    ["agent", "skill", "chat", "serve", "evolution", "learning"].includes(
+      commandName,
+    )
+  ) {
+    const [
+      runtime,
+      adapter,
+      registry,
+      ledgerPorts,
+      artifactPorts,
+      ledgerBackend,
+      artifactStore,
+      manifest,
+    ] = await Promise.all([
+      import("./skill-runtime-revalidation.js"),
+      import("./skill-runtime-revalidation-ledger-adapter.js"),
+      import("./skill-release-registry.js"),
+      import("./evolution-ledger-ports.js"),
+      import("./evolution-artifact-ports.js"),
+      import("./evolution-ledger-file-backend.js"),
+      import("../artifact-store.js"),
+      import("./skill-execution-manifest.js"),
+    ]);
+    Object.assign(factories, {
+      createSkillRuntimeRevalidationAuthority:
+        runtime.createSkillRuntimeRevalidationAuthority,
+      createSkillRuntimeRevalidationLedgerAdapter: (options) =>
+        new adapter.SkillRuntimeRevalidationLedgerAdapter(options),
+      createSkillReleaseRegistry: (options) =>
+        new registry.SkillReleaseRegistry(options),
+      createEvolutionLedgerPorts: ledgerPorts.createEvolutionLedgerPorts,
+      createEvolutionArtifactPorts: (options) =>
+        new artifactPorts.EvolutionArtifactPorts(options),
+      createEvolutionLedgerFileBackend:
+        ledgerBackend.createEvolutionLedgerFileBackend,
+      createArtifactStore: (options) =>
+        new artifactStore.ArtifactStore(options),
+      buildSkillRuntimeManifest: manifest.buildSkillRuntimeManifest,
+      buildSkillDependencyLock: manifest.buildSkillDependencyLock,
+    });
+  }
   if (commandName === "learning") {
     const [
       { createGovernedSkillSynthesisCliHost },
@@ -415,6 +463,7 @@ async function loadBuiltInFactories(commandName) {
   }
   if (
     commandName === "agent" ||
+    commandName === "learning" ||
     commandName === "ask" ||
     commandName === "chat" ||
     commandName === "compact" ||
@@ -424,13 +473,47 @@ async function loadBuiltInFactories(commandName) {
     commandName === "cowork" ||
     commandName === "orchestrate" ||
     commandName === "serve" ||
+    commandName === "skill" ||
     commandName === "stream" ||
     commandName === "ui"
   ) {
-    const { createAgentEvolutionRuntimeComposition } =
-      await import("./agent-evolution-runtime-composition.js");
+    const {
+      assembleAgentSkillOutcomeIndexFromCatalog,
+      createAgentEvolutionRuntimeComposition,
+    } = await import("./agent-evolution-runtime-composition.js");
     factories.createAgentEvolutionRuntimeComposition =
       createAgentEvolutionRuntimeComposition;
+    const [
+      { createEvolutionEvalRuntimeComposition },
+      { EvolutionEvalGate, EvolutionEvalReceiptVerifier },
+      { createEvolutionEvalProcessSupervisor },
+    ] = await Promise.all([
+      import("./evolution-eval-runtime-composition.js"),
+      import("./evolution-eval-gate.js"),
+      import("./evolution-eval-process-supervisor.js"),
+    ]);
+    Object.assign(factories, {
+      createEvolutionEvalRuntimeComposition,
+      createEvolutionEvalGate: (options) => new EvolutionEvalGate(options),
+      createEvolutionEvalReceiptVerifier: (options) =>
+        new EvolutionEvalReceiptVerifier(options),
+      createEvolutionEvalProcessSupervisor,
+    });
+    if (commandName === "skill") {
+      const [
+        { createSkillOutcomeSourceCatalogAuthority },
+        { createSkillVectorProcessAuthority },
+      ] = await Promise.all([
+        import("./skill-outcome-source-catalog-authority.js"),
+        import("../skill-vector-process-authority.js"),
+      ]);
+      factories.assembleAgentSkillOutcomeIndexFromCatalog =
+        assembleAgentSkillOutcomeIndexFromCatalog;
+      factories.createSkillOutcomeSourceCatalogAuthority =
+        createSkillOutcomeSourceCatalogAuthority;
+      factories.createSkillVectorProcessAuthority =
+        createSkillVectorProcessAuthority;
+    }
   }
   return Object.freeze(factories);
 }
@@ -450,6 +533,7 @@ function bindFactoriesToModule(factories, moduleDigest) {
     "createWikiSkillBenchmarkGrader",
     "createWikiSkillBenchmarkReportAttestor",
     "createWikiSkillBenchmarkRunner",
+    "createEvolutionEvalRuntimeComposition",
   ];
   for (const name of providerFactories) {
     if (typeof factories[name] !== "function") continue;

package/src/lib/evolution/evolution-eval-gate.js

@@ -6437,6 +6437,14 @@ export class EvolutionEvalReceiptVerifier {
 Object.freeze(EvolutionEvalGate.prototype);
 Object.freeze(EvolutionEvalReceiptVerifier.prototype);
 
+export function isEvolutionEvalGate(value) {
+  return GATE_INSTANCES.has(value);
+}
+
+export function isEvolutionEvalReceiptVerifier(value) {
+  return RECEIPT_VERIFIER_INSTANCES.has(value);
+}
+
 export async function runEvolutionEvalGate(gate, request) {
   if (!GATE_INSTANCES.has(gate)) {
     throw evalError(

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

@@ -0,0 +1,255 @@
+import { types as utilTypes } from "node:util";
+
+import {
+  EvolutionEvalChildEvidenceLedgerAdapter,
+  createEvolutionEvalChildEvidenceStorePort,
+} from "./evolution-eval-child-evidence-ledger-adapter.js";
+import {
+  SkillTargetMatrixEvalAggregator,
+  SkillTargetMatrixEvalReceiptVerifier,
+} from "./skill-target-matrix-eval.js";
+import { createSkillEvaluatedPromotionDurabilityAdapter } from "./skill-evaluated-promotion-durability.js";
+
+export const EVOLUTION_EVAL_RUNTIME_COMPOSITION_SCHEMA =
+  "chainlesschain.evolution-eval-runtime-composition/v1";
+export const EVOLUTION_EVAL_COMPOSITION_UNAVAILABLE_CODE =
+  "CC_EVOLUTION_EVAL_COMPOSITION_UNAVAILABLE";
+
+const COMPOSITIONS = new WeakMap();
+const DESCRIPTOR_KEYS = [
+  "tenantId",
+  "runId",
+  "authorityId",
+  "revision",
+  "handlerArtifactDigest",
+];
+const ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+
+function unavailable(message, cause) {
+  const error = new Error(message, cause ? { cause } : undefined);
+  error.code = EVOLUTION_EVAL_COMPOSITION_UNAVAILABLE_CODE;
+  return error;
+}
+
+function record(value, keys, label) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    utilTypes.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  )
+    throw unavailable(`${label} must be a plain data record`);
+  const ownKeys = Reflect.ownKeys(value);
+  if (
+    keys &&
+    (ownKeys.length !== keys.length ||
+      ownKeys.some((key) => !keys.includes(key)))
+  )
+    throw unavailable(`${label} must contain exactly the required ports`);
+  for (const key of ownKeys) {
+    const property = Object.getOwnPropertyDescriptor(value, key);
+    if (
+      typeof key !== "string" ||
+      !property ||
+      !("value" in property) ||
+      !property.enumerable
+    )
+      throw unavailable(`${label}.${String(key)} must be an own data property`);
+  }
+  return value;
+}
+
+function descriptor(input) {
+  record(input, DESCRIPTOR_KEYS, "Eval composition descriptor");
+  for (const key of ["tenantId", "runId", "authorityId"])
+    if (typeof input[key] !== "string" || !ID.test(input[key]))
+      throw unavailable(`Eval composition ${key} is invalid`);
+  if (
+    !Number.isSafeInteger(input.revision) ||
+    input.revision < 1 ||
+    typeof input.handlerArtifactDigest !== "string" ||
+    !DIGEST.test(input.handlerArtifactDigest)
+  )
+    throw unavailable("Eval composition authority revision/digest is invalid");
+  return Object.freeze({ ...input });
+}
+
+/**
+ * Host-authorized construction only: supplies no signing keys, policy defaults,
+ * grader, corpus, reservation service, supervisor, or durability authority.
+ * Receipt verification uses the exact authority pair captured by the aggregator.
+ */
+export function createEvolutionEvalRuntimeComposition(options) {
+  try {
+    record(
+      options,
+      [
+        "descriptor",
+        "aggregatorOptions",
+        "verificationLimits",
+        "durabilityOptions",
+      ],
+      "Eval composition options",
+    );
+    const binding = descriptor(options.descriptor);
+    const matrix = {
+      ...record(options.aggregatorOptions, null, "Eval aggregator options"),
+    };
+    const limits = record(
+      options.verificationLimits,
+      ["maximumReceiptTtlMs", "maximumVerificationMs"],
+      "Eval verification limits",
+    );
+    if (matrix.tenantId !== binding.tenantId)
+      throw unavailable("Eval aggregator belongs to another tenant");
+    const aggregator = new SkillTargetMatrixEvalAggregator(matrix);
+    const receiptVerifier = new SkillTargetMatrixEvalReceiptVerifier({
+      matrixReceiptVerifier: matrix.matrixReceiptVerifier,
+      matrixReceiptSignerDescriptor:
+        matrix.matrixReceiptSigner.authorityDescriptor,
+      matrixReceiptTrust: matrix.matrixReceiptTrust,
+      matrixSupervisor: matrix.matrixSupervisor,
+      supervisorPolicy: matrix.supervisorPolicy,
+      clock: matrix.clock,
+      clockPolicy: matrix.clockPolicy,
+      ...limits,
+    });
+    const durability = createSkillEvaluatedPromotionDurabilityAdapter(
+      options.durabilityOptions,
+    );
+    const composition = Object.freeze({
+      schema: EVOLUTION_EVAL_RUNTIME_COMPOSITION_SCHEMA,
+      descriptor: binding,
+      // Downstream promotion can reuse the same read-only receipt authorities.
+      receiptVerifier,
+      receiptResolver: durability.resolver,
+    });
+    COMPOSITIONS.set(
+      composition,
+      Object.freeze({
+        aggregator,
+        receiptVerifier,
+        durability,
+        childReceiptStore: matrix.childReceiptStore,
+      }),
+    );
+    return composition;
+  } catch (cause) {
+    if (cause?.code === EVOLUTION_EVAL_COMPOSITION_UNAVAILABLE_CODE)
+      throw cause;
+    throw unavailable("Eval production authority construction failed", cause);
+  }
+}
+
+export function captureEvolutionEvalRuntimeComposition(value, expected) {
+  const ports = COMPOSITIONS.get(value);
+  if (!ports)
+    throw unavailable("a branded Eval runtime composition is required");
+  if (expected) {
+    for (const key of DESCRIPTOR_KEYS)
+      if (value.descriptor[key] !== expected.descriptor[key])
+        throw unavailable(`Eval composition differs from runtime ${key}`);
+    if (ports.childReceiptStore !== expected.childReceiptStore)
+      throw unavailable(
+        "Eval composition must use the runtime child evidence store",
+      );
+  }
+  return ports;
+}
+
+/** Root-owned authenticated storage; the host receives no ledger write port. */
+export function createEvolutionEvalRuntimeChildEvidenceStore({
+  descriptor: input,
+  artifactPorts,
+  ledger,
+  ledgerArtifactResolver,
+  audience,
+  now,
+}) {
+  const binding = descriptor(input);
+  const storeDescriptor = Object.freeze({
+    tenantId: binding.tenantId,
+    streamId: binding.runId,
+    authorityId: binding.authorityId,
+    revision: binding.revision,
+    handlerArtifactDigest: binding.handlerArtifactDigest,
+  });
+  const adapter = new EvolutionEvalChildEvidenceLedgerAdapter({
+    descriptor: {
+      ...storeDescriptor,
+      artifactTenantId: binding.tenantId,
+      audience,
+      purpose: "evolution-ledger",
+    },
+    artifactPorts,
+    ledger,
+    ledgerArtifactResolver,
+    now,
+  });
+  return createEvolutionEvalChildEvidenceStorePort({
+    descriptor: storeDescriptor,
+    retain: adapter.retain.bind(adapter),
+    resolve: adapter.resolve.bind(adapter),
+  });
+}
+
+/** Called only by the Agent root after constructing its authenticated backend. */
+export function createEvolutionEvalRuntimeStageConfiguration({
+  configuration,
+  tenantId,
+  runId,
+  ...storage
+}) {
+  try {
+    record(
+      configuration,
+      [
+        "descriptor",
+        "createComposition",
+        "planRef",
+        "expectedReceipt",
+        "usage",
+      ],
+      "releaseTrain.domain.eval",
+    );
+    record(
+      configuration.descriptor,
+      ["authorityId", "revision", "handlerArtifactDigest"],
+      "releaseTrain.domain.eval.descriptor",
+    );
+    const binding = descriptor({
+      ...configuration.descriptor,
+      tenantId,
+      runId,
+    });
+    const factory = configuration.createComposition;
+    if (
+      typeof factory !== "function" ||
+      utilTypes.isProxy(factory) ||
+      utilTypes.isAsyncFunction(factory) ||
+      utilTypes.isGeneratorFunction(factory)
+    )
+      throw unavailable("Eval createComposition must be a synchronous factory");
+    const childReceiptStore = createEvolutionEvalRuntimeChildEvidenceStore({
+      descriptor: binding,
+      ...storage,
+    });
+    const context = Object.freeze({ descriptor: binding, childReceiptStore });
+    const composition = Reflect.apply(factory, undefined, [context]);
+    const { aggregator, receiptVerifier, durability } =
+      captureEvolutionEvalRuntimeComposition(composition, context);
+    return Object.freeze({
+      aggregator,
+      receiptVerifier,
+      durability,
+      planRef: configuration.planRef,
+      expectedReceipt: configuration.expectedReceipt,
+      usage: configuration.usage,
+    });
+  } catch (cause) {
+    if (cause?.code === EVOLUTION_EVAL_COMPOSITION_UNAVAILABLE_CODE)
+      throw cause;
+    throw unavailable("Eval production composition is unavailable", cause);
+  }
+}

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

@@ -12,9 +12,11 @@ import { types as utilTypes } from "node:util";
 import { ArtifactStore } from "../artifact-store.js";
 import {
   EvolutionArtifactPorts,
+  EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA,
   EVOLUTION_ARTIFACT_DEFAULT_TTL_MS,
   EVOLUTION_ARTIFACT_MAX_TTL_MS,
 } from "./evolution-artifact-ports.js";
+import { EVOLUTION_ARTIFACT_REF_SCHEMA } from "./evolution-ledger.js";
 import {
   EVOLUTION_RAW_STORAGE_RECEIPT_SCHEMA,
   EvolutionEvidenceBundleVerifier,
@@ -340,6 +342,7 @@ export class EvolutionEvidenceArtifactAdapter {
   #projectAgentModel;
   #verify;
   #ports;
+  #resolveManifestRef;
 
   constructor({
     tenantId,
@@ -384,6 +387,10 @@ export class EvolutionEvidenceArtifactAdapter {
     );
     this.#verify = captureMethod(bundleVerifier, "verify", "bundleVerifier");
     this.#ports = artifactPorts;
+    this.#resolveManifestRef =
+      artifactPorts.createEvolutionLedgerArtifactResolver({
+        purpose: this.#purpose,
+      });
     Object.freeze(this);
   }
 
@@ -468,11 +475,60 @@ export class EvolutionEvidenceArtifactAdapter {
       purpose: this.#purpose,
       tenantId: this.#tenantId,
     });
-    const manifest = manifestResolved.value;
+    return this.#resolveManifest(manifestResolved.value, result.evidenceId);
+  }
+
+  /**
+   * Authenticate retained bytes at a Run's manifest locator. This is NOT Run
+   * membership or caller read authorization: the Wiki resolver obtains the
+   * event from its captured Run capability and separately calls readTrusted.
+   */
+  async resolveRunEvidence({ event, ledgerId, epoch } = {}) {
+    if (
+      event?.type !== "raw-event-referenced" ||
+      event.tenantId !== this.#tenantId ||
+      event.data?.derivationManifestDigest !== event.payloadDigest
+    ) {
+      throw new TypeError("Run evidence manifest binding is invalid");
+    }
+    const evidenceId = normalizeId(event.subjectId, "Run evidenceId");
+    const resolved = this.#resolveManifestRef({
+      tenantId: this.#tenantId,
+      ledgerId,
+      epoch,
+      ref: {
+        schema: EVOLUTION_ARTIFACT_REF_SCHEMA,
+        ref: event.artifactRef,
+        digest: event.payloadDigest,
+      },
+    });
+    if (
+      resolved.authenticated !== true ||
+      resolved.found !== true ||
+      resolved.digest !== event.payloadDigest ||
+      resolved.ref !== event.artifactRef ||
+      !Buffer.isBuffer(resolved.bytes)
+    ) {
+      throw new Error("Run evidence manifest resolution is unbound");
+    }
+    const record = JSON.parse(resolved.bytes.toString("utf8"));
+    if (
+      record.schema !== EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA ||
+      record.tenantId !== this.#tenantId ||
+      record.audience !== this.#audience ||
+      record.purpose !== this.#purpose ||
+      record.type !== "evidence"
+    ) {
+      throw new Error("Run evidence manifest record is unbound");
+    }
+    return this.#resolveManifest(record.value, evidenceId);
+  }
+
+  async #resolveManifest(manifest, evidenceId) {
     if (
       manifest.schema !== EVOLUTION_EVIDENCE_DERIVATION_MANIFEST_SCHEMA ||
       manifest.tenantId !== this.#tenantId ||
-      manifest.evidenceId !== result.evidenceId
+      manifest.evidenceId !== evidenceId
     ) {
       throw new Error("evidence derivation manifest is invalid");
     }

package/src/lib/evolution/evolution-ledger-file-backend.js

@@ -1,7 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { createEvolutionFileWitness } from "./evolution-file-witness.js";
-import { EvolutionLedger } from "./evolution-ledger.js";
+import {
+  EvolutionLedger,
+  captureEvolutionLedgerMigrationSource,
+} from "./evolution-ledger.js";
+import { createEvolutionLedgerV2JournalFromFactory } from "./evolution-ledger-v2-journal.js";
 
 export const EVOLUTION_LEDGER_FILE_BACKEND_SCHEMA =
   "chainlesschain.evolution-ledger-file-backend/v1";
@@ -110,6 +114,7 @@ export function createEvolutionLedgerFileBackend({
   crashHook = null,
   witnessMaximumBytes,
   witnessMaximumHistoryBytes,
+  manifestV2 = null,
 } = {}) {
   if (typeof artifactResolver !== "function") {
     throw new TypeError("artifactResolver port is required");
@@ -151,7 +156,7 @@ export function createEvolutionLedgerFileBackend({
       : { maximumHistoryBytes: witnessMaximumHistoryBytes }),
   };
   const witness = createEvolutionFileWitness(witnessOptions);
-  const ledger = new EvolutionLedger({
+  const sourceLedger = new EvolutionLedger({
     rootDir: paths.eventRoot,
     authorityRootDir: paths.authorityRoot,
     secure,
@@ -170,6 +175,22 @@ export function createEvolutionLedgerFileBackend({
     ...(lockTimeoutMs === undefined ? {} : { lockTimeoutMs }),
     crashHook,
   });
+  if (
+    manifestV2 === null &&
+    captureEvolutionLedgerMigrationSource(sourceLedger).requiresV2()
+  ) {
+    throw Object.assign(
+      new Error("migrated ledger requires its authenticated v2 composition"),
+      { code: "CC_EVOLUTION_LEDGER_V2_REQUIRED" },
+    );
+  }
+  const ledger =
+    manifestV2 === null
+      ? sourceLedger
+      : createEvolutionLedgerV2JournalFromFactory(sourceLedger, manifestV2, {
+          ...(lock === undefined ? {} : { lock }),
+          ...(lockTimeoutMs === undefined ? {} : { lockTimeoutMs }),
+        });
   const backend = Object.freeze({
     schema: EVOLUTION_LEDGER_FILE_BACKEND_SCHEMA,
     descriptor: Object.freeze({