chainlesschain 0.166.65 → 0.166.68

package/src/lib/evolution/evolution-eval-process-supervisor-worker.mjs

@@ -1,14 +1,76 @@
-let input = "";
-for await (const chunk of process.stdin) {
-  input += chunk.toString("utf8");
-  if (Buffer.byteLength(input) > 1024 * 1024)
-    throw new Error("evaluation process input exceeds 1 MiB");
-}
-const request = JSON.parse(input);
+import { createInterface } from "node:readline";
+
+const lines = createInterface({ input: process.stdin, crlfDelay: Infinity });
+const iterator = lines[Symbol.asyncIterator]();
+const first = await iterator.next();
+if (first.done || Buffer.byteLength(first.value) > 1024 * 1024)
+  throw new Error("evaluation process input exceeds 1 MiB");
+const request = JSON.parse(first.value);
 const moduleUrl = new URL(request.moduleUrl);
 const implementation = await import(moduleUrl.href);
 const handler = implementation[request.exportName];
 if (typeof handler !== "function")
   throw new Error("evaluation process export is unavailable");
-const value = await handler(request.payload);
-process.stdout.write(`${JSON.stringify({ ok: true, value })}\n`);
+
+if (request.protocol !== "chainlesschain.evolution-process-broker/v1") {
+  const extra = await iterator.next();
+  if (!extra.done) throw new Error("evaluation process received extra input");
+  const value = await handler(request.payload);
+  process.stdout.write(`${JSON.stringify({ ok: true, value })}\n`);
+} else {
+  let sequence = 0;
+  const pending = new Map();
+  const readResponses = (async () => {
+    for await (const line of iterator) {
+      if (Buffer.byteLength(line) > 1024 * 1024)
+        throw new Error("evaluation broker response exceeds 1 MiB");
+      const message = JSON.parse(line);
+      const waiter = pending.get(message?.requestId);
+      if (
+        !waiter ||
+        message?.type !== "broker-response" ||
+        typeof message.ok !== "boolean" ||
+        Object.keys(message).some(
+          (key) => !["type", "requestId", "ok", "value", "error"].includes(key),
+        )
+      ) {
+        throw new Error("evaluation broker response is invalid");
+      }
+      pending.delete(message.requestId);
+      if (message.ok) waiter.resolve(message.value);
+      else waiter.reject(new Error("parent broker rejected the operation"));
+    }
+    if (pending.size > 0)
+      throw new Error("evaluation broker closed with pending operations");
+  })();
+
+  const call = (operation, input) =>
+    new Promise((resolve, reject) => {
+      sequence += 1;
+      const requestId = `broker-${sequence}`;
+      pending.set(requestId, { resolve, reject });
+      process.stdout.write(
+        `${JSON.stringify({
+          type: "broker-request",
+          requestId,
+          operation,
+          input,
+        })}\n`,
+      );
+    });
+  const runtime = Object.freeze({
+    recordTokens: (count) => call("record-tokens", { count }),
+    invokeTool: (toolId, input) => call("invoke-tool", { toolId, input }),
+    retrieveMemory: (input) => call("retrieve-memory", { input }),
+    invokeModel: (input) => call("invoke-model", { input }),
+  });
+  const value = await handler(request.payload, runtime);
+  if (pending.size > 0)
+    throw new Error(
+      "evaluation target returned with unsettled broker requests",
+    );
+  process.stdout.write(`${JSON.stringify({ type: "result", value })}\n`, () =>
+    process.exit(0),
+  );
+  await readResponses;
+}

package/src/lib/evolution/evolution-eval-process-supervisor.js

@@ -3,6 +3,7 @@ import { lstat, readFile, realpath } from "node:fs/promises";
 import { lstatSync, readFileSync, realpathSync } from "node:fs";
 import { dirname, isAbsolute, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { isProxy } from "node:util/types";
 
 import executionBroker from "../process-execution-broker/index.js";
 import { isEvolutionEvalChildEvidenceStore } from "./evolution-eval-child-evidence-ledger-adapter.js";
@@ -29,6 +30,7 @@ const MIN_MEMORY_LIMIT_MB = 32;
 const MAX_MEMORY_LIMIT_MB = 1024;
 const MAX_PERMISSION_PATHS = 32;
 const PROCESS_SUPERVISORS = new WeakSet();
+const PROCESS_RUNTIME_BROKERS = new WeakMap();
 
 function canonical(value) {
   if (value === null || typeof value !== "object") return JSON.stringify(value);
@@ -127,14 +129,23 @@ function sandboxPolicy(value) {
     if (paths === undefined) return Object.freeze([]);
     if (!Array.isArray(paths) || paths.length > MAX_PERMISSION_PATHS)
       throw new TypeError(`${label} must be a bounded array`);
-    const normalized = paths.map((path) => {
+    const requested = paths.map((path) => {
       if (typeof path !== "string" || !isAbsolute(path))
         throw new TypeError(`${label} paths must be absolute`);
       return resolve(path);
     });
-    if (new Set(normalized).size !== normalized.length)
+    if (new Set(requested).size !== requested.length)
       throw new TypeError(`${label} paths must be unique`);
-    return Object.freeze(normalized);
+    const normalized = requested.flatMap((absolute) => {
+      try {
+        const physical = realpathSync(absolute);
+        return physical === absolute ? [absolute] : [absolute, physical];
+      } catch (cause) {
+        if (cause?.code === "ENOENT") return [absolute];
+        throw new Error(`${label} path could not be resolved`, { cause });
+      }
+    });
+    return Object.freeze([...new Set(normalized)]);
   };
   const memoryLimitMb = value.memoryLimitMb ?? DEFAULT_MEMORY_LIMIT_MB;
   if (
@@ -237,6 +248,253 @@ function processResult(child, input) {
   });
 }
 
+function writeBrokerMessage(child, value) {
+  const encoded = `${JSON.stringify(value)}\n`;
+  if (Buffer.byteLength(encoded) > MAX_OUTPUT_BYTES)
+    return Promise.reject(new Error("evaluation broker message exceeds 1 MiB"));
+  return new Promise((resolveWrite, reject) => {
+    if (child.stdin.destroyed || child.stdin.writableEnded) {
+      reject(new Error("evaluation broker input is closed"));
+      return;
+    }
+    child.stdin.write(encoded, (error) => {
+      if (error) reject(error);
+      else resolveWrite();
+    });
+  });
+}
+
+function processBrokeredResult(child, input, brokerValue) {
+  const broker = PROCESS_RUNTIME_BROKERS.get(brokerValue);
+  if (!broker)
+    return Promise.reject(
+      new TypeError("a branded evaluation process runtime broker is required"),
+    );
+  return new Promise((resolveResult, reject) => {
+    let stdoutBuffer = "";
+    let stdoutBytes = 0;
+    let stderr = "";
+    let settled = false;
+    let completionError = null;
+    let resultSeen = false;
+    let resultValue;
+    let requestCount = 0;
+    const requestIds = new Set();
+    let messages = Promise.resolve();
+    const rejectOnce = (error) => {
+      if (settled) return;
+      settled = true;
+      reject(error);
+    };
+    const handleMessage = async (line) => {
+      if (!line || Buffer.byteLength(line) > MAX_OUTPUT_BYTES)
+        throw new Error("evaluation broker record exceeds 1 MiB");
+      const message = JSON.parse(line);
+      if (message?.type === "result") {
+        if (
+          resultSeen ||
+          Object.keys(message).length !== 2 ||
+          requestIds.size !== 0
+        ) {
+          throw new Error("evaluation broker result is invalid or premature");
+        }
+        resultSeen = true;
+        resultValue = jsonClone(message.value, "evaluation target result");
+        return;
+      }
+      if (
+        resultSeen ||
+        message?.type !== "broker-request" ||
+        typeof message.requestId !== "string" ||
+        !/^broker-[1-9][0-9]*$/u.test(message.requestId) ||
+        ![
+          "record-tokens",
+          "invoke-tool",
+          "retrieve-memory",
+          "invoke-model",
+        ].includes(message.operation) ||
+        !message.input ||
+        typeof message.input !== "object" ||
+        Array.isArray(message.input) ||
+        Object.keys(message).length !== 4 ||
+        requestIds.has(message.requestId) ||
+        requestCount >= 512
+      ) {
+        throw new Error("evaluation broker request is invalid");
+      }
+      requestCount += 1;
+      requestIds.add(message.requestId);
+      try {
+        let value;
+        if (message.operation === "record-tokens") {
+          if (
+            Object.keys(message.input).length !== 1 ||
+            !Number.isSafeInteger(message.input.count) ||
+            message.input.count < 0
+          ) {
+            throw new TypeError("broker token count is invalid");
+          }
+          value = await broker.recordTokens(message.input.count);
+        } else if (message.operation === "invoke-tool") {
+          if (
+            Object.keys(message.input).length !== 2 ||
+            typeof message.input.toolId !== "string"
+          ) {
+            throw new TypeError("broker tool request is invalid");
+          }
+          value = await broker.invokeTool(
+            message.input.toolId,
+            jsonClone(message.input.input, "evaluation broker tool input"),
+          );
+        } else {
+          if (Object.keys(message.input).length !== 1) {
+            throw new TypeError("broker egress request is invalid");
+          }
+          const inputValue = jsonClone(
+            message.input.input,
+            "evaluation broker egress input",
+          );
+          const port =
+            message.operation === "retrieve-memory"
+              ? broker.retrieveMemory
+              : broker.invokeModel;
+          if (port === null)
+            throw new Error("evaluation broker egress port is unavailable");
+          value = await port(inputValue);
+        }
+        await writeBrokerMessage(child, {
+          type: "broker-response",
+          requestId: message.requestId,
+          ok: true,
+          value: jsonClone(value, "evaluation broker result"),
+        });
+      } catch {
+        await writeBrokerMessage(child, {
+          type: "broker-response",
+          requestId: message.requestId,
+          ok: false,
+          error: "operation-rejected",
+        }).catch(() => {});
+      } finally {
+        requestIds.delete(message.requestId);
+      }
+    };
+    child.stdout.on("data", (chunk) => {
+      const text = chunk.toString("utf8");
+      stdoutBytes += Buffer.byteLength(text);
+      if (!completionError && stdoutBytes > MAX_OUTPUT_BYTES) {
+        completionError = new Error("evaluation target stdout exceeds 1 MiB");
+        child.kill("SIGKILL");
+        return;
+      }
+      stdoutBuffer += text;
+      for (;;) {
+        const newline = stdoutBuffer.indexOf("\n");
+        if (newline < 0) break;
+        const line = stdoutBuffer.slice(0, newline);
+        stdoutBuffer = stdoutBuffer.slice(newline + 1);
+        messages = messages.then(() => handleMessage(line));
+      }
+      messages.catch((cause) => {
+        completionError ??= new Error("evaluation broker protocol failed", {
+          cause,
+        });
+        child.kill("SIGKILL");
+      });
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (!completionError && Buffer.byteLength(stderr) > MAX_OUTPUT_BYTES) {
+        completionError = new Error("evaluation target stderr exceeds 1 MiB");
+        child.kill("SIGKILL");
+      }
+    });
+    child.once("error", rejectOnce);
+    child.once("close", (code, signal) => {
+      messages.then(
+        () => {
+          if (settled) return;
+          if (completionError) {
+            rejectOnce(completionError);
+            return;
+          }
+          if (code !== 0) {
+            rejectOnce(
+              new Error(
+                `evaluation target exited ${code ?? "null"}/${signal ?? "none"}: ${stderr.slice(0, 512)}`,
+              ),
+            );
+            return;
+          }
+          if (stdoutBuffer.length !== 0 || !resultSeen) {
+            rejectOnce(new Error("evaluation broker result is incomplete"));
+            return;
+          }
+          settled = true;
+          resolveResult(resultValue);
+        },
+        (cause) =>
+          rejectOnce(
+            new Error("evaluation broker response is invalid", { cause }),
+          ),
+      );
+    });
+    child.stdin.once("error", (error) => {
+      completionError ??= error;
+    });
+    writeBrokerMessage(child, {
+      ...input,
+      protocol: "chainlesschain.evolution-process-broker/v1",
+    }).catch((cause) => {
+      completionError ??= cause;
+      child.kill("SIGKILL");
+    });
+  });
+}
+
+export function createEvolutionEvalProcessRuntimeBroker(options = {}) {
+  const plain =
+    !options ||
+    typeof options !== "object" ||
+    Array.isArray(options) ||
+    isProxy(options) ||
+    Object.getPrototypeOf(options) !== Object.prototype;
+  if (plain)
+    throw new TypeError("evaluation process runtime broker ports are invalid");
+  const hasMemory = Object.hasOwn(options, "retrieveMemory");
+  const hasModel = Object.hasOwn(options, "invokeModel");
+  if (
+    Reflect.ownKeys(options).length !==
+      2 + Number(hasMemory) + Number(hasModel) ||
+    !Object.hasOwn(options, "recordTokens") ||
+    !Object.hasOwn(options, "invokeTool") ||
+    typeof options.recordTokens !== "function" ||
+    isProxy(options.recordTokens) ||
+    typeof options.invokeTool !== "function" ||
+    isProxy(options.invokeTool) ||
+    (hasMemory &&
+      (typeof options.retrieveMemory !== "function" ||
+        isProxy(options.retrieveMemory))) ||
+    (hasModel &&
+      (typeof options.invokeModel !== "function" ||
+        isProxy(options.invokeModel)))
+  ) {
+    throw new TypeError("evaluation process runtime broker ports are invalid");
+  }
+  const broker = Object.freeze({});
+  PROCESS_RUNTIME_BROKERS.set(broker, {
+    recordTokens: options.recordTokens,
+    invokeTool: options.invokeTool,
+    retrieveMemory: hasMemory ? options.retrieveMemory : null,
+    invokeModel: hasModel ? options.invokeModel : null,
+  });
+  return broker;
+}
+
+export function isEvolutionEvalProcessRuntimeBroker(value) {
+  return PROCESS_RUNTIME_BROKERS.has(value);
+}
+
 export function createEvolutionEvalProcessSupervisor({
   targets,
   authorityDescriptor,
@@ -446,7 +704,7 @@ export function createEvolutionEvalProcessSupervisor({
     );
   }
 
-  async function invokeTarget(request) {
+  async function invokeTarget(request, context = null) {
     const entry = registry.get(request?.target?.handlerId);
     if (!entry) {
       if (fallbackSupervisor) return fallbackSupervisor.invokeTarget(request);
@@ -478,11 +736,14 @@ export function createEvolutionEvalProcessSupervisor({
     );
     active.set(request.capabilityDigest, { child, closed });
     try {
-      const value = await processResult(child, {
+      const processInput = {
         moduleUrl: entry.snapshot.moduleUrl,
         exportName: entry.exportName,
         payload: request.payload,
-      });
+      };
+      const value = PROCESS_RUNTIME_BROKERS.has(context)
+        ? await processBrokeredResult(child, processInput, context)
+        : await processResult(child, processInput);
       await moduleSnapshot(entry.snapshot.physical, entry.snapshot.digest);
       return Object.freeze({
         value,
@@ -534,15 +795,21 @@ export function createEvolutionEvalProcessSupervisor({
       terminatedAt: revocation.terminatedAt,
       supervisorRevision,
     };
-    return attest(
-      core,
+    return persistEvidence(
+      "supervision",
+      await attest(
+        core,
+        EVOLUTION_EVAL_ATTESTATION_PURPOSES.supervisor,
+        attestSupervisor,
+      ),
       EVOLUTION_EVAL_ATTESTATION_PURPOSES.supervisor,
-      attestSupervisor,
     );
   }
 
   const supervisor = Object.freeze({
     authorityDescriptor: Object.freeze(structuredClone(authorityDescriptor)),
+    childEvidenceStoreDescriptor:
+      durableEvidence === null ? null : durableEvidence.descriptor,
     invokeTarget,
     revokeTarget,
     verifyEnforcement,

package/src/lib/evolution/evolution-workbench-metrics.js

@@ -3,10 +3,17 @@ import { types as utilTypes } from "node:util";
 
 import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
 
-const { verifySkillInvocationReceipt } = skillInvocationReceipt;
+const {
+  inspectSkillInvocationReceiptCompatibility,
+  verifySkillInvocationReceipt,
+} = skillInvocationReceipt;
 
-export const EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA =
+export const LEGACY_EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA =
   "chainlesschain.evolution-workbench-metrics-snapshot/v1";
+export const EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA =
+  "chainlesschain.evolution-workbench-metrics-snapshot/v2";
+export const EVOLUTION_WORKBENCH_RECEIPT_COMPATIBILITY_POLICY =
+  "environment-bound-v2";
 export const EVOLUTION_WORKBENCH_METRICS_MAX_RECEIPTS = 100_000;
 export const EVOLUTION_WORKBENCH_METRICS_MAX_DELTA = 10_000;
 export const EVOLUTION_WORKBENCH_METRICS_MAX_HOT_RECEIPTS = 10_000;
@@ -39,6 +46,13 @@ const LEGACY_SNAPSHOT_KEYS = Object.freeze(
 const OUTCOME_SNAPSHOT_KEYS = Object.freeze(
   [...RETENTION_SNAPSHOT_KEYS, "outcomeHistoryComplete"].sort(),
 );
+const COMPATIBILITY_SNAPSHOT_KEYS = Object.freeze(
+  [
+    ...OUTCOME_SNAPSHOT_KEYS,
+    "excludedReceiptCount",
+    "receiptCompatibilityPolicy",
+  ].sort(),
+);
 const LEGACY_VERSION_KEYS = Object.freeze(
   [
     "blocked",
@@ -161,6 +175,9 @@ export function createEmptyEvolutionWorkbenchMetricsSnapshot(
     retainedReceiptCount: 0,
     retentionRootDigest: null,
     outcomeHistoryComplete: true,
+    excludedReceiptCount: 0,
+    receiptCompatibilityPolicy:
+      EVOLUTION_WORKBENCH_RECEIPT_COMPATIBILITY_POLICY,
     receiptDigests: [],
     versions: [],
   };
@@ -246,12 +263,17 @@ export function verifyEvolutionWorkbenchMetricsSnapshot(
   value,
   { tenantId, evolutionRunId, skillName },
 ) {
+  const exactCompatibility = exactRecord(value, COMPATIBILITY_SNAPSHOT_KEYS);
   const exactOutcome = exactRecord(value, OUTCOME_SNAPSHOT_KEYS);
   const exactRetention = exactRecord(value, RETENTION_SNAPSHOT_KEYS);
   const exactLegacy = exactRecord(value, LEGACY_SNAPSHOT_KEYS);
+  const currentSchema =
+    value?.schema === EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA;
+  const legacySchema =
+    value?.schema === LEGACY_EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA;
   if (
-    (!exactOutcome && !exactRetention && !exactLegacy) ||
-    value.schema !== EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA ||
+    ((!currentSchema || !exactCompatibility) &&
+      (!legacySchema || (!exactOutcome && !exactRetention && !exactLegacy))) ||
     !boundedString(value.tenantId) ||
     !boundedString(value.evolutionRunId) ||
     !boundedString(value.skillName) ||
@@ -280,6 +302,9 @@ export function verifyEvolutionWorkbenchMetricsSnapshot(
   }
   const retainedReceiptCount = value.retainedReceiptCount ?? 0;
   const retentionRootDigest = value.retentionRootDigest ?? null;
+  const excludedReceiptCount = exactCompatibility
+    ? value.excludedReceiptCount
+    : 0;
   if (
     !safeCount(retainedReceiptCount) ||
     (retainedReceiptCount === 0 && retentionRootDigest !== null) ||
@@ -290,18 +315,27 @@ export function verifyEvolutionWorkbenchMetricsSnapshot(
   if (
     value.revision === 0 &&
     (retainedReceiptCount !== 0 ||
+      excludedReceiptCount !== 0 ||
       value.receiptDigests.length !== 0 ||
       value.versions.length !== 0)
   ) {
     throw new TypeError("Workbench metrics genesis snapshot is invalid");
   }
   if (
-    exactOutcome &&
+    (exactCompatibility || exactOutcome) &&
     (typeof value.outcomeHistoryComplete !== "boolean" ||
       (value.revision === 0 && value.outcomeHistoryComplete !== true))
   ) {
     throw new TypeError("Workbench metrics outcome coverage is invalid");
   }
+  if (
+    exactCompatibility &&
+    (!safeCount(excludedReceiptCount) ||
+      value.receiptCompatibilityPolicy !==
+        EVOLUTION_WORKBENCH_RECEIPT_COMPATIBILITY_POLICY)
+  ) {
+    throw new TypeError("Workbench metrics receipt compatibility is invalid");
+  }
   for (const receiptDigest of value.receiptDigests)
     digest(receiptDigest, "receipt digest");
   const versionDigests = new Set();
@@ -378,23 +412,20 @@ export function verifyEvolutionWorkbenchMetricsSnapshot(
     }
   }
   if (
-    projectedReceiptCount !==
+    projectedReceiptCount + excludedReceiptCount !==
     retainedReceiptCount + value.receiptDigests.length
   ) {
     throw new Error("Workbench metrics receipt retention total is invalid");
   }
   if (
-    (exactOutcome && versionLayout === "legacy") ||
-    (!exactOutcome && versionLayout === "outcome")
+    ((exactCompatibility || exactOutcome) && versionLayout === "legacy") ||
+    (!exactCompatibility && !exactOutcome && versionLayout === "outcome")
   ) {
     throw new TypeError("Workbench metrics outcome layout is invalid");
   }
   const core = structuredClone(value);
   delete core.snapshotDigest;
-  if (
-    hash(EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA, core) !==
-    value.snapshotDigest
-  ) {
+  if (hash(value.schema, core) !== value.snapshotDigest) {
     throw new Error("Workbench metrics snapshot digest is invalid");
   }
   return freeze(structuredClone(value));
@@ -422,11 +453,19 @@ function nextSnapshot(previous, source, receipts, retention) {
   );
   const outcomeHistoryComplete =
     previous.outcomeHistoryComplete === true || previousReceiptCount === 0;
+  let excludedReceiptCount = previous.excludedReceiptCount;
   for (const receipt of receipts) {
     if (seen.has(receipt.receiptDigest)) {
       throw new Error("Workbench metrics source replayed a receipt");
     }
     seen.add(receipt.receiptDigest);
+    if (
+      !inspectSkillInvocationReceiptCompatibility(receipt)
+        .environmentBoundAttributionEligible
+    ) {
+      excludedReceiptCount += 1;
+      continue;
+    }
     for (const contentDigest of receipt.selectedSkillDigests) {
       const current = versions.get(contentDigest) ?? {
         contentDigest,
@@ -485,6 +524,9 @@ function nextSnapshot(previous, source, receipts, retention) {
     retainedReceiptCount: retention.retainedReceiptCount,
     retentionRootDigest: retention.retentionRootDigest,
     outcomeHistoryComplete,
+    excludedReceiptCount,
+    receiptCompatibilityPolicy:
+      EVOLUTION_WORKBENCH_RECEIPT_COMPATIBILITY_POLICY,
     receiptDigests: [...seen].sort(),
     versions: [...versions.values()].sort((left, right) =>
       left.contentDigest.localeCompare(right.contentDigest),
@@ -596,8 +638,8 @@ export class EvolutionWorkbenchMetricsOutcomeBackfiller {
       this.descriptor,
     );
     if (
-      previous.outcomeHistoryComplete === true ||
-      previous.versions.length === 0
+      previous.schema === EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA &&
+      previous.outcomeHistoryComplete === true
     ) {
       return freeze({ status: "already-complete", snapshot: previous });
     }
@@ -643,7 +685,6 @@ export class EvolutionWorkbenchMetricsOutcomeBackfiller {
       const verified = verifySkillInvocationReceipt(receipt);
       if (
         verified.evolutionRunId !== this.descriptor.evolutionRunId ||
-        verified.attributionEligible !== true ||
         Date.parse(verified.completedAt) > Date.parse(previous.throughAt)
       ) {
         throw new Error("Workbench metrics history lacks exact attribution");
@@ -692,9 +733,19 @@ export class EvolutionWorkbenchMetricsOutcomeBackfiller {
         );
       }
     }
-    const versions = projectReceiptHistory(receipts);
+    const eligibleReceipts = receipts.filter(
+      (receipt) =>
+        inspectSkillInvocationReceiptCompatibility(receipt)
+          .environmentBoundAttributionEligible,
+    );
+    const versions = projectReceiptHistory(eligibleReceipts);
+    const reconciliationVersions = projectReceiptHistory(
+      previous.schema === LEGACY_EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA
+        ? receipts
+        : eligibleReceipts,
+    );
     if (
-      canonical(legacyProjection(versions)) !==
+      canonical(legacyProjection(reconciliationVersions)) !==
       canonical(legacyProjection(previous.versions))
     ) {
       throw new Error("Workbench metrics history does not reconcile");
@@ -711,6 +762,9 @@ export class EvolutionWorkbenchMetricsOutcomeBackfiller {
       retainedReceiptCount: previous.retainedReceiptCount ?? 0,
       retentionRootDigest: previous.retentionRootDigest ?? null,
       outcomeHistoryComplete: true,
+      excludedReceiptCount: receipts.length - eligibleReceipts.length,
+      receiptCompatibilityPolicy:
+        EVOLUTION_WORKBENCH_RECEIPT_COMPATIBILITY_POLICY,
       receiptDigests: previous.receiptDigests,
       versions,
     };
@@ -809,6 +863,15 @@ export class EvolutionWorkbenchMetricsAggregator {
         loaded.snapshot,
         this.descriptor,
       );
+      if (
+        previous.schema === LEGACY_EVOLUTION_WORKBENCH_METRICS_SNAPSHOT_SCHEMA
+      ) {
+        const error = new Error(
+          "Workbench metrics snapshot requires receipt compatibility backfill",
+        );
+        error.code = "CC_WORKBENCH_METRICS_COMPATIBILITY_BACKFILL_REQUIRED";
+        throw error;
+      }
     } else {
       throw new Error("Workbench metrics snapshot load is not authoritative");
     }
@@ -832,10 +895,7 @@ export class EvolutionWorkbenchMetricsAggregator {
     }
     const receipts = source.receipts.map((receipt) => {
       const verified = verifySkillInvocationReceipt(receipt);
-      if (
-        verified.evolutionRunId !== this.descriptor.evolutionRunId ||
-        verified.attributionEligible !== true
-      ) {
+      if (verified.evolutionRunId !== this.descriptor.evolutionRunId) {
         throw new Error("Workbench metrics receipt lacks exact attribution");
       }
       return verified;