chainlesschain 0.166.18 → 0.166.21

package/src/lib/evolution/skill-outcome-source-catalog-authority.js

@@ -0,0 +1,237 @@
+import { createHash } from "node:crypto";
+import { types as utilTypes } from "node:util";
+
+export const SKILL_OUTCOME_SOURCE_CATALOG_SCHEMA =
+  "chainlesschain.skill-outcome-source-catalog/v1";
+export const SKILL_OUTCOME_SOURCE_CATALOG_ATTESTATION_SCHEMA =
+  "chainlesschain.skill-outcome-source-catalog-attestation/v1";
+
+const AUTHORITIES = new WeakSet();
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const SAFE_ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,255}$/u;
+const MAX_SOURCES = 128;
+const CATALOG_KEYS = new Set([
+  "attestation",
+  "catalogDigest",
+  "catalogId",
+  "entries",
+  "issuedAt",
+  "revision",
+  "schema",
+  "tenantId",
+]);
+const ENTRY_KEYS = new Set(["runId", "skillNames"]);
+const ATTESTATION_KEYS = new Set(["algorithm", "keyId", "schema", "value"]);
+const VERIFICATION_KEYS = new Set([
+  "authenticated",
+  "catalogDigest",
+  "catalogId",
+  "durable",
+  "receiptDigest",
+  "revision",
+  "tenantId",
+]);
+
+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 hash(value) {
+  return `sha256:${createHash("sha256")
+    .update(SKILL_OUTCOME_SOURCE_CATALOG_SCHEMA)
+    .update("\0")
+    .update(canonical(value))
+    .digest("hex")}`;
+}
+
+function exact(value, keys, label) {
+  if (
+    !value ||
+    typeof value !== "object" ||
+    Array.isArray(value) ||
+    utilTypes.isProxy(value) ||
+    Reflect.ownKeys(value).length !== keys.size ||
+    Reflect.ownKeys(value).some(
+      (key) => typeof key !== "string" || !keys.has(key),
+    )
+  ) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  for (const key of Reflect.ownKeys(value)) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+      throw new TypeError(`${label}.${String(key)} is invalid`);
+    }
+  }
+  return value;
+}
+
+function identifier(value, label) {
+  if (typeof value !== "string" || !SAFE_ID.test(value)) {
+    throw new TypeError(`${label} is invalid`);
+  }
+  return value;
+}
+
+function capture(owner, method, label) {
+  if (!owner || typeof owner !== "object" || utilTypes.isProxy(owner)) {
+    throw new TypeError(`${label}.${method}() is required`);
+  }
+  const operation = owner[method];
+  if (typeof operation !== "function" || utilTypes.isProxy(operation)) {
+    throw new TypeError(`${label}.${method}() is required`);
+  }
+  return Object.freeze((...args) => Reflect.apply(operation, owner, args));
+}
+
+export function digestSkillOutcomeSourceCatalog(value) {
+  return hash({
+    schema: value.schema,
+    tenantId: value.tenantId,
+    catalogId: value.catalogId,
+    revision: value.revision,
+    issuedAt: value.issuedAt,
+    entries: value.entries,
+  });
+}
+
+function verifyCatalog(value, tenantId) {
+  exact(value, CATALOG_KEYS, "Skill outcome source catalog");
+  if (
+    value.schema !== SKILL_OUTCOME_SOURCE_CATALOG_SCHEMA ||
+    value.tenantId !== tenantId ||
+    !SAFE_ID.test(value.catalogId ?? "") ||
+    !Number.isSafeInteger(value.revision) ||
+    value.revision < 1 ||
+    typeof value.issuedAt !== "string" ||
+    !Number.isFinite(Date.parse(value.issuedAt)) ||
+    !Array.isArray(value.entries) ||
+    utilTypes.isProxy(value.entries) ||
+    value.entries.length < 1 ||
+    value.entries.length > MAX_SOURCES ||
+    !DIGEST.test(value.catalogDigest ?? "")
+  ) {
+    throw new TypeError("Skill outcome source catalog is invalid or unbounded");
+  }
+  const runIds = new Set();
+  let sourceCount = 0;
+  const entries = value.entries.map((input, index) => {
+    const entry = exact(input, ENTRY_KEYS, `catalog.entries[${index}]`);
+    const runId = identifier(entry.runId, `catalog.entries[${index}].runId`);
+    if (runIds.has(runId)) {
+      throw new TypeError(
+        "Skill outcome source catalog contains a duplicate run",
+      );
+    }
+    runIds.add(runId);
+    if (
+      !Array.isArray(entry.skillNames) ||
+      utilTypes.isProxy(entry.skillNames) ||
+      entry.skillNames.length < 1 ||
+      entry.skillNames.length > MAX_SOURCES
+    ) {
+      throw new TypeError(
+        `catalog.entries[${index}].skillNames is invalid or unbounded`,
+      );
+    }
+    const skillNames = entry.skillNames.map((skillName, skillIndex) =>
+      identifier(
+        skillName,
+        `catalog.entries[${index}].skillNames[${skillIndex}]`,
+      ),
+    );
+    if (new Set(skillNames).size !== skillNames.length) {
+      throw new TypeError(
+        "Skill outcome source catalog contains a duplicate Skill",
+      );
+    }
+    sourceCount += skillNames.length;
+    if (sourceCount > MAX_SOURCES) {
+      throw new TypeError(
+        "Skill outcome source catalog is invalid or unbounded",
+      );
+    }
+    return Object.freeze({ runId, skillNames: Object.freeze(skillNames) });
+  });
+  exact(
+    value.attestation,
+    ATTESTATION_KEYS,
+    "Skill outcome source catalog attestation",
+  );
+  if (
+    value.attestation.schema !==
+      SKILL_OUTCOME_SOURCE_CATALOG_ATTESTATION_SCHEMA ||
+    !SAFE_ID.test(value.attestation.algorithm ?? "") ||
+    !SAFE_ID.test(value.attestation.keyId ?? "") ||
+    typeof value.attestation.value !== "string" ||
+    value.attestation.value.length < 16 ||
+    value.attestation.value.length > 4096 ||
+    value.catalogDigest !== digestSkillOutcomeSourceCatalog(value)
+  ) {
+    throw new Error("Skill outcome source catalog integrity is invalid");
+  }
+  return Object.freeze({ ...value, entries: Object.freeze(entries) });
+}
+
+export function createSkillOutcomeSourceCatalogAuthority({
+  tenantId: tenantIdInput,
+  loader,
+  verifier,
+} = {}) {
+  const tenantId = identifier(tenantIdInput, "tenantId");
+  const load = capture(loader, "load", "catalog loader");
+  const verify = capture(verifier, "verify", "catalog verifier");
+  const authority = Object.freeze({
+    async loadCatalog() {
+      const catalog = verifyCatalog(await load({ tenantId }), tenantId);
+      const verification = exact(
+        await verify({
+          tenantId,
+          catalogId: catalog.catalogId,
+          revision: catalog.revision,
+          catalogDigest: catalog.catalogDigest,
+          attestation: catalog.attestation,
+        }),
+        VERIFICATION_KEYS,
+        "Skill outcome source catalog verification",
+      );
+      if (
+        verification.authenticated !== true ||
+        verification.durable !== true ||
+        verification.tenantId !== tenantId ||
+        verification.catalogId !== catalog.catalogId ||
+        verification.revision !== catalog.revision ||
+        verification.catalogDigest !== catalog.catalogDigest ||
+        !DIGEST.test(verification.receiptDigest ?? "")
+      ) {
+        throw new Error("Skill outcome source catalog is not authoritative");
+      }
+      return Object.freeze({
+        authenticated: true,
+        durable: true,
+        tenantId,
+        catalogId: catalog.catalogId,
+        revision: catalog.revision,
+        catalogDigest: catalog.catalogDigest,
+        receiptDigest: verification.receiptDigest,
+        entries: catalog.entries,
+      });
+    },
+  });
+  AUTHORITIES.add(authority);
+  return authority;
+}
+
+export function captureSkillOutcomeSourceCatalogAuthority(value) {
+  if (!AUTHORITIES.has(value)) {
+    throw new TypeError(
+      "a branded Skill outcome source catalog authority is required",
+    );
+  }
+  return value;
+}

package/src/lib/public-ide-capability-manifest.js

@@ -59,6 +59,8 @@ const VSCODE_COMMANDS = [
   "chainlesschain.appServerPilot.interrupt",
   "chainlesschain.usage.show",
   "chainlesschain.plugins.manage",
+  "chainlesschain.skills.retrieve",
+  "chainlesschain.evolution.workbench",
   "chainlesschain.worktree.tasks",
   "chainlesschain.chrome.connector",
   "chainlesschain.artifacts.show",
@@ -114,6 +116,8 @@ const JETBRAINS_ACTIONS = [
   "chainlesschain.policy.Viewer",
   "chainlesschain.context.Center",
   "chainlesschain.plugins.Manage",
+  "chainlesschain.skills.Retrieve",
+  "chainlesschain.evolution.Workbench",
   "chainlesschain.worktree.Tasks",
   "chainlesschain.chrome.Connector",
   "chainlesschain.workspace.ScanAutoExec",

package/src/lib/skill-outcome-authority.js

@@ -0,0 +1,43 @@
+import {
+  buildSkillOutcomeIndexAuthority,
+  unavailableSkillOutcomeIndexAuthority,
+} from "./evolution/skill-outcome-index-authority.js";
+import {
+  buildSkillOutcomeTranscriptAuthority,
+  unavailableSkillOutcomeTranscriptAuthority,
+} from "./skill-outcome-transcript-authority.js";
+
+export function resolveSkillOutcomeAuthority(options = {}, dependencies = {}) {
+  if (
+    options &&
+    typeof options === "object" &&
+    Object.prototype.hasOwnProperty.call(options, "index")
+  ) {
+    const buildIndex =
+      dependencies.buildSkillOutcomeIndexAuthority ||
+      buildSkillOutcomeIndexAuthority;
+    const unavailableIndex =
+      dependencies.unavailableSkillOutcomeIndexAuthority ||
+      unavailableSkillOutcomeIndexAuthority;
+    try {
+      return buildIndex(options.index, dependencies.indexDependencies);
+    } catch (error) {
+      return unavailableIndex(error);
+    }
+  }
+
+  const buildTranscript =
+    dependencies.buildSkillOutcomeTranscriptAuthority ||
+    buildSkillOutcomeTranscriptAuthority;
+  const unavailableTranscript =
+    dependencies.unavailableSkillOutcomeTranscriptAuthority ||
+    unavailableSkillOutcomeTranscriptAuthority;
+  try {
+    return buildTranscript(
+      options?.transcriptOptions,
+      dependencies.transcriptDependencies,
+    );
+  } catch (error) {
+    return unavailableTranscript(error);
+  }
+}

package/src/lib/skill-outcome-transcript-authority.js

@@ -0,0 +1,252 @@
+import { createHash } from "node:crypto";
+import skillInvocationReceipt from "@chainlesschain/session-core/skill-invocation-receipt";
+
+import {
+  listSessionAuthoritySummaries,
+  readVerifiedProjection,
+} from "../harness/jsonl-session-store.js";
+import { canonicalJson } from "./scheduler-kernel/contract.js";
+
+const { verifySkillInvocationReceipt } = skillInvocationReceipt;
+
+export const SKILL_OUTCOME_AUTHORITY_SCHEMA =
+  "chainlesschain.skill-outcome-transcript-authority/v1";
+export const MAX_OUTCOME_AUTHORITY_SESSIONS = 128;
+export const MAX_OUTCOME_AUTHORITY_RECEIPTS = 10_000;
+
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+const TRANSCRIPT_HASH = /^[a-f0-9]{64}$/u;
+
+function unavailable(message, code = "CC_SKILL_OUTCOME_AUTHORITY_UNAVAILABLE") {
+  const error = new Error(message);
+  error.code = code;
+  return error;
+}
+
+function verifiedReceipt(receipt) {
+  verifySkillInvocationReceipt(receipt);
+  if (
+    !Array.isArray(receipt.selectedSkillDigests) ||
+    receipt.selectedSkillDigests.length !== 1 ||
+    !DIGEST.test(receipt.selectedSkillDigests[0] || "")
+  ) {
+    throw unavailable("Skill outcome receipt has an invalid selection binding");
+  }
+  if (
+    !Array.isArray(receipt.graderReceipts) ||
+    receipt.graderReceipts.length > 64 ||
+    receipt.graderReceipts.some((digest) => !DIGEST.test(digest || "")) ||
+    (receipt.userCorrectionRef !== null &&
+      (typeof receipt.userCorrectionRef !== "string" ||
+        receipt.userCorrectionRef.length < 1 ||
+        receipt.userCorrectionRef.length > 256)) ||
+    (receipt.attributionEligible === true &&
+      (receipt.attributionStatus !== "complete" ||
+        !Array.isArray(receipt.missingAttribution) ||
+        receipt.missingAttribution.length !== 0))
+  ) {
+    throw unavailable("Skill outcome receipt has an invalid attribution state");
+  }
+  return receipt;
+}
+
+function transcriptReceiptProjection(receipts, capacity) {
+  return {
+    accept(event) {
+      const receipt = event?.data?.skill_invocation_receipt;
+      if (receipt === undefined) return;
+      if (event.type !== "tool_call" || event.data?.tool !== "run_skill") {
+        throw unavailable(
+          "Skill outcome receipt is bound to a non-Skill event",
+        );
+      }
+      if (receipts.length >= capacity) {
+        throw unavailable(
+          "Skill outcome receipt capacity exceeded",
+          "CC_SKILL_OUTCOME_AUTHORITY_CAPACITY",
+        );
+      }
+      receipts.push(verifiedReceipt(receipt));
+    },
+    finish(authority) {
+      if (
+        !authority ||
+        !Number.isSafeInteger(authority.eventCount) ||
+        authority.eventCount < 0 ||
+        (authority.headHash !== null &&
+          !TRANSCRIPT_HASH.test(authority.headHash || ""))
+      ) {
+        throw unavailable("Verified transcript returned invalid authority");
+      }
+      return Object.freeze({
+        headHash: authority.headHash,
+        eventCount: authority.eventCount,
+      });
+    },
+  };
+}
+
+/**
+ * Build bounded outcome metrics only from fully verified canonical transcripts.
+ * Any damaged/blocked selected session or projection failure disables the whole
+ * sample instead of silently ranking from a favorable partial subset.
+ */
+export function buildSkillOutcomeTranscriptAuthority(
+  options = {},
+  dependencies = {},
+) {
+  const maxSessions =
+    options.maxSessions === undefined
+      ? MAX_OUTCOME_AUTHORITY_SESSIONS
+      : Number(options.maxSessions);
+  const maxReceipts =
+    options.maxReceipts === undefined
+      ? MAX_OUTCOME_AUTHORITY_RECEIPTS
+      : Number(options.maxReceipts);
+  if (
+    !Number.isSafeInteger(maxSessions) ||
+    maxSessions < 1 ||
+    maxSessions > MAX_OUTCOME_AUTHORITY_SESSIONS ||
+    !Number.isSafeInteger(maxReceipts) ||
+    maxReceipts < 1 ||
+    maxReceipts > MAX_OUTCOME_AUTHORITY_RECEIPTS
+  ) {
+    throw new TypeError("Skill outcome authority bounds are invalid");
+  }
+  const list =
+    dependencies.listSessionAuthoritySummaries || listSessionAuthoritySummaries;
+  const read = dependencies.readVerifiedProjection || readVerifiedProjection;
+  if (typeof list !== "function" || typeof read !== "function") {
+    throw new TypeError(
+      "Skill outcome transcript authority ports are required",
+    );
+  }
+  const rows = list({ limit: maxSessions });
+  if (!Array.isArray(rows) || rows.length > maxSessions) {
+    throw unavailable(
+      "Skill outcome session authority is invalid or unbounded",
+    );
+  }
+  const sessionIds = new Set();
+  for (const row of rows) {
+    if (
+      !row ||
+      typeof row.id !== "string" ||
+      row.id.length < 1 ||
+      row.id.length > 256 ||
+      sessionIds.has(row.id) ||
+      row._store !== "jsonl" ||
+      row._presence !== "present" ||
+      row._blocked !== false
+    ) {
+      throw unavailable(
+        "Skill outcome session authority contains a blocked row",
+      );
+    }
+    sessionIds.add(row.id);
+  }
+
+  const receipts = [];
+  const sessions = rows.map((row) => {
+    const authority = read(row.id, () =>
+      transcriptReceiptProjection(receipts, maxReceipts),
+    );
+    return Object.freeze({
+      sessionId: row.id,
+      headHash: authority.headHash,
+      eventCount: authority.eventCount,
+    });
+  });
+  const uniqueReceipts = new Map();
+  let duplicateReceiptCount = 0;
+  for (const receipt of receipts) {
+    if (uniqueReceipts.has(receipt.receiptDigest)) {
+      duplicateReceiptCount += 1;
+      continue;
+    }
+    uniqueReceipts.set(receipt.receiptDigest, receipt);
+  }
+
+  const totals = new Map();
+  let attributionEligibleReceiptCount = 0;
+  let outcomeEligibleReceiptCount = 0;
+  for (const receipt of uniqueReceipts.values()) {
+    if (receipt.attributionEligible !== true) continue;
+    attributionEligibleReceiptCount += 1;
+    const hasOutcomeEvidence =
+      receipt.graderReceipts.length > 0 || receipt.userCorrectionRef !== null;
+    if (
+      !hasOutcomeEvidence ||
+      !["completed", "failed"].includes(receipt.executionStatus)
+    ) {
+      continue;
+    }
+    outcomeEligibleReceiptCount += 1;
+    const digest = receipt.selectedSkillDigests[0];
+    const prior = totals.get(digest) || {
+      samples: 0,
+      successes: 0,
+      corrections: 0,
+    };
+    prior.samples += 1;
+    if (receipt.executionStatus === "completed") prior.successes += 1;
+    if (receipt.userCorrectionRef !== null) prior.corrections += 1;
+    totals.set(digest, prior);
+  }
+  const metrics = Object.fromEntries(
+    [...totals.entries()]
+      .sort(([left], [right]) => left.localeCompare(right))
+      .map(([digest, value]) => [
+        digest,
+        Object.freeze({
+          samples: value.samples,
+          successRate: value.successes / value.samples,
+          correctionRate: value.corrections / value.samples,
+        }),
+      ]),
+  );
+  const source = sessions
+    .map(({ sessionId, headHash, eventCount }) => ({
+      sessionId,
+      headHash,
+      eventCount,
+    }))
+    .sort((left, right) => left.sessionId.localeCompare(right.sessionId));
+  const sourceDigest = `sha256:${createHash("sha256")
+    .update(`${SKILL_OUTCOME_AUTHORITY_SCHEMA}\0${canonicalJson(source)}`)
+    .digest("hex")}`;
+  return Object.freeze({
+    schema: SKILL_OUTCOME_AUTHORITY_SCHEMA,
+    status: "verified",
+    metrics: Object.freeze(metrics),
+    evidence: Object.freeze({
+      schema: SKILL_OUTCOME_AUTHORITY_SCHEMA,
+      status: "verified",
+      sourceDigest,
+      selectedSessionCount: sessions.length,
+      receiptCount: receipts.length,
+      uniqueReceiptCount: uniqueReceipts.size,
+      attributionEligibleReceiptCount,
+      outcomeEligibleReceiptCount,
+      duplicateReceiptCount,
+      maxSessions,
+      maxReceipts,
+    }),
+  });
+}
+
+export function unavailableSkillOutcomeTranscriptAuthority(error) {
+  return Object.freeze({
+    schema: SKILL_OUTCOME_AUTHORITY_SCHEMA,
+    status: "unavailable",
+    metrics: null,
+    evidence: Object.freeze({
+      schema: SKILL_OUTCOME_AUTHORITY_SCHEMA,
+      status: "unavailable",
+      code:
+        typeof error?.code === "string" && error.code.startsWith("CC_SKILL_")
+          ? error.code
+          : "CC_SKILL_OUTCOME_AUTHORITY_UNAVAILABLE",
+    }),
+  });
+}

package/src/lib/skill-retrieval-router-benchmark.js

@@ -0,0 +1,135 @@
+import { createHash } from "node:crypto";
+import { performance } from "node:perf_hooks";
+
+import { routeSkillDescriptors } from "./skill-retrieval-router.js";
+
+export const SKILL_RETRIEVAL_BENCHMARK_SCHEMA =
+  "chainlesschain.skill-retrieval-benchmark/v1";
+
+const DIGEST = /^sha256:[a-f0-9]{64}$/u;
+
+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 hash(value) {
+  return `sha256:${createHash("sha256")
+    .update(SKILL_RETRIEVAL_BENCHMARK_SCHEMA)
+    .update("\0")
+    .update(canonical(value))
+    .digest("hex")}`;
+}
+
+function finiteRatio(value, name) {
+  const number = Number(value);
+  if (!Number.isFinite(number) || number < 0 || number > 1)
+    throw new TypeError(`${name} must be between zero and one`);
+  return number;
+}
+
+function normalizeThresholds(input) {
+  const recallAt5 = finiteRatio(input?.recallAt5, "recallAt5");
+  const falseInvocationRate = finiteRatio(
+    input?.falseInvocationRate,
+    "falseInvocationRate",
+  );
+  const p95Ms = Number(input?.p95Ms);
+  if (!Number.isFinite(p95Ms) || p95Ms <= 0)
+    throw new TypeError("p95Ms must be positive");
+  return Object.freeze({ recallAt5, falseInvocationRate, p95Ms });
+}
+
+export function runSkillRetrievalBenchmark({
+  skills,
+  cases,
+  thresholds,
+  clock = () => performance.now(),
+} = {}) {
+  if (
+    !Array.isArray(skills) ||
+    skills.length < 2 ||
+    skills.length > 10_000 ||
+    !Array.isArray(cases) ||
+    cases.length < 1 ||
+    cases.length > 10_000 ||
+    typeof clock !== "function"
+  )
+    throw new TypeError("Skill retrieval benchmark input is invalid");
+  const gate = normalizeThresholds(thresholds);
+  const corpusDigests = new Set(
+    skills.map((skill) => skill.executionIdentity?.contentDigest),
+  );
+  const normalizedCases = cases.map((item, index) => {
+    if (
+      typeof item?.query !== "string" ||
+      item.query.trim() === "" ||
+      !DIGEST.test(item?.expectedDigest ?? "")
+    )
+      throw new TypeError(`benchmark case ${index} is invalid`);
+    if (!corpusDigests.has(item.expectedDigest))
+      throw new TypeError(`benchmark case ${index} is absent from the corpus`);
+    return { query: item.query, expectedDigest: item.expectedDigest };
+  });
+  const plan = Object.freeze({
+    skillCorpusDigest: hash(
+      skills.map((skill) => ({
+        id: skill.id,
+        digest: skill.executionIdentity?.contentDigest ?? null,
+        description: skill.description ?? "",
+      })),
+    ),
+    caseCorpusDigest: hash(normalizedCases),
+    caseCount: normalizedCases.length,
+    thresholds: gate,
+  });
+  const latencies = [];
+  let recalled = 0;
+  let falseInvocations = 0;
+  let abstentions = 0;
+  for (const item of normalizedCases) {
+    const startedAt = Number(clock());
+    const result = routeSkillDescriptors({
+      skills,
+      query: item.query,
+      topK: 5,
+      ambiguityMargin: 0,
+    });
+    const endedAt = Number(clock());
+    if (
+      !Number.isFinite(startedAt) ||
+      !Number.isFinite(endedAt) ||
+      endedAt < startedAt
+    )
+      throw new Error("Skill retrieval benchmark clock is invalid");
+    latencies.push(endedAt - startedAt);
+    if (result.candidates.some(({ digest }) => digest === item.expectedDigest))
+      recalled += 1;
+    if (result.selected === null) abstentions += 1;
+    else if (result.selected.digest !== item.expectedDigest)
+      falseInvocations += 1;
+  }
+  latencies.sort((a, b) => a - b);
+  const recallAt5 = recalled / normalizedCases.length;
+  const falseInvocationRate = falseInvocations / normalizedCases.length;
+  const p95Ms = latencies[Math.max(0, Math.ceil(latencies.length * 0.95) - 1)];
+  const core = {
+    schema: SKILL_RETRIEVAL_BENCHMARK_SCHEMA,
+    plan,
+    metrics: {
+      recallAt5,
+      falseInvocationRate,
+      p95Ms,
+      abstentionRate: abstentions / normalizedCases.length,
+    },
+    passed:
+      recallAt5 >= gate.recallAt5 &&
+      falseInvocationRate < gate.falseInvocationRate &&
+      p95Ms < gate.p95Ms,
+  };
+  return Object.freeze({ ...core, reportDigest: hash(core) });
+}