argus-reviewer-e2e 0.1.3 → 0.3.0

package/dist/pipeline/verify.d.ts

@@ -0,0 +1,27 @@
+import { type LaneId, type RunIdentity, type RunManifest } from '../report/manifest.js';
+import { type BudgetOptions } from './budget.js';
+import { type LaneSelection } from './contracts.js';
+export interface VerifyRunners {
+    review: () => Promise<number>;
+    flow?: (url: string) => Promise<number>;
+    app?: () => Promise<number>;
+    a0?: () => Promise<number>;
+}
+export interface VerifyInput {
+    cwd: string;
+    runId: string;
+    reportDir: string;
+    identity: RunIdentity;
+    selection: LaneSelection;
+    runners: VerifyRunners;
+    budgets?: Partial<Record<LaneId, BudgetOptions>>;
+    flowUrl?: string;
+    flowUnavailableReason?: string;
+}
+export interface VerifyResult {
+    manifest: RunManifest;
+    exitCode: number;
+}
+/** Run selected lanes and return one stable manifest without owning subprocesses. */
+export declare function runVerify(input: VerifyInput): Promise<VerifyResult>;
+export declare function selectedManifestLanes(selection: LaneSelection): LaneId[];

package/dist/pipeline/verify.js

@@ -0,0 +1,197 @@
+import { readFile } from 'node:fs/promises';
+import { join, relative } from 'node:path';
+import { aggregateLanes, addProviderUsage, emptyLane, emptyUsage, isHeadBindingConclusive, MANIFEST_SCHEMA_VERSION, } from '../report/manifest.js';
+import { addProviderCalls, createBudget } from './budget.js';
+import { selectedLanes } from './contracts.js';
+async function readJson(path) {
+    try {
+        return JSON.parse(await readFile(path, 'utf8'));
+    }
+    catch {
+        return undefined;
+    }
+}
+function relativeReport(cwd, reportDir, name) {
+    return relative(cwd, join(reportDir, name)) || name;
+}
+function laneStart(lane, at = new Date()) {
+    return { ...lane, startedAt: at.toISOString() };
+}
+function laneEnd(lane, at = new Date()) {
+    return { ...lane, finishedAt: at.toISOString() };
+}
+function reportStatus(code, report, inconclusive) {
+    if (report?.skipped === true)
+        return 'skipped';
+    if (inconclusive)
+        return 'inconclusive';
+    if (report?.ok === true && code === 0)
+        return 'passed';
+    return 'failed';
+}
+function providerUsageFromCalls(calls) {
+    const usage = emptyUsage('openrouter');
+    return calls === undefined ? usage : addProviderUsage(usage, calls);
+}
+function flowCalls(report) {
+    return report?.tests?.flatMap((test) => test.calls ?? []) ?? [];
+}
+function flowUsage(report) {
+    const calls = flowCalls(report);
+    const usage = providerUsageFromCalls(calls);
+    if (report?.totals !== undefined && calls.length === 0) {
+        return {
+            ...usage,
+            calls: report.totals.visionCalls ?? 0,
+            tokens: 0,
+            costUsd: report.totals.visionCostUsd ?? 0,
+        };
+    }
+    return usage;
+}
+function budgetFor(lane, input, report) {
+    const options = input.budgets?.[lane] ?? {};
+    let budget = createBudget(lane, options);
+    if (lane === 'review') {
+        budget = addProviderCalls(budget, report?.calls);
+    }
+    else if (lane === 'flow') {
+        budget = addProviderCalls(budget, flowCalls(report));
+    }
+    return budget;
+}
+function baseLane(lane, selected) {
+    return emptyLane(lane, selected);
+}
+/** Run selected lanes and return one stable manifest without owning subprocesses. */
+export async function runVerify(input) {
+    const startedAt = new Date();
+    const lanes = Object.fromEntries(['review', 'flow', 'app', 'a0'].map((lane) => [
+        lane,
+        baseLane(lane, input.selection[lane]),
+    ]));
+    const reviewSelected = input.selection.review;
+    if (reviewSelected) {
+        lanes.review = laneStart(lanes.review, startedAt);
+        let code = 1;
+        let runnerError;
+        try {
+            code = await input.runners.review();
+        }
+        catch (error) {
+            runnerError = error instanceof Error ? error.message : String(error);
+            ctxError(runnerError);
+        }
+        const report = await readJson(join(input.reportDir, 'code-review.json'));
+        const inconclusive = report !== undefined &&
+            report.skipped !== true &&
+            !isHeadBindingConclusive(report.headBinding);
+        const status = runnerError !== undefined ? 'failed' : reportStatus(code, report, inconclusive);
+        lanes.review = laneEnd({
+            ...lanes.review,
+            status,
+            reportPath: report === undefined
+                ? undefined
+                : relativeReport(input.cwd, input.reportDir, 'code-review.json'),
+            model: report?.model,
+            summary: report?.summary,
+            reason: runnerError ??
+                (report === undefined
+                    ? 'code-review.json was not produced'
+                    : status === 'passed'
+                        ? undefined
+                        : report.summary),
+            usage: providerUsageFromCalls(report?.calls),
+            budget: budgetFor('review', input, report),
+            headBinding: report?.headBinding,
+        });
+    }
+    if (input.selection.flow) {
+        lanes.flow = laneStart(lanes.flow, startedAt);
+        if (input.runners.flow === undefined) {
+            lanes.flow = laneEnd({
+                ...lanes.flow,
+                status: 'unavailable',
+                reason: 'flow runner is not available in this build',
+            });
+        }
+        else if (input.flowUrl === undefined || input.flowUrl === '') {
+            lanes.flow = laneEnd({
+                ...lanes.flow,
+                status: 'blocked',
+                reason: input.flowUnavailableReason ?? 'no application target configured',
+            });
+        }
+        else {
+            let code = 1;
+            let runnerError;
+            try {
+                code = await input.runners.flow(input.flowUrl);
+            }
+            catch (error) {
+                runnerError = error instanceof Error ? error.message : String(error);
+                ctxError(runnerError);
+            }
+            const report = await readJson(join(input.reportDir, 'run.json'));
+            lanes.flow = laneEnd({
+                ...lanes.flow,
+                status: runnerError !== undefined ? 'failed' : reportStatus(code, report, false),
+                reportPath: report === undefined ? undefined : relativeReport(input.cwd, input.reportDir, 'run.json'),
+                summary: report === undefined ? undefined : report.ok === true ? 'flow passed' : 'flow failed',
+                reason: runnerError ??
+                    (report === undefined
+                        ? 'run.json was not produced'
+                        : report.ok === true
+                            ? undefined
+                            : 'flow failed'),
+                usage: flowUsage(report),
+                budget: budgetFor('flow', input, report),
+            });
+        }
+    }
+    for (const lane of ['app', 'a0']) {
+        if (!input.selection[lane])
+            continue;
+        const runner = input.runners[lane];
+        lanes[lane] = laneStart(lanes[lane], startedAt);
+        if (runner === undefined) {
+            lanes[lane] = laneEnd({
+                ...lanes[lane],
+                status: 'unavailable',
+                reason: `${lane} runner is not available in this build`,
+            });
+            continue;
+        }
+        let code = 1;
+        let runnerError;
+        try {
+            code = await runner();
+        }
+        catch (error) {
+            runnerError = error instanceof Error ? error.message : String(error);
+            ctxError(runnerError);
+        }
+        lanes[lane] = laneEnd({
+            ...lanes[lane],
+            status: code === 0 ? 'passed' : 'failed',
+            reason: runnerError ?? (code === 0 ? undefined : `${lane} runner exited ${code}`),
+        });
+    }
+    const aggregate = aggregateLanes(lanes);
+    const manifest = {
+        schemaVersion: MANIFEST_SCHEMA_VERSION,
+        runId: input.runId,
+        startedAt: startedAt.toISOString(),
+        finishedAt: new Date().toISOString(),
+        identity: input.identity,
+        lanes,
+        aggregate,
+    };
+    return { manifest, exitCode: aggregate.ok ? 0 : 1 };
+}
+function ctxError(message) {
+    console.error(`verify lane error: ${message}`);
+}
+export function selectedManifestLanes(selection) {
+    return selectedLanes(selection);
+}

package/dist/probe/queue.d.ts

@@ -6,6 +6,7 @@ import type { RepoIndex } from '../index/scan.js';
 import type { VisionClient } from '../engine/loop.js';
 import type { CallCost } from '../vision/cost.js';
 import type { Ledger } from '../vision/ledger.js';
+import type { TriageAreaSignal } from '../review/triage.js';
 import { type ProbeOutcome } from './harness.js';
 /**
  * The B.2 probe lane (U4). Called after `linkFindings` inside `code-review`.
@@ -69,13 +70,15 @@ export interface ProbeLaneOptions {
     /** Configured blocking severities — the queue only admits those. */
     severityGates: string[];
     index: RepoIndex | undefined;
+    /** U9 — triage top_risk_area; advisory reorder of probe candidates. */
+    triageArea?: TriageAreaSignal | undefined;
     /** Report sink — authored probe CallCosts are pushed here for the report. */
     calls?: CallCost[] | undefined;
     exec?: ExecFn | undefined;
     log?: ((line: string) => void) | undefined;
 }
 /** Pure selection: not_exercised findings at blocking severities, capped. */
-export declare function selectProbeTargets(findings: LinkedFinding[], severityGates: string[], maxProbes: number): LinkedFinding[];
+export declare function selectProbeTargets(findings: LinkedFinding[], severityGates: string[], maxProbes: number, triageArea?: TriageAreaSignal): LinkedFinding[];
 /**
  * Repo-relative path gate for anything model- or index-derived that is read
  * or written on the HOST: no absolute paths, no `..` escapes, no backslashes.

package/dist/probe/queue.js

@@ -7,14 +7,42 @@ import { isTestFile } from '../evidence/link.js';
 import { buildProbeMessages, parseProbe, probeImportsSafe, PROBE_SCHEMA, } from './author.js';
 import { detectHarness } from './harness.js';
 import { checkSandboxPaths, dockerAvailable, resolveSandboxImage, runProbeInSandbox, SANDBOX_OUTPUT_CAP, SCRATCH_DIR_NAME, stripControlChars, sandboxLimits, } from '../executor/sandbox.js';
+/** U9 — below this confidence the triage area signal is ignored. */
+const MIN_AREA_CONFIDENCE = 0.5;
+/**
+ * U9 triage-informed ordering: a finding's file path "hits" the flagged
+ * risk area when a path segment equals the area token or starts with
+ * it at a camelCase/digit boundary — `src/auth/session.ts` and
+ * `dataStore.ts` hit auth/data, while `author.ts` and `database.ts`
+ * do not. Advisory only.
+ */
+function fileHitsArea(file, area) {
+    const token = area.toLowerCase();
+    return file.split(/[/._-]+/).some((segment) => {
+        const lower = segment.toLowerCase();
+        if (lower === token)
+            return true;
+        if (!lower.startsWith(token))
+            return false;
+        return /[A-Z0-9]/.test(segment.charAt(token.length));
+    });
+}
 /** Pure selection: not_exercised findings at blocking severities, capped. */
-export function selectProbeTargets(findings, severityGates, maxProbes) {
-    return findings
-        .filter((f) => f.evidence.status === 'not_exercised' &&
+export function selectProbeTargets(findings, severityGates, maxProbes, triageArea) {
+    const eligible = findings.filter((f) => f.evidence.status === 'not_exercised' &&
         f.file !== undefined &&
         isSafeRepoPath(f.file) &&
-        severityGates.includes(f.severity ?? ''))
-        .slice(0, Math.max(0, maxProbes));
+        severityGates.includes(f.severity ?? ''));
+    // U9 — a confident triage top_risk_area reorders candidates so probes
+    // prefer the flagged subsystem. Stable sort keeps the original order
+    // within each group; probe count/gates/verdict are unchanged.
+    if (triageArea !== undefined && triageArea.confidence >= MIN_AREA_CONFIDENCE) {
+        // Hit flags precomputed once — the comparator would re-derive them
+        // O(n log n) times otherwise.
+        const hit = new Map(eligible.map((f) => [f, fileHitsArea(f.file ?? '', triageArea.area)]));
+        eligible.sort((a, b) => Number(hit.get(b)) - Number(hit.get(a)));
+    }
+    return eligible.slice(0, Math.max(0, maxProbes));
 }
 /**
  * Repo-relative path gate for anything model- or index-derived that is read
@@ -145,14 +173,24 @@ async function authorProbe(o, target, harness, exemplarPath, indexPaths) {
         });
     }
     catch (e) {
-        return { probe: undefined, reason: `authoring call failed: ${e.message}`, costUsd: 0, tokens: 0 };
+        return {
+            probe: undefined,
+            reason: `authoring call failed: ${e.message}`,
+            costUsd: 0,
+            tokens: 0,
+        };
     }
     o.ledger.recordCall(response.cost);
     o.calls?.push(response.cost);
     const parsed = parseProbe(response.content);
     if (!parsed.ok) {
         // Failed parses still cost the call — carry the spend on the record.
-        return { probe: undefined, reason: parsed.reason, costUsd: response.cost.costUsd, tokens: response.cost.tokens };
+        return {
+            probe: undefined,
+            reason: parsed.reason,
+            costUsd: response.cost.costUsd,
+            tokens: response.cost.tokens,
+        };
     }
     return { probe: parsed.probe, costUsd: response.cost.costUsd, tokens: response.cost.tokens };
 }
@@ -203,7 +241,7 @@ export async function runProbeLane(findings, o) {
     // image/limits/allowForks would self-approve the gate. Forks always run
     // on DEFAULT_SANDBOX and approve only via trusted author or the label.
     const sandbox = o.meta?.isFork ? { ...DEFAULT_SANDBOX, enabled: true } : o.sandbox;
-    const targets = selectProbeTargets(findings, o.severityGates, sandbox.maxProbes);
+    const targets = selectProbeTargets(findings, o.severityGates, sandbox.maxProbes, o.triageArea);
     if (targets.length === 0)
         return { records: [] };
     if (!mayProbePr(o.meta, sandbox)) {

package/dist/report/manifest.d.ts

@@ -0,0 +1,87 @@
+import { type ExecFn } from '../detect.js';
+import type { CallCost } from '../vision/cost.js';
+/** Whether a report's source can be tied to the intended PR head. */
+export type HeadBindingStatus = 'match' | 'mismatch' | 'unknown' | 'not_applicable';
+export type HeadSource = 'github' | 'fixture' | 'local';
+export declare const LANE_IDS: readonly ["review", "flow", "app", "a0"];
+export type LaneId = (typeof LANE_IDS)[number];
+export declare const LANE_STATUSES: readonly ["passed", "failed", "skipped", "blocked", "unavailable", "inconclusive"];
+export type LaneStatus = (typeof LANE_STATUSES)[number];
+export declare const MANIFEST_SCHEMA_VERSION: 1;
+export interface HeadBinding {
+    intendedSha: string | undefined;
+    checkoutSha: string | undefined;
+    status: HeadBindingStatus;
+    source: HeadSource;
+    detail: string;
+}
+export interface UsageSummary {
+    provider: 'openrouter' | 'a0' | 'unknown';
+    model: string | undefined;
+    calls: number;
+    tokens: number;
+    costUsd: number;
+    metered: boolean;
+}
+export interface BudgetSummary {
+    limitUsd: number | undefined;
+    spentUsd: number;
+    exceeded: boolean;
+    maxDurationMs: number | undefined;
+    elapsedMs: number;
+    maxTasks: number | undefined;
+    tasks: number;
+}
+export interface LaneManifest {
+    lane: LaneId;
+    selected: boolean;
+    status: LaneStatus;
+    startedAt: string | undefined;
+    finishedAt: string | undefined;
+    reportPath: string | undefined;
+    model: string | undefined;
+    summary: string | undefined;
+    reason: string | undefined;
+    usage: UsageSummary;
+    budget: BudgetSummary;
+    headBinding: HeadBinding | undefined;
+}
+export interface RunIdentity {
+    repo: string | undefined;
+    pr: string | undefined;
+    intendedHeadSha: string | undefined;
+    checkoutSha: string | undefined;
+    baseSha: string | undefined;
+}
+export interface RunManifest {
+    schemaVersion: typeof MANIFEST_SCHEMA_VERSION;
+    runId: string;
+    startedAt: string;
+    finishedAt: string;
+    identity: RunIdentity;
+    lanes: Record<LaneId, LaneManifest>;
+    aggregate: {
+        status: LaneStatus;
+        ok: boolean;
+        costUsd: number;
+        calls: number;
+        tokens: number;
+    };
+}
+/** Read the checked-out commit without making git identity a hard dependency. */
+export declare function readCheckoutSha(cwd: string, exec?: ExecFn): Promise<string | undefined>;
+/** Classify the relationship between API/fixture head identity and the checkout. */
+export declare function classifyHeadBinding(intendedSha: string | undefined, checkoutSha: string | undefined, source: HeadSource): HeadBinding;
+/** True when runtime evidence is bound to the intended head (or a fixture). */
+export declare function isHeadBindingConclusive(binding: HeadBinding | undefined): boolean;
+export declare function emptyUsage(provider?: UsageSummary['provider']): UsageSummary;
+export declare function emptyBudget(): BudgetSummary;
+export declare function emptyLane(lane: LaneId, selected: boolean): LaneManifest;
+export declare function aggregateLanes(lanes: Record<LaneId, LaneManifest>): {
+    status: LaneStatus;
+    ok: boolean;
+    costUsd: number;
+    calls: number;
+    tokens: number;
+};
+export declare function addProviderUsage(usage: UsageSummary, calls: CallCost[] | undefined): UsageSummary;

package/dist/report/manifest.js

@@ -0,0 +1,143 @@
+import { defaultExec } from '../detect.js';
+export const LANE_IDS = ['review', 'flow', 'app', 'a0'];
+export const LANE_STATUSES = [
+    'passed',
+    'failed',
+    'skipped',
+    'blocked',
+    'unavailable',
+    'inconclusive',
+];
+export const MANIFEST_SCHEMA_VERSION = 1;
+/** Read the checked-out commit without making git identity a hard dependency. */
+export async function readCheckoutSha(cwd, exec = defaultExec) {
+    const result = await exec('git', ['-C', cwd, 'rev-parse', 'HEAD'], 10_000);
+    if (result.code !== 0)
+        return undefined;
+    const sha = result.stdout.trim();
+    return sha === '' ? undefined : sha;
+}
+/** Classify the relationship between API/fixture head identity and the checkout. */
+export function classifyHeadBinding(intendedSha, checkoutSha, source) {
+    if (source === 'fixture') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'not_applicable',
+            source,
+            detail: 'fixture diff is bound to its local fixture head',
+        };
+    }
+    if (intendedSha === undefined || intendedSha === '') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'unknown',
+            source,
+            detail: 'PR head identity was unavailable',
+        };
+    }
+    if (checkoutSha === undefined || checkoutSha === '') {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'unknown',
+            source,
+            detail: 'checkout identity was unavailable',
+        };
+    }
+    if (intendedSha === checkoutSha) {
+        return {
+            intendedSha,
+            checkoutSha,
+            status: 'match',
+            source,
+            detail: 'checkout matches the intended PR head',
+        };
+    }
+    return {
+        intendedSha,
+        checkoutSha,
+        status: 'mismatch',
+        source,
+        detail: `checkout ${checkoutSha} does not match intended PR head ${intendedSha}`,
+    };
+}
+/** True when runtime evidence is bound to the intended head (or a fixture). */
+export function isHeadBindingConclusive(binding) {
+    return binding?.status === 'match' || binding?.status === 'not_applicable';
+}
+export function emptyUsage(provider = 'unknown') {
+    return {
+        provider,
+        model: undefined,
+        calls: 0,
+        tokens: 0,
+        costUsd: 0,
+        metered: provider !== 'a0',
+    };
+}
+export function emptyBudget() {
+    return {
+        limitUsd: undefined,
+        spentUsd: 0,
+        exceeded: false,
+        maxDurationMs: undefined,
+        elapsedMs: 0,
+        maxTasks: undefined,
+        tasks: 0,
+    };
+}
+export function emptyLane(lane, selected) {
+    return {
+        lane,
+        selected,
+        status: selected ? 'blocked' : 'skipped',
+        startedAt: undefined,
+        finishedAt: undefined,
+        reportPath: undefined,
+        model: undefined,
+        summary: undefined,
+        reason: undefined,
+        usage: emptyUsage(),
+        budget: emptyBudget(),
+        headBinding: undefined,
+    };
+}
+export function aggregateLanes(lanes) {
+    const selected = LANE_IDS.map((lane) => lanes[lane]).filter((lane) => lane.selected);
+    const hasFailure = selected.some((lane) => ['failed', 'blocked'].includes(lane.status));
+    const hasInconclusive = selected.some((lane) => lane.status === 'inconclusive');
+    const hasUnavailable = selected.some((lane) => lane.status === 'unavailable');
+    const status = hasFailure
+        ? 'failed'
+        : hasInconclusive || hasUnavailable
+            ? 'inconclusive'
+            : selected.length === 0 || selected.every((lane) => lane.status === 'skipped')
+                ? 'skipped'
+                : selected.every((lane) => lane.status === 'passed' || lane.status === 'skipped')
+                    ? 'passed'
+                    : 'inconclusive';
+    return {
+        status,
+        ok: status === 'passed',
+        costUsd: selected.reduce((sum, lane) => sum + lane.usage.costUsd, 0),
+        calls: selected.reduce((sum, lane) => sum + lane.usage.calls, 0),
+        tokens: selected.reduce((sum, lane) => sum + lane.usage.tokens, 0),
+    };
+}
+export function addProviderUsage(usage, calls) {
+    if (calls === undefined || calls.length === 0)
+        return usage;
+    const costUsd = calls.reduce((sum, call) => sum + call.costUsd, 0);
+    const tokens = calls.reduce((sum, call) => sum + call.tokens, 0);
+    const model = calls.at(-1)?.model;
+    return {
+        provider: 'openrouter',
+        model: usage.model ?? model,
+        calls: usage.calls + calls.length,
+        tokens: usage.tokens + tokens,
+        costUsd: usage.costUsd + costUsd,
+        metered: true,
+    };
+}

package/dist/report/run.d.ts

@@ -1,4 +1,5 @@
 import type { HealEvent, TdAssertRecord, TdStepRecord } from '../api.js';
+import type { CacheStats } from '../engine/loop.js';
 import type { CallCost } from '../vision/cost.js';
 /**
  * JSON run report consumed by the GitHub Action (R10): per-test verdicts,
@@ -20,6 +21,8 @@ export interface TestReport {
     /** Per-call cost rows for model-level attribution. */
     calls: CallCost[];
     videoPath: string | undefined;
+    /** Fingerprint replay/grounding counters for this test. */
+    cache?: CacheStats;
     /** Agent Zero's autonomous second opinion on a failure (heal: 'a0'). */
     a0Diagnosis?: string;
 }
@@ -35,6 +38,12 @@ export interface RunTotals {
     costByModel: Record<string, number>;
     /** OpenRouter call count grouped by model id. */
     callsByModel: Record<string, number>;
+    cacheHits: number;
+    cacheMisses: number;
+    cacheHeals: number;
+    staleEntries: number;
+    assertionHits: number;
+    assertionMisses: number;
 }
 export interface RunReport {
     tool: 'argus-reviewer';

package/dist/report/run.js

@@ -24,6 +24,12 @@ export function buildRunReport(tests, startedAt, durationMs) {
             budgetExceeded: tests.some((t) => t.budgetExceeded),
             callsByModel,
             costByModel,
+            cacheHits: tests.reduce((sum, t) => sum + (t.cache?.hits ?? 0), 0),
+            cacheMisses: tests.reduce((sum, t) => sum + (t.cache?.misses ?? 0), 0),
+            cacheHeals: tests.reduce((sum, t) => sum + (t.cache?.heals ?? 0), 0),
+            staleEntries: tests.reduce((sum, t) => sum + (t.cache?.staleEntries ?? 0), 0),
+            assertionHits: tests.reduce((sum, t) => sum + (t.cache?.assertionHits ?? 0), 0),
+            assertionMisses: tests.reduce((sum, t) => sum + (t.cache?.assertionMisses ?? 0), 0),
         },
         tests,
         artifacts: {

package/dist/review/adjudicate.d.ts

@@ -0,0 +1,63 @@
+import { DecisionClient } from '../vision/decisions.js';
+/**
+ * U8 finding adjudication — one batched Jev decide() scores each
+ * synthesized finding's true-positive probability before posting. Same
+ * posture as the secrets lane: Jev annotates/routes, never gates.
+ * `p` lands on the finding record and the sticky confidence column;
+ * suppression is scoped to `nit`/`q` severities whose false-positive
+ * confidence exceeds `findingThreshold` — `bug`/`risk` are never
+ * suppressed, and a Jev outage leaves every finding unadjudicated and
+ * unsuppressed (degrade open).
+ *
+ * `findingThreshold` is the required P(false positive): a nit/q is
+ * suppressed when `1 - p > threshold`, i.e. `p < 1 - threshold`.
+ * Default 1.0 → nothing can exceed 100% FP → annotate-only.
+ */
+export interface AdjudicableFinding {
+    file: string;
+    line?: number;
+    severity: string;
+    category?: string;
+    message: string;
+}
+export interface FindingAdjudicationRecord {
+    file: string;
+    line?: number;
+    severity: string;
+    category?: string;
+    /** Finding text — capped; suppressed findings keep their message in audit. */
+    message: string;
+    adjudicated: boolean;
+    /** Jev P(true positive) for this finding. */
+    p?: number;
+    /** nit/q below the FP bar — kept for audit, removed from findings. */
+    suppressed?: boolean;
+}
+/** The audit half of the result — what report.findingAdjudication stores. */
+export interface FindingAdjudicationAudit {
+    records: FindingAdjudicationRecord[];
+    /** Findings past MAX_CANDIDATES — unadjudicated, never suppressed. */
+    overflow: number;
+    /** Whole-call failure — nothing adjudicated, nothing suppressed. */
+    unadjudicated?: boolean;
+}
+export interface FindingAdjudicationResult<T extends AdjudicableFinding> extends FindingAdjudicationAudit {
+    /** Surviving findings — adjudicated ones carry `p`. */
+    findings: (T & {
+        p?: number;
+    })[];
+}
+export declare function adjudicateFindings<T extends AdjudicableFinding>(opts: {
+    findings: T[];
+    /** PR file patches keyed by filename — Jev state context. */
+    patchByFile?: Map<string, string>;
+    threshold: number;
+    /**
+     * User-configured blocking severities — a severity listed here drives
+     * the verdict, so it must never be suppressed even if it is nit/q
+     * (otherwise Jev suppression could flip the commit-status gate).
+     */
+    blockSeverities?: string[];
+    client: DecisionClient;
+    model?: string;
+}): Promise<FindingAdjudicationResult<T>>;