@tea-agent/loop-agent 0.15.0 → 0.16.0

package/dist/application/evaluation/experiment.js

@@ -0,0 +1,294 @@
+import { createHash } from "node:crypto";
+import { mkdir, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { experimentProposalRepoPath, listExperimentIds, readExperimentRecord, updateExperimentRecord, writeExperimentRecord, } from "../../infrastructure/evaluation/experiment-store.js";
+import { writeJsonAtomic } from "../../infrastructure/harness/atomic-write.js";
+import { formatContentSha, sha256Hex } from "./candidate-hash.js";
+import { registerCandidate, showCandidate, transitionCandidate, } from "./candidate.js";
+import { readCampaignScorecard } from "../../infrastructure/evaluation/campaign-store.js";
+import { curateKnowledgePatterns } from "../../workflows/dag/knowledge-curator.js";
+const DEFAULT_WHEN_TO_APPLY = "use when the failure class, bounded fix scope, and invariant match a new supervised DAG repair round";
+const DEFAULT_WHEN_NOT_TO_APPLY = "do not apply when the task has different ownership boundaries, missing full verification, or higher-risk public contract changes";
+function toPatternEvidence(patterns) {
+    return patterns.map((pattern) => ({
+        key: pattern.key,
+        failureClass: pattern.failureClass,
+        fixScopeShape: pattern.fixScopeShape,
+        invariant: pattern.invariant,
+        count: pattern.count,
+        sourceRunIds: pattern.sourceRunIds,
+        whenToApply: DEFAULT_WHEN_TO_APPLY,
+        whenNotToApply: DEFAULT_WHEN_NOT_TO_APPLY,
+    }));
+}
+function defaultExperimentId(candidateId) {
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    return `exp-${candidateId}-${stamp}`;
+}
+function defaultCandidateId() {
+    const stamp = createHash("sha256")
+        .update(`${Date.now()}-${Math.random()}`)
+        .digest("hex")
+        .slice(0, 10);
+    return `learned-exp-${stamp}`;
+}
+export async function createExperimentFromCurate(input) {
+    const curated = await curateKnowledgePatterns({ repoRoot: input.repoRoot });
+    if (!curated.ok) {
+        throw new Error(`knowledge curate failed safety audit: ${curated.safetyFindings.map((f) => f.ruleId).join(", ")}`);
+    }
+    if (!curated.proposalMarkdown || curated.patternCount === 0) {
+        throw new Error(`knowledge curate produced no qualifying patterns (${curated.message})`);
+    }
+    const candidateId = input.candidateId ?? defaultCandidateId();
+    const experimentId = input.experimentId ?? defaultExperimentId(candidateId);
+    const now = input.now ?? new Date().toISOString();
+    const proposalRel = experimentProposalRepoPath(experimentId);
+    const proposalAbs = path.join(input.repoRoot, ...proposalRel.split("/"));
+    await mkdir(path.dirname(proposalAbs), { recursive: true });
+    await writeFile(proposalAbs, curated.proposalMarkdown, "utf-8");
+    const proposalSha = formatContentSha(sha256Hex(curated.proposalMarkdown));
+    const stagingManifestPath = path.join(input.repoRoot, "ai_workspace/loop-agent/evaluation/experiments", experimentId, "candidate.manifest.json");
+    await writeJsonAtomic(stagingManifestPath, {
+        schemaVersion: 1,
+        candidateId,
+        parentCandidateId: null,
+        candidateKind: "skill",
+        createdAt: now,
+        description: "Experimental learned guidance from knowledge curate (M6); not accepted skill default",
+        contentRefs: [{ path: proposalRel, sha256: proposalSha }],
+    }, { repoRoot: input.repoRoot });
+    const registered = await registerCandidate({
+        repoRoot: input.repoRoot,
+        manifestPath: stagingManifestPath,
+        now,
+    });
+    if (registered.record.status === "proposed") {
+        await transitionCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+            to: "eligible",
+            reason: "M6: curate proposal eligible for experiment",
+            now,
+        });
+        await transitionCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+            to: "experimenting",
+            reason: "M6: enter experimenting before held-out accept",
+            now,
+        });
+    }
+    else if (registered.record.status === "eligible") {
+        await transitionCandidate({
+            repoRoot: input.repoRoot,
+            candidateId,
+            to: "experimenting",
+            reason: "M6: enter experimenting before held-out accept",
+            now,
+        });
+    }
+    else if (registered.record.status !== "experimenting") {
+        throw new Error(`unexpected candidate status for experiment bridge: ${registered.record.status}`);
+    }
+    const candidate = await showCandidate({
+        repoRoot: input.repoRoot,
+        candidateId,
+    });
+    const record = {
+        schemaVersion: 1,
+        experimentId,
+        candidateId,
+        source: "knowledge-curate",
+        createdAt: now,
+        proposalPath: proposalRel,
+        proposalSha256: proposalSha,
+        patterns: toPatternEvidence(curated.patterns),
+        status: "experimenting",
+    };
+    const stored = await writeExperimentRecord({
+        repoRoot: input.repoRoot,
+        record,
+    });
+    return {
+        record: stored.record,
+        candidate,
+        idempotent: stored.idempotent && registered.idempotent,
+        curateMessage: curated.message,
+    };
+}
+export async function showExperiment(input) {
+    const record = await readExperimentRecord(input.repoRoot, input.experimentId);
+    const candidate = await showCandidate({
+        repoRoot: input.repoRoot,
+        candidateId: record.candidateId,
+    });
+    return { record, candidate };
+}
+export async function listExperiments(input) {
+    const ids = await listExperimentIds(input.repoRoot);
+    const rows = [];
+    for (const experimentId of ids) {
+        const record = await readExperimentRecord(input.repoRoot, experimentId);
+        rows.push({
+            experimentId: record.experimentId,
+            candidateId: record.candidateId,
+            status: record.status,
+            patternCount: record.patterns.length,
+            createdAt: record.createdAt,
+        });
+    }
+    return rows;
+}
+export async function acceptExperiment(input) {
+    const reason = input.reason.trim();
+    if (!reason)
+        throw new Error("experiment accept requires non-empty --reason");
+    const existing = await readExperimentRecord(input.repoRoot, input.experimentId);
+    if (existing.status !== "experimenting") {
+        throw new Error(`experiment ${input.experimentId} is ${existing.status}; only experimenting may be accepted`);
+    }
+    const scorecard = await readCampaignScorecard(input.repoRoot, input.campaignId);
+    if (!scorecard) {
+        throw new Error(`campaign ${input.campaignId} has no scorecard; run eval campaign scorecard first`);
+    }
+    if (scorecard.policy.challengerCandidateId !== existing.candidateId) {
+        throw new Error(`scorecard challenger ${scorecard.policy.challengerCandidateId} does not match experiment candidate ${existing.candidateId}`);
+    }
+    if (scorecard.policy.gates.heldOutNonRegression !== "pass") {
+        throw new Error(`held-out non-regression gate failed: ${scorecard.policy.gates.heldOutNonRegression}`);
+    }
+    const safetyOk = scorecard.policy.gates.safetyOk;
+    if (safetyOk === "fail") {
+        throw new Error("safety gate blocks accept: safetyOk=fail");
+    }
+    if (safetyOk === "review" && !input.acknowledgeReview) {
+        throw new Error("safety gate blocks accept: safetyOk=review (use --acknowledge-review after human review)");
+    }
+    const eligible = scorecard.policy.promotionEligible ||
+        (safetyOk === "review" &&
+            Boolean(input.acknowledgeReview) &&
+            scorecard.policy.gates.privateImprovement === "pass" &&
+            scorecard.policy.gates.heldOutNonRegression === "pass" &&
+            scorecard.policy.gates.budgetOk === "pass");
+    if (!eligible) {
+        throw new Error(`campaign promotion policy not eligible: ${scorecard.policy.reasons.join("; ")}`);
+    }
+    const dryRun = input.dryRun !== false;
+    const now = input.now ?? new Date().toISOString();
+    if (dryRun) {
+        const candidate = await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId: existing.candidateId,
+        });
+        return {
+            dryRun: true,
+            record: existing,
+            candidate,
+            changed: false,
+        };
+    }
+    const candidate = await transitionCandidate({
+        repoRoot: input.repoRoot,
+        candidateId: existing.candidateId,
+        to: "accepted",
+        reason: `M6 experiment accept: ${reason}`,
+        now,
+    });
+    const record = {
+        ...existing,
+        status: "accepted",
+        disposition: {
+            status: "accepted",
+            at: now,
+            reason,
+            campaignId: input.campaignId,
+            scorecardPlanHash: scorecard.planHash,
+            heldOutNonRegression: scorecard.policy.gates.heldOutNonRegression,
+        },
+    };
+    await updateExperimentRecord({ repoRoot: input.repoRoot, record });
+    return { dryRun: false, record, candidate, changed: true };
+}
+export async function rejectExperiment(input) {
+    const reason = input.reason.trim();
+    if (!reason)
+        throw new Error("experiment reject requires non-empty --reason");
+    const existing = await readExperimentRecord(input.repoRoot, input.experimentId);
+    if (existing.status !== "experimenting") {
+        throw new Error(`experiment ${input.experimentId} is ${existing.status}; only experimenting may be rejected`);
+    }
+    const dryRun = input.dryRun !== false;
+    const now = input.now ?? new Date().toISOString();
+    if (dryRun) {
+        const candidate = await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId: existing.candidateId,
+        });
+        return {
+            dryRun: true,
+            record: existing,
+            candidate,
+            changed: false,
+        };
+    }
+    const candidate = await transitionCandidate({
+        repoRoot: input.repoRoot,
+        candidateId: existing.candidateId,
+        to: "rejected",
+        reason: `M6 experiment reject: ${reason}`,
+        now,
+    });
+    const record = {
+        ...existing,
+        status: "rejected",
+        disposition: {
+            status: "rejected",
+            at: now,
+            reason,
+        },
+    };
+    await updateExperimentRecord({ repoRoot: input.repoRoot, record });
+    return { dryRun: false, record, candidate, changed: true };
+}
+export function formatExperimentMarkdown(input) {
+    const { record } = input;
+    const lines = [
+        `# Experiment: ${record.experimentId}`,
+        "",
+        `- status: \`${record.status}\``,
+        `- candidateId: \`${record.candidateId}\``,
+        `- source: \`${record.source}\``,
+        `- createdAt: \`${record.createdAt}\``,
+        `- proposal: \`${record.proposalPath}\``,
+        `- proposalSha256: \`${record.proposalSha256}\``,
+        "",
+        "## Pattern evidence",
+        "",
+    ];
+    if (record.patterns.length === 0) {
+        lines.push("(none)", "");
+    }
+    else {
+        for (const pattern of record.patterns) {
+            lines.push(`### ${pattern.failureClass} / ${pattern.fixScopeShape}`, "", `- key: \`${pattern.key}\``, `- count: ${pattern.count}`, `- invariant: ${pattern.invariant}`, `- when to apply: ${pattern.whenToApply}`, `- when not to apply: ${pattern.whenNotToApply}`, `- source runs: ${pattern.sourceRunIds.join(", ") || "(none)"}`, "");
+        }
+    }
+    if (record.disposition) {
+        lines.push("## Disposition", "", `- status: \`${record.disposition.status}\``, `- at: \`${record.disposition.at}\``, `- reason: ${record.disposition.reason}`);
+        if (record.disposition.campaignId) {
+            lines.push(`- campaignId: \`${record.disposition.campaignId}\``);
+        }
+        if (record.disposition.scorecardPlanHash) {
+            lines.push(`- scorecardPlanHash: \`${record.disposition.scorecardPlanHash}\``);
+        }
+        if (record.disposition.heldOutNonRegression) {
+            lines.push(`- heldOutNonRegression: \`${record.disposition.heldOutNonRegression}\``);
+        }
+        lines.push("");
+    }
+    if (input.candidate) {
+        lines.push("## Candidate", "", `- status: \`${input.candidate.status}\``, `- bundleHash: \`${input.candidate.manifest.bundleHash}\``, "");
+    }
+    return `${lines.join("\n")}\n`;
+}

package/dist/application/evaluation/ignition.js

@@ -0,0 +1,198 @@
+import { listIgnitionIds, readIgnitionReport, writeIgnitionReport, } from "../../infrastructure/evaluation/ignition-store.js";
+import { readCampaignScorecard } from "../../infrastructure/evaluation/campaign-store.js";
+import { readProposerRun } from "../../infrastructure/evaluation/proposer-store.js";
+import { showCandidate } from "./candidate.js";
+export const IGNITION_MIN_GENERATIONS_FOR_SIGNAL = 2;
+export function computeIgnitionMetrics(generations) {
+    const generationCount = generations.length;
+    const meanProposalsPerGeneration = generationCount === 0
+        ? 0
+        : generations.reduce((sum, row) => sum + row.proposalCount, 0) /
+            generationCount;
+    const sorted = [...generations].sort((a, b) => a.generation - b.generation);
+    const first = sorted[0];
+    const last = sorted[sorted.length - 1];
+    const proposalYieldDelta = first && last && sorted.length >= 2
+        ? last.proposalCount - first.proposalCount
+        : null;
+    const observed = generations.filter((row) => row.promotionEligible !== undefined);
+    const scorecardObservedRate = observed.length === 0
+        ? null
+        : observed.filter((row) => row.promotionEligible === true).length /
+            observed.length;
+    const sampleSufficient = generationCount >= IGNITION_MIN_GENERATIONS_FOR_SIGNAL &&
+        generations.every((row) => row.proposalCount >= 0);
+    return {
+        generationCount,
+        meanProposalsPerGeneration,
+        proposalYieldDelta,
+        scorecardObservedRate,
+        minGenerationsForSignal: IGNITION_MIN_GENERATIONS_FOR_SIGNAL,
+        sampleSufficient,
+    };
+}
+export function decideIgnitionVerdict(input) {
+    const reasons = [
+        "rsiLevel1ClaimAllowed=false (Ignition is a research gate, not a product RSI Level 1 claim)",
+        "autoPromote=false",
+    ];
+    if (!input.metrics.sampleSufficient) {
+        reasons.push(`insufficient_evidence: need >= ${input.metrics.minGenerationsForSignal} generations (have ${input.metrics.generationCount})`);
+        return { verdict: "insufficient_evidence", reasons };
+    }
+    const delta = input.metrics.proposalYieldDelta ?? 0;
+    const heldOut = input.generations
+        .map((row) => row.heldOutNonRegression)
+        .filter((value) => value !== undefined);
+    const heldOutFail = heldOut.some((value) => value === "fail");
+    if (heldOutFail) {
+        reasons.push("held-out non-regression failed in at least one generation");
+        return { verdict: "trend_negative", reasons };
+    }
+    if (delta > 0) {
+        reasons.push(`proposalYieldDelta=${delta} (later generation proposed more candidates than the first)`);
+        return { verdict: "trend_positive", reasons };
+    }
+    if (delta < 0) {
+        reasons.push(`proposalYieldDelta=${delta}`);
+        return { verdict: "trend_negative", reasons };
+    }
+    if (input.metrics.scorecardObservedRate !== null &&
+        input.metrics.scorecardObservedRate > 0 &&
+        input.metrics.scorecardObservedRate < 1) {
+        reasons.push(`scorecardObservedRate=${input.metrics.scorecardObservedRate.toFixed(2)} mixed; inconclusive`);
+        return { verdict: "inconclusive", reasons };
+    }
+    reasons.push("proposalYieldDelta=0 with no decisive scorecard trend");
+    return { verdict: "trend_flat", reasons };
+}
+function recomputeReport(base) {
+    const metrics = computeIgnitionMetrics(base.generations);
+    const { verdict, reasons } = decideIgnitionVerdict({
+        metrics,
+        generations: base.generations,
+    });
+    return {
+        schemaVersion: 1,
+        ignitionId: base.ignitionId,
+        createdAt: base.createdAt,
+        updatedAt: base.updatedAt,
+        generations: [...base.generations].sort((a, b) => a.generation - b.generation),
+        metrics,
+        verdict,
+        reasons,
+        rsiLevel1ClaimAllowed: false,
+        autoPromote: false,
+    };
+}
+/**
+ * Record one generation in an Ignition lineage (M8 research gate).
+ * Never promotes and never authorizes RSI Level 1 claims.
+ */
+export async function recordIgnitionGeneration(input) {
+    if (input.generation < 0) {
+        throw new Error("ignition generation must be >= 0");
+    }
+    if (input.parentCandidateId) {
+        await showCandidate({
+            repoRoot: input.repoRoot,
+            candidateId: input.parentCandidateId,
+        });
+    }
+    const proposer = await readProposerRun(input.repoRoot, input.proposerRunId);
+    const now = input.now ?? new Date().toISOString();
+    const generationRow = {
+        generation: input.generation,
+        parentCandidateId: input.parentCandidateId,
+        proposerRunId: input.proposerRunId,
+        proposedCandidateIds: proposer.proposals.map((row) => row.candidateId),
+        proposalCount: proposer.proposals.length,
+        recordedAt: now,
+    };
+    if (input.campaignId) {
+        generationRow.campaignId = input.campaignId;
+        const scorecard = await readCampaignScorecard(input.repoRoot, input.campaignId);
+        if (scorecard) {
+            generationRow.promotionEligible = scorecard.policy.promotionEligible;
+            generationRow.heldOutNonRegression =
+                scorecard.policy.gates.heldOutNonRegression;
+            generationRow.privateImprovement =
+                scorecard.policy.gates.privateImprovement;
+        }
+    }
+    const existing = await readIgnitionReport(input.repoRoot, input.ignitionId);
+    const generations = existing?.generations.filter((row) => row.generation !== input.generation) ?? [];
+    generations.push(generationRow);
+    const report = recomputeReport({
+        ignitionId: input.ignitionId,
+        createdAt: existing?.createdAt ?? now,
+        updatedAt: now,
+        generations,
+    });
+    await writeIgnitionReport({ repoRoot: input.repoRoot, report });
+    return report;
+}
+export async function evaluateIgnition(input) {
+    const existing = await readIgnitionReport(input.repoRoot, input.ignitionId);
+    if (!existing) {
+        throw new Error(`ignition ${input.ignitionId} not found; record generations first`);
+    }
+    const report = recomputeReport({
+        ignitionId: existing.ignitionId,
+        createdAt: existing.createdAt,
+        updatedAt: input.now ?? new Date().toISOString(),
+        generations: existing.generations,
+    });
+    await writeIgnitionReport({ repoRoot: input.repoRoot, report });
+    return report;
+}
+export async function showIgnition(input) {
+    const report = await readIgnitionReport(input.repoRoot, input.ignitionId);
+    if (!report) {
+        throw new Error(`ignition not found: ${input.ignitionId}`);
+    }
+    return report;
+}
+export async function listIgnitions(input) {
+    const ids = await listIgnitionIds(input.repoRoot);
+    const rows = [];
+    for (const ignitionId of ids) {
+        const report = await readIgnitionReport(input.repoRoot, ignitionId);
+        if (!report)
+            continue;
+        rows.push({
+            ignitionId: report.ignitionId,
+            generationCount: report.metrics.generationCount,
+            verdict: report.verdict,
+            updatedAt: report.updatedAt,
+            rsiLevel1ClaimAllowed: false,
+        });
+    }
+    return rows;
+}
+export function formatIgnitionMarkdown(report) {
+    const lines = [
+        `# Ignition Research Gate: ${report.ignitionId}`,
+        "",
+        `- verdict: \`${report.verdict}\``,
+        `- rsiLevel1ClaimAllowed: \`${report.rsiLevel1ClaimAllowed}\``,
+        `- autoPromote: \`${report.autoPromote}\``,
+        `- generations: ${report.metrics.generationCount}`,
+        `- meanProposalsPerGeneration: ${report.metrics.meanProposalsPerGeneration.toFixed(2)}`,
+        `- proposalYieldDelta: ${report.metrics.proposalYieldDelta ?? "null"}`,
+        `- scorecardObservedRate: ${report.metrics.scorecardObservedRate ?? "null"}`,
+        `- sampleSufficient: ${report.metrics.sampleSufficient}`,
+        "",
+        "## Generations",
+        "",
+    ];
+    for (const gen of report.generations) {
+        lines.push(`- g${gen.generation}: parent=\`${gen.parentCandidateId ?? "null"}\` proposals=${gen.proposalCount} proposer=\`${gen.proposerRunId}\` heldOut=${gen.heldOutNonRegression ?? "-"} eligible=${gen.promotionEligible ?? "-"}`);
+    }
+    lines.push("", "## Reasons", "");
+    for (const reason of report.reasons) {
+        lines.push(`- ${reason}`);
+    }
+    lines.push("", "> M8 Ignition evaluates whether later generations propose more/better candidates under fixed research rules. It does **not** claim RSI Level 1 and never auto-promotes.", "");
+    return `${lines.join("\n")}\n`;
+}

package/dist/application/evaluation/integrity-audit.js

@@ -0,0 +1,162 @@
+const WEAKENING_PATTERNS = [
+    { re: /\.only\s*\(/, label: ".only(" },
+    { re: /\.skip\s*\(/, label: ".skip(" },
+    { re: /\bxit\s*\(/, label: "xit(" },
+    { re: /\bxdescribe\s*\(/, label: "xdescribe(" },
+    { re: /\bit\.todo\s*\(/, label: "it.todo(" },
+    { re: /\btest\.todo\s*\(/, label: "test.todo(" },
+    { re: /\bdescribe\.skip\s*\(/, label: "describe.skip(" },
+    { re: /\btest\.skip\s*\(/, label: "test.skip(" },
+    { re: /timeout\s*[:=]\s*\d{5,}/i, label: "timeout increase" },
+];
+function addedLines(unifiedDiff) {
+    return unifiedDiff
+        .split("\n")
+        .filter((line) => line.startsWith("+") && !line.startsWith("+++"))
+        .map((line) => line.slice(1));
+}
+function removedLines(unifiedDiff) {
+    return unifiedDiff
+        .split("\n")
+        .filter((line) => line.startsWith("-") && !line.startsWith("---"))
+        .map((line) => line.slice(1));
+}
+function countTestDeclarations(lines) {
+    let count = 0;
+    for (const line of lines) {
+        if (/\b(it|test|describe)\s*\(/.test(line))
+            count += 1;
+    }
+    return count;
+}
+/** Detect verification weakening signals in challenger diffs (W4.3). */
+export function auditVerificationWeakening(evidence) {
+    const findings = [];
+    for (const diff of evidence.diffs) {
+        const added = addedLines(diff.unifiedDiff);
+        const removed = removedLines(diff.unifiedDiff);
+        const text = added.join("\n");
+        for (const pattern of WEAKENING_PATTERNS) {
+            if (pattern.re.test(text)) {
+                findings.push({
+                    code: "verification_weakening",
+                    severity: "fail",
+                    message: `challenger diff introduces ${pattern.label}`,
+                    path: diff.path,
+                });
+            }
+        }
+        const removedTests = countTestDeclarations(removed);
+        const addedTests = countTestDeclarations(added);
+        if (removedTests > addedTests) {
+            findings.push({
+                code: "verification_weakening",
+                severity: "fail",
+                message: `challenger removes more test declarations than it adds (${removedTests} removed, ${addedTests} added)`,
+                path: diff.path,
+            });
+        }
+    }
+    return findings;
+}
+/** Detect verify command set reduction relative to incumbent (W4.3). */
+export function auditCommandReduction(evidence) {
+    const incumbent = new Set(evidence.verifyCommands.incumbent);
+    const challenger = new Set(evidence.verifyCommands.challenger);
+    if (incumbent.size === 0)
+        return [];
+    const missing = [...incumbent].filter((cmd) => !challenger.has(cmd));
+    if (missing.length === 0)
+        return [];
+    if (challenger.size < incumbent.size) {
+        return [
+            {
+                code: "command_reduction",
+                severity: "fail",
+                message: `challenger verify command set shrank; missing: ${missing.join(", ")}`,
+            },
+        ];
+    }
+    return [
+        {
+            code: "command_reduction",
+            severity: "review",
+            message: `challenger dropped incumbent verify commands without shrinking set size: ${missing.join(", ")}`,
+        },
+    ];
+}
+function pairKey(cell) {
+    return `${cell.split}\u0000${cell.taskRef}\u0000${cell.seed}`;
+}
+/**
+ * Flag suspicious single-task outliers (W4.4).
+ * Does not fail closed; severity=review so humans must acknowledge.
+ */
+export function auditSuspiciousOutliers(input) {
+    const byKey = new Map();
+    for (const cell of input.cells) {
+        if (cell.split === "public")
+            continue;
+        const key = pairKey(cell);
+        const row = byKey.get(key) ?? {
+            taskRef: cell.taskRef,
+            split: cell.split,
+        };
+        if (cell.candidateId === input.incumbentCandidateId) {
+            row.incumbent = cell.verifyPassed;
+        }
+        else if (cell.candidateId === input.challengerCandidateId) {
+            row.challenger = cell.verifyPassed;
+        }
+        byKey.set(key, row);
+    }
+    const deltas = [];
+    for (const row of byKey.values()) {
+        if (row.incumbent === undefined || row.challenger === undefined)
+            continue;
+        const delta = (row.challenger ? 1 : 0) - (row.incumbent ? 1 : 0);
+        deltas.push({ taskRef: row.taskRef, split: row.split, delta });
+    }
+    if (deltas.length < 3)
+        return [];
+    const mean = deltas.reduce((sum, item) => sum + item.delta, 0) / deltas.length;
+    const variance = deltas.reduce((sum, item) => sum + (item.delta - mean) ** 2, 0) /
+        deltas.length;
+    const stddev = Math.sqrt(variance);
+    const soleWins = deltas.filter((item) => item.delta === 1);
+    const findings = [];
+    // Sole-source gains among mostly flat pairs are review-worthy (not auto-dropped).
+    if (soleWins.length === 1 && mean <= 1 / 3) {
+        const item = soleWins[0];
+        findings.push({
+            code: "suspicious_outlier",
+            severity: "review",
+            message: `suspicious sole gain on ${item.split}/${item.taskRef}: delta=1 among ${deltas.length} pairs (mean=${mean.toFixed(2)}); requires human review, score not auto-dropped`,
+        });
+        return findings;
+    }
+    if (stddev === 0)
+        return findings;
+    for (const item of deltas) {
+        const z = (item.delta - mean) / stddev;
+        if (item.delta > 0 && z >= 1.5) {
+            findings.push({
+                code: "suspicious_outlier",
+                severity: "review",
+                message: `suspicious gain on ${item.split}/${item.taskRef}: delta=${item.delta} z=${z.toFixed(2)} (mean=${mean.toFixed(2)}); requires human review, score not auto-dropped`,
+            });
+        }
+    }
+    return findings;
+}
+export function runIntegrityAudits(input) {
+    return [
+        ...auditVerificationWeakening(input.evidence),
+        ...auditCommandReduction(input.evidence),
+        ...auditSuspiciousOutliers({
+            incumbentCandidateId: input.incumbentCandidateId,
+            challengerCandidateId: input.evidence.challengerCandidateId,
+            cells: input.evidence.cells,
+        }),
+    ];
+}