chainlesschain 0.166.22 → 0.166.25

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

@@ -7,7 +7,13 @@ export const EVOLUTION_DEPLOYMENT_DESCRIPTOR_SCHEMA =
   "chainlesschain.evolution-deployment-descriptor/v1";
 
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
-const SUPPORTED_COMMANDS = new Set(["agent", "evolution", "serve"]);
+const SUPPORTED_COMMANDS = new Set([
+  "agent",
+  "desktop",
+  "evolution",
+  "marketplace",
+  "serve",
+]);
 
 function canonical(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -111,17 +117,161 @@ function dependencies(value, commandName) {
 
 async function loadBuiltInFactories(commandName) {
   const factories = {};
+  if (commandName === "marketplace" || commandName === "desktop") {
+    const [
+      { createGovernedSkillMarketplaceCliHost },
+      { createGovernedSkillMarketplaceLedgerAdapter },
+      { createGovernedSkillMarketplaceCandidateInstaller },
+    ] = await Promise.all([
+      import("./governed-skill-marketplace-cli-host.js"),
+      import("./governed-skill-marketplace-ledger-adapter.js"),
+      import("./governed-skill-marketplace-candidate.js"),
+    ]);
+    factories.createGovernedSkillMarketplaceCliHost =
+      createGovernedSkillMarketplaceCliHost;
+    factories.createGovernedSkillMarketplaceLedgerAdapter =
+      createGovernedSkillMarketplaceLedgerAdapter;
+    factories.createGovernedSkillMarketplaceCandidateInstaller =
+      createGovernedSkillMarketplaceCandidateInstaller;
+  }
   if (commandName === "evolution" || commandName === "serve") {
     const [
       { createEvolutionWorkbenchCliHost },
+      { createEvolutionWorkbenchReviewRuntime },
+      { createEvolutionWorkbenchRollbackRuntime },
+      { createEvolutionWorkbenchRegistrySource },
+      { createEvolutionWorkbenchRuntime },
+      { openEvolutionWorkbenchFileResources },
+      { createEvolutionWorkbenchControlPorts },
       { createGovernedKnowledgeReviewHost },
+      { createWikiSkillBenchmarkCliHost },
+      {
+        createWikiSkillBenchmarkDatasetProvider,
+        createWikiSkillBenchmarkExecutionManifest,
+        createWikiSkillBenchmarkGrader,
+        createWikiSkillBenchmarkReportAttestor,
+        createWikiSkillBenchmarkRunner,
+      },
+      { createWikiSkillBenchmarkLedgerAdapter },
+      { createEvolutionEvalProcessSupervisor },
     ] = await Promise.all([
       import("./evolution-workbench-cli-host.js"),
+      import("./evolution-workbench-review-ledger-adapter.js"),
+      import("./evolution-workbench-rollback-ledger-adapter.js"),
+      import("./evolution-workbench-registry-source.js"),
+      import("./evolution-workbench-runtime.js"),
+      import("./evolution-workbench-file-resources.js"),
+      import("./evolution-workbench-control-ports.js"),
       import("./governed-knowledge-review-host.js"),
+      import("./wikiskill-benchmark-cli-host.js"),
+      import("./wikiskill-benchmark-execution-host.js"),
+      import("./wikiskill-benchmark-ledger-adapter.js"),
+      import("./evolution-eval-process-supervisor.js"),
     ]);
     factories.createEvolutionWorkbenchCliHost = createEvolutionWorkbenchCliHost;
+    factories.createEvolutionWorkbenchReviewRuntime =
+      createEvolutionWorkbenchReviewRuntime;
+    factories.createEvolutionWorkbenchRollbackRuntime =
+      createEvolutionWorkbenchRollbackRuntime;
+    factories.createEvolutionWorkbenchRegistrySource =
+      createEvolutionWorkbenchRegistrySource;
+    factories.createEvolutionWorkbenchRuntime = createEvolutionWorkbenchRuntime;
+    factories.openEvolutionWorkbenchFileResources =
+      openEvolutionWorkbenchFileResources;
+    factories.createEvolutionWorkbenchControlPorts =
+      createEvolutionWorkbenchControlPorts;
     factories.createGovernedKnowledgeReviewHost =
       createGovernedKnowledgeReviewHost;
+    factories.createWikiSkillBenchmarkCliHost = createWikiSkillBenchmarkCliHost;
+    factories.createWikiSkillBenchmarkDatasetProvider =
+      createWikiSkillBenchmarkDatasetProvider;
+    factories.createWikiSkillBenchmarkExecutionManifest =
+      createWikiSkillBenchmarkExecutionManifest;
+    factories.createWikiSkillBenchmarkGrader = createWikiSkillBenchmarkGrader;
+    factories.createWikiSkillBenchmarkReportAttestor =
+      createWikiSkillBenchmarkReportAttestor;
+    factories.createWikiSkillBenchmarkRunner = createWikiSkillBenchmarkRunner;
+    factories.createWikiSkillBenchmarkLedgerAdapter =
+      createWikiSkillBenchmarkLedgerAdapter;
+    factories.createEvolutionEvalProcessSupervisor =
+      createEvolutionEvalProcessSupervisor;
+    const [
+      { SkillCandidateRegistry },
+      { SkillReleaseRegistry },
+      { SkillPromotionController },
+      { createEvolutionLedgerPorts },
+      { createWikiMaintainerLedgerAdapter },
+      { createGovernedKnowledgeArtifactLifecycle },
+      { GovernedKnowledgeSyncLedgerAdapter },
+      { GovernedKnowledgeDependencyLedgerExecutor },
+      { GovernedKnowledgeDependencyInventoryPlanner },
+      { GovernedKnowledgeSync },
+      { createGovernedKnowledgeRevocationHost },
+      {
+        createGovernedKnowledgeCandidateQuarantineAuthority,
+        createGovernedKnowledgeCandidateRejectionAuthority,
+      },
+      {
+        createGovernedKnowledgeSkillQuarantineAuthority,
+        createGovernedKnowledgeSkillRollbackAuthority,
+      },
+      {
+        createGovernedKnowledgeWikiQuarantineAuthority,
+        createGovernedKnowledgeWikiTombstoneAuthority,
+      },
+      { createGovernedKnowledgeDependencyRouter },
+      {
+        GovernedKnowledgeQuarantineReleaseLedger,
+        createGovernedKnowledgeQuarantineReleaseDecisionAuthority,
+      },
+    ] = await Promise.all([
+      import("./skill-candidate-registry.js"),
+      import("./skill-release-registry.js"),
+      import("./skill-promotion-controller.js"),
+      import("./evolution-ledger-ports.js"),
+      import("./wiki-maintainer-ledger-adapter.js"),
+      import("./governed-knowledge-artifact-lifecycle.js"),
+      import("./governed-knowledge-sync-ledger-adapter.js"),
+      import("./governed-knowledge-dependency-ledger-executor.js"),
+      import("./governed-knowledge-dependency-inventory.js"),
+      import("./governed-knowledge-sync.js"),
+      import("./governed-knowledge-revocation-host.js"),
+      import("./governed-knowledge-candidate-rejection.js"),
+      import("./governed-knowledge-skill-rollback.js"),
+      import("./governed-knowledge-wiki-tombstone.js"),
+      import("./governed-knowledge-dependency-authority.js"),
+      import("./governed-knowledge-quarantine-release.js"),
+    ]);
+    Object.assign(factories, {
+      createSkillCandidateRegistry: (options) =>
+        new SkillCandidateRegistry(options),
+      createSkillReleaseRegistry: (options) =>
+        new SkillReleaseRegistry(options),
+      createSkillPromotionController: (options) =>
+        new SkillPromotionController(options),
+      createEvolutionLedgerPorts,
+      createWikiMaintainerLedgerAdapter,
+      createGovernedKnowledgeArtifactLifecycle,
+      createGovernedKnowledgeSyncLedgerAdapter: (options) =>
+        new GovernedKnowledgeSyncLedgerAdapter(options),
+      createGovernedKnowledgeDependencyLedgerExecutor: (options) =>
+        new GovernedKnowledgeDependencyLedgerExecutor(options),
+      createGovernedKnowledgeDependencyInventoryPlanner: (options) =>
+        new GovernedKnowledgeDependencyInventoryPlanner(options),
+      createGovernedKnowledgeSync: (options) =>
+        new GovernedKnowledgeSync(options),
+      createGovernedKnowledgeRevocationHost,
+      createGovernedKnowledgeCandidateQuarantineAuthority,
+      createGovernedKnowledgeCandidateRejectionAuthority,
+      createGovernedKnowledgeSkillQuarantineAuthority,
+      createGovernedKnowledgeSkillRollbackAuthority,
+      createGovernedKnowledgeWikiQuarantineAuthority,
+      createGovernedKnowledgeWikiTombstoneAuthority,
+      createGovernedKnowledgeDependencyRouter,
+      createGovernedKnowledgeQuarantineReleaseDecisionAuthority,
+      createGovernedKnowledgeQuarantineReleaseLedger: (options) =>
+        new GovernedKnowledgeQuarantineReleaseLedger(options),
+    });
   }
   if (commandName === "agent" || commandName === "serve") {
     const { createAgentEvolutionRuntimeComposition } =
@@ -132,6 +282,60 @@ async function loadBuiltInFactories(commandName) {
   return Object.freeze(factories);
 }
 
+function bindFactoriesToModule(factories, moduleDigest) {
+  const result = { ...factories };
+  const providerFactories = [
+    "createEvolutionWorkbenchReviewRuntime",
+    "createEvolutionWorkbenchRollbackRuntime",
+    "createEvolutionWorkbenchRegistrySource",
+    "createEvolutionWorkbenchRuntime",
+    "openEvolutionWorkbenchFileResources",
+    "createEvolutionWorkbenchControlPorts",
+    "createWikiSkillBenchmarkDatasetProvider",
+    "createWikiSkillBenchmarkGrader",
+    "createWikiSkillBenchmarkReportAttestor",
+    "createWikiSkillBenchmarkRunner",
+  ];
+  for (const name of providerFactories) {
+    if (typeof factories[name] !== "function") continue;
+    result[name] = (options = {}) => {
+      if (options?.descriptor?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          `${name} handlerArtifactDigest must equal the authenticated deployment module digest`,
+        );
+      return factories[name](options);
+    };
+  }
+  if (
+    typeof factories.createWikiSkillBenchmarkExecutionManifest === "function"
+  ) {
+    result.createWikiSkillBenchmarkExecutionManifest = (input = {}) => {
+      for (const authority of [
+        "datasetProvider",
+        "runner",
+        "grader",
+        "reportAttestor",
+      ]) {
+        if (input?.[authority]?.handlerArtifactDigest !== moduleDigest)
+          throw new Error(
+            `benchmark ${authority} handlerArtifactDigest must equal the authenticated deployment module digest`,
+          );
+      }
+      return factories.createWikiSkillBenchmarkExecutionManifest(input);
+    };
+  }
+  if (typeof factories.createEvolutionEvalProcessSupervisor === "function") {
+    result.createEvolutionEvalProcessSupervisor = (options = {}) => {
+      if (options?.authorityDescriptor?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          "process Eval supervisor handlerArtifactDigest must equal the authenticated deployment module digest",
+        );
+      return factories.createEvolutionEvalProcessSupervisor(options);
+    };
+  }
+  return Object.freeze(result);
+}
+
 export async function loadEvolutionDeploymentCommandDependencies(
   commandName,
   {
@@ -139,6 +343,7 @@ export async function loadEvolutionDeploymentCommandDependencies(
     read = readFile,
     resolveRealPath = realpath,
     importModule = (url) => import(url),
+    additionalFactories = {},
   } = {},
 ) {
   if (!SUPPORTED_COMMANDS.has(commandName)) return null;
@@ -195,12 +400,45 @@ export async function loadEvolutionDeploymentCommandDependencies(
     throw new Error(
       "evolution deployment module must export createChainlessChainCommandDependencies",
     );
+  const builtInFactories = bindFactoriesToModule(
+    await loadBuiltInFactories(commandName),
+    descriptor.moduleDigest,
+  );
+  if (
+    !additionalFactories ||
+    typeof additionalFactories !== "object" ||
+    Array.isArray(additionalFactories) ||
+    utilTypes.isProxy(additionalFactories)
+  ) {
+    throw new TypeError(
+      "additional evolution deployment factories are invalid",
+    );
+  }
+  const additionalFactoryEntries = Object.entries(additionalFactories);
+  if (additionalFactoryEntries.length > 0 && commandName !== "desktop") {
+    throw new Error(
+      "additional evolution deployment factories are reserved for desktop",
+    );
+  }
+  if (
+    additionalFactoryEntries.some(
+      ([name, factory]) =>
+        Object.hasOwn(builtInFactories, name) || typeof factory !== "function",
+    )
+  ) {
+    throw new TypeError(
+      "additional evolution deployment factories are invalid",
+    );
+  }
   return dependencies(
     await loaded.createChainlessChainCommandDependencies(
       Object.freeze({
         commandName,
         descriptor: Object.freeze({ ...descriptor }),
-        factories: await loadBuiltInFactories(commandName),
+        factories: Object.freeze({
+          ...builtInFactories,
+          ...additionalFactories,
+        }),
       }),
     ),
     commandName,

package/src/lib/evolution/evolution-eval-child-evidence-ledger-adapter.js

@@ -0,0 +1,373 @@
+import {
+  EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA,
+  isEvolutionLedgerArtifactResolver,
+} from "./evolution-artifact-ports.js";
+import {
+  EVOLUTION_EVAL_ATTESTATION_PURPOSES,
+  EVOLUTION_EVAL_RECEIPT_SCHEMA,
+  EVOLUTION_EVAL_TARGET_INVOCATION_SCHEMA,
+  EVOLUTION_EVAL_TARGET_REVOCATION_SCHEMA,
+  computeEvolutionEvalReceiptDigest,
+  computeEvolutionEvalSignedEvidenceDigest,
+} from "./evolution-eval-gate.js";
+import {
+  EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA,
+  EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA,
+} from "./evolution-ledger.js";
+
+export const EVOLUTION_EVAL_CHILD_EVIDENCE_RECORD_SCHEMA =
+  "chainlesschain.evolution-eval-child-evidence-record/v1";
+export const EVOLUTION_EVAL_CHILD_EVIDENCE_RESOLUTION_SCHEMA =
+  "chainlesschain.evolution-eval-child-evidence-resolution/v1";
+export const EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE =
+  "evolution.eval-child-evidence.retained";
+export const EVOLUTION_EVAL_CHILD_EVIDENCE_CORRUPT_CODE =
+  "CC_EVOLUTION_EVAL_CHILD_EVIDENCE_CORRUPT";
+
+const ARTIFACT_TYPE = "evolution-eval-child-evidence";
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const CHILD_EVIDENCE_STORES = new WeakSet();
+const KINDS = Object.freeze({
+  "gate-receipt": Object.freeze({
+    purpose: null,
+    schema: EVOLUTION_EVAL_RECEIPT_SCHEMA,
+  }),
+  invocation: Object.freeze({
+    purpose: EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetInvocation,
+    schema: EVOLUTION_EVAL_TARGET_INVOCATION_SCHEMA,
+  }),
+  revocation: Object.freeze({
+    purpose: EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetRevocation,
+    schema: EVOLUTION_EVAL_TARGET_REVOCATION_SCHEMA,
+  }),
+});
+
+function requiredString(value, label) {
+  if (typeof value !== "string" || value.trim() === "")
+    throw new TypeError(`${label} is required`);
+  return value;
+}
+
+function capture(owner, method, label = method) {
+  if (typeof owner?.[method] !== "function")
+    throw new TypeError(`${label} port is required`);
+  return (...args) => Reflect.apply(owner[method], owner, args);
+}
+
+function canonical(value) {
+  if (value === null || typeof value !== "object") return JSON.stringify(value);
+  if (Array.isArray(value)) return `[${value.map(canonical).join(",")}]`;
+  return `{${Object.keys(value)
+    .sort()
+    .map((key) => `${JSON.stringify(key)}:${canonical(value[key])}`)
+    .join(",")}}`;
+}
+
+function corrupt(message) {
+  const error = new Error(message);
+  error.code = EVOLUTION_EVAL_CHILD_EVIDENCE_CORRUPT_CODE;
+  throw error;
+}
+
+function descriptor(input) {
+  if (!Number.isSafeInteger(input?.revision) || input.revision < 1)
+    throw new TypeError("revision must be a positive integer");
+  if (!DIGEST.test(input?.handlerArtifactDigest || ""))
+    throw new TypeError("handlerArtifactDigest must be sha256-bound");
+  return Object.freeze({
+    tenantId: requiredString(input.tenantId, "tenantId"),
+    artifactTenantId: requiredString(
+      input.artifactTenantId,
+      "artifactTenantId",
+    ),
+    streamId: requiredString(input.streamId, "streamId"),
+    audience: requiredString(input.audience, "audience"),
+    purpose: requiredString(input.purpose, "purpose"),
+    authorityId: requiredString(input.authorityId, "authorityId"),
+    revision: input.revision,
+    handlerArtifactDigest: input.handlerArtifactDigest,
+  });
+}
+
+function storeDescriptor(input) {
+  if (!Number.isSafeInteger(input?.revision) || input.revision < 1)
+    throw new TypeError("child evidence store revision must be positive");
+  if (!DIGEST.test(input?.handlerArtifactDigest || ""))
+    throw new TypeError("child evidence store handler digest is invalid");
+  return Object.freeze({
+    tenantId: requiredString(input.tenantId, "child evidence store tenantId"),
+    streamId: requiredString(input.streamId, "child evidence store streamId"),
+    authorityId: requiredString(
+      input.authorityId,
+      "child evidence store authorityId",
+    ),
+    revision: input.revision,
+    handlerArtifactDigest: input.handlerArtifactDigest,
+  });
+}
+
+function captureEvidence(kind, evidence, expectedDigest) {
+  const policy = KINDS[kind];
+  if (!policy) throw new TypeError("child evidence kind is invalid");
+  if (!evidence || typeof evidence !== "object" || Array.isArray(evidence))
+    throw new TypeError("child evidence must be a record");
+  const captured = Object.freeze(structuredClone(evidence));
+  if (captured.schema !== policy.schema)
+    throw new TypeError("child evidence schema does not match its kind");
+  const receiptDigest =
+    kind === "gate-receipt"
+      ? computeEvolutionEvalReceiptDigest(captured)
+      : computeEvolutionEvalSignedEvidenceDigest(captured, policy.purpose);
+  if (kind === "gate-receipt" && captured.receiptDigest !== receiptDigest)
+    throw new TypeError("Gate child receipt digest is invalid");
+  if (expectedDigest !== undefined && receiptDigest !== expectedDigest)
+    throw new TypeError("child evidence digest does not match its bytes");
+  return Object.freeze({ captured, receiptDigest });
+}
+
+export class EvolutionEvalChildEvidenceLedgerAdapter {
+  constructor({
+    descriptor: input,
+    artifactPorts,
+    ledger,
+    ledgerArtifactResolver,
+    now = Date.now,
+  } = {}) {
+    this.descriptor = descriptor(input);
+    this._put = capture(artifactPorts, "putCanonical");
+    this._read = capture(ledger, "read");
+    this._verifyLedger = capture(ledger, "verify");
+    this._append = capture(ledger, "appendDomainEvent");
+    if (!isEvolutionLedgerArtifactResolver(ledgerArtifactResolver))
+      throw new TypeError(
+        "a branded EvolutionArtifactPorts ledger resolver is required",
+      );
+    if (typeof now !== "function")
+      throw new TypeError("now must be a function");
+    this._resolveArtifact = ledgerArtifactResolver;
+    this._now = now;
+    CHILD_EVIDENCE_STORES.add(this);
+    Object.freeze(this);
+  }
+
+  _events() {
+    const events = this._read();
+    if (!Array.isArray(events))
+      corrupt("EvolutionLedger did not return events");
+    return events.filter(
+      (event) =>
+        event.schema === EVOLUTION_LEDGER_DOMAIN_EVENT_SCHEMA &&
+        event.type === EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE &&
+        event.tenantId === this.descriptor.tenantId &&
+        event.correlationId === this.descriptor.streamId,
+    );
+  }
+
+  _resolveEvent(event) {
+    if (
+      event.artifactTenantId !== this.descriptor.artifactTenantId ||
+      event.decision !== "accepted" ||
+      event.skillName !== "evolution-eval" ||
+      !Array.isArray(event.sourceRefs) ||
+      event.sourceRefs.length !== 0
+    ) {
+      corrupt("child evidence ledger event binding is invalid");
+    }
+    const identity = this._verifyLedger();
+    const resolution = this._resolveArtifact({
+      epoch: identity.epoch,
+      ledgerId: identity.ledgerId,
+      ref: event.subjectRef,
+      tenantId: this.descriptor.artifactTenantId,
+    });
+    if (
+      resolution?.schema !== EVOLUTION_ARTIFACT_RESOLUTION_SCHEMA ||
+      resolution.authenticated !== true ||
+      resolution.found !== true ||
+      resolution.ref !== event.subjectRef.ref ||
+      resolution.digest !== event.subjectRef.digest ||
+      !Buffer.isBuffer(resolution.bytes)
+    ) {
+      corrupt("child evidence artifact resolution is invalid");
+    }
+    let durableRecord;
+    try {
+      durableRecord = JSON.parse(resolution.bytes.toString("utf8"));
+    } catch {
+      corrupt("child evidence artifact is not JSON");
+    }
+    if (
+      durableRecord?.schema !== EVOLUTION_DURABLE_ARTIFACT_RECORD_SCHEMA ||
+      durableRecord.tenantId !== this.descriptor.artifactTenantId ||
+      durableRecord.audience !== this.descriptor.audience ||
+      durableRecord.purpose !== this.descriptor.purpose ||
+      durableRecord.retention !== "ledger" ||
+      durableRecord.type !== ARTIFACT_TYPE
+    ) {
+      corrupt("child evidence durable record binding is invalid");
+    }
+    const value = durableRecord.value;
+    if (
+      value?.schema !== EVOLUTION_EVAL_CHILD_EVIDENCE_RECORD_SCHEMA ||
+      value.tenantId !== this.descriptor.tenantId ||
+      value.streamId !== this.descriptor.streamId
+    ) {
+      corrupt("child evidence record scope is invalid");
+    }
+    const verified = captureEvidence(
+      value.kind,
+      value.evidence,
+      value.receiptDigest,
+    );
+    if (
+      event.eventId !==
+      `${EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE}.${verified.receiptDigest.slice(7)}`
+    ) {
+      corrupt("child evidence event identity is invalid");
+    }
+    return Object.freeze({
+      kind: value.kind,
+      evidence: verified.captured,
+      receiptDigest: verified.receiptDigest,
+      event,
+    });
+  }
+
+  async retain({ kind, evidence, receiptDigest } = {}) {
+    const verified = captureEvidence(kind, evidence, receiptDigest);
+    const eventId = `${EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE}.${verified.receiptDigest.slice(7)}`;
+    const existing = this._events().filter(
+      (event) => event.eventId === eventId,
+    );
+    if (existing.length > 1) corrupt("child evidence event is ambiguous");
+    if (existing.length === 1) {
+      const recovered = this._resolveEvent(existing[0]);
+      if (
+        recovered.kind !== kind ||
+        canonical(recovered.evidence) !== canonical(verified.captured)
+      ) {
+        corrupt("child evidence event resolved substituted bytes");
+      }
+      return Object.freeze({
+        authenticated: true,
+        durable: true,
+        recovered: true,
+        kind,
+        receiptDigest: verified.receiptDigest,
+      });
+    }
+    const head = this._verifyLedger();
+    const nowMs = Number(this._now());
+    if (!Number.isFinite(nowMs))
+      throw new TypeError("child evidence clock is invalid");
+    const record = Object.freeze({
+      schema: EVOLUTION_EVAL_CHILD_EVIDENCE_RECORD_SCHEMA,
+      tenantId: this.descriptor.tenantId,
+      streamId: this.descriptor.streamId,
+      kind,
+      receiptDigest: verified.receiptDigest,
+      evidence: verified.captured,
+    });
+    const published = this._put(ARTIFACT_TYPE, record, {
+      audience: this.descriptor.audience,
+      purpose: this.descriptor.purpose,
+      retention: "ledger",
+    });
+    if (
+      published?.receipt?.persisted !== true ||
+      published.receipt.readbackVerified !== true ||
+      published.receipt.integrityVerified !== true ||
+      published.receipt.retention !== "ledger"
+    ) {
+      corrupt("child evidence persistence was not durably confirmed");
+    }
+    const receipt = this._append(
+      {
+        artifactTenantId: this.descriptor.artifactTenantId,
+        correlationId: this.descriptor.streamId,
+        decision: "accepted",
+        eventId,
+        reason: `durable ${kind} child evidence`,
+        skillName: "evolution-eval",
+        sourceRefs: [],
+        subjectRef: published.ref,
+        tenantId: this.descriptor.tenantId,
+        timestamp: new Date(nowMs).toISOString(),
+        type: EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE,
+      },
+      { expectedHeadDigest: head.headDigest, expectedSequence: head.sequence },
+    );
+    if (receipt?.authenticated !== true || receipt.durable !== true)
+      corrupt("child evidence ledger append was not durable");
+    return Object.freeze({
+      authenticated: true,
+      durable: true,
+      recovered: false,
+      kind,
+      receiptDigest: verified.receiptDigest,
+      ledgerReceiptDigest: receipt.receiptDigest,
+    });
+  }
+
+  async resolve({ tenantId, kind, receiptDigest } = {}) {
+    if (
+      tenantId !== this.descriptor.tenantId ||
+      !KINDS[kind] ||
+      !DIGEST.test(receiptDigest || "")
+    ) {
+      throw new TypeError("child evidence resolution request is invalid");
+    }
+    const matches = this._events()
+      .filter(
+        (event) =>
+          event.eventId ===
+          `${EVOLUTION_EVAL_CHILD_EVIDENCE_EVENT_TYPE}.${receiptDigest.slice(7)}`,
+      )
+      .map((event) => this._resolveEvent(event))
+      .filter(
+        (entry) => entry.kind === kind && entry.receiptDigest === receiptDigest,
+      );
+    if (matches.length !== 1) corrupt("child evidence is missing or ambiguous");
+    const resolvedAtMs = Number(this._now());
+    if (!Number.isFinite(resolvedAtMs))
+      throw new TypeError("child evidence clock is invalid");
+    return Object.freeze({
+      schema: EVOLUTION_EVAL_CHILD_EVIDENCE_RESOLUTION_SCHEMA,
+      authenticated: true,
+      durable: true,
+      authorityId: this.descriptor.authorityId,
+      revision: this.descriptor.revision,
+      handlerArtifactDigest: this.descriptor.handlerArtifactDigest,
+      tenantId,
+      streamId: this.descriptor.streamId,
+      kind,
+      receiptDigest,
+      evidence: matches[0].evidence,
+      resolvedAt: new Date(resolvedAtMs).toISOString(),
+    });
+  }
+}
+
+export function createEvolutionEvalChildEvidenceLedgerAdapter(options) {
+  return new EvolutionEvalChildEvidenceLedgerAdapter(options);
+}
+
+export function createEvolutionEvalChildEvidenceStorePort({
+  descriptor: input,
+  retain,
+  resolve,
+} = {}) {
+  if (typeof retain !== "function" || typeof resolve !== "function")
+    throw new TypeError("child evidence store ports are required");
+  const port = Object.freeze({
+    descriptor: storeDescriptor(input),
+    retain: (...args) => Reflect.apply(retain, undefined, args),
+    resolve: (...args) => Reflect.apply(resolve, undefined, args),
+  });
+  CHILD_EVIDENCE_STORES.add(port);
+  return port;
+}
+
+export function isEvolutionEvalChildEvidenceStore(value) {
+  return CHILD_EVIDENCE_STORES.has(value);
+}

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

@@ -1055,6 +1055,19 @@ export function buildEvolutionEvalAttestationDigest(value, purpose) {
   return digest(value, `chainlesschain.evolution-eval-attestation/${purpose}`);
 }
 
+export function computeEvolutionEvalSignedEvidenceDigest(record, purpose) {
+  if (
+    purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetInvocation &&
+    purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetRevocation
+  ) {
+    throw evalError(
+      EVOLUTION_EVAL_INVALID_CODE,
+      "signed evidence purpose is invalid",
+    );
+  }
+  return digest(cloneCanonical(record), `${purpose}/signed-record`);
+}
+
 export function computeEvolutionEvalEnvironmentDigest(environment) {
   return digest(
     cloneCanonical(environment),
@@ -2345,7 +2358,7 @@ function verifySynchronousEvidence({
   }
   return deepFreeze({
     core,
-    recordDigest: digest(cloneCanonical(record), `${purpose}/signed-record`),
+    recordDigest: computeEvolutionEvalSignedEvidenceDigest(record, purpose),
   });
 }