chainlesschain 0.166.65 → 0.166.69

package/src/lib/evolution/browser-vision-observation-authority.js

@@ -0,0 +1,304 @@
+import { createHash } from "node:crypto";
+import { types } from "node:util";
+
+export const BROWSER_VISION_OBSERVATION_AUTHORITY_DESCRIPTOR_SCHEMA =
+  "chainlesschain.browser-vision-observation-authority-descriptor/v1";
+export const BROWSER_VISION_OBSERVATION_REQUEST_SCHEMA =
+  "chainlesschain.browser-vision-observation-request/v1";
+export const BROWSER_VISION_OBSERVATION_RECEIPT_SCHEMA =
+  "chainlesschain.browser-vision-observation-receipt/v1";
+
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const ID = /^[A-Za-z0-9._:-]{1,128}$/u;
+const OPERATIONS = new Set(["analyze", "locate", "compare", "describe", "ocr"]);
+const authorities = new WeakMap();
+
+function canonical(value) {
+  if (value === null || typeof value === "boolean")
+    return JSON.stringify(value);
+  if (typeof value === "number" && Number.isFinite(value))
+    return JSON.stringify(value);
+  if (typeof value === "string") 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 digest(domain, value) {
+  return `sha256:${createHash("sha256")
+    .update(`${domain}\0`)
+    .update(canonical(value))
+    .digest("hex")}`;
+}
+
+function exactObject(value, keys, label) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    types.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value)) ||
+    Object.keys(value).sort().join("\0") !== [...keys].sort().join("\0")
+  ) {
+    throw new TypeError(`${label} has an invalid shape`);
+  }
+  for (const key of keys) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor?.enumerable || !("value" in descriptor))
+      throw new TypeError(`${label} must contain plain data`);
+  }
+}
+
+function snapshotJson(value, label) {
+  let nodes = 0;
+  const visit = (entry, depth) => {
+    if (++nodes > 2048 || depth > 12)
+      throw new TypeError(`${label} exceeds its structure budget`);
+    if (
+      entry === null ||
+      typeof entry === "boolean" ||
+      (typeof entry === "number" && Number.isFinite(entry)) ||
+      typeof entry === "string"
+    ) {
+      return entry;
+    }
+    if (
+      !entry ||
+      typeof entry !== "object" ||
+      types.isProxy(entry) ||
+      ![Object.prototype, null, Array.prototype].includes(
+        Object.getPrototypeOf(entry),
+      )
+    ) {
+      throw new TypeError(`${label} must be finite plain JSON data`);
+    }
+    if (Array.isArray(entry))
+      return Object.freeze(entry.map((v) => visit(v, depth + 1)));
+    const output = {};
+    for (const key of Object.keys(entry)) {
+      const descriptor = Object.getOwnPropertyDescriptor(entry, key);
+      if (!descriptor?.enumerable || !("value" in descriptor))
+        throw new TypeError(`${label} must contain plain data`);
+      output[key] = visit(descriptor.value, depth + 1);
+    }
+    return Object.freeze(output);
+  };
+  const snapshot = visit(value, 0);
+  if (Buffer.byteLength(canonical(snapshot), "utf8") > 16 * 1024)
+    throw new TypeError(`${label} exceeds its byte budget`);
+  return snapshot;
+}
+
+function normalizeDescriptor(value) {
+  const keys = [
+    "schema",
+    "authorityId",
+    "tenantId",
+    "handlerArtifactDigest",
+    "policyRevision",
+    "maxGrantTtlMs",
+  ];
+  exactObject(value, keys, "browser vision authority descriptor");
+  if (
+    value.schema !== BROWSER_VISION_OBSERVATION_AUTHORITY_DESCRIPTOR_SCHEMA ||
+    !ID.test(value.authorityId) ||
+    !ID.test(value.tenantId) ||
+    !DIGEST.test(value.handlerArtifactDigest) ||
+    !ID.test(value.policyRevision) ||
+    !Number.isSafeInteger(value.maxGrantTtlMs) ||
+    value.maxGrantTtlMs < 1 ||
+    value.maxGrantTtlMs > 60_000
+  ) {
+    throw new TypeError("browser vision authority descriptor is invalid");
+  }
+  return Object.freeze({ ...value });
+}
+
+function normalizeRequest(value) {
+  const keys = [
+    "schema",
+    "requestId",
+    "targetId",
+    "operation",
+    "senderId",
+    "frameUrlDigest",
+    "inputDigest",
+    "authorization",
+    "requestedAt",
+  ];
+  exactObject(value, keys, "browser vision observation request");
+  const requestedAtMs = Date.parse(value.requestedAt);
+  if (
+    value.schema !== BROWSER_VISION_OBSERVATION_REQUEST_SCHEMA ||
+    !ID.test(value.requestId) ||
+    typeof value.targetId !== "string" ||
+    value.targetId.length < 1 ||
+    value.targetId.length > 512 ||
+    !OPERATIONS.has(value.operation) ||
+    !Number.isSafeInteger(value.senderId) ||
+    value.senderId < 1 ||
+    !DIGEST.test(value.frameUrlDigest) ||
+    !DIGEST.test(value.inputDigest) ||
+    !Number.isFinite(requestedAtMs)
+  ) {
+    throw new TypeError("browser vision observation request is invalid");
+  }
+  const authorization = snapshotJson(
+    value.authorization,
+    "browser vision observation authorization",
+  );
+  return Object.freeze({ ...value, authorization, requestedAtMs });
+}
+
+function requestEvidence(request) {
+  const authorizationDigest = digest(
+    "chainlesschain.browser-vision-observation-authorization/v1",
+    request.authorization,
+  );
+  const core = {
+    schema: request.schema,
+    requestId: request.requestId,
+    targetId: request.targetId,
+    operation: request.operation,
+    senderId: request.senderId,
+    frameUrlDigest: request.frameUrlDigest,
+    inputDigest: request.inputDigest,
+    authorizationDigest,
+    requestedAt: request.requestedAt,
+  };
+  return Object.freeze({
+    ...core,
+    requestDigest: digest(
+      "chainlesschain.browser-vision-observation-request/v1",
+      core,
+    ),
+  });
+}
+
+function normalizeDecision(value) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    types.isProxy(value) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(value))
+  ) {
+    throw new TypeError("browser vision observation decision is invalid");
+  }
+  const decisionDescriptor = Object.getOwnPropertyDescriptor(value, "decision");
+  if (!decisionDescriptor?.enumerable || !("value" in decisionDescriptor))
+    throw new TypeError(
+      "browser vision observation decision must be plain data",
+    );
+  if (decisionDescriptor.value === "deny") {
+    const keys = Object.hasOwn(value, "reason")
+      ? ["decision", "reason"]
+      : ["decision"];
+    exactObject(value, keys, "browser vision observation decision");
+    const reason = Object.hasOwn(value, "reason") ? value.reason : null;
+    if (reason !== null && (typeof reason !== "string" || reason.length > 512))
+      throw new TypeError(
+        "browser vision observation denial reason is invalid",
+      );
+    return Object.freeze({ decision: "deny", reason });
+  }
+  exactObject(
+    value,
+    ["decision", "authorizationEvidenceRef", "validUntil"],
+    "browser vision observation decision",
+  );
+  if (decisionDescriptor.value !== "allow")
+    throw new TypeError("browser vision observation decision is invalid");
+  return Object.freeze({
+    decision: "allow",
+    authorizationEvidenceRef: value.authorizationEvidenceRef,
+    validUntil: value.validUntil,
+  });
+}
+
+export function createBrowserVisionObservationAuthority({
+  descriptor,
+  authorize,
+  now = () => Date.now(),
+} = {}) {
+  const normalizedDescriptor = normalizeDescriptor(descriptor);
+  if (typeof authorize !== "function" || types.isProxy(authorize))
+    throw new TypeError("browser vision observation authorize port is invalid");
+  if (typeof now !== "function" || types.isProxy(now))
+    throw new TypeError("browser vision observation clock is invalid");
+  const authority = Object.freeze({});
+  authorities.set(authority, {
+    descriptor: normalizedDescriptor,
+    authorize,
+    now,
+  });
+  return authority;
+}
+
+export function captureBrowserVisionObservationAuthority(value) {
+  const captured = authorities.get(value);
+  if (!captured)
+    throw new TypeError(
+      "A branded browser vision observation authority is required",
+    );
+  return Object.freeze({
+    descriptor: captured.descriptor,
+    authorizeObservation: async (value) => {
+      const request = normalizeRequest(value);
+      const evidence = requestEvidence(request);
+      const decision = normalizeDecision(
+        await captured.authorize(
+          Object.freeze({ ...request, requestDigest: evidence.requestDigest }),
+        ),
+      );
+      if (decision.decision !== "allow") {
+        const error = new Error(
+          decision.reason ?? "Browser vision observation was denied",
+        );
+        error.code = "BROWSER_VISION_OBSERVATION_DENIED";
+        throw error;
+      }
+      const nowMs = captured.now();
+      const validUntilMs = Date.parse(decision.validUntil);
+      if (
+        typeof decision.authorizationEvidenceRef !== "string" ||
+        decision.authorizationEvidenceRef.length < 1 ||
+        decision.authorizationEvidenceRef.length > 512 ||
+        !Number.isFinite(nowMs) ||
+        !Number.isFinite(validUntilMs) ||
+        validUntilMs <= nowMs ||
+        validUntilMs > nowMs + captured.descriptor.maxGrantTtlMs
+      ) {
+        throw new Error("Browser vision observation decision is invalid");
+      }
+      const authorizedAt = new Date(nowMs).toISOString();
+      const core = {
+        schema: BROWSER_VISION_OBSERVATION_RECEIPT_SCHEMA,
+        authorityId: captured.descriptor.authorityId,
+        tenantId: captured.descriptor.tenantId,
+        policyRevision: captured.descriptor.policyRevision,
+        handlerArtifactDigest: captured.descriptor.handlerArtifactDigest,
+        requestId: request.requestId,
+        targetId: request.targetId,
+        operation: request.operation,
+        senderId: request.senderId,
+        frameUrlDigest: request.frameUrlDigest,
+        inputDigest: request.inputDigest,
+        authorizationDigest: evidence.authorizationDigest,
+        requestDigest: evidence.requestDigest,
+        authorizationEvidenceRef: decision.authorizationEvidenceRef,
+        authorizedAt,
+        validUntil: new Date(validUntilMs).toISOString(),
+      };
+      return Object.freeze({
+        ...core,
+        receiptDigest: digest(
+          "chainlesschain.browser-vision-observation-receipt/v1",
+          core,
+        ),
+      });
+    },
+  });
+}

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

@@ -264,6 +264,27 @@ async function loadBuiltInFactories(commandName) {
       provider,
       settlementAdapter,
       businessGrader,
+      egressAuthority,
+      processSupervisor,
+      childEvidenceStore,
+      browserVisionObservation,
+      browserVisionAction,
+      browserNavigationAction,
+      browserKeyboardAction,
+      browserTabOpenAction,
+      browserDownloadAction,
+      browserQuarantinedDownloadExecutor,
+      browserFilesystemQuarantineCustody,
+      browserFilesystemQuarantineDisposal,
+      browserQuarantineRetention,
+      browserQuarantineRetentionScheduler,
+      browserQuarantineOperatorRevocation,
+      browserQuarantineLockMaintenance,
+      browserDownloadArtifactDisposal,
+      volcengineFunctionExecution,
+      volcengineFunctionProcessExecutor,
+      volcengineFunctionReplay,
+      volcengineFunctionRevocationStatusFloor,
       ledgerPorts,
       artifactPorts,
       ledgerBackend,
@@ -279,6 +300,27 @@ async function loadBuiltInFactories(commandName) {
       import("./pm-exploration-volcengine-provider.js"),
       import("./pm-exploration-provider-settlement-adapter.js"),
       import("./pm-exploration-business-grader.js"),
+      import("./pm-exploration-egress-authority.js"),
+      import("./evolution-eval-process-supervisor.js"),
+      import("./evolution-eval-child-evidence-ledger-adapter.js"),
+      import("./browser-vision-observation-authority.js"),
+      import("./browser-vision-action-authority.js"),
+      import("./browser-navigation-action-authority.js"),
+      import("./browser-keyboard-action-authority.js"),
+      import("./browser-tab-open-action-authority.js"),
+      import("./browser-download-action-authority.js"),
+      import("./browser-quarantined-download-executor.js"),
+      import("./browser-filesystem-quarantine-custody.js"),
+      import("./browser-filesystem-quarantine-disposal.js"),
+      import("./browser-quarantine-retention-authority.js"),
+      import("./browser-quarantine-retention-scheduler.js"),
+      import("./browser-quarantine-operator-revocation-authority.js"),
+      import("./browser-quarantine-lock-maintenance-authority.js"),
+      import("./browser-download-artifact-disposal-authority.js"),
+      import("./volcengine-function-execution-authority.js"),
+      import("./volcengine-function-process-executor.js"),
+      import("./volcengine-function-replay-store.js"),
+      import("./volcengine-function-revocation-status-floor-store.js"),
       import("./evolution-ledger-ports.js"),
       import("./evolution-artifact-ports.js"),
       import("./evolution-ledger-file-backend.js"),
@@ -303,15 +345,39 @@ async function loadBuiltInFactories(commandName) {
         receipts.inspectPmExplorationReceiptAuthority,
       createPmExplorationExecutionManifest:
         execution.createPmExplorationExecutionManifest,
+      createPmExplorationProcessCurriculum:
+        execution.createPmExplorationProcessCurriculum,
+      inspectPmExplorationCurriculumIsolation:
+        execution.inspectPmExplorationCurriculumIsolation,
       createPmExplorationRunner: execution.createPmExplorationRunner,
+      createPmExplorationProcessRunner:
+        execution.createPmExplorationProcessRunner,
+      inspectPmExplorationRunnerIsolation:
+        execution.inspectPmExplorationRunnerIsolation,
       createPmExplorationGrader: execution.createPmExplorationGrader,
+      createPmExplorationProcessGrader:
+        execution.createPmExplorationProcessGrader,
+      inspectPmExplorationGraderIsolation:
+        execution.inspectPmExplorationGraderIsolation,
       createPmExplorationMerger: execution.createPmExplorationMerger,
+      createPmExplorationProcessMerger:
+        execution.createPmExplorationProcessMerger,
+      inspectPmExplorationMergerIsolation:
+        execution.inspectPmExplorationMergerIsolation,
       createPmExplorationEvaluator: execution.createPmExplorationEvaluator,
+      createPmExplorationProcessEvaluator:
+        execution.createPmExplorationProcessEvaluator,
+      inspectPmExplorationEvaluatorIsolation:
+        execution.inspectPmExplorationEvaluatorIsolation,
       createPmExplorationExecutionHost:
         execution.createPmExplorationExecutionHost,
       isPmExplorationExecutionHost: execution.isPmExplorationExecutionHost,
       inspectPmExplorationExecutionHost:
         execution.inspectPmExplorationExecutionHost,
+      createEvolutionEvalProcessSupervisor:
+        processSupervisor.createEvolutionEvalProcessSupervisor,
+      createEvolutionEvalChildEvidenceLedgerAdapter:
+        childEvidenceStore.createEvolutionEvalChildEvidenceLedgerAdapter,
       createPmExplorationTransitionCommitter:
         transitionCommitter.createPmExplorationTransitionCommitter,
       capturePmExplorationTransitionCommitter:
@@ -325,6 +391,7 @@ async function loadBuiltInFactories(commandName) {
       verifyPmExplorationRecoverySnapshotAck:
         recoverySnapshotStore.verifyPmExplorationRecoverySnapshotAck,
       executePmExplorationRound: execution.executePmExplorationRound,
+      selectPmExplorationTask: execution.selectPmExplorationTask,
       mergePmExplorationBranches: execution.mergePmExplorationBranches,
       evaluatePmExplorationMemory: execution.evaluatePmExplorationMemory,
       createPmExplorationEvidenceBundle:
@@ -350,6 +417,56 @@ async function loadBuiltInFactories(commandName) {
         businessGrader.inspectPmExplorationReadOnlyOutcomeSource,
       createPmExplorationBusinessGrader:
         businessGrader.createPmExplorationBusinessGrader,
+      createPmExplorationMemoryRetrievalAuthority:
+        egressAuthority.createPmExplorationMemoryRetrievalAuthority,
+      createPmExplorationModelEgressAuthority:
+        egressAuthority.createPmExplorationModelEgressAuthority,
+      inspectPmExplorationEgressAuthority:
+        egressAuthority.inspectPmExplorationEgressAuthority,
+      createBrowserVisionObservationAuthority:
+        browserVisionObservation.createBrowserVisionObservationAuthority,
+      createBrowserVisionActionAuthority:
+        browserVisionAction.createBrowserVisionActionAuthority,
+      createBrowserNavigationActionAuthority:
+        browserNavigationAction.createBrowserNavigationActionAuthority,
+      createBrowserKeyboardActionAuthority:
+        browserKeyboardAction.createBrowserKeyboardActionAuthority,
+      createBrowserTabOpenActionAuthority:
+        browserTabOpenAction.createBrowserTabOpenActionAuthority,
+      createBrowserDownloadActionAuthority:
+        browserDownloadAction.createBrowserDownloadActionAuthority,
+      createBrowserQuarantinedDownloadExecutor:
+        browserQuarantinedDownloadExecutor.createBrowserQuarantinedDownloadExecutor,
+      createBrowserFilesystemQuarantineCustody:
+        browserFilesystemQuarantineCustody.createBrowserFilesystemQuarantineCustody,
+      createBrowserFilesystemQuarantineDisposalAuthority:
+        browserFilesystemQuarantineDisposal.createBrowserFilesystemQuarantineDisposalAuthority,
+      createBrowserQuarantineRetentionAuthority:
+        browserQuarantineRetention.createBrowserQuarantineRetentionAuthority,
+      createBrowserQuarantineRetentionScheduler:
+        browserQuarantineRetentionScheduler.createBrowserQuarantineRetentionScheduler,
+      createBrowserQuarantineOperatorRevocationAuthority:
+        browserQuarantineOperatorRevocation.createBrowserQuarantineOperatorRevocationAuthority,
+      createBrowserQuarantineLockMaintenanceAuthority:
+        browserQuarantineLockMaintenance.createBrowserQuarantineLockMaintenanceAuthority,
+      createBrowserDownloadArtifactDisposalAuthority:
+        browserDownloadArtifactDisposal.createBrowserDownloadArtifactDisposalAuthority,
+      createVolcengineFunctionExecutionAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionExecutionAuthority,
+      createVolcengineFunctionProcessExecutionAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionProcessExecutionAuthority,
+      revokeVolcengineFunctionExecutionAuthority:
+        volcengineFunctionExecution.revokeVolcengineFunctionExecutionAuthority,
+      createVolcengineFunctionRevocationAuthority:
+        volcengineFunctionExecution.createVolcengineFunctionRevocationAuthority,
+      createVolcengineFunctionRevocationEvidenceResolver:
+        volcengineFunctionExecution.createVolcengineFunctionRevocationEvidenceResolver,
+      createVolcengineFunctionProcessExecutor:
+        volcengineFunctionProcessExecutor.createVolcengineFunctionProcessExecutor,
+      createVolcengineFunctionReplayStore:
+        volcengineFunctionReplay.createVolcengineFunctionReplayStore,
+      createVolcengineFunctionRevocationStatusFloorStore:
+        volcengineFunctionRevocationStatusFloor.createVolcengineFunctionRevocationStatusFloorStore,
       createEvolutionLedgerDurableArtifactResolver:
         ledgerPorts.createEvolutionLedgerDurableArtifactResolver,
       createEvolutionArtifactPorts: (options) =>
@@ -417,6 +534,56 @@ async function loadBuiltInFactories(commandName) {
     factories.createGovernedSkillMarketplaceCandidateInstaller =
       createGovernedSkillMarketplaceCandidateInstaller;
   }
+  if (commandName === "evolution" || commandName === "serve") {
+    const [
+      { SkillCandidateRegistry },
+      { createSkillEvaluatedPromotionProvider },
+      { createSkillPromotionReviewProvider },
+      { createSkillEvaluatedPromotionControlPlane },
+      { createSkillEvaluatedPromotionDurabilityAdapter },
+      { createSkillPromotionReviewLedgerAdapter },
+      { createStructuredMemoryLedgerAdapter },
+      { createStructuredMemoryAuthorityLedgerAdapter },
+      { createStructuredMemoryPromotionReceiptWriter },
+      { createStructuredMemoryPolicyReceiptWriter },
+      { createStructuredMemoryAgentControlPlane },
+      { createSkillRevocationPropagation },
+      { openSkillRetrievalRevocationAuthority },
+      { createSkillRetrievalRevocationLedgerAdapter },
+    ] = await Promise.all([
+      import("./skill-candidate-registry.js"),
+      import("./skill-evaluated-promotion.js"),
+      import("./skill-promotion-review.js"),
+      import("./skill-promotion-controller.js"),
+      import("./skill-evaluated-promotion-durability.js"),
+      import("./skill-promotion-review-ledger-adapter.js"),
+      import("./structured-memory-ledger-adapter.js"),
+      import("./structured-memory-authority-ledger-adapter.js"),
+      import("./structured-memory-promotion-receipt-writer.js"),
+      import("./structured-memory-policy-receipt-writer.js"),
+      import("./structured-memory-agent-control-plane.js"),
+      import("./skill-revocation-propagation.js"),
+      import("./skill-retrieval-revocation-authority.js"),
+      import("./skill-retrieval-revocation-ledger-adapter.js"),
+    ]);
+    Object.assign(factories, {
+      createSkillCandidateRegistry: (options) =>
+        new SkillCandidateRegistry(options),
+      createSkillEvaluatedPromotionProvider,
+      createSkillPromotionReviewProvider,
+      createSkillEvaluatedPromotionControlPlane,
+      createSkillEvaluatedPromotionDurabilityAdapter,
+      createSkillPromotionReviewLedgerAdapter,
+      createStructuredMemoryLedgerAdapter,
+      createStructuredMemoryAuthorityLedgerAdapter,
+      createStructuredMemoryPromotionReceiptWriter,
+      createStructuredMemoryPolicyReceiptWriter,
+      createStructuredMemoryAgentControlPlane,
+      createSkillRevocationPropagation,
+      openSkillRetrievalRevocationAuthority,
+      createSkillRetrievalRevocationLedgerAdapter,
+    });
+  }
   if (commandName === "evolution" || commandName === "serve") {
     const [
       { createEvolutionWorkbenchCliHost },
@@ -641,6 +808,27 @@ function bindFactoriesToModule(factories, moduleDigest) {
     "createWikiSkillBenchmarkReportAttestor",
     "createWikiSkillBenchmarkRunner",
     "createEvolutionEvalRuntimeComposition",
+    "createEvolutionEvalChildEvidenceLedgerAdapter",
+    "createBrowserVisionObservationAuthority",
+    "createBrowserVisionActionAuthority",
+    "createBrowserNavigationActionAuthority",
+    "createBrowserKeyboardActionAuthority",
+    "createBrowserTabOpenActionAuthority",
+    "createBrowserDownloadActionAuthority",
+    "createBrowserQuarantinedDownloadExecutor",
+    "createBrowserFilesystemQuarantineCustody",
+    "createBrowserFilesystemQuarantineDisposalAuthority",
+    "createBrowserQuarantineRetentionAuthority",
+    "createBrowserQuarantineRetentionScheduler",
+    "createBrowserQuarantineOperatorRevocationAuthority",
+    "createBrowserQuarantineLockMaintenanceAuthority",
+    "createBrowserDownloadArtifactDisposalAuthority",
+    "createVolcengineFunctionExecutionAuthority",
+    "createVolcengineFunctionProcessExecutionAuthority",
+    "createVolcengineFunctionRevocationAuthority",
+    "createVolcengineFunctionRevocationEvidenceResolver",
+    "createVolcengineFunctionReplayStore",
+    "createVolcengineFunctionRevocationStatusFloorStore",
   ];
   for (const name of providerFactories) {
     if (typeof factories[name] !== "function") continue;
@@ -652,11 +840,49 @@ function bindFactoriesToModule(factories, moduleDigest) {
       return factories[name](options);
     };
   }
+  for (const name of [
+    "createSkillEvaluatedPromotionProvider",
+    "createSkillPromotionReviewProvider",
+  ]) {
+    if (typeof factories[name] !== "function") continue;
+    result[name] = (options = {}) => {
+      if (options?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          `${name} handlerArtifactDigest must equal the authenticated deployment module digest`,
+        );
+      return factories[name](options);
+    };
+  }
+  for (const name of ["createSkillPromotionReviewLedgerAdapter"]) {
+    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);
+    };
+  }
+  for (const name of [
+    "createStructuredMemoryPromotionReceiptWriter",
+    "createStructuredMemoryPolicyReceiptWriter",
+  ]) {
+    if (typeof factories[name] !== "function") continue;
+    result[name] = (options = {}) => {
+      if (options?.descriptor?.issuerHandlerDigest !== moduleDigest)
+        throw new Error(
+          `${name} issuerHandlerDigest must equal the authenticated deployment module digest`,
+        );
+      return factories[name](options);
+    };
+  }
   for (const name of [
     "createPmExplorationReceiptAuthority",
     "createPmExplorationReceiptSigner",
     "createPmExplorationProviderSettlementAdapter",
     "createPmExplorationReadOnlyOutcomeSource",
+    "createPmExplorationMemoryRetrievalAuthority",
+    "createPmExplorationModelEgressAuthority",
   ]) {
     if (typeof factories[name] !== "function") continue;
     result[name] = (options = {}) => {
@@ -675,7 +901,12 @@ function bindFactoriesToModule(factories, moduleDigest) {
   }
   if (typeof factories.createPmExplorationExecutionManifest === "function") {
     result.createPmExplorationExecutionManifest = (input = {}) => {
-      for (const authority of ["runner", "grader", "merger", "evaluator"]) {
+      const authorities = ["runner", "grader", "merger", "evaluator"];
+      if (Object.hasOwn(input, "curriculum")) authorities.unshift("curriculum");
+      if (Object.hasOwn(input, "memoryRetrieval")) {
+        authorities.push("memoryRetrieval", "modelEgress");
+      }
+      for (const authority of authorities) {
         if (input?.[authority]?.handlerArtifactDigest !== moduleDigest)
           throw new Error(
             `PM exploration ${authority} handlerArtifactDigest must equal the authenticated deployment module digest`,
@@ -711,6 +942,15 @@ function bindFactoriesToModule(factories, moduleDigest) {
       return factories.createEvolutionEvalProcessSupervisor(options);
     };
   }
+  if (typeof factories.createVolcengineFunctionProcessExecutor === "function") {
+    result.createVolcengineFunctionProcessExecutor = (options = {}) => {
+      if (options?.target?.handlerArtifactDigest !== moduleDigest)
+        throw new Error(
+          "Volcengine function process target handlerArtifactDigest must equal the authenticated deployment module digest",
+        );
+      return factories.createVolcengineFunctionProcessExecutor(options);
+    };
+  }
   return Object.freeze(result);
 }
 

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

@@ -5,6 +5,7 @@ import {
 import {
   EVOLUTION_EVAL_ATTESTATION_PURPOSES,
   EVOLUTION_EVAL_RECEIPT_SCHEMA,
+  EVOLUTION_EVAL_SUPERVISION_SCHEMA,
   EVOLUTION_EVAL_TARGET_INVOCATION_SCHEMA,
   EVOLUTION_EVAL_TARGET_REVOCATION_SCHEMA,
   computeEvolutionEvalReceiptDigest,
@@ -40,6 +41,10 @@ const KINDS = Object.freeze({
     purpose: EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetRevocation,
     schema: EVOLUTION_EVAL_TARGET_REVOCATION_SCHEMA,
   }),
+  supervision: Object.freeze({
+    purpose: EVOLUTION_EVAL_ATTESTATION_PURPOSES.supervisor,
+    schema: EVOLUTION_EVAL_SUPERVISION_SCHEMA,
+  }),
 });
 
 function requiredString(value, label) {

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

@@ -1058,7 +1058,8 @@ export function buildEvolutionEvalAttestationDigest(value, purpose) {
 export function computeEvolutionEvalSignedEvidenceDigest(record, purpose) {
   if (
     purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetInvocation &&
-    purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetRevocation
+    purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.targetRevocation &&
+    purpose !== EVOLUTION_EVAL_ATTESTATION_PURPOSES.supervisor
   ) {
     throw evalError(
       EVOLUTION_EVAL_INVALID_CODE,