akm-cli 0.7.0 → 0.7.2

package/dist/tests/bench/metrics.js

@@ -1,2395 +0,0 @@
-/**
- * akm-bench metrics (spec §6).
- *
- * Outcome metrics (§6.1) and trajectory metrics (§6.2). Both are pure
- * functions over `RunResult[]` slices so the runner can compose them
- * however it likes. The §6.3+ catalog (proposal-quality, longitudinal,
- * attribution, failure-mode taxonomy) lands in #239/#240/#243.
- *
- * The failure-mode taxonomy classifier (§6.6) lives in this file
- * (`classifyFailureMode`).
- *
- * Search-pipeline bridge metrics (§6.7) are below: they tie the synthetic
- * MRR/Recall@K view in `tests/benchmark-suite.ts` to real-task pass rate
- * by logging gold-rank-of-search per `akm search` invocation and slicing
- * pass-rate by the rank of the agent's *chosen* search.
- */
-import fs from "node:fs";
-import path from "node:path";
-import { safeRealpath } from "../../src/core/common";
-import { MEMORY_ABILITY_VALUES } from "./corpus";
-import { serializeRunForReport } from "./report";
-import { benchMkdtemp } from "./tmp";
-import { normalizeRunToTrace } from "./workflow-trace";
-/**
- * Aggregate outcome metrics over a flat list of RunResults.
- *
- * Aggregations across multiple arms are the caller's responsibility — pass
- * each arm's slice in separately. Backward-compatible v1 contract; the
- * richer per-task / corpus shapes below subsume this.
- */
-export function computeOutcomeAggregate(results) {
-    if (results.length === 0) {
-        return { passRate: 0, tokensPerPass: 0, wallclockMs: 0, budgetExceeded: 0, runsWithMeasuredTokens: 0 };
-    }
-    let passes = 0;
-    let budgetExceeded = 0;
-    let totalTokensInMeasuredPasses = 0;
-    let measuredPasses = 0;
-    let runsWithMeasuredTokens = 0;
-    let totalWallclock = 0;
-    for (const r of results) {
-        totalWallclock += r.wallclockMs;
-        if (isMeasured(r)) {
-            runsWithMeasuredTokens += 1;
-        }
-        if (r.outcome === "pass") {
-            passes += 1;
-            // Only fold tokens into the mean when we actually measured them
-            // (issue #252) — otherwise a `0` would silently understate cost.
-            if (isMeasured(r)) {
-                measuredPasses += 1;
-                totalTokensInMeasuredPasses += r.tokens.input + r.tokens.output;
-            }
-        }
-        else if (r.outcome === "budget_exceeded") {
-            budgetExceeded += 1;
-        }
-    }
-    return {
-        passRate: passes / results.length,
-        tokensPerPass: measuredPasses === 0 ? 0 : totalTokensInMeasuredPasses / measuredPasses,
-        wallclockMs: totalWallclock / results.length,
-        budgetExceeded,
-        runsWithMeasuredTokens,
-    };
-}
-/**
- * Treat older artefacts without `tokenMeasurement` as `"parsed"` for backward
- * compatibility — pre-#252 reports always returned numeric zero, and rejecting
- * them entirely would break compare/attribute over historical runs.
- */
-function isMeasured(r) {
-    return (r.tokenMeasurement ?? "parsed") === "parsed";
-}
-/**
- * Aggregate K seed runs of one (task, arm) pair into PerTaskMetrics. Returns
- * a zeroed envelope on empty input — callers decide whether to skip or render.
- */
-export function aggregatePerTask(results) {
-    if (results.length === 0) {
-        return {
-            passRate: 0,
-            passAt1: 0,
-            tokensPerPass: null,
-            wallclockMs: 0,
-            passRateStdev: 0,
-            budgetExceededCount: 0,
-            harnessErrorCount: 0,
-            count: 0,
-            runsWithMeasuredTokens: 0,
-            tokensPerRun: null,
-        };
-    }
-    let passes = 0;
-    let measuredPasses = 0;
-    let totalTokensInMeasuredPasses = 0;
-    let totalWallclock = 0;
-    let budgetExceeded = 0;
-    let harnessError = 0;
-    let runsWithMeasuredTokens = 0;
-    let totalTokensInMeasuredRuns = 0;
-    let measuredRuns = 0;
-    // For the standard deviation we need a fixed-iteration buffer of pass/fail.
-    const passSamples = [];
-    for (const r of results) {
-        totalWallclock += r.wallclockMs;
-        if (isMeasured(r)) {
-            runsWithMeasuredTokens += 1;
-            measuredRuns += 1;
-            totalTokensInMeasuredRuns += r.tokens.input + r.tokens.output;
-        }
-        const isPass = r.outcome === "pass" ? 1 : 0;
-        passSamples.push(isPass);
-        if (isPass === 1) {
-            passes += 1;
-            // Only count tokens for measured passes (issue #252). A pass with
-            // missing measurement contributes to `passRate` but NOT to
-            // `tokensPerPass` — preserving "tokens per measured pass" semantics.
-            if (isMeasured(r)) {
-                measuredPasses += 1;
-                totalTokensInMeasuredPasses += r.tokens.input + r.tokens.output;
-            }
-        }
-        else if (r.outcome === "budget_exceeded") {
-            budgetExceeded += 1;
-        }
-        else if (r.outcome === "harness_error") {
-            harnessError += 1;
-        }
-    }
-    const seed0 = results.find((r) => r.seed === 0) ?? results[0];
-    const passAt1 = seed0 && seed0.outcome === "pass" ? 1 : 0;
-    return {
-        passRate: passes / results.length,
-        passAt1,
-        tokensPerPass: measuredPasses === 0 ? null : totalTokensInMeasuredPasses / measuredPasses,
-        wallclockMs: totalWallclock / results.length,
-        passRateStdev: stdev(passSamples),
-        budgetExceededCount: budgetExceeded,
-        harnessErrorCount: harnessError,
-        count: results.length,
-        runsWithMeasuredTokens,
-        tokensPerRun: measuredRuns === 0 ? null : totalTokensInMeasuredRuns / measuredRuns,
-    };
-}
-/** Sample standard deviation. Returns 0 for length ≤ 1 (no spread to measure). */
-function stdev(values) {
-    if (values.length <= 1)
-        return 0;
-    const mean = values.reduce((a, b) => a + b, 0) / values.length;
-    const sumSq = values.reduce((acc, v) => acc + (v - mean) * (v - mean), 0);
-    // Sample stdev (Bessel's correction) — n-1 denominator.
-    return Math.sqrt(sumSq / (values.length - 1));
-}
-/**
- * Mean across per-task metrics. Each task contributes once, regardless of
- * how many seeds it ran (K is already collapsed in `aggregatePerTask`).
- *
- * `tokensPerPass`: tasks where `tokensPerPass` is `null` (no passes) are
- * dropped from that mean. The result is `null` if every task failed.
- */
-export function aggregateCorpus(perTask) {
-    const tasks = Object.values(perTask);
-    if (tasks.length === 0) {
-        return { passRate: 0, tokensPerPass: null, wallclockMs: 0, tokensPerRun: null };
-    }
-    const passRate = tasks.reduce((a, t) => a + t.passRate, 0) / tasks.length;
-    const wallclockMs = tasks.reduce((a, t) => a + t.wallclockMs, 0) / tasks.length;
-    const tppValues = tasks.map((t) => t.tokensPerPass).filter((v) => v !== null);
-    const tokensPerPass = tppValues.length === 0 ? null : tppValues.reduce((a, b) => a + b, 0) / tppValues.length;
-    const tprValues = tasks.map((t) => t.tokensPerRun).filter((v) => v !== null);
-    const tokensPerRun = tprValues.length === 0 ? null : tprValues.reduce((a, b) => a + b, 0) / tprValues.length;
-    return { passRate, tokensPerPass, wallclockMs, tokensPerRun };
-}
-/**
- * Compute the akm − noakm delta. Negative `tokensPerPass`/`wallclockMs` mean
- * akm was cheaper / faster; positive means it cost more. Pass-rate uses the
- * opposite convention (positive = akm wins).
- */
-export function computeCorpusDelta(noakm, akm) {
-    return {
-        passRate: akm.passRate - noakm.passRate,
-        tokensPerPass: akm.tokensPerPass === null || noakm.tokensPerPass === null ? null : akm.tokensPerPass - noakm.tokensPerPass,
-        wallclockMs: akm.wallclockMs - noakm.wallclockMs,
-        tokensPerRun: akm.tokensPerRun === null || noakm.tokensPerRun === null ? null : akm.tokensPerRun - noakm.tokensPerRun,
-    };
-}
-/** Per-task delta with the same null-safety as the corpus delta. */
-export function computePerTaskDelta(noakm, akm) {
-    return {
-        passRate: akm.passRate - noakm.passRate,
-        tokensPerPass: akm.tokensPerPass === null || noakm.tokensPerPass === null ? null : akm.tokensPerPass - noakm.tokensPerPass,
-        wallclockMs: akm.wallclockMs - noakm.wallclockMs,
-        tokensPerRun: akm.tokensPerRun === null || noakm.tokensPerRun === null ? null : akm.tokensPerRun - noakm.tokensPerRun,
-    };
-}
-/**
- * Extract the domain prefix from a task ID. The corpus convention is
- * `<domain>/<task-name>`; we split on the first `/`. Tasks lacking a slash
- * fall back to the literal `unknown` bucket so they aggregate predictably
- * rather than producing per-task domains-of-one.
- */
-export function domainOfTaskId(taskId) {
-    const idx = taskId.indexOf("/");
-    if (idx <= 0)
-        return "unknown";
-    return taskId.slice(0, idx);
-}
-/**
- * Compute the negative-transfer aggregate over a set of per-task entries
- * (one entry per task; both arms already aggregated into PerTaskMetrics).
- *
- * A task is "regressed" when `akm.passRate < noakm.passRate`. Ties (equal
- * pass rate, including 0=0) are NOT regressions. `topRegressedTasks` is
- * sorted by `severity` descending then `taskId` ascending so output is
- * deterministic.
- */
-export function computeNegativeTransfer(tasks) {
-    const regressed = [];
-    for (const t of tasks) {
-        const delta = t.akm.passRate - t.noakm.passRate;
-        if (delta >= 0)
-            continue;
-        regressed.push({
-            taskId: t.id,
-            domain: domainOfTaskId(t.id),
-            noakmPassRate: t.noakm.passRate,
-            akmPassRate: t.akm.passRate,
-            delta,
-            severity: -delta,
-        });
-    }
-    regressed.sort((a, b) => {
-        if (b.severity !== a.severity)
-            return b.severity - a.severity;
-        return a.taskId.localeCompare(b.taskId);
-    });
-    const severity = regressed.reduce((acc, r) => acc + r.severity, 0);
-    return { count: regressed.length, severity, topRegressedTasks: regressed };
-}
-/**
- * Compute per-domain aggregates over a set of per-task entries. Each task
- * contributes once to its domain (K seeds already collapsed). Output rows
- * are sorted by `domain` ascending so JSON / markdown are byte-stable.
- *
- * Domain extraction uses `domainOfTaskId` (split on first `/`).
- */
-export function computeDomainAggregates(tasks) {
-    const buckets = new Map();
-    for (const t of tasks) {
-        const d = domainOfTaskId(t.id);
-        let arr = buckets.get(d);
-        if (!arr) {
-            arr = [];
-            buckets.set(d, arr);
-        }
-        arr.push(t);
-    }
-    const rows = [];
-    for (const [domain, group] of buckets) {
-        const n = group.length;
-        let noakmSum = 0;
-        let akmSum = 0;
-        let wallNoakm = 0;
-        let wallAkm = 0;
-        let regressionCount = 0;
-        const noakmTpp = [];
-        const akmTpp = [];
-        for (const t of group) {
-            noakmSum += t.noakm.passRate;
-            akmSum += t.akm.passRate;
-            wallNoakm += t.noakm.wallclockMs;
-            wallAkm += t.akm.wallclockMs;
-            if (t.akm.passRate < t.noakm.passRate)
-                regressionCount += 1;
-            if (t.noakm.tokensPerPass !== null)
-                noakmTpp.push(t.noakm.tokensPerPass);
-            if (t.akm.tokensPerPass !== null)
-                akmTpp.push(t.akm.tokensPerPass);
-        }
-        const passRateNoakm = noakmSum / n;
-        const passRateAkm = akmSum / n;
-        const meanNoakmTpp = noakmTpp.length === 0 ? null : noakmTpp.reduce((a, b) => a + b, 0) / noakmTpp.length;
-        const meanAkmTpp = akmTpp.length === 0 ? null : akmTpp.reduce((a, b) => a + b, 0) / akmTpp.length;
-        const tokensPerPassDelta = meanNoakmTpp === null || meanAkmTpp === null ? null : meanAkmTpp - meanNoakmTpp;
-        rows.push({
-            domain,
-            taskCount: n,
-            regressionCount,
-            passRateNoakm,
-            passRateAkm,
-            passRateDelta: passRateAkm - passRateNoakm,
-            tokensPerPassDelta,
-            wallclockMsDelta: wallAkm / n - wallNoakm / n,
-        });
-    }
-    rows.sort((a, b) => a.domain.localeCompare(b.domain));
-    return rows;
-}
-/**
- * Compute asset-regression-candidate rows (#260). Walks the AKM-arm runs,
- * keeps only those whose `taskId` is in `regressedTaskIds`, and tallies how
- * often each loaded asset shows up. `regressedTaskCount` (distinct task IDs
- * touched) is the primary sort key — assets that hurt many tasks are more
- * actionable than assets that flooded one task across seeds.
- *
- * Sort: regressedTaskCount desc, totalLoadCount desc, assetRef asc.
- */
-export function computeAssetRegressionCandidates(regressedTaskIds, akmRuns) {
-    const regressed = new Set(regressedTaskIds);
-    if (regressed.size === 0)
-        return [];
-    const taskIdsByAsset = new Map();
-    const totalLoadByAsset = new Map();
-    for (const run of akmRuns) {
-        if (!regressed.has(run.taskId))
-            continue;
-        const assets = run.assetsLoaded ?? [];
-        for (const ref of assets) {
-            let bucket = taskIdsByAsset.get(ref);
-            if (!bucket) {
-                bucket = new Set();
-                taskIdsByAsset.set(ref, bucket);
-            }
-            bucket.add(run.taskId);
-            totalLoadByAsset.set(ref, (totalLoadByAsset.get(ref) ?? 0) + 1);
-        }
-    }
-    const rows = [];
-    for (const [assetRef, taskIds] of taskIdsByAsset) {
-        rows.push({
-            assetRef,
-            regressedTaskCount: taskIds.size,
-            regressedTaskIds: [...taskIds].sort(),
-            totalLoadCount: totalLoadByAsset.get(assetRef) ?? 0,
-        });
-    }
-    rows.sort((a, b) => {
-        if (b.regressedTaskCount !== a.regressedTaskCount)
-            return b.regressedTaskCount - a.regressedTaskCount;
-        if (b.totalLoadCount !== a.totalLoadCount)
-            return b.totalLoadCount - a.totalLoadCount;
-        return a.assetRef.localeCompare(b.assetRef);
-    });
-    return rows;
-}
-// ── Per-asset attribution (§6.5) ───────────────────────────────────────────
-/**
- * Extract the unique asset refs an agent loaded during a run by scanning
- * `events[]` and `verifierStdout` for `akm show <ref>` invocations.
- *
- * Detection strategy (all heuristic, all conservative):
- *   1. `event.eventType === "show"` with `event.ref` (forward-compat — akm
- *      itself does not currently emit `show` events).
- *   2. Substring match on `akm show <ref>` in stdout. The ref shape is
- *      `[origin//]type:name` per the v1 contract; we accept word-boundary
- *      terminators after the name.
- *   3. Tool-call JSON `{"args":["show","<ref>"]}` — the form opencode logs
- *      when the agent invokes the akm CLI as a tool. We extract refs that
- *      look like asset refs from the args array entries adjacent to "show".
- *
- * Returns refs in first-seen order, deduplicated. Bounded scan: stdout is
- * truncated at 16 MiB (the same cap the trajectory parser uses) to keep
- * runaway agents from OOMing the bench.
- */
-const ASSET_LOAD_STDOUT_SCAN_CAP = 16 * 1024 * 1024;
-// Asset ref grammar: optional `origin//` prefix, type:name, where type and
-// name are lowercase letters, digits, `_`, `-`. We deliberately do NOT match
-// `://` schemes (those are install locators, not asset refs). The character
-// class is intentionally tight so we don't mis-pickup arbitrary words after
-// `akm show`. The `name` segment is restricted to `[A-Za-z0-9_-]+` (no `/`,
-// no `.`) — the v1 grammar in src/core/asset-ref.ts permits `/` and `.` in
-// names (e.g. `script:db/migrate/run.sh`), but the masker treats names as
-// untrusted input and rejects any traversal-shaped value, so the bench-side
-// scanner does not need (or want) to extract such refs from agent stdout.
-// Limiting the regex here is defense-in-depth against a prompt-injected
-// agent emitting `akm show "skill:../../etc"` and us pulling that ref into
-// the masking flow.
-const ASSET_REF_PATTERN = /(?:[a-z0-9_-]+\/\/)?[a-z][a-z0-9_-]*:[A-Za-z0-9_-]+/g;
-export function extractAssetLoads(runResult) {
-    const seen = new Set();
-    const out = [];
-    const push = (ref) => {
-        if (!ref)
-            return;
-        if (seen.has(ref))
-            return;
-        seen.add(ref);
-        out.push(ref);
-    };
-    // 1. Events stream.
-    for (const event of runResult.events) {
-        if (event.eventType === "show" && typeof event.ref === "string") {
-            push(event.ref);
-        }
-        const meta = event.metadata;
-        if (meta && typeof meta === "object" && event.eventType === "show") {
-            const candidate = meta.ref;
-            if (typeof candidate === "string")
-                push(candidate);
-        }
-    }
-    // 2 & 3. Stdout scanning. Bound the scan so a runaway agent stdout cannot
-    // OOM the bench. Truncation is silent — the trajectory parser already
-    // surfaces a warning for the same data on its own scan.
-    let haystack = runResult.verifierStdout || "";
-    if (haystack.length > ASSET_LOAD_STDOUT_SCAN_CAP) {
-        haystack = haystack.slice(0, ASSET_LOAD_STDOUT_SCAN_CAP);
-    }
-    // `akm show <ref>` literal form. Accept optional quoting around the ref so
-    // shell traces like `akm show "skill:foo"` work too.
-    const literalRe = /akm\s+show\s+["']?((?:[a-z0-9_-]+\/\/)?[a-z][a-z0-9_-]*:[A-Za-z0-9_-]+)["']?/g;
-    for (const literalMatch of haystack.matchAll(literalRe)) {
-        push(literalMatch[1]);
-    }
-    // Tool-call JSON form. `"args":[..., "show", "<ref>", ...]`. We extract
-    // every refish token in the haystack that follows a "show" arg in JSON-y
-    // form. A second cheap pass keeps the pattern simple.
-    const toolCallRe = /"show"\s*,\s*"((?:[a-z0-9_-]+\/\/)?[a-z][a-z0-9_-]*:[A-Za-z0-9_-]+)"/g;
-    for (const toolCallMatch of haystack.matchAll(toolCallRe)) {
-        push(toolCallMatch[1]);
-    }
-    return out;
-}
-// Suppress the unused warning for `ASSET_REF_PATTERN` above. The constant is
-// retained as the documentation seam called out by the #251 review addenda,
-// even though `extractAssetLoads` uses inline regexes for its two scan forms.
-void ASSET_REF_PATTERN;
-/**
- * Anchored variant of `ASSET_REF_PATTERN` for whole-string validation.
- *
- * Used by `materialiseMaskedStash` (#251) to gate every asset ref BEFORE we
- * touch the filesystem. The base `ASSET_REF_PATTERN` is `/g`-flagged for
- * scanning agent stdout; we re-anchor here so a hostile string like
- * `skill:foo/../../etc` is rejected as a whole even though the regex would
- * happily match a `skill:foo` substring under `/g`.
- *
- * Rejects `..`, absolute paths, drive letters, null bytes, `/`, `\`, and
- * anything else outside the v1 ref grammar (mirrors src/core/asset-ref.ts).
- */
-const ASSET_REF_ANCHORED = /^(?:[a-z0-9_-]+\/\/)?[a-z][a-z0-9_-]*:[A-Za-z0-9_-]+$/;
-/**
- * Reject hostile asset refs before they reach any `fs.rmSync` call. The ref
- * comes from agent stdout (untrusted; the agent could be prompt-injected) so
- * we apply the anchored grammar pattern first, then the per-segment shape
- * check after the colon-split. Defense in depth — each layer is sufficient
- * on its own; the layered structure makes a future grammar relax safe.
- */
-function isSafeAssetRef(ref) {
-    if (!ref)
-        return false;
-    if (ref.includes("\0"))
-        return false;
-    return ASSET_REF_ANCHORED.test(ref);
-}
-/**
- * Aggregate per-asset load + pass counts across all akm-arm runs in a report.
- *
- * Sort order (stable, deterministic):
- *   1. loadCount descending (most-used first)
- *   2. loadPassRate descending (working assets above broken ones at the same load count)
- *   3. assetRef ascending (alphabetical tiebreak)
- *
- * Only `arm === "akm"` runs contribute. The `noakm` arm has no stash and
- * cannot load assets, so including it would zero-bias the rates.
- */
-export function computePerAssetAttribution(report) {
-    const passing = new Map();
-    const failing = new Map();
-    let totalAkmRuns = 0;
-    // The §13.3 task entry doesn't carry RunResults — we read them from the
-    // shared akm-arm runs collection that the runner stamps onto `report.akmRuns`.
-    const akmRuns = collectAkmRuns(report);
-    for (const r of akmRuns) {
-        totalAkmRuns += 1;
-        const isPass = r.outcome === "pass";
-        for (const ref of r.assetsLoaded ?? []) {
-            const bucket = isPass ? passing : failing;
-            bucket.set(ref, (bucket.get(ref) ?? 0) + 1);
-        }
-    }
-    const refs = new Set([...passing.keys(), ...failing.keys()]);
-    const rows = [];
-    for (const ref of refs) {
-        const p = passing.get(ref) ?? 0;
-        const f = failing.get(ref) ?? 0;
-        const total = p + f;
-        rows.push({
-            assetRef: ref,
-            loadCountPassing: p,
-            loadCountFailing: f,
-            loadCount: total,
-            loadPassRate: total === 0 ? null : p / total,
-        });
-    }
-    rows.sort((a, b) => {
-        if (b.loadCount !== a.loadCount)
-            return b.loadCount - a.loadCount;
-        const ar = a.loadPassRate ?? -1;
-        const br = b.loadPassRate ?? -1;
-        if (br !== ar)
-            return br - ar;
-        return a.assetRef.localeCompare(b.assetRef);
-    });
-    return { rows, totalAkmRuns };
-}
-/**
- * Pull the akm-arm RunResults out of a UtilityRunReport. The runner stamps
- * them into the optional `akmRuns` field on the report so attribution can
- * post-process them without re-running.
- */
-function collectAkmRuns(report) {
-    if (Array.isArray(report.akmRuns))
-        return report.akmRuns;
-    return [];
-}
-// ── runs[] serialisation (#249) ────────────────────────────────────────────
-/**
- * Project a list of RunResults onto the compact `runs[]` rows persisted
- * inside the §13.3 JSON envelope (#249). One row per (task, arm, seed)
- * triple; the renderer walks the input order verbatim, which the runner
- * already builds deterministically (per-task block, noakm before akm,
- * seeds in ascending order).
- *
- * Aggregate metrics (per-task, trajectory, failure-mode, search-bridge,
- * attribution) MUST be recomputable from these rows + task metadata. This
- * helper is the canonical projection — keep it in lockstep with the field
- * list in the issue body.
- */
-export function aggregateRunsForReport(runs) {
-    return runs.map(serializeRunForReport);
-}
-/**
- * Hydrate a persisted `runs[]` row back into the `RunResult` shape that
- * downstream metrics helpers (`computePerAssetAttribution`, `aggregateCorpus`,
- * etc.) expect. Used by `bench attribute` / `bench compare` when they read a
- * §13.3 envelope from disk: the persisted row carries a compact subset, but
- * it carries everything those helpers need.
- *
- * Fields the row deliberately does NOT carry are filled with safe defaults:
- *   • `events: []` — events.jsonl is not persisted; downstream attribution
- *     only consults `assetsLoaded` and `verifierStdout`.
- *   • `verifierStdout: ""` — full stdout is intentionally omitted from the
- *     envelope (#249 acceptance criterion). `assetsLoaded` already carries
- *     the post-hoc extraction the agent run produced.
- *   • `schemaVersion: 1` — the report schema implies it.
- *
- * Tokens are passed through as-is so a future `measurement` field added by
- * #252 lands on the rehydrated row automatically. TODO(#252): keep this
- * spread.
- */
-export function rehydrateRunFromSerialized(row) {
-    // The compact row uses a permissive Record shape for tokens (see
-    // RunRecordSerialized). Coerce defensively so older artefacts with only
-    // {input, output} hydrate cleanly.
-    const tok = row.tokens;
-    return {
-        schemaVersion: 1,
-        taskId: row.task_id,
-        arm: row.arm,
-        seed: row.seed,
-        model: row.model,
-        outcome: row.outcome,
-        tokens: {
-            ...tok,
-            input: typeof tok.input === "number" ? tok.input : 0,
-            output: typeof tok.output === "number" ? tok.output : 0,
-        },
-        wallclockMs: row.wallclock_ms,
-        trajectory: {
-            correctAssetLoaded: row.trajectory.correct_asset_loaded,
-            feedbackRecorded: row.trajectory.feedback_recorded,
-        },
-        events: [],
-        verifierStdout: "",
-        verifierExitCode: row.verifier_exit_code,
-        assetsLoaded: [...row.assets_loaded],
-        failureMode: (row.failure_mode ?? null),
-    };
-}
-/**
- * Pick the top-N most-loaded assets from a base report and re-run the corpus
- * with each one masked from its source stash. Returns a marginal-contribution
- * row per masked asset.
- *
- * Cost: N * (tasks × arms × seedsPerArm) re-runs. Operators clamp N before
- * calling — but we also clamp internally if `topN` exceeds the unique-asset
- * count to avoid surprising no-op runs.
- *
- * Source-fixture safety: every masked re-run materialises a fresh tmp copy
- * of the fixture stash, deletes the masked asset's files there, and points
- * the re-run at the tmp dir. The shipped fixture in `tests/fixtures/stashes/`
- * is NEVER mutated.
- */
-export async function runMaskedCorpus(opts) {
-    const baseReport = opts.baseReport;
-    const fixturesRoot = opts.fixturesRoot ?? path.resolve(__dirname, "..", "fixtures", "stashes");
-    const attribution = computePerAssetAttribution(baseReport);
-    const desired = Math.max(1, opts.topN ?? 5);
-    const clamped = Math.min(desired, attribution.rows.length);
-    const baseAkmPassRate = baseReport.aggregateAkm.passRate;
-    const top = attribution.rows.slice(0, clamped);
-    const attributions = [];
-    const maskedRefs = [];
-    for (const row of top) {
-        const maskedTasks = [];
-        const tmpDirs = [];
-        try {
-            for (const baseTask of baseReport.taskMetadata ?? []) {
-                const maskedStashDir = materialiseMaskedStash(fixturesRoot, baseTask.stash, row.assetRef);
-                if (maskedStashDir)
-                    tmpDirs.push(maskedStashDir);
-                // Issue #251: forward the masked stashDir via the explicit
-                // `stashDirOverride` field on the cloned TaskMetadata. We MUST NOT
-                // mutate `baseTask.stash` (the fixture name) — the runner uses that
-                // to call `loadFixtureStash`, and overloading it breaks the
-                // `__no-stash__` resolution branch in runner.ts. The runner's AKM-arm
-                // branch checks `task.stashDirOverride` first.
-                //
-                // When `materialiseMaskedStash` returned `null` (asset not present in
-                // this fixture, or hostile ref shape rejected by the validator), we
-                // intentionally leave both fields untouched. The runner falls back to
-                // the normal materialisation flow against the unchanged source
-                // fixture — so the re-run still happens, but the result mirrors the
-                // base. This is a meaningful diagnostic (the ref didn't bind in this
-                // fixture) and is the same accounting `cost-accounting`-style tests
-                // assert against.
-                if (maskedStashDir) {
-                    maskedTasks.push({ ...baseTask, stashDirOverride: maskedStashDir });
-                }
-                else {
-                    maskedTasks.push({ ...baseTask });
-                }
-            }
-            const maskedReport = await opts.runUtility({
-                ...opts.baseOptions,
-                tasks: maskedTasks,
-                // The masked stash already has the correct content on disk, and the
-                // runner now resolves it via `task.stashDirOverride`. We still pass
-                // `materialiseStash: false` so the runner does not call
-                // `loadFixtureStash` against the (unmasked) named fixture — that
-                // would waste work and risk re-indexing the source dir.
-                materialiseStash: false,
-            });
-            const maskedPassRate = maskedReport.aggregateAkm.passRate;
-            attributions.push({
-                assetRef: row.assetRef,
-                basePassRate: baseAkmPassRate,
-                maskedPassRate,
-                marginalContribution: baseAkmPassRate - maskedPassRate,
-            });
-            maskedRefs.push(row.assetRef);
-        }
-        finally {
-            // Cleanup runs in BOTH success and failure paths (acceptance criterion).
-            // Best-effort: a tmpfs failure here is logged via the `try/catch` below
-            // and the host OS reaps the tmp dir on reboot.
-            for (const dir of tmpDirs) {
-                try {
-                    fs.rmSync(dir, { recursive: true, force: true });
-                }
-                catch {
-                    // Best-effort cleanup; tmpfs cleanup will handle leaks.
-                }
-            }
-        }
-    }
-    return {
-        baseReport,
-        attributions,
-        runsPerformed: clamped,
-        maskingStrategy: "leave-one-out",
-        maskedRefs,
-    };
-}
-/**
- * Copy a fixture stash into a fresh tmp dir, delete every file matching the
- * masked asset ref, and return the tmp dir path. Returns `null` if the named
- * asset is not present in the fixture (we still re-run, but the result will
- * mirror the base — which is itself a meaningful diagnostic).
- *
- * The masking heuristic:
- *   1. Walk `<stash>/*<...>/.stash.json` files.
- *   2. For each entry whose `name` + `type` matches the asset ref, drop the
- *      entry and delete its `filename` if present.
- *   3. Rewrite the `.stash.json` with the trimmed entries (or remove it if
- *      it is now empty).
- */
-export function materialiseMaskedStash(fixturesRoot, stashName, assetRef) {
-    // #271: validate stashName containment BEFORE touching the filesystem.
-    // `stashName` originates from a task YAML which, while authored, is part
-    // of the fixture corpus the bench loads; a fixture with `stash: "../../etc"`
-    // would otherwise resolve outside `fixturesRoot` and let masking edits or
-    // copies escape the bench sandbox. path.relative gives the cleanest
-    // containment check (handles `..` AND absolute path injection in one go).
-    const fixturesRootResolved = path.resolve(fixturesRoot);
-    const sourceDir = path.resolve(fixturesRootResolved, stashName);
-    const rel = path.relative(fixturesRootResolved, sourceDir);
-    if (rel.startsWith("..") || path.isAbsolute(rel))
-        return null;
-    if (!fs.existsSync(path.join(sourceDir, "MANIFEST.json")))
-        return null;
-    // Issue #251 review addendum: validate the WHOLE ref against the anchored
-    // grammar before we touch the filesystem. The downstream `isSafeAssetNameSegment`
-    // + `isPathContained` checks are still applied — this is defense in depth.
-    if (!isSafeAssetRef(assetRef))
-        return null;
-    const colonIdx = assetRef.indexOf(":");
-    if (colonIdx < 0) {
-        // Malformed ref: still produce a tmp copy with no edits so the caller's
-        // re-run sees the unmodified fixture.
-        const tmpRoot = benchMkdtemp(`akm-bench-masked-${stashName}-`);
-        copyDirRecursive(sourceDir, tmpRoot);
-        return tmpRoot;
-    }
-    const typeWithOrigin = assetRef.slice(0, colonIdx);
-    const name = assetRef.slice(colonIdx + 1);
-    const type = typeWithOrigin.includes("//") ? (typeWithOrigin.split("//")[1] ?? typeWithOrigin) : typeWithOrigin;
-    // SECURITY: the asset ref originates from agent stdout (untrusted; the
-    // agent could be prompt-injected). The masking heuristic below will
-    // `fs.rmSync` files under the tmp stash dir whose names are derived from
-    // `name`. A traversal-shaped name (`../etc`, `/abs/path`, `..\\..`) would
-    // escape the tmp root and delete arbitrary disk content. Reject those
-    // shapes BEFORE we materialise — and re-validate after path-resolving
-    // each candidate. Mirrors src/core/asset-ref.ts validateName().
-    if (!isSafeAssetNameSegment(name))
-        return null;
-    const tmpRoot = benchMkdtemp(`akm-bench-masked-${stashName}-`);
-    copyDirRecursive(sourceDir, tmpRoot);
-    // Walk every .stash.json under the tmp root and edit in place.
-    walkStashJsonFiles(tmpRoot, (jsonPath) => {
-        let raw;
-        try {
-            raw = fs.readFileSync(jsonPath, "utf8");
-        }
-        catch {
-            return;
-        }
-        let parsed;
-        try {
-            parsed = JSON.parse(raw);
-        }
-        catch {
-            return;
-        }
-        const entries = parsed.entries ?? [];
-        const kept = [];
-        const jsonDir = path.dirname(jsonPath);
-        for (const entry of entries) {
-            if (entry.type === type && entry.name === name) {
-                // Remove the entry's content file(s). The on-disk `filename` is read
-                // from the fixture .stash.json (trusted) but the value still passes
-                // through path.relative containment so a malicious fixture can't use
-                // this path to escape either.
-                const filename = entry.filename;
-                if (typeof filename === "string" && isSafeAssetNameSegment(filename)) {
-                    const target = path.resolve(jsonDir, filename);
-                    if (isPathContained(tmpRoot, target)) {
-                        try {
-                            fs.rmSync(target, { force: true });
-                        }
-                        catch {
-                            // ignore
-                        }
-                    }
-                }
-                // Some fixtures keep a per-asset directory (e.g. skills/<name>/SKILL.md).
-                const dirCandidate = path.resolve(jsonDir, name);
-                if (isPathContained(tmpRoot, dirCandidate) &&
-                    fs.existsSync(dirCandidate) &&
-                    fs.statSync(dirCandidate).isDirectory()) {
-                    try {
-                        fs.rmSync(dirCandidate, { recursive: true, force: true });
-                    }
-                    catch {
-                        // ignore
-                    }
-                }
-                continue;
-            }
-            kept.push(entry);
-        }
-        if (kept.length === entries.length)
-            return; // nothing changed
-        if (kept.length === 0) {
-            try {
-                fs.rmSync(jsonPath, { force: true });
-            }
-            catch {
-                // ignore
-            }
-        }
-        else {
-            fs.writeFileSync(jsonPath, `${JSON.stringify({ ...parsed, entries: kept }, null, 2)}\n`);
-        }
-    });
-    return tmpRoot;
-}
-/**
- * Reject any segment that could escape the tmp stash root when used as a
- * relative path component:
- *   - empty string
- *   - any `/` or `\\` (path separators)
- *   - a `..` segment in any form
- *   - a leading `/` (POSIX absolute) or `C:` (Windows drive)
- *   - any null byte
- *
- * Mirrors src/core/asset-ref.ts validateName(), but returns a boolean
- * (callers map this to "skip" rather than "throw").
- */
-function isSafeAssetNameSegment(value) {
-    if (!value)
-        return false;
-    if (value.includes("\0"))
-        return false;
-    if (value.includes("/") || value.includes("\\"))
-        return false;
-    if (value === ".." || value === ".")
-        return false;
-    if (/^[A-Za-z]:/.test(value))
-        return false;
-    return true;
-}
-/**
- * After resolving a target path, confirm it lives under `root`. Defense in
- * depth: even if a traversal-shaped name slipped past the segment check,
- * this catches escapes via symlinks or odd `path.join` semantics.
- *
- * #271: aligned with `isWithin` in `src/core/common.ts` — both inputs go
- * through `safeRealpath` so a symlink inside `root` that points outside
- * cannot fool the `path.relative` containment check. The shared helper
- * also handles not-yet-existing children (walks up to the closest existing
- * ancestor and resolves symlinks there) so we keep the existing semantics
- * for `target` paths the masking heuristic is about to create.
- */
-export function isPathContained(root, target) {
-    const rootResolved = safeRealpath(root);
-    const targetResolved = safeRealpath(target);
-    const rel = path.relative(rootResolved, targetResolved);
-    if (rel === "")
-        return true;
-    if (rel.startsWith(".."))
-        return false;
-    if (path.isAbsolute(rel))
-        return false;
-    return true;
-}
-function walkStashJsonFiles(root, visit) {
-    const stack = [root];
-    while (stack.length > 0) {
-        const cur = stack.pop();
-        if (!cur)
-            continue;
-        let entries;
-        try {
-            entries = fs.readdirSync(cur, { withFileTypes: true });
-        }
-        catch {
-            continue;
-        }
-        for (const entry of entries) {
-            const abs = path.join(cur, entry.name);
-            if (entry.isDirectory())
-                stack.push(abs);
-            else if (entry.isFile() && entry.name === ".stash.json")
-                visit(abs);
-        }
-    }
-}
-function copyDirRecursive(src, dest) {
-    fs.mkdirSync(dest, { recursive: true });
-    const entries = fs.readdirSync(src, { withFileTypes: true });
-    for (const entry of entries) {
-        const s = path.join(src, entry.name);
-        const d = path.join(dest, entry.name);
-        if (entry.isDirectory())
-            copyDirRecursive(s, d);
-        else if (entry.isFile())
-            fs.copyFileSync(s, d);
-    }
-}
-/** Aggregate trajectory booleans across a bag of runs. */
-export function aggregateTrajectory(results) {
-    if (results.length === 0) {
-        return { correctAssetLoaded: null, feedbackRecorded: 0 };
-    }
-    let knownAsset = 0;
-    let assetLoaded = 0;
-    let feedback = 0;
-    for (const r of results) {
-        if (r.trajectory.correctAssetLoaded !== null) {
-            knownAsset += 1;
-            if (r.trajectory.correctAssetLoaded)
-                assetLoaded += 1;
-        }
-        if (r.trajectory.feedbackRecorded === true)
-            feedback += 1;
-    }
-    return {
-        correctAssetLoaded: knownAsset === 0 ? null : assetLoaded / knownAsset,
-        feedbackRecorded: feedback / results.length,
-    };
-}
-/**
- * Sign threshold below which a delta is rendered as `flat`. `pass_rate` is
- * normalised to `[0, 1]`, so a 0.005 (0.5pp) tolerance keeps tiny K-seed
- * sampling jitter from looking like a regression.
- */
-const PASS_RATE_FLAT_TOLERANCE = 0.005;
-/** `tokens_per_pass` and `wallclock_ms` use raw counts; 0 is the only "flat". */
-const COUNT_FLAT_TOLERANCE = 0;
-function classifyPassRate(delta) {
-    if (delta === null)
-        return "flat";
-    if (Math.abs(delta) <= PASS_RATE_FLAT_TOLERANCE)
-        return "flat";
-    return delta > 0 ? "improve" : "regress";
-}
-function classifyCount(delta, lowerIsBetter) {
-    if (delta === null)
-        return "flat";
-    if (Math.abs(delta) <= COUNT_FLAT_TOLERANCE)
-        return "flat";
-    if (lowerIsBetter)
-        return delta < 0 ? "improve" : "regress";
-    return delta > 0 ? "improve" : "regress";
-}
-function readModel(r) {
-    return r.agent?.model ?? "<unknown>";
-}
-function readFixtureHash(r) {
-    const v = r.corpus?.fixtureContentHash;
-    return v === undefined || v === null ? null : v;
-}
-function readTaskCorpusHash(r) {
-    const v = r.corpus?.taskCorpusHash;
-    return v === undefined || v === null ? null : v;
-}
-function readSelectedTaskIds(r) {
-    const v = r.corpus?.selectedTaskIds;
-    return Array.isArray(v) ? v : null;
-}
-function arraysEqualIgnoringOrder(a, b) {
-    if (a.length !== b.length)
-        return false;
-    const sa = [...a].sort();
-    const sb = [...b].sort();
-    for (let i = 0; i < sa.length; i += 1)
-        if (sa[i] !== sb[i])
-            return false;
-    return true;
-}
-function akmAgg(r) {
-    const a = r.aggregate?.akm ?? {};
-    return {
-        pass_rate: a.pass_rate ?? 0,
-        tokens_per_pass: a.tokens_per_pass ?? null,
-        wallclock_ms: a.wallclock_ms ?? 0,
-    };
-}
-/**
- * Diff two parsed UtilityRunReport JSONs.
- *
- * Refusal cases:
- *   • Either side missing `schemaVersion: 1` or `track: "utility"` →
- *     `schema_mismatch` / `track_mismatch`.
- *   • `agent.model` differs → `model_mismatch`.
- *   • Both sides report a `corpus.fixtureContentHash` and they differ →
- *     `hash_mismatch`. Missing hash on either side proceeds with a warning
- *     (Wave A may add it; older reports won't have it).
- *
- * On success the per-task table includes rows for every task in either side,
- * plus aggregate deltas computed against the akm arm only (the noakm arm is
- * the control — its delta is meaningless). `pass_rate` is in `[0, 1]`,
- * higher is better; `tokens_per_pass` and `wallclock_ms` are counts, lower
- * is better.
- */
-export function compareReports(base, current, options = {}) {
-    // Schema-version gate.
-    if (base.schemaVersion !== 1 || current.schemaVersion !== 1) {
-        return {
-            ok: false,
-            reason: "schema_mismatch",
-            message: `compare requires schemaVersion=1 on both sides; got base=${String(base.schemaVersion)}, current=${String(current.schemaVersion)}`,
-        };
-    }
-    // Track gate. Cross-track diffs are nonsensical.
-    if (base.track !== "utility" || current.track !== "utility") {
-        return {
-            ok: false,
-            reason: "track_mismatch",
-            message: `compare only supports track="utility"; got base="${String(base.track)}", current="${String(current.track)}"`,
-        };
-    }
-    const baseModel = readModel(base);
-    const currentModel = readModel(current);
-    if (baseModel !== currentModel) {
-        return {
-            ok: false,
-            reason: "model_mismatch",
-            message: `cannot compare across different models: base="${baseModel}", current="${currentModel}". Rerun on the same model.`,
-            baseModel,
-            currentModel,
-        };
-    }
-    const baseHash = readFixtureHash(base);
-    const currentHash = readFixtureHash(current);
-    const warnings = [];
-    // #250 — task corpus hash + selected task IDs. Refused unless either side
-    // is legacy (missing the hash) or the operator passed
-    // `allowCorpusMismatch`. Legacy reports (no taskCorpusHash) degrade to a
-    // warning so older artefacts can still be diffed.
-    const baseTaskHash = readTaskCorpusHash(base);
-    const currentTaskHash = readTaskCorpusHash(current);
-    const baseIds = readSelectedTaskIds(base);
-    const currentIds = readSelectedTaskIds(current);
-    if (baseTaskHash !== null && currentTaskHash !== null && baseTaskHash !== currentTaskHash) {
-        if (!options.allowCorpusMismatch) {
-            return {
-                ok: false,
-                reason: "corpus_mismatch",
-                message: `cannot compare across different task corpora: base taskCorpusHash="${baseTaskHash}", current="${currentTaskHash}". Rerun against the same task selection or pass --allow-corpus-mismatch to override.`,
-                baseModel,
-                currentModel,
-                baseTaskCorpusHash: baseTaskHash,
-                currentTaskCorpusHash: currentTaskHash,
-                ...(baseIds ? { baseSelectedTaskIds: baseIds } : {}),
-                ...(currentIds ? { currentSelectedTaskIds: currentIds } : {}),
-            };
-        }
-        warnings.push(`task corpus hashes differ (base="${baseTaskHash}", current="${currentTaskHash}") — diff requested via --allow-corpus-mismatch`);
-    }
-    else if (baseTaskHash === null &&
-        currentTaskHash === null &&
-        baseIds !== null &&
-        currentIds !== null &&
-        !arraysEqualIgnoringOrder(baseIds, currentIds)) {
-        // Both sides legacy (no taskCorpusHash) but both expose selectedTaskIds
-        // and they differ. We can still detect a mismatched corpus from the ID
-        // list alone — refuse unless the operator opted in.
-        if (!options.allowCorpusMismatch) {
-            return {
-                ok: false,
-                reason: "corpus_mismatch",
-                message: `cannot compare across different selected task IDs. Rerun against the same task selection or pass --allow-corpus-mismatch to override.`,
-                baseModel,
-                currentModel,
-                baseSelectedTaskIds: baseIds,
-                currentSelectedTaskIds: currentIds,
-            };
-        }
-        warnings.push("selected task IDs differ — diff requested via --allow-corpus-mismatch");
-    }
-    if (baseTaskHash === null)
-        warnings.push("base report has no corpus.taskCorpusHash; proceeding without task-corpus-pin check");
-    if (currentTaskHash === null)
-        warnings.push("current report has no corpus.taskCorpusHash; proceeding without task-corpus-pin check");
-    if (baseHash !== null && currentHash !== null && baseHash !== currentHash) {
-        if (!options.allowFixtureMismatch) {
-            return {
-                ok: false,
-                reason: "hash_mismatch",
-                message: `cannot compare across different fixture-content hashes: base="${baseHash}", current="${currentHash}". Rerun against matching fixtures or pass --allow-fixture-mismatch to override.`,
-                baseModel,
-                currentModel,
-                baseFixtureContentHash: baseHash,
-                currentFixtureContentHash: currentHash,
-            };
-        }
-        warnings.push(`fixture-content hashes differ (base="${baseHash}", current="${currentHash}") — diff requested via --allow-fixture-mismatch`);
-    }
-    if (baseHash === null)
-        warnings.push("base report has no corpus.fixtureContentHash; proceeding without fixture-pin check");
-    if (currentHash === null)
-        warnings.push("current report has no corpus.fixtureContentHash; proceeding without fixture-pin check");
-    // Aggregate (akm arm is the one that matters — noakm is the control).
-    const ba = akmAgg(base);
-    const ca = akmAgg(current);
-    const passRateDelta = ca.pass_rate - ba.pass_rate;
-    const tokensPerPassDelta = ba.tokens_per_pass === null || ca.tokens_per_pass === null ? null : ca.tokens_per_pass - ba.tokens_per_pass;
-    const wallclockMsDelta = ca.wallclock_ms - ba.wallclock_ms;
-    const aggregate = {
-        passRateDelta,
-        passRateSign: classifyPassRate(passRateDelta),
-        tokensPerPassDelta,
-        tokensPerPassSign: classifyCount(tokensPerPassDelta, true),
-        wallclockMsDelta,
-        wallclockMsSign: classifyCount(wallclockMsDelta, true),
-    };
-    // Per-task rows. Outer-join on task id.
-    const baseTasks = new Map();
-    for (const t of base.tasks ?? [])
-        baseTasks.set(t.id, t);
-    const currentTasks = new Map();
-    for (const t of current.tasks ?? [])
-        currentTasks.set(t.id, t);
-    const allIds = new Set();
-    for (const id of baseTasks.keys())
-        allIds.add(id);
-    for (const id of currentTasks.keys())
-        allIds.add(id);
-    const perTask = [];
-    for (const id of [...allIds].sort()) {
-        const b = baseTasks.get(id);
-        const c = currentTasks.get(id);
-        const bM = b?.akm ?? null;
-        const cM = c?.akm ?? null;
-        const presence = b !== undefined && c !== undefined ? "both" : b !== undefined ? "base-only" : "current-only";
-        const passRateDelta_ = bM !== null && cM !== null ? cM.pass_rate - bM.pass_rate : null;
-        const tokensPerPassDelta_ = bM !== null && cM !== null && bM.tokens_per_pass !== null && cM.tokens_per_pass !== null
-            ? cM.tokens_per_pass - bM.tokens_per_pass
-            : null;
-        const wallclockMsDelta_ = bM !== null && cM !== null ? cM.wallclock_ms - bM.wallclock_ms : null;
-        perTask.push({
-            id,
-            presence,
-            baseMetrics: bM,
-            currentMetrics: cM,
-            delta: { passRate: passRateDelta_, tokensPerPass: tokensPerPassDelta_, wallclockMs: wallclockMsDelta_ },
-            signMarker: classifyPassRate(passRateDelta_),
-        });
-    }
-    return {
-        ok: true,
-        baseModel,
-        currentModel,
-        baseFixtureContentHash: baseHash,
-        currentFixtureContentHash: currentHash,
-        warnings,
-        aggregate,
-        perTask,
-    };
-}
-/** Maximum rank at which the gold ref still counts as "found"; > this is `search_low_rank`. */
-const SEARCH_RANK_CUTOFF = 5;
-/** Cap on the number of characters of `verifierStdout` we substring-scan. Mirrors trajectory.ts. */
-const FAILURE_MODE_STDOUT_SCAN_CAP = 16 * 1024 * 1024;
-/**
- * Classify a single failed run into one of the §6.6 labels. Pure function —
- * consults `runResult.trajectory.correctAssetLoaded` first (trajectory data
- * is authoritative when present), then falls back to string-matching
- * `runResult.events[]` and `runResult.verifierStdout`. Never calls an LLM,
- * never touches the filesystem.
- *
- * Decision tree (priority order — first match wins):
- *   1. Run not failed (`pass`, `budget_exceeded`, `harness_error`) → `null`.
- *   2. `trajectory.correctAssetLoaded === true` → the agent loaded the gold
- *      asset but still failed. This is `loaded_ignored` (agent wrote from
- *      memory instead of applying asset content). This short-circuit fixes
- *      the 2026-05-03 baseline bug where 24/25 `search_no_gold` labels were
- *      wrong because the classifier didn't consult trajectory data.
- *   3. No `akm search` call in the trace:
- *      a. If task has no `goldRef` (so `correctAssetLoaded` is always null)
- *         → `no_events` (trajectory metric undefined; cannot distinguish
- *         "agent ran but events absent" from "agent never ran").
- *      b. Otherwise → `no_search`.
- *   4. Search ran, no goldRef → `unrelated_bug`.
- *   5. Search ran; gold ref absent from results → `search_no_gold`.
- *      (Only reachable when `correctAssetLoaded` is false or null, since
- *      true is handled in step 2.)
- *   6. Gold ref present at rank > 5 → `search_low_rank`.
- *   7. `akm show` invoked on a non-gold ref AND gold ref never loaded
- *      → `loaded_wrong`.
- *   8. Gold ref loaded; verifier output suggests the action contradicts the
- *      asset's guidance → `loaded_ignored`.
- *   9. Gold ref loaded and apparently followed → `followed_wrong`.
- *  10. Default → `unrelated_bug`.
- */
-export function classifyFailureMode(taskMeta, runResult) {
-    if (runResult.outcome !== "fail")
-        return null;
-    const goldRef = taskMeta.goldRef;
-    const correctAssetLoaded = runResult.trajectory?.correctAssetLoaded;
-    // 1. Trajectory short-circuit: if events data confirms the gold asset was
-    //    loaded, the failure must be compliance-related, not discovery-related.
-    //    Return `loaded_ignored` immediately without scanning stdout.
-    if (correctAssetLoaded === true) {
-        return "loaded_ignored";
-    }
-    const trace = collectTrace(runResult);
-    // 2. no_search / no_events — no `akm search` invocation anywhere in the trace.
-    if (!hasAkmSearch(trace, runResult)) {
-        // When there is no goldRef, correctAssetLoaded is always null (the metric
-        // is undefined). We cannot tell whether the agent genuinely didn't search
-        // or whether events data was simply absent. Use `no_events` to surface
-        // this ambiguity rather than conflating it with `no_search`.
-        if (!goldRef) {
-            return "no_events";
-        }
-        return "no_search";
-    }
-    // Without a gold ref the search-based and load-based checks are undefined.
-    // We can only distinguish "no_search" / "no_events" from everything else.
-    if (!goldRef) {
-        return "unrelated_bug";
-    }
-    const searchRank = findGoldSearchRank(trace, goldRef);
-    // 3. search_no_gold — search ran (precondition above) but gold ref absent.
-    //    Only reachable when correctAssetLoaded is false or null (trajectory
-    //    data indicates gold was not loaded), because true is handled above.
-    if (searchRank === null) {
-        return "search_no_gold";
-    }
-    // 4. search_low_rank — present but below the cutoff.
-    if (searchRank > SEARCH_RANK_CUTOFF) {
-        return "search_low_rank";
-    }
-    const goldLoaded = hasAkmShow(trace, runResult, goldRef);
-    const otherRefLoaded = hasAkmShowOtherRef(trace, runResult, goldRef);
-    // 5. loaded_wrong — agent showed a non-gold ref AND never loaded the gold.
-    if (otherRefLoaded && !goldLoaded) {
-        return "loaded_wrong";
-    }
-    // The remaining branches all assume the gold was loaded.
-    if (!goldLoaded) {
-        // Gold ref was found in search at an acceptable rank, but the agent
-        // never loaded anything (gold or otherwise) before failing. The taxonomy
-        // table has no row for "found but never opened" — treat as unrelated_bug.
-        return "unrelated_bug";
-    }
-    // 6. loaded_ignored — verifier diagnostic indicates the action contradicts
-    //    the loaded asset. Conservative heuristic: look for explicit "ignored"
-    //    or "not applied" markers in the verifier stdout. Without an LLM we
-    //    cannot detect subtler contradictions, so this branch only fires when
-    //    the verifier itself flagged the contradiction.
-    if (verifierIndicatesIgnored(runResult.verifierStdout)) {
-        return "loaded_ignored";
-    }
-    // 7. followed_wrong — gold loaded, apparently followed, verifier still
-    //    failed. The §6.6 spec maps this to "the asset itself is wrong".
-    return "followed_wrong";
-}
-/** Build a `FailureModeAggregate` from a list of (taskId, label) pairs. */
-export function aggregateFailureModes(entries) {
-    const byLabel = {};
-    const byTask = {};
-    for (const { taskId, mode } of entries) {
-        byLabel[mode] = (byLabel[mode] ?? 0) + 1;
-        if (!byTask[taskId])
-            byTask[taskId] = {};
-        byTask[taskId][mode] = (byTask[taskId][mode] ?? 0) + 1;
-    }
-    return { byLabel, byTask };
-}
-// ── Failure-mode classifier helpers ────────────────────────────────────────
-/**
- * Concatenated string used for substring scans. We pre-build this once per
- * classify call so the helper functions can share it. Stdout is capped per
- * the trajectory parser convention to keep runaway agents from OOMing the
- * bench.
- */
-function collectTrace(runResult) {
-    const stdout = runResult.verifierStdout ?? "";
-    const capped = stdout.length > FAILURE_MODE_STDOUT_SCAN_CAP ? stdout.slice(0, FAILURE_MODE_STDOUT_SCAN_CAP) : stdout;
-    return capped;
-}
-/** Does the trace contain any `akm search` invocation (CLI form OR event)? */
-function hasAkmSearch(trace, runResult) {
-    // Tool-call CLI form, e.g. `akm search "deploy homelab"`.
-    if (/\bakm\s+search\b/.test(trace))
-        return true;
-    // Tool-call JSON form, e.g. `"args":["search","..."]`.
-    if (trace.includes(`"search"`) && /["']search["']/.test(trace))
-        return true;
-    // Event-stream form (search verbs aren't currently emitted but the field
-    // is forward-compatible — see core/events.ts).
-    for (const event of runResult.events) {
-        if (event.eventType === "search" || event.eventType === "search_invoked")
-            return true;
-    }
-    return false;
-}
-/**
- * Find the 1-based rank of `goldRef` in the search results captured in the
- * trace, or `null` if not present. Best-effort heuristics:
- *   1. Look for an `akm search` block followed by a numbered list (`1. skill:foo`).
- *   2. Look for a JSON-ish results array containing the ref.
- *   3. Fall back to substring presence — if the ref appears anywhere after
- *      a search invocation, treat it as rank-unknown. We err on the side of
- *      `1` (best case for the agent) so the classifier doesn't false-positive
- *      on `search_low_rank`.
- */
-function findGoldSearchRank(trace, goldRef) {
-    // Locate the first `akm search` invocation; restrict the rank search to
-    // text after it so we don't pick up `akm show` output.
-    const searchMatch = trace.match(/\bakm\s+search\b/);
-    if (!searchMatch || searchMatch.index === undefined) {
-        // Caller already verified search ran; if our regex disagrees, fall back
-        // to scanning the full trace.
-        return findRefRankInText(trace, goldRef);
-    }
-    const after = trace.slice(searchMatch.index);
-    return findRefRankInText(after, goldRef);
-}
-function findRefRankInText(text, goldRef) {
-    const escaped = goldRef.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // Numbered list: lines of the form `<rank>. <ref>` or `<rank>) <ref>`.
-    const numberedRe = /^\s*(\d{1,3})[.)]\s+([^\s]+)/gm;
-    let match;
-    while (true) {
-        match = numberedRe.exec(text);
-        if (match === null)
-            break;
-        const ref = match[2];
-        if (refsMatch(ref, goldRef)) {
-            return Number.parseInt(match[1], 10);
-        }
-    }
-    // JSON array form: `"results":["a","b","skill:foo"]`. Estimate rank by
-    // splitting on commas after the bracket. Best-effort.
-    const jsonRe = /"results"\s*:\s*\[([^\]]+)\]/;
-    const jsonMatch = text.match(jsonRe);
-    if (jsonMatch) {
-        const items = jsonMatch[1].split(",").map((s) => s.trim().replace(/^["']|["']$/g, ""));
-        const idx = items.findIndex((item) => refsMatch(item, goldRef));
-        if (idx >= 0)
-            return idx + 1;
-    }
-    // Substring presence — assume rank 1 (best case for the agent, conservative
-    // for the `search_low_rank` rule).
-    const refRe = new RegExp(`\\b${escaped}\\b`);
-    if (refRe.test(text))
-        return 1;
-    return null;
-}
-/** True when `candidate` is `goldRef` or a strict ref-extension thereof. */
-function refsMatch(candidate, goldRef) {
-    if (candidate === goldRef)
-        return true;
-    if (candidate.endsWith(`//${goldRef}`))
-        return true;
-    if (candidate.startsWith(`${goldRef}/`))
-        return true;
-    return false;
-}
-/** Did the agent invoke `akm show <goldRef>` at any point? */
-function hasAkmShow(trace, runResult, goldRef) {
-    const escaped = goldRef.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-    // CLI form, exact ref. Also matches origin-prefixed variants like
-    // `akm show team//skill:foo` because the `[\w/]*//` prefix is optional.
-    const cliRe = new RegExp(`\\bakm\\s+show\\s+["']?(?:[\\w-]+//)?${escaped}(?:\\b|\\W)`);
-    if (cliRe.test(trace))
-        return true;
-    // Tool-call JSON form: `"args":["show","skill:foo"]`.
-    if (trace.includes(`"show"`) && trace.includes(goldRef))
-        return true;
-    // Event-stream metadata.ref.
-    for (const event of runResult.events) {
-        if (typeof event.ref === "string" && refsMatch(event.ref, goldRef)) {
-            // Only count "show" or "load" eventTypes; a `feedback` event mentioning
-            // the ref doesn't mean the agent loaded it during this run.
-            if (event.eventType === "show" || event.eventType === "load" || event.eventType === "tool_call")
-                return true;
-        }
-        const meta = event.metadata;
-        if (meta && typeof meta === "object") {
-            const candidate = meta.ref;
-            if (typeof candidate === "string" && refsMatch(candidate, goldRef)) {
-                if (event.eventType === "show" || event.eventType === "load" || event.eventType === "tool_call")
-                    return true;
-            }
-        }
-    }
-    return false;
-}
-/** Did the agent invoke `akm show <ref>` for some ref OTHER than `goldRef`? */
-function hasAkmShowOtherRef(trace, runResult, goldRef) {
-    // CLI form: capture the ref argument and reject when it matches the gold.
-    const cliRe = /\bakm\s+show\s+["']?([^\s"'`]+)/g;
-    let match;
-    while (true) {
-        match = cliRe.exec(trace);
-        if (match === null)
-            break;
-        if (!refsMatch(match[1], goldRef))
-            return true;
-    }
-    // Tool-call JSON form: `"args":["show","..."]`. Best-effort scan.
-    const jsonRe = /\["show",\s*"([^"]+)"/g;
-    while (true) {
-        match = jsonRe.exec(trace);
-        if (match === null)
-            break;
-        if (!refsMatch(match[1], goldRef))
-            return true;
-    }
-    // Event-stream form.
-    for (const event of runResult.events) {
-        if (event.eventType !== "show" && event.eventType !== "load" && event.eventType !== "tool_call")
-            continue;
-        if (typeof event.ref === "string" && !refsMatch(event.ref, goldRef))
-            return true;
-        const meta = event.metadata;
-        if (meta && typeof meta === "object") {
-            const candidate = meta.ref;
-            if (typeof candidate === "string" && !refsMatch(candidate, goldRef))
-                return true;
-        }
-    }
-    return false;
-}
-/**
- * Conservative heuristic for the `loaded_ignored` branch. Without an LLM we
- * cannot reliably decide whether an arbitrary action contradicts arbitrary
- * asset content; we only fire when the verifier's own diagnostic explicitly
- * flags the gold-asset guidance as ignored.
- *
- * The verifier stdout strings are deterministic — they come from
- * `runVerifier` and the per-task `verify.sh` scripts. Tasks that want to
- * surface this label should emit one of the agreed-upon markers below.
- */
-function verifierIndicatesIgnored(verifierStdout) {
-    if (!verifierStdout)
-        return false;
-    const lower = verifierStdout.toLowerCase();
-    return (lower.includes("ignored gold guidance") ||
-        lower.includes("guidance ignored") ||
-        lower.includes("did not follow loaded asset") ||
-        lower.includes("contradicts loaded asset"));
-}
-/** Cap on the number of result refs we extract per `akm search` invocation. */
-const TOP_K = 10;
-/**
- * Extract the gold rank for every `akm search` invocation in a run.
- *
- * The parser scans `runResult.verifierStdout` (which carries the captured
- * agent stdout including its tool-call trace) for `akm search` commands
- * and the result lists that follow them. The first 10 hits are considered;
- * if the gold ref appears, `rankOfGold` is its 1-based position, else
- * `null`.
- *
- * Pure function: never reads from disk and never mutates inputs. When
- * `goldRef` is undefined the function returns `[]` — we only attribute
- * ranks for tasks that actually have a gold asset.
- */
-export function extractGoldRanks(runResult, goldRef) {
-    if (!goldRef)
-        return [];
-    const haystack = runResult.verifierStdout;
-    if (!haystack)
-        return [];
-    const events = [];
-    // Walk the stdout linearly. A search invocation looks like
-    //   `akm search "<query>"` or `akm search <query>`
-    // and the subsequent block carries the result list. A new `akm` command
-    // (or end of stdout) terminates the previous search's result block.
-    const lines = haystack.split(/\r?\n/);
-    let active = null;
-    // Regex for an `akm search` invocation. Captures the rest of the line
-    // after `search ` so we can pick up the query whether it's quoted or not.
-    const searchInvocationRe = /\bakm\s+search\s+(.+?)(?:\s+--|$)/;
-    // A different `akm <verb>` (not `search`) terminates the active block.
-    const akmInvocationRe = /\bakm\s+(\w+)/;
-    for (const rawLine of lines) {
-        const line = rawLine.trim();
-        if (!line)
-            continue;
-        const searchMatch = line.match(searchInvocationRe);
-        if (searchMatch) {
-            // Flush any active block before starting a new one.
-            if (active) {
-                active.rankOfGold = computeRank(active.results, goldRef);
-                events.push(active);
-            }
-            const query = stripQuotes(searchMatch[1].trim());
-            active = { query, results: [], rankOfGold: null };
-            // Some traces inline the JSON result on the same line — try to extract.
-            collectRefsFromLine(line, active.results);
-            continue;
-        }
-        if (!active)
-            continue;
-        // A non-search akm invocation closes the active search block.
-        const akmMatch = line.match(akmInvocationRe);
-        if (akmMatch && akmMatch[1] !== "search") {
-            active.rankOfGold = computeRank(active.results, goldRef);
-            events.push(active);
-            active = null;
-            continue;
-        }
-        collectRefsFromLine(line, active.results);
-    }
-    if (active) {
-        active.rankOfGold = computeRank(active.results, goldRef);
-        events.push(active);
-    }
-    return events;
-}
-/** Trim leading/trailing single or double quotes from a query string. */
-function stripQuotes(s) {
-    if (s.length >= 2) {
-        const first = s[0];
-        const last = s[s.length - 1];
-        if ((first === '"' && last === '"') || (first === "'" && last === "'")) {
-            return s.slice(1, -1);
-        }
-    }
-    return s;
-}
-/**
- * Pull asset refs from a single line into `out`. Matches both plain
- * `ref: <ref>` lines (text mode) and `"ref":"<ref>"` (JSON mode). We
- * stop at TOP_K results to mirror the spec's top-10 cutoff.
- */
-function collectRefsFromLine(line, out) {
-    if (out.length >= TOP_K)
-        return;
-    // JSON form: `"ref":"skill:foo"` or `"ref": "skill:foo"`. Multiple per line possible.
-    const jsonRe = /"ref"\s*:\s*"([^"]+)"/g;
-    let m;
-    m = jsonRe.exec(line);
-    while (m !== null) {
-        if (out.length >= TOP_K)
-            return;
-        out.push(m[1]);
-        m = jsonRe.exec(line);
-    }
-    // Plain text form: `  ref: skill:foo`. Only treat the line as a ref-bearing
-    // line if it starts with `ref:` (after whitespace). Avoids picking up
-    // every `:` in arbitrary stdout.
-    const textRe = /^ref:\s*([^\s,]+)/;
-    const tm = line.match(textRe);
-    if (tm && out.length < TOP_K) {
-        out.push(tm[1]);
-    }
-}
-/**
- * 1-based rank of `goldRef` in `results`, or `null` if absent within the
- * top 10. We use `matchesGold` for prefix-tolerant matching so
- * `team//skill:foo` counts as `skill:foo` (mirrors trajectory parser).
- */
-function computeRank(results, goldRef) {
-    const cap = Math.min(results.length, TOP_K);
-    for (let i = 0; i < cap; i += 1) {
-        if (matchesGold(results[i], goldRef))
-            return i + 1;
-    }
-    return null;
-}
-function matchesGold(candidate, gold) {
-    if (candidate === gold)
-        return true;
-    if (candidate.endsWith(`//${gold}`))
-        return true;
-    if (candidate.startsWith(`${gold}/`))
-        return true;
-    return false;
-}
-/**
- * Aggregate gold-rank records across all akm-arm runs in the corpus.
- *
- * The function operates on `report.goldRankRecords`, which the runner
- * populates per (task, arm, seed). When the corpus has no gold-ref tasks
- * at all (every record list is empty), every metric collapses to a zero
- * envelope and the `passRateByRank` table is empty — the renderer turns
- * that into a single "(N/A)" sentence.
- */
-export function computeSearchBridge(report) {
-    const records = report.goldRankRecords ?? [];
-    // Histogram + percentile inputs across every search.
-    const histogram = emptyHistogram();
-    const allRanks = [];
-    let totalSearches = 0;
-    for (const rec of records) {
-        for (const ev of rec.searches) {
-            totalSearches += 1;
-            allRanks.push(ev.rankOfGold);
-            const bucket = ev.rankOfGold === null ? "missing" : String(ev.rankOfGold);
-            histogram[bucket] = (histogram[bucket] ?? 0) + 1;
-        }
-    }
-    const goldAtRank1 = totalSearches === 0 ? 0 : (histogram["1"] ?? 0) / totalSearches;
-    const goldMissing = totalSearches === 0 ? 0 : (histogram.missing ?? 0) / totalSearches;
-    const goldRankP50 = totalSearches === 0 ? null : percentile(allRanks, 50);
-    const goldRankP90 = totalSearches === 0 ? null : percentile(allRanks, 90);
-    // pass_rate_by_rank — split runs by the rank in *the search the agent
-    // actually ran*. We use the last `akm search` of the run (or "missing"
-    // when no search at all happened, or "missing" when the agent searched
-    // but gold wasn't in the top 10 in that final search). Runs without any
-    // `akm search` invocation are dropped from this slice — `pass_rate_by_rank`
-    // only describes what happened given a search.
-    const passRateBuckets = new Map();
-    for (const rec of records) {
-        if (rec.searches.length === 0)
-            continue;
-        const chosen = rec.searches[rec.searches.length - 1];
-        const bucket = chosen.rankOfGold === null ? "missing" : String(chosen.rankOfGold);
-        const slot = passRateBuckets.get(bucket) ?? { passes: 0, total: 0 };
-        slot.total += 1;
-        if (rec.outcome === "pass")
-            slot.passes += 1;
-        passRateBuckets.set(bucket, slot);
-    }
-    const passRateByRank = [];
-    for (const rank of histogramKeys()) {
-        const slot = passRateBuckets.get(rank);
-        if (!slot)
-            continue;
-        passRateByRank.push({
-            rank,
-            passRate: slot.total === 0 ? 0 : slot.passes / slot.total,
-            runCount: slot.total,
-        });
-    }
-    return {
-        goldRankDistribution: histogram,
-        goldRankP50,
-        goldRankP90,
-        goldAtRank1,
-        goldMissing,
-        passRateByRank,
-        runsObserved: records.length,
-        searchesObserved: totalSearches,
-    };
-}
-/** Ordered keys used for both the histogram and the pass_rate_by_rank table. */
-export function histogramKeys() {
-    return ["1", "2", "3", "4", "5", "6", "7", "8", "9", "10", "missing"];
-}
-function emptyHistogram() {
-    const out = {};
-    for (const k of histogramKeys())
-        out[k] = 0;
-    return out;
-}
-/**
- * Linear-interpolated percentile over a list of ranks. `null` ranks are
- * treated as `Infinity` so the missing bucket pushes percentiles up
- * correctly. Returns `Infinity` when the percentile lands in the missing
- * region; the renderer surfaces that as the literal `"missing"` token so
- * downstream JSON consumers don't choke on `Infinity`.
- */
-function percentile(ranks, p) {
-    if (ranks.length === 0)
-        return Number.NaN;
-    const sorted = ranks.map((r) => (r === null ? Number.POSITIVE_INFINITY : r)).sort((a, b) => a - b);
-    // Nearest-rank method (avoids interpolation between Infinity and a finite).
-    // index = ceil(p/100 * N) - 1, clamped to [0, N-1].
-    const idx = Math.min(sorted.length - 1, Math.max(0, Math.ceil((p / 100) * sorted.length) - 1));
-    return sorted[idx];
-}
-/**
- * Aggregate proposal-quality metrics from the evolve runner's proposal log.
- * Pure function — does not touch disk and does not invoke any subprocess.
- */
-export function computeProposalQualityMetrics(proposalLog) {
-    const byRef = new Map();
-    let totalAccepted = 0;
-    let totalLintPass = 0;
-    for (const entry of proposalLog) {
-        let row = byRef.get(entry.assetRef);
-        if (!row) {
-            row = { assetRef: entry.assetRef, proposalCount: 0, lintPassCount: 0, acceptedCount: 0 };
-            byRef.set(entry.assetRef, row);
-        }
-        row.proposalCount += 1;
-        if (entry.lintPass) {
-            row.lintPassCount += 1;
-            totalLintPass += 1;
-        }
-        if (entry.decision === "accept") {
-            row.acceptedCount += 1;
-            totalAccepted += 1;
-        }
-    }
-    const rows = [...byRef.values()].sort((a, b) => a.assetRef.localeCompare(b.assetRef));
-    const totalProposals = proposalLog.length;
-    return {
-        rows,
-        totalProposals,
-        totalAccepted,
-        acceptanceRate: totalProposals === 0 ? 0 : totalAccepted / totalProposals,
-        lintPassRate: totalProposals === 0 ? 0 : totalLintPass / totalProposals,
-    };
-}
-/**
- * Compute longitudinal metrics from three §13.3 utility-shaped reports. Each
- * input report is expected to share the same eval-slice corpus, with one arm
- * driving the akm side: `pre` = pre-evolve stash, `post` = evolved stash,
- * `synthetic` = no-stash scratchpad arm.
- *
- * The "arm" we read off each report is `aggregateAkm.passRate` — the runners
- * produce the akm arm for all three (synthetic is just the akm arm with a
- * stripped stashDir; pre/post differ by stash content). `seedsPerArm` for
- * the degradation threshold is taken from the post report's corpus envelope.
- */
-export function computeLongitudinalMetrics(preReport, postReport, syntheticReport) {
-    const prePassRate = preReport.aggregateAkm.passRate;
-    const postPassRate = postReport.aggregateAkm.passRate;
-    const syntheticPassRate = syntheticReport.aggregateAkm.passRate;
-    const seedsPerArm = Math.max(1, postReport.corpus.seedsPerArm);
-    const oneSeedFraction = 1 / seedsPerArm;
-    // Per-task degradation: outer-join pre and post on task id.
-    const preTasks = new Map();
-    for (const t of preReport.tasks)
-        preTasks.set(t.id, t);
-    const postTasks = new Map();
-    for (const t of postReport.tasks)
-        postTasks.set(t.id, t);
-    // Index post failure-mode labels by task id (one mode per task — first
-    // failed run wins; matches the §6.6 by-task aggregate's natural ordering).
-    const postFailureByTask = {};
-    const postFailureByTaskMap = postReport.failureModes?.byTask ?? {};
-    for (const [taskId, byMode] of Object.entries(postFailureByTaskMap)) {
-        const labels = Object.keys(byMode);
-        if (labels.length > 0)
-            postFailureByTask[taskId] = labels[0];
-    }
-    const degradations = [];
-    const allIds = new Set();
-    for (const id of preTasks.keys())
-        allIds.add(id);
-    for (const id of postTasks.keys())
-        allIds.add(id);
-    for (const id of [...allIds].sort()) {
-        const pre = preTasks.get(id);
-        const post = postTasks.get(id);
-        if (!pre || !post)
-            continue;
-        const preRate = pre.akm.passRate;
-        const postRate = post.akm.passRate;
-        const dropped = preRate - postRate;
-        if (dropped > oneSeedFraction) {
-            degradations.push({
-                taskId: id,
-                prePassRate: preRate,
-                postPassRate: postRate,
-                delta: postRate - preRate,
-                failureMode: postFailureByTask[id] ?? null,
-            });
-        }
-    }
-    return {
-        improvementSlope: postPassRate - prePassRate,
-        overSyntheticLift: postPassRate - syntheticPassRate,
-        degradationCount: degradations.length,
-        degradations,
-        prePassRate,
-        postPassRate,
-        syntheticPassRate,
-    };
-}
-/** Threshold above `pass_rate[0]` that defines "improvement" for §6.4. */
-export const LEARNING_IMPROVEMENT_THRESHOLD = 0.05;
-export function computeLearningCurve(episodes) {
-    // Stable sort by episode_index — defensive against unordered inputs.
-    const sorted = [...episodes].sort((a, b) => a.episode_index - b.episode_index);
-    // Recompute per-episode deltas so the contract holds regardless of what
-    // the caller stamped on the input record.
-    const normalised = sorted.map((ep, i) => {
-        const prev = i === 0 ? null : sorted[i - 1];
-        const delta = prev === null ? 0 : ep.pass_rate - prev.pass_rate;
-        return { ...ep, delta_from_previous_episode: delta };
-    });
-    const passRateByEpisode = normalised.map((ep) => ep.pass_rate);
-    // Linear regression slope: sum((xi - x_mean) * (yi - y_mean)) /
-    // sum((xi - x_mean)^2). For a single episode the denominator is 0 — we
-    // return 0 (no observable trend) rather than NaN.
-    const n = normalised.length;
-    let learningSlope = 0;
-    if (n >= 2) {
-        const xs = normalised.map((ep) => ep.episode_index);
-        const xMean = xs.reduce((s, v) => s + v, 0) / n;
-        const yMean = passRateByEpisode.reduce((s, v) => s + v, 0) / n;
-        let num = 0;
-        let den = 0;
-        for (let i = 0; i < n; i += 1) {
-            const dx = xs[i] - xMean;
-            const dy = passRateByEpisode[i] - yMean;
-            num += dx * dy;
-            den += dx * dx;
-        }
-        learningSlope = den === 0 ? 0 : num / den;
-    }
-    // time_to_improvement: smallest episode_index strictly greater than
-    // `pass_rate[0] + threshold`. Episode 0 itself is excluded — improvement
-    // is only meaningful relative to baseline.
-    let timeToImprovement = null;
-    if (n >= 2) {
-        const baseline = passRateByEpisode[0];
-        for (let i = 1; i < n; i += 1) {
-            if (passRateByEpisode[i] > baseline + LEARNING_IMPROVEMENT_THRESHOLD) {
-                timeToImprovement = normalised[i].episode_index;
-                break;
-            }
-        }
-    }
-    return {
-        episodes: normalised,
-        pass_rate_by_episode: passRateByEpisode,
-        learning_slope: learningSlope,
-        time_to_improvement: timeToImprovement,
-    };
-}
-/**
- * Compute the §6.8 feedback-signal integrity confusion matrix.
- *
- * Pure function — does not touch disk and does not invoke any subprocess.
- * The join is by `(taskId, seed)` so that a feedback event is attributed
- * to the run that produced it, NOT to a later run that happens to touch
- * the same gold ref. This matters when the same gold ref appears across
- * multiple Phase 1 runs (e.g. multiple seeds, or two tasks sharing a
- * skill); the per-asset row aggregates across all runs that referenced it
- * in feedback, but each individual feedback event's matrix cell is
- * decided by its own run's outcome.
- *
- * NaN-safety: a per-asset row with zero feedback events (cannot happen via
- * this function — every row is derived from at least one feedback entry —
- * but defensive against future callers passing curated subsets) emits all
- * three rates as `null`. `false_positive_rate` is `null` when `FP+TN===0`
- * even if the row has `FN+TP>0`, and vice versa.
- */
-export function computeFeedbackIntegrity(input) {
-    const akmRuns = input.phase1.akmRuns ?? [];
-    // Build a (taskId, seed) → outcome lookup so every feedback event
-    // resolves in O(1). When two runs share the same key (shouldn't happen
-    // — runner emits unique seeds per task — but defensive) the first
-    // wins.
-    const runOutcomeByKey = new Map();
-    for (const r of akmRuns) {
-        const key = `${r.taskId}::${r.seed}`;
-        if (!runOutcomeByKey.has(key))
-            runOutcomeByKey.set(key, r.outcome);
-    }
-    const perRef = new Map();
-    let aggTP = 0;
-    let aggFP = 0;
-    let aggTN = 0;
-    let aggFN = 0;
-    // Track which (taskId, seed) keys had any feedback dispatched (ok or
-    // not), for the coverage denominator. We count an attempted dispatch as
-    // covered — if `ok===false`, the operator wanted feedback but the CLI
-    // failed; that's still a covered run for the purpose of §6.8 (and is
-    // surfaced in the warnings list elsewhere).
-    const coveredKeys = new Set();
-    for (const fb of input.feedbackLog) {
-        const key = `${fb.taskId}::${fb.seed}`;
-        coveredKeys.add(key);
-        if (!fb.ok)
-            continue; // failed dispatches don't label a matrix cell.
-        const outcome = runOutcomeByKey.get(key);
-        if (outcome === undefined)
-            continue; // run not found — defensive, drop.
-        // harness_error runs are not labelled (the bench skips dispatching
-        // feedback for them; if a fake test injects one, we drop it from the
-        // matrix to avoid mislabelling).
-        if (outcome === "harness_error")
-            continue;
-        const passed = outcome === "pass";
-        let row = perRef.get(fb.goldRef);
-        if (!row) {
-            row = { truePositive: 0, falsePositive: 0, trueNegative: 0, falseNegative: 0 };
-            perRef.set(fb.goldRef, row);
-        }
-        if (fb.signal === "positive" && passed) {
-            row.truePositive += 1;
-            aggTP += 1;
-        }
-        else if (fb.signal === "positive" && !passed) {
-            row.falsePositive += 1;
-            aggFP += 1;
-        }
-        else if (fb.signal === "negative" && !passed) {
-            row.trueNegative += 1;
-            aggTN += 1;
-        }
-        else if (fb.signal === "negative" && passed) {
-            row.falseNegative += 1;
-            aggFN += 1;
-        }
-    }
-    const aggTotal = aggTP + aggFP + aggTN + aggFN;
-    const totalPhase1Runs = akmRuns.length;
-    const aggregate = {
-        truePositive: aggTP,
-        falsePositive: aggFP,
-        trueNegative: aggTN,
-        falseNegative: aggFN,
-        feedback_agreement: aggTotal === 0 ? 0 : (aggTP + aggTN) / aggTotal,
-        false_positive_rate: aggFP + aggTN === 0 ? 0 : aggFP / (aggFP + aggTN),
-        false_negative_rate: aggFN + aggTP === 0 ? 0 : aggFN / (aggFN + aggTP),
-        feedback_coverage: totalPhase1Runs === 0 ? 0 : coveredKeys.size / totalPhase1Runs,
-    };
-    const perAsset = [];
-    for (const [ref, row] of [...perRef.entries()].sort((a, b) => a[0].localeCompare(b[0]))) {
-        const total = row.truePositive + row.falsePositive + row.trueNegative + row.falseNegative;
-        const fpDenom = row.falsePositive + row.trueNegative;
-        const fnDenom = row.falseNegative + row.truePositive;
-        perAsset.push({
-            ref,
-            truePositive: row.truePositive,
-            falsePositive: row.falsePositive,
-            trueNegative: row.trueNegative,
-            falseNegative: row.falseNegative,
-            feedback_agreement: total === 0 ? null : (row.truePositive + row.trueNegative) / total,
-            false_positive_rate: fpDenom === 0 ? null : row.falsePositive / fpDenom,
-            false_negative_rate: fnDenom === 0 ? null : row.falseNegative / fnDenom,
-        });
-    }
-    return { aggregate, perAsset };
-}
-function aggregateByKey(entries, pickKey) {
-    const buckets = new Map();
-    for (const entry of entries) {
-        const key = pickKey(entry);
-        if (!key)
-            continue;
-        let arr = buckets.get(key);
-        if (!arr) {
-            arr = [];
-            buckets.set(key, arr);
-        }
-        arr.push(entry);
-    }
-    const rows = [];
-    for (const [category, group] of buckets) {
-        const n = group.length;
-        let noakmSum = 0;
-        let akmSum = 0;
-        let regressionCount = 0;
-        let complianceSum = 0;
-        let complianceCount = 0;
-        for (const t of group) {
-            noakmSum += t.noakm.passRate;
-            akmSum += t.akm.passRate;
-            if (t.akm.passRate < t.noakm.passRate)
-                regressionCount += 1;
-            if (typeof t.workflowCompliance === "number" && Number.isFinite(t.workflowCompliance)) {
-                complianceSum += t.workflowCompliance;
-                complianceCount += 1;
-            }
-        }
-        rows.push({
-            category,
-            taskCount: n,
-            passRateNoakm: noakmSum / n,
-            passRateAkm: akmSum / n,
-            passRateDelta: akmSum / n - noakmSum / n,
-            negativeTransferCount: regressionCount,
-            workflowCompliance: complianceCount === 0 ? null : complianceSum / complianceCount,
-        });
-    }
-    rows.sort((a, b) => a.category.localeCompare(b.category));
-    return rows;
-}
-/**
- * Aggregate per-task entries by `memoryAbility` (#262). Tasks lacking a tag
- * are skipped so the report only surfaces categories with explicit
- * coverage. Output rows are sorted by category for byte-stable JSON.
- *
- * The closed set of memory-ability values is exported as
- * {@link MEMORY_ABILITY_VALUES} from `corpus.ts`.
- */
-export function aggregateByMemoryAbility(entries) {
-    return aggregateByKey(entries, (e) => e.memoryAbility);
-}
-/**
- * Aggregate per-task entries by `taskFamily` (#262). Tasks lacking a tag
- * are skipped. `taskFamily` follows the `<domain>/<short-name>` grammar —
- * tasks sharing a family are expected to transfer knowledge between each
- * other. Output rows are sorted by category for byte-stable JSON.
- */
-export function aggregateByTaskFamily(entries) {
-    return aggregateByKey(entries, (e) => e.taskFamily);
-}
-export function computeCorpusCoverage(tasks) {
-    const memoryAbilityCounts = {
-        untagged: 0,
-    };
-    for (const ability of MEMORY_ABILITY_VALUES) {
-        memoryAbilityCounts[ability] = 0;
-    }
-    const taskFamilyCounts = {};
-    let untaggedFamily = 0;
-    for (const task of tasks) {
-        if (task.memoryAbility) {
-            memoryAbilityCounts[task.memoryAbility] = (memoryAbilityCounts[task.memoryAbility] ?? 0) + 1;
-        }
-        else {
-            memoryAbilityCounts.untagged += 1;
-        }
-        if (task.taskFamily) {
-            taskFamilyCounts[task.taskFamily] = (taskFamilyCounts[task.taskFamily] ?? 0) + 1;
-        }
-        else {
-            untaggedFamily += 1;
-        }
-    }
-    if (untaggedFamily > 0)
-        taskFamilyCounts.untagged = untaggedFamily;
-    return {
-        totalTasks: tasks.length,
-        memoryAbilityCounts,
-        taskFamilyCounts,
-    };
-}
-/**
- * Verb counts considered "AKM tool calls" for `totalToolCalls`. We
- * deliberately keep this list small — each verb folded in MUST be a
- * user-initiated CLI invocation, not a background bookkeeping event.
- * Adding new verbs here is additive and changes only `totalToolCalls`.
- */
-export const AKM_TOOL_CALL_TYPES = new Set([
-    "akm_search",
-    "akm_show",
-    "akm_feedback",
-]);
-/**
- * Compute per-run AKM overhead records by replaying #254's normalised trace.
- *
- * Pure function: never mutates `runs` and never reads disk. The optional
- * `taskMetadata` lookup is used only to label loads as relevant / irrelevant
- * and to compute `timeToFirstCorrectAssetMs`.
- *
- * Returned array length matches `runs.length`; element order matches input
- * order. Runs whose trace contains no AKM events still produce a record
- * with all counts at zero and timings at `null`.
- */
-export function computeAkmOverhead(runs, options = {}) {
-    const out = [];
-    for (const run of runs) {
-        out.push(perRun(run, options.taskMetadata));
-    }
-    return out;
-}
-function perRun(run, taskMetadata) {
-    const trace = normalizeRunToTrace(run);
-    const events = trace.events;
-    let searchCount = 0;
-    let showCount = 0;
-    let feedbackCount = 0;
-    let positiveFeedbackCount = 0;
-    let negativeFeedbackCount = 0;
-    const uniqueShowRefs = new Set();
-    for (const ev of events) {
-        if (ev.type === "akm_search")
-            searchCount += 1;
-        else if (ev.type === "akm_show") {
-            showCount += 1;
-            if (typeof ev.assetRef === "string" && ev.assetRef.length > 0) {
-                uniqueShowRefs.add(ev.assetRef);
-            }
-        }
-        else if (ev.type === "akm_feedback") {
-            feedbackCount += 1;
-            // Polarity is carried in args as "--positive" or "--negative".
-            // Events sourced from events.jsonl also have args populated by
-            // normalizeRunToTrace. Absence of both flags is treated as unknown
-            // (contributes to feedbackCount but not to either polarity counter).
-            if (ev.args?.includes("--positive"))
-                positiveFeedbackCount += 1;
-            else if (ev.args?.includes("--negative"))
-                negativeFeedbackCount += 1;
-        }
-    }
-    const totalToolCalls = searchCount + showCount + feedbackCount;
-    // Run-start anchor: earliest parseable ts in the trace. We use the trace
-    // (not RunResult.events directly) so harness lifecycle markers, when
-    // supplied, can serve as the anchor for stdout-derived events that lack a
-    // native ts.
-    const runStartMs = earliestEventMs(events);
-    const timeToFirstSearchMs = computeFirstEventOffsetMs(events, runStartMs, (ev) => ev.type === "akm_search");
-    // Resolve task metadata once. Missing metadata means we can't judge
-    // relevance — emit null counts rather than zero.
-    const meta = taskMetadata?.get(run.taskId);
-    const goldRef = meta?.goldRef;
-    const transferFrom = meta?.expectedTransferFrom ?? [];
-    const knownRelevant = new Set();
-    if (typeof goldRef === "string" && goldRef.length > 0)
-        knownRelevant.add(goldRef);
-    for (const r of transferFrom) {
-        if (typeof r === "string" && r.length > 0)
-            knownRelevant.add(r);
-    }
-    let irrelevantAssetsLoadedCount;
-    if (!meta) {
-        // No metadata: cannot tell relevant from irrelevant. Surface null.
-        irrelevantAssetsLoadedCount = null;
-    }
-    else {
-        let count = 0;
-        for (const ref of uniqueShowRefs) {
-            if (!knownRelevant.has(ref))
-                count += 1;
-        }
-        irrelevantAssetsLoadedCount = count;
-    }
-    let timeToFirstCorrectAssetMs = null;
-    if (typeof goldRef === "string" && goldRef.length > 0) {
-        timeToFirstCorrectAssetMs = computeFirstEventOffsetMs(events, runStartMs, (ev) => ev.type === "akm_show" && ev.assetRef === goldRef);
-    }
-    return {
-        taskId: run.taskId,
-        arm: run.arm,
-        seed: run.seed,
-        outcome: run.outcome,
-        searchCount,
-        showCount,
-        feedbackCount,
-        positiveFeedbackCount,
-        negativeFeedbackCount,
-        totalToolCalls,
-        assetsLoadedCount: uniqueShowRefs.size,
-        irrelevantAssetsLoadedCount,
-        timeToFirstSearchMs,
-        timeToFirstCorrectAssetMs,
-        // Byte sizes are not yet wired through the trace (#254 does not capture
-        // payload sizes). Callers MUST treat null as "unavailable", not zero.
-        contextBytesLoaded: null,
-        assetBytesLoaded: null,
-    };
-}
-/**
- * Aggregate per-run AKM overhead records into the corpus-wide block (#263).
- *
- * Pure: never mutates `perRun`. When `perRun` is empty, returns a zero/null
- * envelope so callers can render a "no AKM activity" section without
- * branching. `passingRuns === 0` always implies `toolCallsPerSuccess === null`
- * and `costPerSuccess === null`.
- */
-export function aggregateAkmOverhead(perRun, rawRuns = []) {
-    const n = perRun.length;
-    if (n === 0) {
-        return {
-            totalRuns: 0,
-            passingRuns: 0,
-            meanSearchCount: 0,
-            meanShowCount: 0,
-            meanFeedbackCount: 0,
-            meanToolCalls: 0,
-            meanAssetsLoaded: 0,
-            meanIrrelevantAssetsLoaded: null,
-            meanTimeToFirstSearchMs: null,
-            meanTimeToFirstCorrectAssetMs: null,
-            meanContextBytesLoaded: null,
-            meanAssetBytesLoaded: null,
-            totalToolCalls: 0,
-            toolCallsPerSuccess: null,
-            costPerSuccess: null,
-            searchEngagementRate: 0,
-            showEngagementRate: 0,
-            feedbackEngagementRate: 0,
-            searchToShowRatio: null,
-            meanPositiveFeedbackCount: 0,
-            meanNegativeFeedbackCount: 0,
-        };
-    }
-    let searchSum = 0;
-    let showSum = 0;
-    let feedbackSum = 0;
-    let toolCallsSum = 0;
-    let assetsSum = 0;
-    let irrelevantSum = 0;
-    let irrelevantCount = 0;
-    let firstSearchSum = 0;
-    let firstSearchCount = 0;
-    let firstCorrectSum = 0;
-    let firstCorrectCount = 0;
-    let contextBytesSum = 0;
-    let contextBytesCount = 0;
-    let assetBytesSum = 0;
-    let assetBytesCount = 0;
-    // Build a quick lookup for token measurement off `rawRuns` so the cost-
-    // per-success calc can honour the parsed/missing/unsupported distinction
-    // without forcing the caller to project tokens onto AkmOverheadPerRun.
-    const rawByKey = new Map();
-    for (const r of rawRuns) {
-        rawByKey.set(`${r.taskId}${r.arm}${r.seed}`, r);
-    }
-    let passingRuns = 0;
-    let parsedPassTokenSum = 0;
-    let parsedPassCount = 0;
-    let anyPassMissingMeasurement = false;
-    let searchEngagedRuns = 0;
-    let showEngagedRuns = 0;
-    let feedbackEngagedRuns = 0;
-    let positiveFeedbackSum = 0;
-    let negativeFeedbackSum = 0;
-    for (const row of perRun) {
-        searchSum += row.searchCount;
-        showSum += row.showCount;
-        feedbackSum += row.feedbackCount;
-        toolCallsSum += row.totalToolCalls;
-        assetsSum += row.assetsLoadedCount;
-        if (row.searchCount > 0)
-            searchEngagedRuns += 1;
-        if (row.showCount > 0)
-            showEngagedRuns += 1;
-        if (row.feedbackCount > 0)
-            feedbackEngagedRuns += 1;
-        positiveFeedbackSum += row.positiveFeedbackCount;
-        negativeFeedbackSum += row.negativeFeedbackCount;
-        if (row.irrelevantAssetsLoadedCount !== null) {
-            irrelevantSum += row.irrelevantAssetsLoadedCount;
-            irrelevantCount += 1;
-        }
-        if (row.timeToFirstSearchMs !== null) {
-            firstSearchSum += row.timeToFirstSearchMs;
-            firstSearchCount += 1;
-        }
-        if (row.timeToFirstCorrectAssetMs !== null) {
-            firstCorrectSum += row.timeToFirstCorrectAssetMs;
-            firstCorrectCount += 1;
-        }
-        if (row.contextBytesLoaded !== null) {
-            contextBytesSum += row.contextBytesLoaded;
-            contextBytesCount += 1;
-        }
-        if (row.assetBytesLoaded !== null) {
-            assetBytesSum += row.assetBytesLoaded;
-            assetBytesCount += 1;
-        }
-        if (row.outcome === "pass") {
-            passingRuns += 1;
-            const raw = rawByKey.get(`${row.taskId}${row.arm}${row.seed}`);
-            // Treat absent tokenMeasurement as `parsed` for backward compat with
-            // older artefacts (mirrors `isMeasured` behaviour above).
-            const measurement = raw?.tokenMeasurement ?? "parsed";
-            if (raw && measurement === "parsed") {
-                parsedPassTokenSum += raw.tokens.input + raw.tokens.output;
-                parsedPassCount += 1;
-            }
-            else if (raw) {
-                anyPassMissingMeasurement = true;
-            }
-            else {
-                // No matching raw run supplied — cannot honour cost-per-success.
-                anyPassMissingMeasurement = true;
-            }
-        }
-    }
-    const toolCallsPerSuccess = passingRuns === 0 ? null : toolCallsSum / passingRuns;
-    // Cost-per-success: null unless EVERY passing run has parsed measurement.
-    // Mixed measurement statuses cannot be averaged honestly (issue #252).
-    const costPerSuccess = passingRuns === 0 || anyPassMissingMeasurement || parsedPassCount === 0
-        ? null
-        : parsedPassTokenSum / parsedPassCount;
-    const searchToShowRatio = searchSum === 0 ? null : showSum / searchSum;
-    return {
-        totalRuns: n,
-        passingRuns,
-        meanSearchCount: searchSum / n,
-        meanShowCount: showSum / n,
-        meanFeedbackCount: feedbackSum / n,
-        meanToolCalls: toolCallsSum / n,
-        meanAssetsLoaded: assetsSum / n,
-        meanIrrelevantAssetsLoaded: irrelevantCount === 0 ? null : irrelevantSum / irrelevantCount,
-        meanTimeToFirstSearchMs: firstSearchCount === 0 ? null : firstSearchSum / firstSearchCount,
-        meanTimeToFirstCorrectAssetMs: firstCorrectCount === 0 ? null : firstCorrectSum / firstCorrectCount,
-        meanContextBytesLoaded: contextBytesCount === 0 ? null : contextBytesSum / contextBytesCount,
-        meanAssetBytesLoaded: assetBytesCount === 0 ? null : assetBytesSum / assetBytesCount,
-        totalToolCalls: toolCallsSum,
-        toolCallsPerSuccess,
-        costPerSuccess,
-        searchEngagementRate: searchEngagedRuns / n,
-        showEngagementRate: showEngagedRuns / n,
-        feedbackEngagementRate: feedbackEngagedRuns / n,
-        searchToShowRatio,
-        meanPositiveFeedbackCount: positiveFeedbackSum / n,
-        meanNegativeFeedbackCount: negativeFeedbackSum / n,
-    };
-}
-/**
- * Bucket a workflow check status onto pass / non-pass for reliability.
- *
- * Reliability is a strict pass-or-not metric (issue #258). Anything other
- * than `pass` (including `partial`, `fail`, `harness_error`) counts as a
- * non-pass. `not_applicable` returns `null` so the caller can skip the
- * entire (task, seed) pair — it never contributes to either numerator or
- * denominator.
- */
-function bucketReliabilityStatus(status) {
-    if (status === "not_applicable")
-        return null;
-    if (status === "pass")
-        return "pass";
-    return "non_pass";
-}
-/**
- * Compute workflow reliability metrics (`pass@k` and `pass^k`) per workflow
- * and corpus-wide from a flat list of `WorkflowCheckResult`.
- *
- * Methodology (per #258 review addendum):
- *   1. Filter out `not_applicable` checks entirely.
- *   2. For each `(workflow_id, task_id)` group, collapse seeds to the set
- *      of statuses observed.
- *   3. `pass_at_k` per task = 1 if at least one seed is `pass`, else 0.
- *   4. `pass_all_k` per task = 1 if every seed is `pass`, else 0.
- *   5. Per-workflow row averages over its task set.
- *   6. Corpus rollup averages over every (workflow, task) group equally.
- *
- * Pure: never mutates `checks`. Returns a stable shape for empty input.
- */
-export function computeWorkflowReliability(checks) {
-    // Group by (workflow_id, task_id) → list of statuses across seeds.
-    // Use Map<string, Map<string, WorkflowCheckStatus[]>> so iteration order
-    // is insertion order (deterministic given deterministic input).
-    const grouped = new Map();
-    for (const c of checks) {
-        if (bucketReliabilityStatus(c.status) === null)
-            continue;
-        let perWorkflow = grouped.get(c.workflowId);
-        if (!perWorkflow) {
-            perWorkflow = new Map();
-            grouped.set(c.workflowId, perWorkflow);
-        }
-        const list = perWorkflow.get(c.taskId);
-        if (list)
-            list.push(c.status);
-        else
-            perWorkflow.set(c.taskId, [c.status]);
-    }
-    const byWorkflow = {};
-    let corpusPassAtKSum = 0;
-    let corpusPassAllKSum = 0;
-    let corpusGroupCount = 0;
-    const corpusTasks = new Set();
-    for (const [workflowId, perTask] of grouped) {
-        let passAtKSum = 0;
-        let passAllKSum = 0;
-        let kMax = 0;
-        for (const [taskId, statuses] of perTask) {
-            if (statuses.length > kMax)
-                kMax = statuses.length;
-            const allPass = statuses.every((s) => s === "pass");
-            const anyPass = statuses.some((s) => s === "pass");
-            if (anyPass)
-                passAtKSum += 1;
-            if (allPass)
-                passAllKSum += 1;
-            corpusPassAtKSum += anyPass ? 1 : 0;
-            corpusPassAllKSum += allPass ? 1 : 0;
-            corpusGroupCount += 1;
-            corpusTasks.add(taskId);
-        }
-        const taskCount = perTask.size;
-        byWorkflow[workflowId] = {
-            workflow_id: workflowId,
-            pass_at_k: taskCount === 0 ? 0 : passAtKSum / taskCount,
-            pass_all_k: taskCount === 0 ? 0 : passAllKSum / taskCount,
-            tasks: taskCount,
-            k: kMax,
-        };
-    }
-    const corpus = {
-        pass_at_k: corpusGroupCount === 0 ? 0 : corpusPassAtKSum / corpusGroupCount,
-        pass_all_k: corpusGroupCount === 0 ? 0 : corpusPassAllKSum / corpusGroupCount,
-        groups: corpusGroupCount,
-        tasks: corpusTasks.size,
-    };
-    return { byWorkflow, corpus };
-}
-/** Earliest parseable ts (ms epoch) among events; null when none. */
-function earliestEventMs(events) {
-    let earliest = null;
-    for (const ev of events) {
-        const ms = parseTsToMs(ev.ts);
-        if (ms === null)
-            continue;
-        if (earliest === null || ms < earliest)
-            earliest = ms;
-    }
-    return earliest;
-}
-/**
- * Find the first event matching `predicate`, parse its ts, and return
- * `(ts - runStartMs)`. Returns `null` if no matching event has a parseable
- * ts, if `runStartMs` is null, or if the offset would be negative (a clock
- * inversion we refuse to silently coerce to zero).
- */
-function computeFirstEventOffsetMs(events, runStartMs, predicate) {
-    if (runStartMs === null)
-        return null;
-    for (const ev of events) {
-        if (!predicate(ev))
-            continue;
-        const ms = parseTsToMs(ev.ts);
-        if (ms === null)
-            continue;
-        const offset = ms - runStartMs;
-        if (offset < 0)
-            return null;
-        return offset;
-    }
-    return null;
-}
-/** Parse an ISO ts to ms-epoch; null when missing or unparseable. */
-function parseTsToMs(ts) {
-    if (typeof ts !== "string" || ts.length === 0)
-        return null;
-    const ms = Date.parse(ts);
-    if (Number.isNaN(ms))
-        return null;
-    return ms;
-}