@remnic/bench 9.7.0 → 9.7.1

package/dist/index.d.ts

@@ -3214,6 +3214,26 @@ interface DiagnoseLoComoProfileDeltaOptions {
 declare function diagnoseLoComoProfileDelta(options: DiagnoseLoComoProfileDeltaOptions): LoComoProfileDeltaReport;
 declare function renderLoComoProfileDeltaMarkdown(report: LoComoProfileDeltaReport): string;
 
+declare const LOCOMO_TASK_SELECTION_VERSION: 1;
+type LoCoMoTaskSelector = {
+    taskIds: readonly string[];
+    sampleSize?: never;
+    seed?: never;
+} | {
+    taskIds?: never;
+    sampleSize: number;
+    seed: number;
+};
+interface LoCoMoTaskSelectionManifest {
+    algorithm: "explicit-task-ids" | "sha256-seeded-sample";
+    version: typeof LOCOMO_TASK_SELECTION_VERSION;
+    seed?: number;
+    candidateCount: number;
+    selectedCount: number;
+    selectedTaskIds: string[];
+    selectedTaskIdsSha256: string;
+}
+
 declare const LOCOMO_FULL_TASK_COUNT = 1986;
 declare const LOCOMO_RECALL_EXCERPT_CHARS = 240;
 declare const LOCOMO_RECALL_DIFF_LINE_LIMIT = 20;
@@ -3289,6 +3309,7 @@ interface LoComoRecallResultProvenance {
     judgeModel: string;
     seeds: number[];
     taskPayloadSha256: string;
+    taskSelection?: LoCoMoTaskSelectionManifest;
 }
 interface LoComoRecallDeltaReport {
     schemaVersion: 1;
@@ -3377,24 +3398,8 @@ declare const LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION: 1;
 declare const LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION: 1;
 declare const LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION: 1;
 type LoCoMoRetrievalTraceProfile = "baseline" | "real";
-type LoCoMoRetrievalTraceSelector = {
-    taskIds: readonly string[];
-    sampleSize?: never;
-    seed?: never;
-} | {
-    taskIds?: never;
-    sampleSize: number;
-    seed: number;
-};
-interface LoCoMoRetrievalTraceSelectionManifest {
-    algorithm: "explicit-task-ids" | "sha256-seeded-sample";
-    version: typeof LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION;
-    seed?: number;
-    candidateCount: number;
-    selectedCount: number;
-    selectedTaskIds: string[];
-    selectedTaskIdsSha256: string;
-}
+type LoCoMoRetrievalTraceSelector = LoCoMoTaskSelector;
+type LoCoMoRetrievalTraceSelectionManifest = LoCoMoTaskSelectionManifest;
 interface LoCoMoRetrievalTraceCoreCaptureReceipt {
     budget: BenchRecallTraceCoreCapture["budget"];
     filters: BenchRecallTraceCoreCapture["filters"];

package/dist/index.js

@@ -21025,6 +21025,163 @@ async function loadDataset5(mode, datasetDir, limit) {
   return loaded.items;
 }
 
+// src/benchmarks/published/locomo/task-selection.ts
+var LOCOMO_TASK_SELECTION_VERSION = 1;
+function parseLoCoMoTaskSelectionManifest(value, label = "LoCoMo task selection") {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    throw new Error(`${label} must be an object.`);
+  }
+  const record = value;
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "algorithm",
+    "version",
+    "seed",
+    "candidateCount",
+    "selectedCount",
+    "selectedTaskIds",
+    "selectedTaskIdsSha256"
+  ]);
+  const unknownKey = Object.keys(record).find((key) => !allowedKeys.has(key));
+  if (unknownKey !== void 0) {
+    throw new Error(`${label} contains unknown field ${unknownKey}.`);
+  }
+  if (record.algorithm !== "explicit-task-ids" && record.algorithm !== "sha256-seeded-sample") {
+    throw new Error(`${label}.algorithm is invalid.`);
+  }
+  if (record.version !== LOCOMO_TASK_SELECTION_VERSION) {
+    throw new Error(
+      `${label}.version must be ${LOCOMO_TASK_SELECTION_VERSION}.`
+    );
+  }
+  const candidateCountRaw = record.candidateCount;
+  const selectedCountRaw = record.selectedCount;
+  if (typeof candidateCountRaw !== "number" || !Number.isSafeInteger(candidateCountRaw) || candidateCountRaw <= 0) {
+    throw new Error(`${label}.candidateCount must be a positive safe integer.`);
+  }
+  if (typeof selectedCountRaw !== "number" || !Number.isSafeInteger(selectedCountRaw) || selectedCountRaw <= 0) {
+    throw new Error(`${label}.selectedCount must be a positive safe integer.`);
+  }
+  const candidateCount = candidateCountRaw;
+  const selectedCount = selectedCountRaw;
+  if (selectedCount > candidateCount) {
+    throw new Error(`${label}.selectedCount cannot exceed candidateCount.`);
+  }
+  if (!Array.isArray(record.selectedTaskIds) || record.selectedTaskIds.some(
+    (taskId) => typeof taskId !== "string" || taskId.length === 0
+  )) {
+    throw new Error(`${label}.selectedTaskIds must contain non-empty strings.`);
+  }
+  const selectedTaskIds = [...record.selectedTaskIds];
+  if (new Set(selectedTaskIds).size !== selectedTaskIds.length) {
+    throw new Error(`${label}.selectedTaskIds must not contain duplicates.`);
+  }
+  if (selectedTaskIds.length !== selectedCount) {
+    throw new Error(
+      `${label}.selectedCount must equal selectedTaskIds.length.`
+    );
+  }
+  const selectedTaskIdsSha256 = record.selectedTaskIdsSha256;
+  if (typeof selectedTaskIdsSha256 !== "string" || !/^[0-9a-f]{64}$/u.test(selectedTaskIdsSha256) || selectedTaskIdsSha256 !== hashCanonicalJson(selectedTaskIds)) {
+    throw new Error(`${label}.selectedTaskIdsSha256 does not match selectedTaskIds.`);
+  }
+  const seed = record.seed;
+  if (record.algorithm === "explicit-task-ids") {
+    if (seed !== void 0) {
+      throw new Error(`${label}.seed is invalid for explicit task ids.`);
+    }
+  } else if (!Number.isSafeInteger(seed) || seed < 0) {
+    throw new Error(`${label}.seed must be a non-negative safe integer.`);
+  }
+  return {
+    algorithm: record.algorithm,
+    version: LOCOMO_TASK_SELECTION_VERSION,
+    ...seed === void 0 ? {} : { seed },
+    candidateCount,
+    selectedCount,
+    selectedTaskIds,
+    selectedTaskIdsSha256
+  };
+}
+function selectLoCoMoTasks(tasks, selector) {
+  const allIds = tasks.map((task) => task.taskId);
+  if (allIds.some((taskId) => typeof taskId !== "string" || taskId.length === 0)) {
+    throw new Error("LoCoMo candidate task ids must be non-empty strings.");
+  }
+  if (new Set(allIds).size !== allIds.length) {
+    throw new Error("LoCoMo candidate task ids must be unique.");
+  }
+  const hasTaskIds = "taskIds" in selector && selector.taskIds !== void 0;
+  const hasSampleSize = "sampleSize" in selector && selector.sampleSize !== void 0;
+  if (Number(hasTaskIds) + Number(hasSampleSize) !== 1) {
+    throw new Error("Choose exactly one LoCoMo task selector.");
+  }
+  if (hasTaskIds && "seed" in selector && selector.seed !== void 0) {
+    throw new Error("LoCoMo task-selection seed is valid only for seeded sampling.");
+  }
+  let selected;
+  let algorithm;
+  let seed;
+  if (hasTaskIds) {
+    algorithm = "explicit-task-ids";
+    const requestedTaskIds = selector.taskIds;
+    if (!requestedTaskIds) {
+      throw new Error("LoCoMo explicit task ids are required.");
+    }
+    const requested = [...requestedTaskIds];
+    if (requested.length === 0) {
+      throw new Error("LoCoMo explicit task selection cannot be empty.");
+    }
+    if (requested.some(
+      (taskId) => typeof taskId !== "string" || taskId.length === 0
+    )) {
+      throw new Error("LoCoMo explicit task ids must be non-empty strings.");
+    }
+    if (new Set(requested).size !== requested.length) {
+      throw new Error("LoCoMo explicit task ids must not contain duplicates.");
+    }
+    const available = new Set(allIds);
+    const unknown = requested.find((taskId) => !available.has(taskId));
+    if (unknown !== void 0) {
+      throw new Error(`Unknown LoCoMo task id: ${unknown}`);
+    }
+    const requestedSet = new Set(requested);
+    selected = allIds.filter((taskId) => requestedSet.has(taskId));
+  } else {
+    algorithm = "sha256-seeded-sample";
+    const sampleSize = selector.sampleSize;
+    seed = selector.seed;
+    if (sampleSize === void 0 || seed === void 0) {
+      throw new Error("LoCoMo seeded sampling requires sampleSize and seed.");
+    }
+    if (!Number.isSafeInteger(sampleSize) || sampleSize <= 0 || sampleSize > allIds.length) {
+      throw new Error(
+        `LoCoMo task-selection sampleSize must be an integer from 1 to ${allIds.length}.`
+      );
+    }
+    if (!Number.isSafeInteger(seed) || seed < 0) {
+      throw new Error(
+        "LoCoMo task-selection seed must be a non-negative safe integer."
+      );
+    }
+    const sampled = [...allIds].sort((left, right) => {
+      const leftHash = hashString(`${seed}\0${left}`);
+      const rightHash = hashString(`${seed}\0${right}`);
+      return leftHash.localeCompare(rightHash) || left.localeCompare(right);
+    }).slice(0, sampleSize);
+    const sampledSet = new Set(sampled);
+    selected = allIds.filter((taskId) => sampledSet.has(taskId));
+  }
+  return {
+    algorithm,
+    version: LOCOMO_TASK_SELECTION_VERSION,
+    ...seed === void 0 ? {} : { seed },
+    candidateCount: allIds.length,
+    selectedCount: selected.length,
+    selectedTaskIds: selected,
+    selectedTaskIdsSha256: hashCanonicalJson(selected)
+  };
+}
+
 // src/benchmarks/published/locomo/runner.ts
 var CATEGORY_NAMES = {
   1: "single_hop",
@@ -21265,30 +21422,47 @@ var locomoDefinition = {
   }
 };
 async function runLoCoMoBenchmark(options) {
+  const rawBenchmarkOptions = options.benchmarkOptions ?? {};
+  if (rawBenchmarkOptions.taskSelection !== void 0) {
+    throw new Error(
+      "LoCoMo benchmarkOptions.taskSelection is runner-owned and cannot be supplied by callers."
+    );
+  }
+  const taskSelector = resolvePinnedTaskSelector(
+    rawBenchmarkOptions.taskSelector
+  );
+  if (taskSelector !== void 0) {
+    assertTaskSelectorCompatibility(options, rawBenchmarkOptions);
+  }
   const loaded = await loadLoCoMoDataset(
     options.mode,
     options.datasetDir,
     options.limit
   );
   const conversations = loaded.items;
-  const trialLimit = resolveTrialLimit(options.benchmarkOptions?.trialLimit);
+  const trialLimit = resolveTrialLimit(rawBenchmarkOptions.trialLimit);
   const multiHopRecallComposition = resolveLoCoMoBooleanOption(
-    options.benchmarkOptions?.multiHopRecallComposition,
+    rawBenchmarkOptions.multiHopRecallComposition,
     "multiHopRecallComposition",
     true
   );
-  const plans = applyTrialLimit(
-    conversations.map(
-      (conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition)
-    ),
-    trialLimit
+  const allPlans = conversations.map(
+    (conversation) => buildLoCoMoPlan(conversation, multiHopRecallComposition)
   );
+  const selected = taskSelector === void 0 ? void 0 : applyTaskSelection(allPlans, taskSelector);
+  const plans = selected === void 0 ? applyTrialLimit(allPlans, trialLimit) : selected.plans;
+  const {
+    taskSelector: _taskSelector,
+    taskSelection: _taskSelection,
+    ...callerBenchmarkOptions
+  } = rawBenchmarkOptions;
   const benchmarkOptions = {
-    ...options.benchmarkOptions ?? {},
+    ...callerBenchmarkOptions,
     ...trialLimit === void 0 ? {} : { trialLimit },
+    ...selected === void 0 ? {} : { taskSelection: selected.manifest },
     multiHopRecallComposition
   };
-  return runPublishedHarness({
+  const result = await runPublishedHarness({
     options: { ...options, benchmarkOptions },
     metricsSpec: {
       metrics: ["f1", "contains_answer", "rouge_l", "llm_judge"]
@@ -21296,6 +21470,87 @@ async function runLoCoMoBenchmark(options) {
     plans,
     totalCount: plans.reduce((sum, plan) => sum + plan.trials.length, 0)
   });
+  result.meta.datasetHash = loaded.sha256;
+  return result;
+}
+function resolvePinnedTaskSelector(raw) {
+  if (raw === void 0) {
+    return void 0;
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error("LoCoMo benchmarkOptions.taskSelector must be an object.");
+  }
+  const record = raw;
+  const allowedKeys = /* @__PURE__ */ new Set([
+    "kind",
+    "taskIds",
+    "expectedSelectedTaskIdsSha256"
+  ]);
+  const unknownKey = Object.keys(record).find((key) => !allowedKeys.has(key));
+  if (unknownKey !== void 0) {
+    throw new Error(
+      `LoCoMo benchmarkOptions.taskSelector contains unknown field ${unknownKey}.`
+    );
+  }
+  if (record.kind !== "explicit-task-ids") {
+    throw new Error(
+      'LoCoMo benchmarkOptions.taskSelector.kind must be "explicit-task-ids".'
+    );
+  }
+  if (!Array.isArray(record.taskIds) || record.taskIds.some(
+    (taskId) => typeof taskId !== "string" || taskId.length === 0
+  )) {
+    throw new Error(
+      "LoCoMo benchmarkOptions.taskSelector.taskIds must contain non-empty strings."
+    );
+  }
+  if (typeof record.expectedSelectedTaskIdsSha256 !== "string" || !/^[0-9a-f]{64}$/u.test(record.expectedSelectedTaskIdsSha256)) {
+    throw new Error(
+      "LoCoMo benchmarkOptions.taskSelector.expectedSelectedTaskIdsSha256 must be 64 lowercase hexadecimal characters."
+    );
+  }
+  return {
+    kind: "explicit-task-ids",
+    taskIds: [...record.taskIds],
+    expectedSelectedTaskIdsSha256: record.expectedSelectedTaskIdsSha256
+  };
+}
+function assertTaskSelectorCompatibility(options, benchmarkOptions) {
+  if (options.mode !== "full") {
+    throw new Error("LoCoMo task selection requires full benchmark mode.");
+  }
+  if (options.limit !== void 0) {
+    throw new Error("LoCoMo task selection cannot be combined with limit.");
+  }
+  if (benchmarkOptions.trialLimit !== void 0) {
+    throw new Error(
+      "LoCoMo task selection cannot be combined with benchmarkOptions.trialLimit."
+    );
+  }
+  if (benchmarkOptions.trialConcurrency !== void 0 && Number(benchmarkOptions.trialConcurrency) !== 1) {
+    throw new Error(
+      "LoCoMo task selection requires benchmarkOptions.trialConcurrency to be 1."
+    );
+  }
+}
+function applyTaskSelection(plans, selector) {
+  const candidateTrials = plans.flatMap((plan) => plan.trials);
+  const manifest = selectLoCoMoTasks(candidateTrials, {
+    taskIds: selector.taskIds
+  });
+  if (manifest.selectedTaskIdsSha256 !== selector.expectedSelectedTaskIdsSha256) {
+    throw new Error(
+      "LoCoMo selected task-id hash does not match benchmarkOptions.taskSelector.expectedSelectedTaskIdsSha256."
+    );
+  }
+  const selectedTaskIds = new Set(manifest.selectedTaskIds);
+  const selectedPlans = plans.flatMap((plan) => {
+    const trials = plan.trials.filter(
+      (trial) => selectedTaskIds.has(trial.taskId)
+    );
+    return trials.length === 0 ? [] : [{ ...plan, trials }];
+  });
+  return { plans: selectedPlans, manifest };
 }
 function resolveLoCoMoBooleanOption(raw, optionName, defaultValue) {
   if (raw === void 0) {
@@ -38786,9 +39041,14 @@ function diagnoseLoComoRecallDelta(options) {
   const maxRegressions = parseNonNegativeInteger(options.maxRegressions ?? 20, "maxRegressions");
   assertEvidenceEnvelope(options.baseline, "baseline");
   assertEvidenceEnvelope(options.real, "real");
-  assertCompleteResult(options.baseline.result, "baseline");
-  assertCompleteResult(options.real.result, "real");
-  assertComparableResults(options.baseline.result, options.real.result);
+  const baselineSelection = assertCompleteResult(options.baseline.result, "baseline");
+  const realSelection = assertCompleteResult(options.real.result, "real");
+  assertComparableResults(
+    options.baseline.result,
+    options.real.result,
+    baselineSelection,
+    realSelection
+  );
   const joined = joinTasks2(options.baseline.result, options.real.result);
   assertMetricSets(joined, primaryMetric2);
   verifyAggregateMeans(options.baseline.result, joined, "baseline");
@@ -38807,8 +39067,8 @@ function diagnoseLoComoRecallDelta(options) {
     schemaVersion: 1,
     benchmarkId: "locomo",
     comparison: {
-      baseline: buildProvenance(options.baseline, "baseline", joined, "baseline"),
-      real: buildProvenance(options.real, "real", joined, "real")
+      baseline: buildProvenance(options.baseline, "baseline", joined, "baseline", baselineSelection),
+      real: buildProvenance(options.real, "real", joined, "real", realSelection)
     },
     taskCount: joined.length,
     primaryMetric: primaryMetric2,
@@ -38904,11 +39164,30 @@ function assertCompleteResult(result, label) {
   if (limit !== void 0 || trialLimit !== void 0) {
     throw new Error(`${label} result is limited and cannot be used as complete evidence.`);
   }
-  if (result.results.tasks.length !== LOCOMO_FULL_TASK_COUNT) {
+  const benchmarkOptions = result.config.benchmarkOptions;
+  const hasTaskSelection = benchmarkOptions !== null && typeof benchmarkOptions === "object" && Object.prototype.hasOwnProperty.call(benchmarkOptions, "taskSelection");
+  const taskSelection = hasTaskSelection ? parseLoCoMoTaskSelectionManifest(
+    benchmarkOptions.taskSelection,
+    `${label} result taskSelection`
+  ) : void 0;
+  if (!taskSelection && result.results.tasks.length !== LOCOMO_FULL_TASK_COUNT) {
     throw new Error(
       `${label} result must contain exactly ${LOCOMO_FULL_TASK_COUNT} tasks; got ${result.results.tasks.length}.`
     );
   }
+  if (taskSelection) {
+    if (taskSelection.candidateCount !== LOCOMO_FULL_TASK_COUNT) {
+      throw new Error(
+        `${label} result taskSelection.candidateCount must be ${LOCOMO_FULL_TASK_COUNT}.`
+      );
+    }
+    const resultTaskIds = result.results.tasks.map((task) => task.taskId);
+    if (stableJson(resultTaskIds) !== stableJson(taskSelection.selectedTaskIds)) {
+      throw new Error(
+        `${label} result task ids must exactly match taskSelection.selectedTaskIds in canonical order.`
+      );
+    }
+  }
   for (const task of result.results.tasks) {
     const details = asRecord(task.details);
     const failure = details?.benchmarkFailure;
@@ -38917,14 +39196,20 @@ function assertCompleteResult(result, label) {
       throw new Error(`${label} result contains failed task ${JSON.stringify(task.taskId)}.`);
     }
   }
+  return taskSelection;
 }
-function assertComparableResults(baseline, real) {
+function assertComparableResults(baseline, real, baselineSelection, realSelection) {
   if (baseline.config.runtimeProfile !== "baseline") {
     throw new Error('baseline result runtimeProfile must be "baseline".');
   }
   if (real.config.runtimeProfile !== "real") {
     throw new Error('real result runtimeProfile must be "real".');
   }
+  if (stableJson(baselineSelection ?? null) !== stableJson(realSelection ?? null)) {
+    throw new Error(
+      `Results are not comparable: config.benchmarkOptions.taskSelection differs (${stableJson(baselineSelection ?? null)} vs ${stableJson(realSelection ?? null)}).`
+    );
+  }
   const checks = [
     ["meta.version", baseline.meta.version, real.meta.version],
     ["meta.remnicVersion", baseline.meta.remnicVersion, real.meta.remnicVersion],
@@ -39063,7 +39348,7 @@ function buildRegression(task, metric, excerptChars, maxDiffLines) {
     introducedLines: lineDelta(introduced, maxDiffLines, excerptChars)
   };
 }
-function buildProvenance(evidence, profile, joined, side) {
+function buildProvenance(evidence, profile, joined, side, taskSelection) {
   const system = requireProvider(evidence.result.config.systemProvider, profile, "system");
   const judge = requireProvider(evidence.result.config.judgeProvider, profile, "judge");
   const payload = joined.map((task) => ({
@@ -39084,7 +39369,8 @@ function buildProvenance(evidence, profile, joined, side) {
     judgeProvider: judge.provider,
     judgeModel: judge.model,
     seeds: [...evidence.result.meta.seeds],
-    taskPayloadSha256: sha2562(stableJson(payload))
+    taskPayloadSha256: sha2562(stableJson(payload)),
+    ...taskSelection ? { taskSelection } : {}
   };
 }
 function summarizeMetric(tasks, metric) {
@@ -40082,7 +40368,7 @@ function isDigest(value) {
 
 // src/benchmarks/published/locomo/retrieval-trace-runner.ts
 var LOCOMO_RETRIEVAL_TRACE_SCHEMA_VERSION = 1;
-var LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION = 1;
+var LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION = LOCOMO_TASK_SELECTION_VERSION;
 var LOCOMO_RETRIEVAL_TRACE_BUDGET_VERSION = 1;
 async function preflightLoCoMoRetrievalTraceCapture(options) {
   assertCaptureOptions(options);
@@ -40209,69 +40495,7 @@ async function captureLoCoMoRetrievalTrace(options) {
   };
 }
 function selectLoCoMoRetrievalTraceTasks(tasks, selector) {
-  const allIds = tasks.map((task) => task.taskId);
-  if (new Set(allIds).size !== allIds.length) {
-    throw new Error("LoCoMo retrieval trace task ids must be unique.");
-  }
-  let selected;
-  let algorithm;
-  let seed;
-  const hasTaskIds = "taskIds" in selector && selector.taskIds !== void 0;
-  const hasSampleSize = "sampleSize" in selector && selector.sampleSize !== void 0;
-  if (Number(hasTaskIds) + Number(hasSampleSize) !== 1) {
-    throw new Error("Choose exactly one LoCoMo retrieval trace selector.");
-  }
-  if (hasTaskIds && "seed" in selector && selector.seed !== void 0) {
-    throw new Error("LoCoMo retrieval trace seed is valid only for seeded sampling.");
-  }
-  if (hasTaskIds) {
-    algorithm = "explicit-task-ids";
-    const requestedTaskIds = selector.taskIds;
-    if (!requestedTaskIds) throw new Error("LoCoMo explicit task ids are required.");
-    const requested = [...requestedTaskIds];
-    if (requested.length === 0) {
-      throw new Error("LoCoMo retrieval trace explicit task selection cannot be empty.");
-    }
-    if (new Set(requested).size !== requested.length) {
-      throw new Error("LoCoMo retrieval trace explicit task ids must not contain duplicates.");
-    }
-    const available = new Set(allIds);
-    const unknown = requested.filter((taskId) => !available.has(taskId));
-    if (unknown.length > 0) {
-      throw new Error(`Unknown LoCoMo retrieval trace task id: ${unknown[0]}`);
-    }
-    const requestedSet = new Set(requested);
-    selected = allIds.filter((taskId) => requestedSet.has(taskId));
-  } else {
-    algorithm = "sha256-seeded-sample";
-    const sampleSize = selector.sampleSize;
-    seed = selector.seed;
-    if (sampleSize === void 0 || seed === void 0) {
-      throw new Error("LoCoMo seeded sampling requires sampleSize and seed.");
-    }
-    if (!Number.isSafeInteger(sampleSize) || sampleSize <= 0 || sampleSize > allIds.length) {
-      throw new Error(`LoCoMo retrieval trace sampleSize must be an integer from 1 to ${allIds.length}.`);
-    }
-    if (!Number.isSafeInteger(seed) || seed < 0) {
-      throw new Error("LoCoMo retrieval trace seed must be a non-negative safe integer.");
-    }
-    const sampled = [...allIds].sort((left, right) => {
-      const leftHash = hashString(`${seed}\0${left}`);
-      const rightHash = hashString(`${seed}\0${right}`);
-      return leftHash.localeCompare(rightHash) || left.localeCompare(right);
-    }).slice(0, sampleSize);
-    const sampledSet = new Set(sampled);
-    selected = allIds.filter((taskId) => sampledSet.has(taskId));
-  }
-  return {
-    algorithm,
-    version: LOCOMO_RETRIEVAL_TRACE_SELECTION_VERSION,
-    ...seed === void 0 ? {} : { seed },
-    candidateCount: allIds.length,
-    selectedCount: selected.length,
-    selectedTaskIds: selected,
-    selectedTaskIdsSha256: hashCanonicalJson(selected)
-  };
+  return selectLoCoMoTasks(tasks, selector);
 }
 function serializeLoCoMoRetrievalTraceReceipt(receipt) {
   return `${canonicalJsonStringify(receipt, 2)}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/bench",
-  "version": "9.7.0",
+  "version": "9.7.1",
   "description": "Retrieval latency ladder benchmarks + CI regression gates for @remnic/core",
   "type": "module",
   "main": "./dist/index.js",
@@ -39,8 +39,8 @@
     "hyparquet": "^1.25.7",
     "yaml": "^2.4.2",
     "zod": "^3.24.0",
-    "@remnic/coding-graph": "^9.7.0",
-    "@remnic/core": "^9.7.0"
+    "@remnic/coding-graph": "^9.7.1",
+    "@remnic/core": "^9.7.1"
   },
   "devDependencies": {
     "tsup": "^8.5.1",