chainlesschain 0.166.21 → 0.166.24

package/src/lib/evolution/governed-knowledge-dependency-authority.js

@@ -1,12 +1,31 @@
 import { createHash } from "node:crypto";
 import { types as utilTypes } from "node:util";
 
+import { verifyGovernedKnowledgeRecord } from "./governed-knowledge-sync.js";
+import {
+  digestGovernedKnowledgeDependencyOperation,
+  isGovernedKnowledgeDependencyExecutionRequest,
+} from "./governed-knowledge-dependency-ledger-executor.js";
+
 export const GOVERNED_KNOWLEDGE_DEPENDENCY_REQUEST_SCHEMA =
   "chainlesschain.governed-knowledge-dependency-request/v1";
 export const GOVERNED_KNOWLEDGE_DEPENDENCY_RESULT_SCHEMA =
   "chainlesschain.governed-knowledge-dependency-result/v1";
 
 const AUTHORITIES = new WeakSet();
+// Only this module can dispatch a prepared router request into a leaf's full
+// request/result verification pipeline. No public rebranding API is exposed.
+const PREPARED_EXECUTIONS = new WeakMap();
+const PREPARED_REVERIFIERS = new WeakMap();
+
+// A read-only final check for the genuine executor. Reverification cannot call
+// a provider again, mint a request, or bypass the original leaf verifier.
+export function captureGovernedKnowledgeDependencyReverifier(authority) {
+  const verify = PREPARED_REVERIFIERS.get(authority);
+  if (!verify)
+    throw new TypeError("a genuine dependency authority is required");
+  return verify;
+}
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
 const DESCRIPTOR_KEYS = new Set([
@@ -36,6 +55,14 @@ const RESULT_KEYS = new Set([
   "tenantId",
 ]);
 const ATTESTATION_KEYS = new Set(["algorithm", "keyId", "value"]);
+const INPUT_KEYS = new Set([
+  "tenantId",
+  "deviceId",
+  "operationDigest",
+  "knowledge",
+  "dependency",
+]);
+const DEPENDENCY_KEYS = new Set(["kind", "digest", "disposition"]);
 
 function canonical(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -83,6 +110,14 @@ function exact(value, keys, label) {
   ) {
     throw new TypeError(`${label} has an invalid shape`);
   }
+  if (
+    actual.some(
+      (key) =>
+        !Object.hasOwn(Object.getOwnPropertyDescriptor(value, key), "value"),
+    )
+  ) {
+    throw new TypeError(`${label} must contain only data properties`);
+  }
   return value;
 }
 
@@ -94,15 +129,17 @@ function identifier(value, label) {
 }
 
 function capture(owner, method, label) {
+  if (!owner || typeof owner !== "object" || utilTypes.isProxy(owner)) {
+    throw new TypeError(`${label}.${method}() is required`);
+  }
+  const implementation = owner[method];
   if (
-    !owner ||
-    typeof owner !== "object" ||
-    utilTypes.isProxy(owner) ||
-    typeof owner[method] !== "function"
+    typeof implementation !== "function" ||
+    utilTypes.isProxy(implementation)
   ) {
-    throw new TypeError(`${label}.${method}() is required`);
+    throw new TypeError(`${label}.${method}() must be a non-proxy function`);
   }
-  return (...args) => Reflect.apply(owner[method], owner, args);
+  return (...args) => Reflect.apply(implementation, owner, args);
 }
 
 function descriptor(input, label) {
@@ -219,55 +256,201 @@ export function createGovernedKnowledgeDependencyAuthority({
   }
   const apply = capture(provider, "apply", "provider");
   const verify = capture(verifier, "verify", "verifier");
+  const executePrepared = async (input, revalidation = null) => {
+    exact(input, INPUT_KEYS, "dependency execution input");
+    if (
+      input?.tenantId !== tenantId ||
+      input.deviceId !== deviceId ||
+      !DIGEST.test(input.operationDigest ?? "")
+    ) {
+      throw new Error("dependency request crossed its authority boundary");
+    }
+    // Normalize and snapshot before the first await, then bind both the entire
+    // operation and the selected edge. A plausible digest is not authorization
+    // to apply an unlisted dependency or to change its disposition.
+    const knowledge = verifyGovernedKnowledgeRecord(input.knowledge, {
+      tenantId,
+    });
+    const dependency = exact(input.dependency, DEPENDENCY_KEYS, "dependency");
+    const selected = knowledge.dependencies.find(
+      (entry) =>
+        entry.kind === dependency.kind &&
+        entry.digest === dependency.digest &&
+        entry.disposition === dependency.disposition,
+    );
+    if (
+      !["tombstone", "revoke"].includes(knowledge.action) ||
+      !selected ||
+      input.operationDigest !==
+        digestGovernedKnowledgeDependencyOperation({
+          tenantId,
+          deviceId,
+          knowledge,
+        })
+    ) {
+      throw new Error(
+        "dependency request is not bound to its revocation operation",
+      );
+    }
+    const request = requestFor({
+      tenantId,
+      deviceId,
+      operationDigest: input.operationDigest,
+      knowledge,
+      dependency: selected,
+    });
+    let supplied;
+    if (revalidation !== null) {
+      exact(
+        revalidation.result,
+        new Set([...RESULT_KEYS, "verificationReceiptDigest"]),
+        "previously verified dependency result",
+      );
+      if (!DIGEST.test(revalidation.result.verificationReceiptDigest))
+        throw new TypeError("dependency verification receipt is invalid");
+      supplied = clone(revalidation.result);
+      delete supplied.verificationReceiptDigest;
+    }
+    const result = validateResult(
+      revalidation === null ? await apply(request) : supplied,
+      request,
+      providerDescriptor,
+    );
+    const verified = await verify({
+      request,
+      result,
+      providerDescriptor,
+      verifierDescriptor,
+    });
+    if (
+      verified?.authenticated !== true ||
+      verified.durable !== true ||
+      verified.tenantId !== tenantId ||
+      verified.deviceId !== deviceId ||
+      verified.operationId !== request.operationId ||
+      verified.requestDigest !== request.requestDigest ||
+      verified.resultDigest !== result.resultDigest ||
+      verified.providerAuthorityId !== providerDescriptor.authorityId ||
+      verified.providerRevision !== providerDescriptor.revision ||
+      verified.verifierAuthorityId !== verifierDescriptor.authorityId ||
+      verified.verifierRevision !== verifierDescriptor.revision ||
+      !DIGEST.test(verified.verificationReceiptDigest ?? "")
+    ) {
+      throw new Error("dependency result was not independently verified");
+    }
+    return freeze({
+      ...clone(result),
+      verificationReceiptDigest: verified.verificationReceiptDigest,
+    });
+  };
   const authority = Object.freeze({
     tenantId,
     deviceId,
     async apply(input) {
-      if (
-        input?.tenantId !== tenantId ||
-        input.deviceId !== deviceId ||
-        !DIGEST.test(input.operationDigest ?? "")
-      ) {
-        throw new Error("dependency request crossed its authority boundary");
+      if (!isGovernedKnowledgeDependencyExecutionRequest(input, authority)) {
+        throw new TypeError(
+          "dependency execution requires a prepared executor request",
+        );
       }
-      const request = requestFor(input);
-      const result = validateResult(
-        await apply(request),
-        request,
-        providerDescriptor,
-      );
-      const verified = await verify({
-        request,
-        result,
-        providerDescriptor,
-        verifierDescriptor,
-      });
-      if (
-        verified?.authenticated !== true ||
-        verified.durable !== true ||
-        verified.tenantId !== tenantId ||
-        verified.deviceId !== deviceId ||
-        verified.operationId !== request.operationId ||
-        verified.requestDigest !== request.requestDigest ||
-        verified.resultDigest !== result.resultDigest ||
-        verified.providerAuthorityId !== providerDescriptor.authorityId ||
-        verified.providerRevision !== providerDescriptor.revision ||
-        verified.verifierAuthorityId !== verifierDescriptor.authorityId ||
-        verified.verifierRevision !== verifierDescriptor.revision ||
-        !DIGEST.test(verified.verificationReceiptDigest ?? "")
-      ) {
-        throw new Error("dependency result was not independently verified");
-      }
-      return freeze({
-        ...clone(result),
-        verificationReceiptDigest: verified.verificationReceiptDigest,
-      });
+      return executePrepared(input);
     },
   });
   AUTHORITIES.add(authority);
+  PREPARED_EXECUTIONS.set(authority, executePrepared);
+  PREPARED_REVERIFIERS.set(
+    authority,
+    Object.freeze((input, result) => {
+      if (!isGovernedKnowledgeDependencyExecutionRequest(input, authority))
+        throw new TypeError(
+          "dependency verification requires a prepared executor request",
+        );
+      return executePrepared(input, { result });
+    }),
+  );
   return authority;
 }
 
+export function createGovernedKnowledgeDependencyRouter({
+  tenantId,
+  deviceId,
+  routes,
+} = {}) {
+  identifier(tenantId, "router tenantId");
+  identifier(deviceId, "router deviceId");
+  if (
+    !routes ||
+    typeof routes !== "object" ||
+    utilTypes.isProxy(routes) ||
+    ![Object.prototype, null].includes(Object.getPrototypeOf(routes))
+  ) {
+    throw new TypeError("dependency routes must be a plain object");
+  }
+  const keys = Reflect.ownKeys(routes);
+  exact(routes, new Set(keys), "dependency routes");
+  const allowed = new Set([
+    "wiki/tombstone",
+    "wiki/quarantine",
+    "candidate/reject-candidate",
+    "candidate/quarantine",
+    "active-skill/rollback-active",
+    "active-skill/quarantine",
+  ]);
+  if (!keys.length || keys.some((key) => !allowed.has(key)))
+    throw new TypeError("dependency route is unsupported");
+  const handlers = new Map();
+  for (const key of keys) {
+    const authority = routes[key];
+    const execute = PREPARED_EXECUTIONS.get(authority);
+    if (
+      !execute ||
+      authority.tenantId !== tenantId ||
+      authority.deviceId !== deviceId
+    ) {
+      throw new TypeError(
+        "dependency route requires a genuine same-boundary leaf authority",
+      );
+    }
+    handlers.set(key, execute);
+  }
+  const router = Object.freeze({
+    tenantId,
+    deviceId,
+    async apply(input) {
+      if (!isGovernedKnowledgeDependencyExecutionRequest(input, router))
+        throw new TypeError(
+          "dependency routing requires a prepared executor request",
+        );
+      exact(input, INPUT_KEYS, "dependency routing input");
+      exact(input.dependency, DEPENDENCY_KEYS, "dependency route selection");
+      const execute = handlers.get(
+        `${input.dependency.kind}/${input.dependency.disposition}`,
+      );
+      if (!execute)
+        throw new Error("no real authority for this dependency disposition");
+      return execute(input);
+    },
+  });
+  AUTHORITIES.add(router);
+  PREPARED_REVERIFIERS.set(
+    router,
+    Object.freeze((input, result) => {
+      if (!isGovernedKnowledgeDependencyExecutionRequest(input, router))
+        throw new TypeError(
+          "dependency verification requires a prepared router request",
+        );
+      exact(input, INPUT_KEYS, "dependency verification input");
+      exact(input.dependency, DEPENDENCY_KEYS, "dependency verification route");
+      const execute = handlers.get(
+        `${input.dependency.kind}/${input.dependency.disposition}`,
+      );
+      if (!execute)
+        throw new Error("no real authority for dependency verification");
+      return execute(input, { result });
+    }),
+  );
+  return router;
+}
+
 export function isGovernedKnowledgeDependencyAuthority(value) {
   return AUTHORITIES.has(value);
 }

package/src/lib/evolution/governed-knowledge-dependency-ledger-executor.js

@@ -14,36 +14,37 @@ import {
   GOVERNED_KNOWLEDGE_DEPENDENCY_RESULT_SCHEMA,
   digestGovernedKnowledgeDependencyResult,
   isGovernedKnowledgeDependencyAuthority,
+  captureGovernedKnowledgeDependencyReverifier,
 } from "./governed-knowledge-dependency-authority.js";
 import {
   isGovernedKnowledgeExecutionRecord,
   verifyGovernedKnowledgeRecord,
 } from "./governed-knowledge-sync.js";
 
-export const GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA =
-  "chainlesschain.governed-knowledge-dependencies-prepared/v1";
+import {
+  GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA,
+  GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_EVENT_TYPE,
+  GOVERNED_KNOWLEDGE_DEPENDENCY_LEDGER_CORRUPT_CODE,
+  digestGovernedKnowledgeDependencyOperation,
+  verifyGovernedKnowledgeDependencyPrepared,
+} from "./governed-knowledge-revocation-record.js";
+export {
+  GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA,
+  GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_EVENT_TYPE,
+  GOVERNED_KNOWLEDGE_DEPENDENCY_LEDGER_CORRUPT_CODE,
+  digestGovernedKnowledgeDependencyOperation,
+  verifyGovernedKnowledgeDependencyPrepared,
+} from "./governed-knowledge-revocation-record.js";
+
 export const GOVERNED_KNOWLEDGE_DEPENDENCY_SETTLED_SCHEMA =
   "chainlesschain.governed-knowledge-dependencies-settled/v1";
-export const GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_EVENT_TYPE =
-  "knowledge.revocation-dependencies.prepared";
 export const GOVERNED_KNOWLEDGE_DEPENDENCY_SETTLED_EVENT_TYPE =
   "knowledge.revocation-dependencies.settled";
-export const GOVERNED_KNOWLEDGE_DEPENDENCY_LEDGER_CORRUPT_CODE =
-  "CC_GOVERNED_KNOWLEDGE_DEPENDENCY_LEDGER_CORRUPT";
-
 const EXECUTORS = new WeakSet();
+const EXECUTION_REQUESTS = new WeakMap();
 const ARTIFACT_TYPE = "governed-knowledge-dependency-operation";
 const DIGEST = /^sha256:[a-f0-9]{64}$/u;
 const ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
-const PREPARED_KEYS = new Set([
-  "deviceId",
-  "knowledge",
-  "operationDigest",
-  "preparedAt",
-  "recordDigest",
-  "schema",
-  "tenantId",
-]);
 const SETTLED_KEYS = new Set([
   "deviceId",
   "operationDigest",
@@ -139,15 +140,26 @@ function identifier(value, label) {
 }
 
 function capture(owner, method, label) {
+  if (!owner || typeof owner !== "object" || utilTypes.isProxy(owner)) {
+    throw new TypeError(`${label}.${method}() is required`);
+  }
+  const implementation = owner[method];
   if (
-    !owner ||
-    typeof owner !== "object" ||
-    utilTypes.isProxy(owner) ||
-    typeof owner[method] !== "function"
+    typeof implementation !== "function" ||
+    utilTypes.isProxy(implementation)
   ) {
-    throw new TypeError(`${label}.${method}() is required`);
+    throw new TypeError(`${label}.${method}() must be a non-proxy function`);
   }
-  return (...args) => Reflect.apply(owner[method], owner, args);
+  return (...args) => Reflect.apply(implementation, owner, args);
+}
+
+export function isGovernedKnowledgeDependencyExecutionRequest(
+  value,
+  authority,
+) {
+  return (
+    EXECUTION_REQUESTS.has(value) && EXECUTION_REQUESTS.get(value) === authority
+  );
 }
 
 function descriptor(input) {
@@ -161,29 +173,6 @@ function descriptor(input) {
   });
 }
 
-export function digestGovernedKnowledgeDependencyOperation({
-  tenantId,
-  deviceId,
-  knowledge,
-}) {
-  return hash(GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA, {
-    tenantId,
-    deviceId,
-    knowledge,
-  });
-}
-
-function preparedCore(value) {
-  return {
-    schema: value.schema,
-    tenantId: value.tenantId,
-    deviceId: value.deviceId,
-    operationDigest: value.operationDigest,
-    knowledge: value.knowledge,
-    preparedAt: value.preparedAt,
-  };
-}
-
 function settledCore(value) {
   return {
     schema: value.schema,
@@ -243,31 +232,6 @@ function validateResult(
   return freeze(clone(value));
 }
 
-function validatePrepared(value, descriptorValue) {
-  exact(value, PREPARED_KEYS, "dependency prepared record");
-  const knowledge = verifyGovernedKnowledgeRecord(value.knowledge, {
-    tenantId: descriptorValue.tenantId,
-  });
-  const operationDigest = digestGovernedKnowledgeDependencyOperation({
-    tenantId: descriptorValue.tenantId,
-    deviceId: descriptorValue.deviceId,
-    knowledge,
-  });
-  if (
-    value.schema !== GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA ||
-    value.tenantId !== descriptorValue.tenantId ||
-    value.deviceId !== descriptorValue.deviceId ||
-    !["tombstone", "revoke"].includes(knowledge.action) ||
-    value.operationDigest !== operationDigest ||
-    !Number.isFinite(Date.parse(value.preparedAt)) ||
-    value.recordDigest !==
-      hash(GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_SCHEMA, preparedCore(value))
-  ) {
-    corrupt("dependency prepared record is invalid");
-  }
-  return freeze(clone(value));
-}
-
 function validateSettled(value, prepared, descriptorValue) {
   exact(value, SETTLED_KEYS, "dependency settled record");
   const { knowledge, operationDigest } = prepared;
@@ -305,6 +269,9 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
     dependencyAuthority,
     now = Date.now,
   } = {}) {
+    if (new.target !== GovernedKnowledgeDependencyLedgerExecutor) {
+      throw new TypeError("dependency executors cannot be subclassed");
+    }
     this.descriptor = descriptor(descriptorInput);
     this._put = capture(artifactPorts, "putCanonical", "artifactPorts");
     this._read = capture(ledger, "read", "ledger");
@@ -331,6 +298,9 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
     }
     this._resolveArtifact = ledgerArtifactResolver;
     this._apply = capture(dependencyAuthority, "apply", "dependencyAuthority");
+    this._reverify =
+      captureGovernedKnowledgeDependencyReverifier(dependencyAuthority);
+    this._dependencyAuthority = dependencyAuthority;
     this._now = now;
     Object.freeze(this);
     EXECUTORS.add(this);
@@ -401,7 +371,10 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
       GOVERNED_KNOWLEDGE_DEPENDENCY_PREPARED_EVENT_TYPE,
     );
     if (!event) return null;
-    const record = validatePrepared(this._resolve(event), this.descriptor);
+    const record = verifyGovernedKnowledgeDependencyPrepared(
+      this._resolve(event),
+      this.descriptor,
+    );
     if (
       record.operationDigest !== operationDigest ||
       event.decision !== "prepared" ||
@@ -528,7 +501,7 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
     return this._prepared(operationDigest);
   }
 
-  async _settle(prepared, results) {
+  async _settle(prepared, results, verifiedHead) {
     const existing = this._settled(prepared);
     if (existing) return existing;
     const settledAt = this._timestamp();
@@ -547,6 +520,13 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
     const preparedEntry = this._prepared(prepared.operationDigest);
     if (!preparedEntry) corrupt("cannot settle unprepared dependencies");
     const head = this._verifyLedger();
+    if (
+      !verifiedHead ||
+      ["epoch", "ledgerId", "identityDigest", "sequence", "headDigest"].some(
+        (key) => verifiedHead[key] !== head[key],
+      )
+    )
+      corrupt("dependency effects changed before settlement authorization");
     const ref = this._publishArtifact(record);
     const eventId = `${GOVERNED_KNOWLEDGE_DEPENDENCY_SETTLED_EVENT_TYPE}.${prepared.operationDigest.slice(7)}`;
     try {
@@ -585,6 +565,9 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
   }
 
   async execute(knowledgeInput) {
+    if (!EXECUTORS.has(this)) {
+      throw new TypeError("dependency execution requires its branded executor");
+    }
     const knowledge = verifyGovernedKnowledgeRecord(knowledgeInput, {
       tenantId: this.descriptor.tenantId,
     });
@@ -599,24 +582,51 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
     const prepared = this._prepared(operationDigest);
     const completed = prepared ? this._settled(prepared.record) : null;
     if (completed) return this._result(completed.record, knowledge, true);
-    await this._prepare(knowledgeInput, knowledge, operationDigest);
+    const durablePrepare = await this._prepare(
+      knowledgeInput,
+      knowledge,
+      operationDigest,
+    );
+    if (
+      !durablePrepare ||
+      durablePrepare.record.operationDigest !== operationDigest ||
+      canonical(durablePrepare.record.knowledge) !== canonical(knowledge)
+    ) {
+      corrupt("dependency prepare was not durably read back");
+    }
     const results = [];
+    const requests = [];
     for (const dependency of knowledge.dependencies) {
-      results.push(
-        await this._apply({
-          tenantId: this.descriptor.tenantId,
-          deviceId: this.descriptor.deviceId,
-          operationDigest,
-          knowledge,
-          dependency,
-        }),
-      );
+      const request = freeze({
+        tenantId: this.descriptor.tenantId,
+        deviceId: this.descriptor.deviceId,
+        operationDigest,
+        knowledge,
+        dependency,
+      });
+      EXECUTION_REQUESTS.set(request, this._dependencyAuthority);
+      requests.push(request);
+      results.push(await this._apply(request));
     }
-    const settled = await this._settle({ operationDigest, knowledge }, results);
+    // All effects must still hold together at one authenticated head. Earlier
+    // per-effect checks may predate later dependencies or a concurrent writer.
+    // This path only rereads/verifies; it never repeats provider side effects.
+    const verifiedHead = this._verifyLedger();
+    const verifiedResults = [];
+    for (const [index, request] of requests.entries())
+      verifiedResults.push(await this._reverify(request, results[index]));
+    const settled = await this._settle(
+      { operationDigest, knowledge },
+      verifiedResults,
+      verifiedHead,
+    );
     return this._result(settled.record, knowledge, prepared !== null);
   }
 
   async resume({ operationDigest } = {}) {
+    if (!EXECUTORS.has(this)) {
+      throw new TypeError("dependency recovery requires its branded executor");
+    }
     if (!DIGEST.test(operationDigest ?? "")) {
       throw new TypeError("operationDigest is invalid");
     }
@@ -641,6 +651,8 @@ export class GovernedKnowledgeDependencyLedgerExecutor {
   }
 }
 
+Object.freeze(GovernedKnowledgeDependencyLedgerExecutor.prototype);
+
 export function isGovernedKnowledgeDependencyExecutor(value) {
   return EXECUTORS.has(value);
 }

package/src/lib/evolution/governed-knowledge-merge-ledger-executor.js

@@ -15,6 +15,7 @@ import {
 } from "./governed-knowledge-conflict-merge.js";
 import {
   GOVERNED_KNOWLEDGE_MERGE_PUBLISH_REQUEST_SCHEMA,
+  GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_LEGACY_SCHEMA,
   GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_SCHEMA,
   digestGovernedKnowledgeMergePublishResult,
   isGovernedKnowledgeMergePublisherAuthority,
@@ -55,6 +56,11 @@ const SETTLED_KEYS = new Set([
 ]);
 const PUBLISH_EVIDENCE_KEYS = new Set([
   "attestation",
+  "artifactCandidateDigest",
+  "artifactDigest",
+  "artifactReleaseId",
+  "artifactTransitionOperationId",
+  "artifactTransitionReceiptDigest",
   "deviceId",
   "durable",
   "envelopeDigest",
@@ -73,6 +79,9 @@ const PUBLISH_EVIDENCE_KEYS = new Set([
   "tenantId",
   "verificationReceiptDigest",
 ]);
+const LEGACY_PUBLISH_EVIDENCE_KEYS = new Set(
+  [...PUBLISH_EVIDENCE_KEYS].filter((key) => !key.startsWith("artifact")),
+);
 
 function canonical(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -181,7 +190,13 @@ function settledCore(value) {
 }
 
 function validatePublishEvidence(value, plan, descriptorValue) {
-  exact(value, PUBLISH_EVIDENCE_KEYS, "merge publish evidence");
+  const legacy =
+    value?.schema === GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_LEGACY_SCHEMA;
+  exact(
+    value,
+    legacy ? LEGACY_PUBLISH_EVIDENCE_KEYS : PUBLISH_EVIDENCE_KEYS,
+    "merge publish evidence",
+  );
   const requestCore = {
     schema: GOVERNED_KNOWLEDGE_MERGE_PUBLISH_REQUEST_SCHEMA,
     tenantId: plan.tenantId,
@@ -193,7 +208,10 @@ function validatePublishEvidence(value, plan, descriptorValue) {
     mergedKnowledge: plan.mergedKnowledge,
   };
   if (
-    value.schema !== GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_SCHEMA ||
+    ![
+      GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_SCHEMA,
+      GOVERNED_KNOWLEDGE_MERGE_PUBLISH_RESULT_LEGACY_SCHEMA,
+    ].includes(value.schema) ||
     value.tenantId !== descriptorValue.tenantId ||
     value.deviceId !== descriptorValue.deviceId ||
     value.operationId !== `knowledge-merge:${plan.planDigest.slice(7)}` ||
@@ -207,6 +225,15 @@ function validatePublishEvidence(value, plan, descriptorValue) {
     !DIGEST.test(value.envelopeDigest ?? "") ||
     !DIGEST.test(value.resultDigest ?? "") ||
     !DIGEST.test(value.verificationReceiptDigest ?? "") ||
+    (!legacy &&
+      (!DIGEST.test(value.artifactCandidateDigest ?? "") ||
+        !DIGEST.test(value.artifactDigest ?? "") ||
+        !ID.test(value.artifactReleaseId ?? "") ||
+        !ID.test(value.artifactTransitionOperationId ?? "") ||
+        !value.artifactTransitionOperationId.startsWith(
+          "artifact-transition:",
+        ) ||
+        !DIGEST.test(value.artifactTransitionReceiptDigest ?? ""))) ||
     value.resultDigest !== digestGovernedKnowledgeMergePublishResult(value)
   ) {
     corrupt("merge publish evidence is not exactly bound");