@tangle-network/agent-knowledge 3.2.1 → 4.0.1

package/dist/chunk-RIHIYCX2.js

@@ -1,1853 +0,0 @@
-import {
-  searchKnowledge
-} from "./chunk-DQ3PDMDP.js";
-import {
-  memoryHitToSourceRecord,
-  memoryWriteResultToSourceRecord
-} from "./chunk-XVU5FFQA.js";
-
-// src/benchmarks/index.ts
-import { join } from "path";
-import {
-  fsCampaignStorage,
-  runCampaign
-} from "@tangle-network/agent-eval/campaign";
-
-// src/retrieval-eval.ts
-import {
-  heldOutGate,
-  parameterSweepProposer,
-  runImprovementLoop
-} from "@tangle-network/agent-eval/campaign";
-function retrievalConfigSurface(config) {
-  return canonicalJson(config);
-}
-function retrievalConfigFromSurface(surface) {
-  if (typeof surface !== "string") {
-    throw new Error(
-      `retrievalConfigFromSurface expected a JSON string surface, got ${typeof surface}`
-    );
-  }
-  let parsed;
-  try {
-    parsed = JSON.parse(surface);
-  } catch (error) {
-    throw new Error(`retrievalConfigFromSurface could not parse JSON: ${error.message}`);
-  }
-  if (!isJsonObject(parsed)) {
-    throw new Error("retrievalConfigFromSurface expected a JSON object");
-  }
-  return parsed;
-}
-function buildRetrievalEvalDispatch(options) {
-  if (!options.retrieve && !options.index) {
-    throw new Error("buildRetrievalEvalDispatch requires either index or retrieve");
-  }
-  const defaultK = options.defaultK ?? 5;
-  const retrieve = options.retrieve ?? defaultSearchRetriever;
-  return async (surface, scenario, context) => {
-    const config = retrievalConfigFromSurface(surface);
-    const k = retrievalK(config, scenario, defaultK);
-    const startedAt = Date.now();
-    const result = await retrieve({
-      index: options.index,
-      config,
-      scenario,
-      k,
-      signal: context.signal,
-      context
-    });
-    const normalized = normalizeRetrieverResult(result);
-    return {
-      config,
-      query: scenario.query,
-      requestedK: k,
-      hits: normalized.hits,
-      durationMs: Date.now() - startedAt,
-      costUsd: normalized.costUsd,
-      metadata: normalized.metadata
-    };
-  };
-}
-function retrievalRecallJudge(options = {}) {
-  const weights = normalizeWeights(options.weights ?? { recall: 1 });
-  return {
-    name: options.name ?? "retrieval-recall",
-    dimensions: [
-      { key: "recall", description: "fraction of expected knowledge targets retrieved" },
-      { key: "mrr", description: "reciprocal rank of the first matching hit" },
-      { key: "ndcg", description: "rank-aware gain for newly matched targets" },
-      {
-        key: "precision_at_k",
-        description: "share of returned hits that match at least one target"
-      }
-    ],
-    appliesTo: (scenario) => scenario.kind === "retrieval-eval",
-    async score({ artifact, scenario }) {
-      const metrics = scoreRetrievalArtifact(artifact, scenario);
-      const composite = (metrics.recall * weights.recall + metrics.mrr * weights.mrr + metrics.ndcg * weights.ndcg + metrics.precisionAtK * weights.precisionAtK) / (weights.recall + weights.mrr + weights.ndcg + weights.precisionAtK);
-      return {
-        dimensions: {
-          recall: metrics.recall,
-          mrr: metrics.mrr,
-          ndcg: metrics.ndcg,
-          precision_at_k: metrics.precisionAtK
-        },
-        composite,
-        notes: `matched ${metrics.matchedCount}/${metrics.expectedCount}; first_hit_rank=${metrics.firstHitRank ?? "none"}`
-      };
-    }
-  };
-}
-function scoreRetrievalArtifact(artifact, scenario) {
-  const targets = normalizeTargets(scenario.expected);
-  if (targets.length === 0) {
-    throw new Error(`retrieval eval scenario ${scenario.id} has no expected targets`);
-  }
-  const matchedTargetIds = /* @__PURE__ */ new Set();
-  let firstHitRank = null;
-  let relevantHitCount = 0;
-  let dcg = 0;
-  for (const hit of artifact.hits) {
-    const newlyMatched = targets.filter((target) => {
-      const targetId = retrievalTargetId(target);
-      return !matchedTargetIds.has(targetId) && hitMatchesTarget(hit, target);
-    });
-    if (newlyMatched.length === 0) {
-      continue;
-    }
-    relevantHitCount += 1;
-    if (firstHitRank === null) {
-      firstHitRank = hit.rank;
-    }
-    dcg += 1 / Math.log2(hit.rank + 1);
-    for (const target of newlyMatched) {
-      matchedTargetIds.add(retrievalTargetId(target));
-    }
-  }
-  const expectedCount = targets.length;
-  const matchedCount = matchedTargetIds.size;
-  const idealRankCount = Math.min(expectedCount, Math.max(1, artifact.requestedK));
-  const idcg = idealDcg(idealRankCount);
-  return {
-    recall: matchedCount / expectedCount,
-    mrr: firstHitRank === null ? 0 : 1 / firstHitRank,
-    ndcg: idcg === 0 ? 0 : dcg / idcg,
-    precisionAtK: artifact.hits.length === 0 ? 0 : relevantHitCount / artifact.hits.length,
-    expectedCount,
-    matchedCount,
-    relevantHitCount,
-    firstHitRank,
-    matchedTargetIds: [...matchedTargetIds].sort()
-  };
-}
-function buildRetrievalParameterCandidates(searchSpace, options = {}) {
-  const candidates = [];
-  for (const [path, values] of Object.entries(searchSpace).sort(([a], [b]) => a.localeCompare(b))) {
-    for (const value of values) {
-      if (options.baseline && canonicalJson(getConfigPath(options.baseline, path)) === canonicalJson(value)) {
-        continue;
-      }
-      candidates.push({
-        label: `${path}=${formatCandidateValue(value)}`,
-        rationale: `Set retrieval config ${path} to ${formatCandidateValue(value)}`,
-        changes: [{ path, value }]
-      });
-    }
-  }
-  return candidates;
-}
-function retrievalParameterSweepProposer(options) {
-  const candidates = options.candidates ?? (options.searchSpace ? buildRetrievalParameterCandidates(options.searchSpace, { baseline: options.baseline }) : []);
-  if (candidates.length === 0) {
-    throw new Error("retrievalParameterSweepProposer requires at least one candidate");
-  }
-  return parameterSweepProposer({ candidates });
-}
-async function runRetrievalImprovementLoop(options) {
-  const split = splitRetrievalScenarios(options);
-  const candidates = resolveRetrievalCandidates(options);
-  const populationSize = options.populationSize ?? Math.max(1, Math.min(4, candidates.length));
-  const maxGenerations = options.maxGenerations ?? Math.max(1, Math.ceil(candidates.length / populationSize));
-  const proposer = withTargetRecallStop(
-    retrievalParameterSweepProposer({ candidates }),
-    options.targetRecall
-  );
-  const gate = options.gate ?? heldOutGate({
-    scenarios: split.holdoutScenarios,
-    deltaThreshold: options.deltaThreshold ?? 0.02
-  });
-  const result = await runImprovementLoop({
-    baselineSurface: retrievalConfigSurface(options.baseline),
-    scenarios: split.trainScenarios,
-    holdoutScenarios: split.holdoutScenarios,
-    dispatchWithSurface: buildRetrievalEvalDispatch({
-      index: options.index,
-      defaultK: options.defaultK,
-      retrieve: options.retrieve
-    }),
-    judges: [...options.judges ?? [retrievalRecallJudge({ weights: options.metricWeights })]],
-    proposer,
-    gate,
-    autoOnPromote: "none",
-    runDir: options.runDir ?? ".agent-knowledge/retrieval-improvement",
-    seed: options.seed,
-    reps: options.reps,
-    resumable: options.resumable,
-    costCeiling: options.costCeiling,
-    maxConcurrency: options.maxConcurrency,
-    dispatchTimeoutMs: options.dispatchTimeoutMs,
-    expectUsage: options.expectUsage ?? "off",
-    tracing: options.tracing,
-    storage: options.storage,
-    populationSize,
-    maxGenerations,
-    promoteTopK: options.promoteTopK,
-    maxImprovementShots: options.maxImprovementShots,
-    report: options.report,
-    findings: options.findings,
-    now: options.now
-  });
-  return {
-    ...result,
-    baselineConfig: options.baseline,
-    winnerConfig: retrievalConfigFromSurface(result.winnerSurface),
-    trainScenarios: split.trainScenarios,
-    holdoutScenarios: split.holdoutScenarios,
-    candidates,
-    targetRecall: options.targetRecall
-  };
-}
-function splitRetrievalScenarios(options) {
-  const scenarios = [...options.scenarios];
-  if (scenarios.length === 0) {
-    throw new Error("runRetrievalImprovementLoop requires at least one training scenario");
-  }
-  if (options.holdoutScenarios) {
-    const holdoutScenarios = [...options.holdoutScenarios];
-    if (holdoutScenarios.length === 0) {
-      throw new Error("runRetrievalImprovementLoop holdoutScenarios must not be empty");
-    }
-    return { trainScenarios: scenarios, holdoutScenarios };
-  }
-  if (scenarios.length < 2) {
-    throw new Error(
-      "runRetrievalImprovementLoop requires at least 2 scenarios when holdoutScenarios are not provided"
-    );
-  }
-  const holdoutFraction = options.holdoutFraction ?? 0.3;
-  if (!Number.isFinite(holdoutFraction) || holdoutFraction <= 0 || holdoutFraction >= 1) {
-    throw new Error(
-      `runRetrievalImprovementLoop holdoutFraction must be > 0 and < 1, got ${String(holdoutFraction)}`
-    );
-  }
-  const shuffled = seededShuffle(scenarios, options.splitSeed ?? options.seed ?? 42);
-  const holdoutCount = Math.min(
-    shuffled.length - 1,
-    Math.max(1, Math.round(shuffled.length * holdoutFraction))
-  );
-  const splitIndex = shuffled.length - holdoutCount;
-  return {
-    trainScenarios: shuffled.slice(0, splitIndex),
-    holdoutScenarios: shuffled.slice(splitIndex)
-  };
-}
-function resolveRetrievalCandidates(options) {
-  const candidates = options.candidates ? [...options.candidates] : options.searchSpace ? buildRetrievalParameterCandidates(options.searchSpace, { baseline: options.baseline }) : [];
-  if (candidates.length === 0) {
-    throw new Error("runRetrievalImprovementLoop requires candidates or searchSpace");
-  }
-  return candidates;
-}
-function withTargetRecallStop(proposer, targetRecall) {
-  if (targetRecall === void 0) {
-    return proposer;
-  }
-  if (!Number.isFinite(targetRecall) || targetRecall < 0 || targetRecall > 1) {
-    throw new Error(`targetRecall must be between 0 and 1, got ${String(targetRecall)}`);
-  }
-  return {
-    kind: `${proposer.kind}:target-recall`,
-    propose: (context) => proposer.propose(context),
-    decide(args) {
-      const baseDecision = proposer.decide?.(args);
-      if (baseDecision?.stop) {
-        return baseDecision;
-      }
-      const bestRecall = bestObservedRecall(args.history);
-      if (bestRecall >= targetRecall) {
-        return {
-          stop: true,
-          reason: `target recall ${targetRecall} reached with train recall ${bestRecall}`
-        };
-      }
-      return { stop: false };
-    }
-  };
-}
-function bestObservedRecall(history) {
-  let best = Number.NEGATIVE_INFINITY;
-  for (const generation of history) {
-    for (const candidate of generation.candidates) {
-      const recall = candidate.dimensions.recall;
-      if (recall !== void 0 && Number.isFinite(recall) && recall > best) {
-        best = recall;
-      }
-    }
-  }
-  return best;
-}
-function retrievalK(config, scenario, defaultK) {
-  const rawK = config.k ?? config.topK ?? scenario.k ?? defaultK;
-  if (typeof rawK !== "number" || !Number.isFinite(rawK) || rawK <= 0) {
-    throw new Error(`retrieval k must be a positive number, got ${String(rawK)}`);
-  }
-  return Math.floor(rawK);
-}
-async function defaultSearchRetriever(input) {
-  if (!input.index) {
-    throw new Error("default retrieval eval search requires an index");
-  }
-  const results = searchKnowledge(input.index, input.scenario.query, input.k);
-  return { hits: results.map(hitFromSearchResult) };
-}
-function hitFromSearchResult(result) {
-  return {
-    pageId: result.page.id,
-    path: result.page.path,
-    title: result.page.title,
-    rank: result.rank,
-    score: result.score,
-    normalizedScore: result.normalizedScore,
-    sourceIds: result.page.sourceIds,
-    snippet: result.snippet
-  };
-}
-function normalizeRetrieverResult(result) {
-  if (isHitArray(result)) {
-    return { hits: result };
-  }
-  return result;
-}
-function normalizeTargets(expected) {
-  return isTargetArray(expected) ? [...expected] : [expected];
-}
-function isHitArray(result) {
-  return Array.isArray(result);
-}
-function isTargetArray(expected) {
-  return Array.isArray(expected);
-}
-function hitMatchesTarget(hit, target) {
-  switch (target.kind) {
-    case "page":
-      return hit.pageId === target.pageId;
-    case "page-path":
-      return hit.path === target.path;
-    case "source":
-      return Boolean(hit.sourceIds?.includes(target.sourceId));
-    case "source-anchor":
-      return Boolean(
-        hit.sourceSpans?.some(
-          (span) => span.sourceId === target.sourceId && span.anchorId === target.anchorId
-        )
-      );
-    case "source-span":
-      return Boolean(
-        hit.sourceSpans?.some(
-          (span) => span.sourceId === target.sourceId && spanOverlaps(span, target)
-        )
-      );
-  }
-}
-function spanOverlaps(hit, target) {
-  if (typeof hit.charStart !== "number" || typeof hit.charEnd !== "number") {
-    return false;
-  }
-  return hit.charStart < target.charEnd && target.charStart < hit.charEnd;
-}
-function retrievalTargetId(target) {
-  switch (target.kind) {
-    case "page":
-      return `page:${target.pageId}`;
-    case "page-path":
-      return `page-path:${target.path}`;
-    case "source":
-      return `source:${target.sourceId}`;
-    case "source-anchor":
-      return `source-anchor:${target.sourceId}:${target.anchorId}`;
-    case "source-span":
-      return `source-span:${target.sourceId}:${target.charStart}:${target.charEnd}`;
-  }
-}
-function idealDcg(count) {
-  let score = 0;
-  for (let i = 1; i <= count; i += 1) {
-    score += 1 / Math.log2(i + 1);
-  }
-  return score;
-}
-function normalizeWeights(weights) {
-  const normalized = {
-    recall: normalizeWeight(weights.recall),
-    mrr: normalizeWeight(weights.mrr),
-    ndcg: normalizeWeight(weights.ndcg),
-    precisionAtK: normalizeWeight(weights.precisionAtK)
-  };
-  const total = normalized.recall + normalized.mrr + normalized.ndcg + normalized.precisionAtK;
-  if (total <= 0) {
-    throw new Error("retrievalRecallJudge requires at least one positive metric weight");
-  }
-  return normalized;
-}
-function normalizeWeight(value) {
-  if (value === void 0) {
-    return 0;
-  }
-  if (!Number.isFinite(value) || value < 0) {
-    throw new Error(
-      `retrievalRecallJudge metric weights must be non-negative finite numbers, got ${String(value)}`
-    );
-  }
-  return value;
-}
-function getConfigPath(config, path) {
-  let current = config;
-  for (const part of path.split(".")) {
-    if (!isJsonObject(current)) {
-      return void 0;
-    }
-    current = current[part];
-  }
-  return current;
-}
-function formatCandidateValue(value) {
-  if (typeof value === "string") {
-    return value;
-  }
-  return canonicalJson(value);
-}
-function canonicalJson(value) {
-  if (value === void 0) {
-    return "undefined";
-  }
-  if (Array.isArray(value)) {
-    return `[${value.map(canonicalJson).join(",")}]`;
-  }
-  if (isJsonObject(value)) {
-    const entries = Object.entries(value).sort(([a], [b]) => a.localeCompare(b)).map(([key, child]) => `${JSON.stringify(key)}:${canonicalJson(child)}`);
-    return `{${entries.join(",")}}`;
-  }
-  return JSON.stringify(value);
-}
-function isJsonObject(value) {
-  return Boolean(value) && typeof value === "object" && !Array.isArray(value);
-}
-function seededShuffle(items, seed) {
-  const out = [...items];
-  let state = seed >>> 0;
-  for (let i = out.length - 1; i > 0; i -= 1) {
-    state = state * 1664525 + 1013904223 >>> 0;
-    const j = state % (i + 1);
-    [out[i], out[j]] = [out[j], out[i]];
-  }
-  return out;
-}
-
-// src/benchmarks/index.ts
-var INDUSTRY_RAG_BENCHMARKS = [
-  {
-    id: "beir",
-    family: "beir",
-    taskKind: "retrieval",
-    primaryMetrics: ["nDCG@10", "Recall@100", "MRR@10"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Classic zero-shot retrieval suites using query/corpus/qrels files."
-  },
-  {
-    id: "mteb-retrieval",
-    family: "mteb-retrieval",
-    taskKind: "retrieval",
-    primaryMetrics: ["nDCG@10", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "MTEB retrieval task shape; same qrels bridge, different dataset provenance."
-  },
-  {
-    id: "msmarco",
-    family: "msmarco",
-    taskKind: "retrieval",
-    primaryMetrics: ["MRR@10", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Passage retrieval and reranking smoke for web-style questions."
-  },
-  {
-    id: "trec-dl",
-    family: "trec-dl",
-    taskKind: "retrieval",
-    primaryMetrics: ["nDCG@10", "MAP", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Deep Learning Track judgments over MS MARCO-derived corpora."
-  },
-  {
-    id: "miracl",
-    family: "miracl",
-    taskKind: "retrieval",
-    primaryMetrics: ["nDCG@10", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Multilingual retrieval; use language tags on cases."
-  },
-  {
-    id: "lotte",
-    family: "lotte",
-    taskKind: "retrieval",
-    primaryMetrics: ["Success@5", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Long-tail search tasks; map collection/domain into tags."
-  },
-  {
-    id: "bright",
-    family: "bright",
-    taskKind: "retrieval",
-    primaryMetrics: ["nDCG@10", "Recall@100"],
-    adapter: "buildRetrievalBenchmarkCasesFromQrels",
-    notes: "Reasoning-heavy retrieval; preserve domain tags for slice reporting."
-  },
-  {
-    id: "crag",
-    family: "crag",
-    taskKind: "rag-answer",
-    primaryMetrics: ["claim_recall", "citation_recall", "hallucination_safe"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Answer quality and freshness cases; use required/forbidden claims plus citations."
-  },
-  {
-    id: "hotpotqa",
-    family: "hotpotqa",
-    taskKind: "rag-answer",
-    primaryMetrics: ["claim_recall", "citation_recall"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Multihop QA; encode each supporting fact as a required claim."
-  },
-  {
-    id: "kilt",
-    family: "kilt",
-    taskKind: "rag-answer",
-    primaryMetrics: ["claim_recall", "citation_recall"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Knowledge-intensive generation with provenance; encode expected pages/sources."
-  },
-  {
-    id: "ragtruth",
-    family: "ragtruth",
-    taskKind: "hallucination",
-    primaryMetrics: ["hallucination_safe", "forbidden_claim_rate"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Hallucination detection; encode hallucinated spans as forbidden claims."
-  },
-  {
-    id: "faithbench",
-    family: "faithbench",
-    taskKind: "hallucination",
-    primaryMetrics: ["hallucination_safe", "forbidden_claim_rate"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Faithfulness benchmark; score unsupported claims as forbidden claims."
-  },
-  {
-    id: "first-party/kb-improvement",
-    family: "first-party",
-    taskKind: "kb-improvement",
-    primaryMetrics: ["claim_recall", "hallucination_safe", "score"],
-    adapter: "KnowledgeAnswerBenchmarkCase",
-    notes: "Project-owned candidate-KB validation; grade the produced KB text or answer bundle."
-  }
-];
-var INDUSTRY_MEMORY_BENCHMARKS = [
-  {
-    id: "locomo/qa",
-    family: "locomo",
-    taskKind: "memory-recall",
-    primaryMetrics: ["memory_fact_recall", "memory_event_recall"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Long-term conversational QA over multi-session histories."
-  },
-  {
-    id: "locomo/event-summary",
-    family: "locomo",
-    taskKind: "memory-summarization",
-    primaryMetrics: ["memory_fact_recall", "memory_event_recall"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Event summarization over long conversational histories."
-  },
-  {
-    id: "longmemeval",
-    family: "longmemeval",
-    taskKind: "memory-temporal",
-    primaryMetrics: ["memory_fact_recall", "memory_stale_safe", "memory_event_recall"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Long-term assistant memory with temporal and update-sensitive probes."
-  },
-  {
-    id: "longmemeval-v2",
-    family: "longmemeval-v2",
-    taskKind: "memory-reasoning",
-    primaryMetrics: ["memory_fact_recall", "memory_event_recall", "score"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Experience reuse from long agent histories; track accuracy and latency."
-  },
-  {
-    id: "memora",
-    family: "memora",
-    taskKind: "memory-update",
-    primaryMetrics: ["memory_fact_recall", "memory_stale_safe", "memory_stale_rate"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Forgetting-aware memory accuracy: reward current facts and penalize obsolete ones."
-  },
-  {
-    id: "memoryagentbench",
-    family: "memoryagentbench",
-    taskKind: "memory-ingest",
-    primaryMetrics: ["memory_fact_recall", "memory_event_recall"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Incremental multi-turn information intake before later recall."
-  },
-  {
-    id: "memorybank",
-    family: "memorybank",
-    taskKind: "memory-recommendation",
-    primaryMetrics: ["memory_fact_recall", "memory_stale_safe"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Personalized memory use for preference-aware downstream choices."
-  },
-  {
-    id: "groupmembench",
-    family: "groupmembench",
-    taskKind: "memory-multiparty",
-    primaryMetrics: ["memory_fact_recall", "memory_actor_recall", "memory_stale_safe"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Multi-party memory with speaker attribution, update, and term ambiguity pressure."
-  },
-  {
-    id: "first-party/memory-lifecycle",
-    family: "first-party",
-    taskKind: "memory-forgetting",
-    primaryMetrics: ["memory_fact_recall", "memory_stale_safe", "memory_event_recall"],
-    adapter: "KnowledgeMemoryBenchmarkCase",
-    notes: "Project-owned lifecycle pack for ingest, recall, update, forgetting, and ambiguity."
-  }
-];
-function buildIndustryRagBenchmarkSmokeCases(specs = INDUSTRY_RAG_BENCHMARKS) {
-  return specs.map((spec) => {
-    const source = {
-      name: spec.id,
-      version: "smoke"
-    };
-    const split = spec.taskKind === "retrieval" ? "search" : "holdout";
-    const tags = unique(["industry-smoke", spec.id, spec.family, spec.taskKind]);
-    if (spec.taskKind === "retrieval") {
-      return {
-        id: `${spec.id}/smoke:q1`,
-        family: spec.family,
-        taskKind: "retrieval",
-        split,
-        tags,
-        source,
-        query: `${spec.id} smoke retrieval query`,
-        expected: [{ kind: "page", pageId: `${spec.id}:doc-1` }],
-        k: 5,
-        metadata: {
-          adapter: spec.adapter,
-          primaryMetrics: spec.primaryMetrics
-        }
-      };
-    }
-    return {
-      id: `${spec.id}/smoke:q1`,
-      family: spec.family,
-      taskKind: spec.taskKind,
-      split,
-      tags,
-      source,
-      prompt: `${spec.id} smoke benchmark prompt`,
-      requiredClaims: [
-        {
-          id: `${spec.id}:required`,
-          anyOf: [`${spec.id} supported answer`]
-        }
-      ],
-      forbiddenClaims: [
-        {
-          id: `${spec.id}:unsupported`,
-          anyOf: [`${spec.id} unsupported claim`]
-        }
-      ],
-      expectedSourceIds: [`${spec.id}:source-1`],
-      referenceAnswer: `${spec.id} supported answer`,
-      metadata: {
-        adapter: spec.adapter,
-        primaryMetrics: spec.primaryMetrics
-      }
-    };
-  });
-}
-function respondToIndustryRagBenchmarkSmokeCase(input) {
-  const testCase = input.case;
-  if (isKnowledgeMemoryBenchmarkCase(testCase)) {
-    return respondToIndustryMemoryBenchmarkSmokeCase({ case: testCase });
-  }
-  if (testCase.taskKind === "retrieval") {
-    const expected = Array.isArray(testCase.expected) ? testCase.expected[0] : testCase.expected;
-    const hit = hitForExpectedTarget(expected, testCase.id);
-    return {
-      hits: [hit],
-      durationMs: 1,
-      metadata: {
-        smoke: true
-      }
-    };
-  }
-  return {
-    answer: (testCase.requiredClaims ?? []).map((claim) => claim.anyOf[0]).filter((fragment) => Boolean(fragment)).join(" "),
-    citedSourceIds: testCase.expectedSourceIds ?? [],
-    durationMs: 1,
-    metadata: {
-      smoke: true
-    }
-  };
-}
-function buildIndustryMemoryBenchmarkSmokeCases(specs = INDUSTRY_MEMORY_BENCHMARKS) {
-  return specs.map((spec) => {
-    const currentEventId = `${spec.id}:event-current`;
-    const staleEventId = `${spec.id}:event-stale`;
-    const actorId = spec.taskKind === "memory-multiparty" ? "teammate-ada" : "user";
-    const currentFact = `${spec.id} current memory`;
-    const staleFact = `${spec.id} stale memory`;
-    return {
-      id: `${spec.id}/smoke:q1`,
-      family: spec.family,
-      taskKind: spec.taskKind,
-      split: spec.taskKind === "memory-forgetting" ? "holdout" : "dev",
-      tags: unique(["memory-smoke", spec.id, spec.family, spec.taskKind]),
-      source: {
-        name: spec.id,
-        version: "smoke"
-      },
-      events: [
-        {
-          id: staleEventId,
-          actorId,
-          sessionId: `${spec.id}:session-1`,
-          timestamp: "2026-01-01T00:00:00.000Z",
-          text: `${actorId} once had this obsolete fact: ${staleFact}.`
-        },
-        {
-          id: currentEventId,
-          actorId,
-          sessionId: `${spec.id}:session-2`,
-          timestamp: "2026-02-01T00:00:00.000Z",
-          text: `${actorId} updated the durable fact to: ${currentFact}.`
-        }
-      ],
-      prompt: `Use memory to answer the ${spec.id} smoke probe.`,
-      requiredFacts: [
-        {
-          id: `${spec.id}:current`,
-          anyOf: [currentFact],
-          sourceEventIds: [currentEventId]
-        }
-      ],
-      forbiddenFacts: [
-        {
-          id: `${spec.id}:stale`,
-          anyOf: [staleFact],
-          sourceEventIds: [staleEventId],
-          obsolete: true
-        }
-      ],
-      expectedEventIds: [currentEventId],
-      expectedActorIds: [actorId],
-      referenceAnswer: currentFact,
-      metadata: {
-        adapter: spec.adapter,
-        primaryMetrics: spec.primaryMetrics
-      }
-    };
-  });
-}
-function respondToIndustryMemoryBenchmarkSmokeCase(input) {
-  const testCase = input.case;
-  const facts = testCase.requiredFacts?.map((fact) => fact.anyOf[0]).filter((fragment) => Boolean(fragment));
-  return {
-    answer: facts?.join(" ") ?? "",
-    rememberedFacts: facts ?? [],
-    citedEventIds: testCase.expectedEventIds ?? [],
-    actorIds: testCase.expectedActorIds ?? [],
-    durationMs: 1,
-    metadata: {
-      smoke: true
-    }
-  };
-}
-function buildFirstPartyMemoryLifecycleBenchmarkCases() {
-  const base = {
-    family: "first-party",
-    source: {
-      name: "first-party/memory-lifecycle",
-      version: "real-v1"
-    }
-  };
-  return [
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:allergy",
-      taskKind: "memory-ingest",
-      split: "dev",
-      actorId: "user",
-      prompt: "What food restriction should catering remember for this user?",
-      staleText: "The user said they had no food allergies on the first onboarding form.",
-      currentText: "The user later corrected the profile: they have a severe peanut allergy.",
-      required: "severe peanut allergy",
-      forbidden: "no food allergies"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:account-tier",
-      taskKind: "memory-recall",
-      split: "dev",
-      actorId: "sales-ops",
-      prompt: "What is the customer account tier now?",
-      staleText: "Sales ops originally marked the customer as starter tier.",
-      currentText: "Sales ops updated the customer to enterprise tier after procurement approval.",
-      required: "enterprise tier",
-      forbidden: "starter tier"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:launch-date",
-      taskKind: "memory-temporal",
-      split: "holdout",
-      actorId: "pm",
-      prompt: "What launch date should the agent use?",
-      staleText: "The PM first planned the launch for April 3.",
-      currentText: "The PM moved the launch date to April 17 after legal review.",
-      required: "April 17",
-      forbidden: "April 3"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:briefing-channel",
-      taskKind: "memory-update",
-      split: "holdout",
-      actorId: "user",
-      prompt: "How should daily briefings be delivered now?",
-      staleText: "The user used to want daily briefings by SMS.",
-      currentText: "The user changed daily briefings to email only.",
-      required: "email only",
-      forbidden: "SMS"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:shipping-address",
-      taskKind: "memory-forgetting",
-      split: "holdout",
-      actorId: "user",
-      prompt: "What shipping address is current?",
-      staleText: "The old shipping address was 14 Pine Street, Apartment 2.",
-      currentText: "The current shipping address is 88 Cedar Avenue, Suite 9.",
-      required: "88 Cedar Avenue, Suite 9",
-      forbidden: "14 Pine Street"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:approval-owner",
-      taskKind: "memory-reasoning",
-      split: "holdout",
-      actorId: "finance",
-      prompt: "Who owns travel approval now?",
-      staleText: "Finance said Liam owned travel approvals last quarter.",
-      currentText: "Finance reassigned travel approvals to Maya this quarter.",
-      required: "Maya",
-      forbidden: "Liam"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:project-summary",
-      taskKind: "memory-summarization",
-      split: "dev",
-      actorId: "pm",
-      prompt: "Summarize the current Project Orion risks.",
-      staleText: "The old Project Orion risk was logo color churn.",
-      currentText: "The current Project Orion risks are vendor delay and a QA staffing gap.",
-      required: "vendor delay",
-      extraRequired: "QA staffing gap",
-      forbidden: "logo color churn"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:meeting-format",
-      taskKind: "memory-recommendation",
-      split: "holdout",
-      actorId: "user",
-      prompt: "What meeting format should the agent recommend?",
-      staleText: "The user previously preferred long video calls for planning.",
-      currentText: "The user now prefers async docs for planning instead of video calls.",
-      required: "async docs",
-      forbidden: "long video calls"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:multiparty-ada",
-      taskKind: "memory-multiparty",
-      split: "holdout",
-      actorId: "ada",
-      prompt: "Which SDK language did Ada ask for?",
-      staleText: "Ben asked for a Python notebook example.",
-      currentText: "Ada asked for a Rust SDK example.",
-      required: "Rust SDK",
-      forbidden: "Python notebook"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:timezone",
-      taskKind: "memory-recall",
-      split: "dev",
-      actorId: "user",
-      prompt: "What timezone should scheduling use for this user?",
-      staleText: "The user profile originally listed Pacific time.",
-      currentText: "The user corrected scheduling to America/Denver time.",
-      required: "America/Denver",
-      forbidden: "Pacific time"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:dinner-preference",
-      taskKind: "memory-update",
-      split: "holdout",
-      actorId: "user",
-      prompt: "What dinner preference should the assistant use?",
-      staleText: "The user was previously vegetarian for team dinners.",
-      currentText: "The user updated dinner restrictions to no shellfish.",
-      required: "no shellfish",
-      forbidden: "vegetarian"
-    }),
-    memoryLifecycleCase({
-      ...base,
-      id: "first-party/memory-lifecycle:support-sla",
-      taskKind: "memory-temporal",
-      split: "holdout",
-      actorId: "support-lead",
-      prompt: "What support SLA is current?",
-      staleText: "Support used to promise a 24 hour response SLA.",
-      currentText: "Support changed the current response SLA to 2 business hours.",
-      required: "2 business hours",
-      forbidden: "24 hour"
-    })
-  ];
-}
-function createMemoryAdapterBenchmarkResponder(options) {
-  return async ({ case: testCase, context: dispatchContext }) => {
-    if (!isKnowledgeMemoryBenchmarkCase(testCase)) {
-      return { answer: "", metadata: { candidateId: options.candidateId, skipped: true } };
-    }
-    const costUsd = options.costUsdPerCase ?? 0;
-    if (!Number.isFinite(costUsd) || costUsd < 0) {
-      throw new Error(`memory adapter costUsdPerCase must be non-negative finite, got ${costUsd}`);
-    }
-    const execute = async () => {
-      const startedAt = Date.now();
-      const scope = benchmarkMemoryScope(options.candidateId, testCase, options.scope);
-      for (const event of testCase.events) {
-        await options.adapter.write({
-          id: event.id,
-          kind: "message",
-          text: event.text,
-          role: event.actorId === "user" ? "user" : "assistant",
-          title: `${testCase.id}:${event.id}`,
-          scope,
-          metadata: compactObject({
-            benchmarkCaseId: testCase.id,
-            eventId: event.id,
-            actorId: event.actorId,
-            sessionId: event.sessionId,
-            timestamp: event.timestamp,
-            ...event.metadata
-          })
-        });
-      }
-      const adapterContext = await options.adapter.getContext(testCase.prompt, {
-        scope,
-        limit: options.searchLimit ?? 1,
-        metadata: {
-          benchmarkCaseId: testCase.id,
-          candidateId: options.candidateId
-        }
-      });
-      const hits = adapterContext.hits;
-      return {
-        answer: adapterContext.text,
-        rememberedFacts: hits.map((hit) => hit.text),
-        citedEventIds: unique(hits.map(memoryEventId).filter((id) => Boolean(id))),
-        usedMemoryIds: hits.map((hit) => hit.id),
-        actorIds: unique(hits.map(memoryActorId).filter((id) => Boolean(id))),
-        costUsd,
-        durationMs: Math.max(0, Date.now() - startedAt),
-        metadata: {
-          candidateId: options.candidateId,
-          adapterId: options.adapter.id,
-          hitCount: hits.length
-        }
-      };
-    };
-    if (costUsd === 0) return execute();
-    const receipt = {
-      model: options.adapter.id,
-      inputTokens: 0,
-      outputTokens: 0,
-      usageUnknown: true,
-      actualCostUsd: costUsd
-    };
-    const paid = await dispatchContext.cost.runPaidCall({
-      actor: `agent-knowledge:memory-adapter:${options.adapter.id}`,
-      model: options.adapter.id,
-      maximumCharge: { externallyEnforcedMaximumUsd: costUsd },
-      execute,
-      receipt: () => receipt,
-      receiptFromError: () => receipt
-    });
-    if (!paid.succeeded) throw paid.error;
-    return paid.value;
-  };
-}
-async function runMemoryAdapterBenchmark(options) {
-  const storage = options.storage ?? fsCampaignStorage();
-  const rows = [];
-  for (const candidate of options.candidates) {
-    const adapter = await candidate.createAdapter();
-    const run = await runKnowledgeBenchmarkSuite({
-      cases: options.cases,
-      respond: createMemoryAdapterBenchmarkResponder({
-        adapter,
-        candidateId: candidate.id,
-        searchLimit: candidate.searchLimit,
-        scope: candidate.scope,
-        costUsdPerCase: candidate.costUsdPerCase,
-        now: options.now
-      }),
-      runDir: join(options.runDir, candidate.id),
-      storage,
-      repo: options.repo,
-      seed: options.seed,
-      reps: options.reps,
-      resumable: options.resumable,
-      costCeiling: options.costCeiling,
-      maxConcurrency: options.maxConcurrency,
-      dispatchTimeoutMs: options.dispatchTimeoutMs,
-      expectUsage: options.expectUsage ?? "off",
-      now: options.now
-    });
-    rows.push({
-      rank: 0,
-      candidateId: candidate.id,
-      label: candidate.label ?? candidate.id,
-      adapterId: adapter.id,
-      scoreMean: run.report.score.mean,
-      passRate: run.report.dimensions.passed?.mean ?? 0,
-      totalCases: run.report.totalCases,
-      totalCells: run.report.totalCells,
-      cellsFailed: run.report.cellsFailed,
-      totalCostUsd: run.report.totalCostUsd,
-      reportJsonPath: run.reportJsonPath,
-      reportMarkdownPath: run.reportMarkdownPath,
-      report: run.report
-    });
-    await adapter.flush?.();
-  }
-  const ranked = rows.sort((a, b) => b.scoreMean - a.scoreMean || a.totalCostUsd - b.totalCostUsd).map((row, index) => ({ ...row, rank: index + 1 }));
-  const rankingJsonPath = join(options.runDir, "memory-adapter-ranking.json");
-  const rankingMarkdownPath = join(options.runDir, "memory-adapter-ranking.md");
-  storage.write(rankingJsonPath, `${JSON.stringify({ rows: ranked }, null, 2)}
-`);
-  storage.write(rankingMarkdownPath, renderMemoryAdapterRankingMarkdown(ranked));
-  return {
-    rows: ranked,
-    rankingJsonPath,
-    rankingMarkdownPath
-  };
-}
-function createNoopMemoryBenchmarkAdapter(id = "no-memory") {
-  return {
-    id,
-    async search() {
-      return [];
-    },
-    async getContext(query) {
-      return { query, text: "", hits: [], sourceRecords: [] };
-    },
-    async write(input) {
-      return {
-        accepted: false,
-        id: input.id ?? `${id}:ignored`,
-        uri: `memory://${id}/ignored`,
-        kind: input.kind
-      };
-    },
-    async flush() {
-    }
-  };
-}
-function createInMemoryBenchmarkAdapter(options = {}) {
-  const id = options.id ?? "in-memory";
-  const rows = [];
-  let seq = 0;
-  const adapter = {
-    id,
-    async search(query, searchOptions = {}) {
-      const scored = rows.filter((row) => memoryScopeMatches(row.input.scope, searchOptions.scope)).filter((row) => !searchOptions.kinds?.length || searchOptions.kinds.includes(row.hit.kind)).map((row) => {
-        const lexical = tokenOverlap(query, row.hit.text);
-        const recency = row.seq / Math.max(1, seq);
-        return {
-          ...row.hit,
-          score: lexical + recency * 0.01,
-          normalizedScore: lexical
-        };
-      }).filter(
-        (hit) => searchOptions.minScore === void 0 ? true : hit.score >= searchOptions.minScore
-      ).sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
-      return scored.slice(0, searchOptions.limit ?? 5);
-    },
-    async getContext(query, searchOptions = {}) {
-      const hits = await adapter.search(query, searchOptions);
-      return {
-        query,
-        hits,
-        sourceRecords: hits.map(
-          (hit) => memoryHitToSourceRecord(hit, { scope: searchOptions.scope })
-        ),
-        text: renderMemoryHits(hits)
-      };
-    },
-    async write(input) {
-      seq += 1;
-      const memoryId = input.id ?? `${id}:${seq}`;
-      const hit = {
-        id: memoryId,
-        uri: `memory://${id}/${encodeURIComponent(memoryId)}`,
-        kind: input.kind,
-        text: input.text,
-        title: input.title,
-        score: 1,
-        normalizedScore: 1,
-        createdAt: input.metadata?.timestamp,
-        metadata: {
-          ...input.metadata ?? {},
-          scope: input.scope
-        }
-      };
-      rows.push({ seq, input, hit });
-      return {
-        accepted: true,
-        id: memoryId,
-        uri: hit.uri,
-        kind: input.kind,
-        sourceRecord: memoryWriteResultToSourceRecord(
-          {
-            accepted: true,
-            id: memoryId,
-            uri: hit.uri,
-            kind: input.kind,
-            metadata: hit.metadata
-          },
-          input.text,
-          { scope: input.scope }
-        ),
-        metadata: hit.metadata
-      };
-    },
-    async flush() {
-      rows.length = 0;
-      seq = 0;
-    }
-  };
-  return adapter;
-}
-function parseKnowledgeBenchmarkJsonl(text) {
-  return text.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line, index) => {
-    try {
-      return JSON.parse(line);
-    } catch (error) {
-      throw new Error(`invalid JSONL row ${index + 1}: ${error.message}`);
-    }
-  });
-}
-function parseKnowledgeBenchmarkQrels(text) {
-  return text.split(/\r?\n/).map((line) => line.trim()).filter((line) => line && !line.startsWith("#")).flatMap((line, index) => {
-    const parts = line.split(/\t|\s+/);
-    if (parts.length < 3) return [];
-    const [queryId, maybeZeroOrDocId, maybeDocIdOrScore, maybeScore] = parts;
-    if (!queryId || !maybeZeroOrDocId || !maybeDocIdOrScore) return [];
-    if (queryId.toLowerCase() === "qid" || queryId.toLowerCase() === "query-id") return [];
-    const documentId = maybeScore === void 0 ? maybeZeroOrDocId : maybeDocIdOrScore;
-    const scoreText = maybeScore === void 0 ? maybeDocIdOrScore : maybeScore;
-    const score = Number(scoreText);
-    if (!documentId || !Number.isFinite(score)) {
-      throw new Error(`invalid qrels row ${index + 1}: expected query id, doc id, score`);
-    }
-    return [{ queryId, documentId, score }];
-  });
-}
-function buildRetrievalBenchmarkCasesFromQrels(options) {
-  const qrelsByQuery = /* @__PURE__ */ new Map();
-  for (const qrel of options.qrels) {
-    if (qrel.score <= 0) continue;
-    const list = qrelsByQuery.get(qrel.queryId) ?? [];
-    list.push(qrel);
-    qrelsByQuery.set(qrel.queryId, list);
-  }
-  return options.queries.flatMap((query) => {
-    const qrels = qrelsByQuery.get(query.id) ?? [];
-    if (qrels.length === 0) return [];
-    const split = query.split ?? options.splitOf?.(query.id);
-    const expected = qrels.map(
-      (qrel) => options.documentTarget ? options.documentTarget(qrel.documentId, qrel) : defaultDocumentTarget(qrel.documentId, options.targetKind ?? "page")
-    );
-    return [
-      compactObject({
-        id: `${options.benchmarkId}:${query.id}`,
-        family: options.family,
-        taskKind: "retrieval",
-        query: query.text,
-        expected,
-        k: options.k,
-        split,
-        tags: unique([...options.tags ?? [], ...query.tags ?? [], ...split ? [split] : []]),
-        source: options.source,
-        metadata: query.metadata
-      })
-    ];
-  });
-}
-async function runKnowledgeBenchmarkSuite(options) {
-  const storage = options.storage ?? fsCampaignStorage();
-  const scenarios = buildKnowledgeBenchmarkScenarios(options.cases, options.splits);
-  const dispatch = async (scenario, context) => {
-    const artifact = await options.respond({ case: scenario.case, scenario, context });
-    return artifact;
-  };
-  const campaign = await runCampaign({
-    scenarios,
-    dispatch,
-    dispatchRef: "agent-knowledge:benchmark-suite",
-    judges: [knowledgeBenchmarkJudge()],
-    runDir: options.runDir,
-    repo: options.repo,
-    seed: options.seed,
-    reps: options.reps,
-    resumable: options.resumable,
-    costCeiling: options.costCeiling,
-    maxConcurrency: options.maxConcurrency,
-    dispatchTimeoutMs: options.dispatchTimeoutMs,
-    expectUsage: options.expectUsage ?? "off",
-    storage,
-    now: options.now
-  });
-  const report = summarizeKnowledgeBenchmarkCampaign({ scenarios, campaign });
-  const reportJsonPath = join(campaign.runDir, "knowledge-benchmark-report.json");
-  const reportMarkdownPath = join(campaign.runDir, "knowledge-benchmark-report.md");
-  storage.write(reportJsonPath, `${JSON.stringify(report, null, 2)}
-`);
-  storage.write(reportMarkdownPath, renderKnowledgeBenchmarkReportMarkdown(report));
-  return {
-    scenarios,
-    campaign,
-    report,
-    reportJsonPath,
-    reportMarkdownPath
-  };
-}
-function renderKnowledgeBenchmarkReportMarkdown(report) {
-  return [
-    "# Knowledge Benchmark Report",
-    "",
-    `- cases: ${report.totalCases}`,
-    `- cells: ${report.totalCells} total, ${report.cellsFailed} failed, ${report.cellsCached} cached`,
-    `- cost: $${formatNumber(report.totalCostUsd)}`,
-    `- score: mean ${formatNumber(report.score.mean)}, median ${formatNumber(report.score.median)}, p90 ${formatNumber(report.score.p90)}, n=${report.score.n}`,
-    "",
-    "## Task Kinds",
-    "",
-    renderSliceTable(report.byTaskKind),
-    "",
-    "## Splits",
-    "",
-    renderSliceTable(report.bySplit),
-    "",
-    "## Dimensions",
-    "",
-    "| dimension | n | mean | p90 |",
-    "| --- | ---: | ---: | ---: |",
-    ...Object.entries(report.dimensions).sort(([a], [b]) => a.localeCompare(b)).map(
-      ([key, dist]) => `| ${key} | ${dist.n} | ${formatNumber(dist.mean)} | ${formatNumber(dist.p90)} |`
-    ),
-    ""
-  ].join("\n");
-}
-function buildKnowledgeBenchmarkScenarios(cases, splits) {
-  const splitSet = splits ? new Set(splits) : null;
-  return cases.flatMap((testCase) => {
-    const splitTag = testCase.split ?? "dev";
-    if (splitSet && !splitSet.has(splitTag)) return [];
-    return [
-      compactObject({
-        id: testCase.id,
-        kind: "knowledge-benchmark",
-        family: testCase.family,
-        taskKind: testCase.taskKind,
-        splitTag,
-        tags: unique([splitTag, ...testCase.tags ?? []]),
-        case: compactObject(testCase)
-      })
-    ];
-  });
-}
-function knowledgeBenchmarkJudge() {
-  return {
-    name: "knowledge-benchmark",
-    dimensions: [
-      { key: "score", description: "primary knowledge benchmark score" },
-      { key: "passed", description: "1 when the benchmark case passes" },
-      { key: "claim_recall", description: "required claim coverage" },
-      { key: "citation_recall", description: "expected citation/source coverage" },
-      { key: "hallucination_safe", description: "1 when no forbidden claim appears" },
-      { key: "memory_fact_recall", description: "current memory fact coverage" },
-      { key: "memory_event_recall", description: "expected memory event/source coverage" },
-      { key: "memory_stale_safe", description: "1 when obsolete memory is not reused" },
-      { key: "memory_actor_recall", description: "expected speaker/user attribution coverage" }
-    ],
-    appliesTo: (scenario) => scenario.kind === "knowledge-benchmark",
-    score({ artifact, scenario }) {
-      const evaluation = scoreKnowledgeBenchmarkArtifact(scenario.case, artifact);
-      return {
-        dimensions: {
-          score: evaluation.score,
-          passed: evaluation.passed ? 1 : 0,
-          ...evaluation.dimensions
-        },
-        composite: evaluation.score,
-        notes: evaluation.notes
-      };
-    }
-  };
-}
-function scoreKnowledgeBenchmarkArtifact(testCase, artifact) {
-  if (testCase.taskKind === "retrieval") {
-    const retrievalArtifact = normalizeRetrievalArtifact(testCase, artifact);
-    const metrics = scoreRetrievalArtifact(retrievalArtifact, retrievalScenarioForCase(testCase));
-    return {
-      score: metrics.recall,
-      passed: metrics.recall >= 1,
-      dimensions: {
-        recall: metrics.recall,
-        mrr: metrics.mrr,
-        ndcg: metrics.ndcg,
-        precision_at_k: metrics.precisionAtK,
-        expected_count: metrics.expectedCount,
-        matched_count: metrics.matchedCount
-      },
-      notes: `matched ${metrics.matchedCount}/${metrics.expectedCount}; first_hit_rank=${metrics.firstHitRank ?? "none"}`,
-      raw: { matchedTargetIds: metrics.matchedTargetIds }
-    };
-  }
-  if (isKnowledgeMemoryBenchmarkCase(testCase)) {
-    return scoreMemoryBenchmarkArtifact(testCase, artifact);
-  }
-  const answerArtifact = artifact;
-  const text = answerArtifact.text ?? answerArtifact.answer ?? "";
-  const required = scoreClaims(text, testCase.requiredClaims ?? []);
-  const forbidden = scoreForbiddenClaims(text, testCase.forbiddenClaims ?? []);
-  const citation = scoreCitationRecall(
-    answerArtifact.citedSourceIds ?? [],
-    testCase.expectedSourceIds ?? []
-  );
-  const components = [
-    required.totalWeight > 0 ? required.recall : void 0,
-    testCase.expectedSourceIds && testCase.expectedSourceIds.length > 0 ? citation : void 0,
-    forbidden.safe
-  ].filter((value) => value !== void 0);
-  const score = mean(components);
-  return {
-    score,
-    passed: score >= 1,
-    dimensions: {
-      claim_recall: required.recall,
-      citation_recall: citation,
-      hallucination_safe: forbidden.safe,
-      forbidden_claim_rate: forbidden.rate,
-      required_claim_count: required.total,
-      matched_claim_count: required.matched,
-      forbidden_claim_count: forbidden.total,
-      matched_forbidden_claim_count: forbidden.matched
-    },
-    notes: `required=${required.matched}/${required.total}; forbidden=${forbidden.matched}/${forbidden.total}; citation_recall=${citation.toFixed(3)}`,
-    raw: {
-      matchedRequiredClaimIds: required.matchedIds,
-      matchedForbiddenClaimIds: forbidden.matchedIds
-    }
-  };
-}
-function summarizeKnowledgeBenchmarkCampaign(input) {
-  const scenariosById = new Map(input.scenarios.map((scenario) => [scenario.id, scenario]));
-  const rows = input.campaign.cells.map((cell) => {
-    const score = Object.values(cell.judgeScores)[0];
-    const scenario = scenariosById.get(cell.scenarioId);
-    return {
-      cell,
-      scenario,
-      composite: score?.composite ?? 0,
-      passed: (score?.dimensions.passed ?? 0) >= 1,
-      dimensions: score?.dimensions ?? {}
-    };
-  });
-  const successful = rows.filter((row) => !row.cell.error);
-  return {
-    totalCases: input.scenarios.length,
-    totalCells: input.campaign.cells.length,
-    cellsFailed: input.campaign.aggregates.cellsFailed,
-    cellsCached: input.campaign.aggregates.cellsCached,
-    totalCostUsd: input.campaign.aggregates.totalCostUsd,
-    bySplit: summarizeSlices(successful, (row) => row.scenario?.splitTag ?? "unknown"),
-    byFamily: summarizeSlices(successful, (row) => row.scenario?.family ?? "unknown"),
-    byTaskKind: summarizeSlices(successful, (row) => row.scenario?.taskKind ?? "unknown"),
-    dimensions: summarizeDimensions(successful.map((row) => row.dimensions)),
-    score: distribution(successful.map((row) => row.composite))
-  };
-}
-function scoreMemoryBenchmarkArtifact(testCase, artifact) {
-  const memoryArtifact = artifact;
-  const text = [
-    memoryArtifact.text,
-    memoryArtifact.answer,
-    ...memoryArtifact.rememberedFacts ?? []
-  ].filter((part) => typeof part === "string" && part.length > 0).join("\n");
-  const required = scoreClaims(text, testCase.requiredFacts ?? []);
-  const forbidden = scoreForbiddenClaims(text, testCase.forbiddenFacts ?? []);
-  const eventIds = unique([
-    ...memoryArtifact.citedEventIds ?? [],
-    ...memoryArtifact.usedMemoryIds ?? []
-  ]);
-  const eventRecall = scoreCitationRecall(eventIds, testCase.expectedEventIds ?? []);
-  const actorRecall = scoreCitationRecall(
-    memoryArtifact.actorIds ?? [],
-    testCase.expectedActorIds ?? []
-  );
-  const components = [
-    required.totalWeight > 0 ? required.recall : void 0,
-    testCase.expectedEventIds && testCase.expectedEventIds.length > 0 ? eventRecall : void 0,
-    testCase.expectedActorIds && testCase.expectedActorIds.length > 0 ? actorRecall : void 0,
-    forbidden.safe
-  ].filter((value) => value !== void 0);
-  const score = mean(components);
-  return {
-    score,
-    passed: score >= 1,
-    dimensions: {
-      memory_fact_recall: required.recall,
-      memory_event_recall: eventRecall,
-      memory_actor_recall: actorRecall,
-      memory_stale_safe: forbidden.safe,
-      memory_stale_rate: forbidden.rate,
-      memory_required_fact_count: required.total,
-      memory_matched_fact_count: required.matched,
-      memory_forbidden_fact_count: forbidden.total,
-      memory_matched_forbidden_fact_count: forbidden.matched
-    },
-    notes: `memory required=${required.matched}/${required.total}; stale=${forbidden.matched}/${forbidden.total}; event_recall=${eventRecall.toFixed(3)}; actor_recall=${actorRecall.toFixed(3)}`,
-    raw: {
-      matchedRequiredFactIds: required.matchedIds,
-      matchedForbiddenFactIds: forbidden.matchedIds,
-      citedEventIds: eventIds,
-      actorIds: memoryArtifact.actorIds ?? []
-    }
-  };
-}
-function retrievalScenarioForCase(testCase) {
-  return {
-    id: testCase.id,
-    kind: "retrieval-eval",
-    query: testCase.query,
-    expected: testCase.expected,
-    ...testCase.k !== void 0 ? { k: testCase.k } : {}
-  };
-}
-function normalizeRetrievalArtifact(testCase, artifact) {
-  const maybe = artifact;
-  const hits = maybe.hits ?? [];
-  if (Array.isArray(maybe.hits) && maybe.query && maybe.requestedK !== void 0) {
-    return maybe;
-  }
-  return {
-    config: {},
-    query: testCase.query,
-    requestedK: testCase.k ?? Math.max(1, hits.length),
-    hits,
-    durationMs: maybe.durationMs ?? 0,
-    ...maybe.costUsd !== void 0 ? { costUsd: maybe.costUsd } : {},
-    ...maybe.metadata ? { metadata: maybe.metadata } : {}
-  };
-}
-function defaultDocumentTarget(documentId, targetKind) {
-  switch (targetKind) {
-    case "page":
-      return { kind: "page", pageId: documentId };
-    case "page-path":
-      return { kind: "page-path", path: documentId };
-    case "source":
-      return { kind: "source", sourceId: documentId };
-  }
-}
-function hitForExpectedTarget(expected, fallbackId) {
-  if (!expected) {
-    return {
-      pageId: fallbackId,
-      path: `${fallbackId}.md`,
-      rank: 1
-    };
-  }
-  switch (expected.kind) {
-    case "page":
-      return {
-        pageId: expected.pageId,
-        path: `${expected.pageId}.md`,
-        rank: 1
-      };
-    case "page-path":
-      return {
-        pageId: expected.path,
-        path: expected.path,
-        rank: 1
-      };
-    case "source":
-      return {
-        pageId: expected.sourceId,
-        path: `${expected.sourceId}.md`,
-        sourceIds: [expected.sourceId],
-        rank: 1
-      };
-    case "source-anchor":
-      return {
-        pageId: expected.sourceId,
-        path: `${expected.sourceId}.md`,
-        sourceIds: [expected.sourceId],
-        sourceSpans: [{ sourceId: expected.sourceId, anchorId: expected.anchorId }],
-        rank: 1
-      };
-    case "source-span":
-      return {
-        pageId: expected.sourceId,
-        path: `${expected.sourceId}.md`,
-        sourceIds: [expected.sourceId],
-        sourceSpans: [
-          {
-            sourceId: expected.sourceId,
-            charStart: expected.charStart,
-            charEnd: expected.charEnd
-          }
-        ],
-        rank: 1
-      };
-  }
-}
-function memoryLifecycleCase(input) {
-  const staleEventId = `${input.id}:stale`;
-  const currentEventId = `${input.id}:current`;
-  return {
-    id: input.id,
-    family: input.family,
-    taskKind: input.taskKind,
-    split: input.split,
-    tags: unique(["first-party-memory-lifecycle", input.taskKind, input.split]),
-    source: input.source,
-    events: [
-      {
-        id: staleEventId,
-        actorId: input.actorId,
-        sessionId: `${input.id}:session-1`,
-        timestamp: "2026-01-01T00:00:00.000Z",
-        text: input.staleText
-      },
-      {
-        id: currentEventId,
-        actorId: input.actorId,
-        sessionId: `${input.id}:session-2`,
-        timestamp: "2026-02-01T00:00:00.000Z",
-        text: input.currentText
-      }
-    ],
-    prompt: input.prompt,
-    requiredFacts: [
-      {
-        id: `${input.id}:required-1`,
-        anyOf: [input.required],
-        sourceEventIds: [currentEventId]
-      },
-      ...input.extraRequired ? [
-        {
-          id: `${input.id}:required-2`,
-          anyOf: [input.extraRequired],
-          sourceEventIds: [currentEventId]
-        }
-      ] : []
-    ],
-    forbiddenFacts: [
-      {
-        id: `${input.id}:stale`,
-        anyOf: [input.forbidden],
-        sourceEventIds: [staleEventId],
-        obsolete: true
-      }
-    ],
-    expectedEventIds: [currentEventId],
-    expectedActorIds: [input.actorId],
-    referenceAnswer: input.required
-  };
-}
-function renderMemoryAdapterRankingMarkdown(rows) {
-  return [
-    "# Memory Adapter Ranking",
-    "",
-    "| rank | candidate | adapter | cases | cells | failed | mean score | pass rate | cost |",
-    "| ---: | --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |",
-    ...rows.map(
-      (row) => `| ${row.rank} | ${row.label} | ${row.adapterId} | ${row.totalCases} | ${row.totalCells} | ${row.cellsFailed} | ${formatNumber(row.scoreMean)} | ${formatNumber(row.passRate)} | $${formatNumber(row.totalCostUsd)} |`
-    ),
-    ""
-  ].join("\n");
-}
-function benchmarkMemoryScope(candidateId, testCase, scope = {}) {
-  return {
-    ...scope,
-    namespace: scope.namespace ?? "agent-knowledge-memory-benchmark",
-    tags: {
-      ...scope.tags ?? {},
-      benchmarkCandidateId: candidateId,
-      benchmarkCaseId: testCase.id
-    }
-  };
-}
-function memoryEventId(hit) {
-  const eventId = hit.metadata?.eventId;
-  return typeof eventId === "string" ? eventId : void 0;
-}
-function memoryActorId(hit) {
-  const actorId = hit.metadata?.actorId;
-  return typeof actorId === "string" ? actorId : void 0;
-}
-function memoryScopeMatches(stored, requested) {
-  if (!requested) return true;
-  if (requested.tenantId !== void 0 && stored?.tenantId !== requested.tenantId) return false;
-  if (requested.userId !== void 0 && stored?.userId !== requested.userId) return false;
-  if (requested.sessionId !== void 0 && stored?.sessionId !== requested.sessionId) return false;
-  if (requested.namespace !== void 0 && stored?.namespace !== requested.namespace) return false;
-  for (const [key, value] of Object.entries(requested.tags ?? {})) {
-    if (stored?.tags?.[key] !== value) return false;
-  }
-  return true;
-}
-function tokenOverlap(query, text) {
-  const queryTokens = new Set(tokenize(query));
-  if (queryTokens.size === 0) return 0;
-  const textTokens = new Set(tokenize(text));
-  let matched = 0;
-  for (const token of queryTokens) {
-    if (textTokens.has(token)) matched += 1;
-  }
-  return matched / queryTokens.size;
-}
-function tokenize(text) {
-  const stop = /* @__PURE__ */ new Set([
-    "the",
-    "and",
-    "for",
-    "this",
-    "that",
-    "with",
-    "what",
-    "should",
-    "agent",
-    "user",
-    "current",
-    "now",
-    "use"
-  ]);
-  return text.toLowerCase().split(/[^a-z0-9/]+/).filter((token) => token.length > 2 && !stop.has(token));
-}
-function renderMemoryHits(hits) {
-  return hits.map((hit, index) => {
-    const eventId = memoryEventId(hit);
-    const actorId = memoryActorId(hit);
-    return [
-      `[${index + 1}] ${hit.title ?? hit.id}`,
-      eventId ? `event=${eventId}` : "",
-      actorId ? `actor=${actorId}` : "",
-      hit.text
-    ].filter(Boolean).join("\n");
-  }).join("\n\n");
-}
-function isKnowledgeMemoryBenchmarkCase(testCase) {
-  return testCase.taskKind.startsWith("memory-");
-}
-function scoreClaims(text, claims) {
-  let matched = 0;
-  let matchedWeight = 0;
-  let totalWeight = 0;
-  const matchedIds = [];
-  const haystack = text.toLowerCase();
-  for (const claim of claims) {
-    const weight = claim.weight ?? 1;
-    totalWeight += weight;
-    if (claim.anyOf.some((fragment) => haystack.includes(fragment.toLowerCase()))) {
-      matched += 1;
-      matchedWeight += weight;
-      matchedIds.push(claim.id);
-    }
-  }
-  return {
-    total: claims.length,
-    matched,
-    totalWeight,
-    recall: totalWeight === 0 ? 1 : matchedWeight / totalWeight,
-    matchedIds
-  };
-}
-function scoreForbiddenClaims(text, claims) {
-  const matched = scoreClaims(text, claims);
-  return {
-    total: claims.length,
-    matched: matched.matched,
-    matchedIds: matched.matchedIds,
-    rate: claims.length === 0 ? 0 : matched.matched / claims.length,
-    safe: matched.matched === 0 ? 1 : 0
-  };
-}
-function scoreCitationRecall(citedSourceIds, expectedSourceIds) {
-  if (expectedSourceIds.length === 0) return 1;
-  const cited = new Set(citedSourceIds);
-  const matched = expectedSourceIds.filter((sourceId) => cited.has(sourceId)).length;
-  return matched / expectedSourceIds.length;
-}
-function summarizeDimensions(rows) {
-  const values = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    for (const [key, value] of Object.entries(row)) {
-      if (!Number.isFinite(value)) continue;
-      const list = values.get(key) ?? [];
-      list.push(value);
-      values.set(key, list);
-    }
-  }
-  return Object.fromEntries([...values.entries()].map(([key, vals]) => [key, distribution(vals)]));
-}
-function summarizeSlices(rows, keyOf) {
-  const grouped = /* @__PURE__ */ new Map();
-  for (const row of rows) {
-    const key = keyOf(row);
-    const list = grouped.get(key) ?? [];
-    list.push(row);
-    grouped.set(key, list);
-  }
-  return Object.fromEntries(
-    [...grouped.entries()].map(([key, list]) => {
-      const withShape = list;
-      return [
-        key,
-        {
-          n: list.length,
-          meanScore: mean(withShape.map((row) => row.composite)),
-          passRate: mean(withShape.map((row) => row.passed ? 1 : 0)),
-          score: distribution(withShape.map((row) => row.composite))
-        }
-      ];
-    })
-  );
-}
-function distribution(values) {
-  const finite = [...values].filter(Number.isFinite).sort((a, b) => a - b);
-  if (finite.length === 0) return { n: 0, min: 0, mean: 0, median: 0, p90: 0, max: 0 };
-  return {
-    n: finite.length,
-    min: finite[0],
-    mean: mean(finite),
-    median: percentile(finite, 0.5),
-    p90: percentile(finite, 0.9),
-    max: finite[finite.length - 1]
-  };
-}
-function percentile(sortedValues, p) {
-  if (sortedValues.length === 0) return 0;
-  const index = Math.min(
-    sortedValues.length - 1,
-    Math.max(0, Math.ceil(p * sortedValues.length) - 1)
-  );
-  return sortedValues[index];
-}
-function mean(values) {
-  const finite = values.filter(Number.isFinite);
-  if (finite.length === 0) return 0;
-  return finite.reduce((sum, value) => sum + value, 0) / finite.length;
-}
-function unique(values) {
-  return [...new Set(values.filter(Boolean))];
-}
-function renderSliceTable(slices) {
-  const rows = Object.entries(slices).map(
-    ([key, slice]) => `| ${key} | ${slice.n} | ${formatNumber(slice.meanScore)} | ${formatNumber(slice.passRate)} | ${formatNumber(slice.score.p90)} |`
-  );
-  return [
-    "| slice | n | mean score | pass rate | score p90 |",
-    "| --- | ---: | ---: | ---: | ---: |",
-    ...rows.length ? rows : ["| none | 0 | 0 | 0 | 0 |"]
-  ].join("\n");
-}
-function formatNumber(value) {
-  if (!Number.isFinite(value)) return "0";
-  return value.toFixed(value === 0 || Math.abs(value) >= 10 ? 0 : 3);
-}
-function compactObject(value) {
-  if (Array.isArray(value)) return value.map(compactObject);
-  if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(
-    Object.entries(value).filter(([, entry]) => entry !== void 0).map(([key, entry]) => [key, compactObject(entry)])
-  );
-}
-
-export {
-  retrievalConfigSurface,
-  retrievalConfigFromSurface,
-  buildRetrievalEvalDispatch,
-  retrievalRecallJudge,
-  scoreRetrievalArtifact,
-  buildRetrievalParameterCandidates,
-  retrievalParameterSweepProposer,
-  runRetrievalImprovementLoop,
-  INDUSTRY_RAG_BENCHMARKS,
-  INDUSTRY_MEMORY_BENCHMARKS,
-  buildIndustryRagBenchmarkSmokeCases,
-  respondToIndustryRagBenchmarkSmokeCase,
-  buildIndustryMemoryBenchmarkSmokeCases,
-  respondToIndustryMemoryBenchmarkSmokeCase,
-  buildFirstPartyMemoryLifecycleBenchmarkCases,
-  createMemoryAdapterBenchmarkResponder,
-  runMemoryAdapterBenchmark,
-  createNoopMemoryBenchmarkAdapter,
-  createInMemoryBenchmarkAdapter,
-  parseKnowledgeBenchmarkJsonl,
-  parseKnowledgeBenchmarkQrels,
-  buildRetrievalBenchmarkCasesFromQrels,
-  runKnowledgeBenchmarkSuite,
-  renderKnowledgeBenchmarkReportMarkdown,
-  buildKnowledgeBenchmarkScenarios,
-  knowledgeBenchmarkJudge,
-  scoreKnowledgeBenchmarkArtifact,
-  summarizeKnowledgeBenchmarkCampaign,
-  scoreMemoryBenchmarkArtifact,
-  isKnowledgeMemoryBenchmarkCase
-};
-//# sourceMappingURL=chunk-RIHIYCX2.js.map