@open-cr-agent/core 0.4.0 → 0.6.0

package/dist/index.d.ts

@@ -1,26 +1,40 @@
-export type { AgentEvent, AgentRuntime, AgentTaskSpec, AppliedSampling, AppliedSettings, CodeMatch, CompletionRequest, CompletionResult, Effort, ModelTier, ReviewContext, Sampling, Usage, VcsAdapter, } from "./contracts.js";
-export type { AnchorMethod, ChangeRequest, DiffLine, FileChangeKind, FileDiff, Finding, FindingProvenance, FindingStatus, Hunk, LineRange, PriorFinding, PriorReview, QuoteSignature, ReportedFinding, RiskTier, Severity, Verdict, Verification, } from "./domain.js";
-export { CompletionError, isOcraError, OCRA_ERROR_CODES, OcraError, type OcraErrorCode, } from "./errors.js";
+export { SpendLimitReached } from "./agent/budget.js";
+export type { ReviewerOverride, ReviewerOverrides } from "./agent/settings.js";
+export { type AgentRole, EFFORT_LEVELS, type RoleSetting, type RoleSettings, type TierEfforts, } from "./agent/settings.js";
+export { addUsage, emptyUsage } from "./agent/usage.js";
+export type { AgentEvent, AgentRuntime, AgentTaskSpec, AppliedSampling, AppliedSettings, CodeMatch, CompletionRequest, CompletionResult, Effort, ModelChains, ModelTier, ReviewContext, Sampling, Usage, } from "./contracts.js";
+export { MODEL_TIERS } from "./contracts.js";
+export type { AnchorMethod, ChangeRequest, DiffLine, FileChangeKind, FileDiff, Finding, FindingFix, FindingProvenance, FindingStatus, Hunk, LineRange, PriorFinding, PriorReview, QuoteSignature, ReportedFinding, RiskTier, Severity, Verdict, Verification, } from "./domain.js";
+export { CompletionError, errorMessage, isOcraError, OCRA_ERROR_CODES, OcraError, type OcraErrorCode, } from "./errors.js";
 export type { JudgeDecisions } from "./judge/judge.js";
-export type { MemoryEntry } from "./memory/memory.js";
-export type { AgentRole, RoleSetting, RoleSettings, TierEfforts, } from "./pipeline/agents.js";
-export { SpendLimitReached } from "./pipeline/budget.js";
+export type { MemoryEntry, MemorySource, RememberedEntry } from "./memory/memory.js";
+export { type ProxyEnv, proxiedFetch } from "./net/proxied-fetch.js";
 export { AccessDeniedError } from "./pipeline/context.js";
-export type { ReviewerOverride, ReviewerOverrides, SkippedCell, SkipReason, } from "./pipeline/matrix.js";
-export { type OutputFinding, type OutputPriorFinding, REPORT_VERSION, type ReportOutput, toReportOutput, } from "./pipeline/output.js";
-export { reportJsonSchema, reportOutputSchema } from "./pipeline/output-schema.js";
-export type { AgentProvenance, ProvenanceInput, RunProvenance, } from "./pipeline/provenance.js";
-export { type AnchoringSummary, type CoverageEntry, coverageGaps, type ReviewEvent, type ReviewReport, type TaskOutcome, type TaskStatus, } from "./pipeline/report.js";
-export { type ReviewOptions, review } from "./pipeline/run.js";
+export type { SkippedCell, SkipReason } from "./pipeline/matrix.js";
+export type { ReviewLimits, ReviewMode, ReviewOptions, ReviewStages, RunIdentity, } from "./pipeline/options.js";
+export type { ProvenanceInput } from "./pipeline/provenance.js";
+export { review } from "./pipeline/run.js";
 export { agentsMdReviewerPlugin, correctnessReviewerPlugin, docsReviewerPlugin, performanceReviewerPlugin, securityReviewerPlugin, sessionJsonlPlugin, } from "./plugin/builtin.js";
 export { type PluginHostOptions, startPlugins } from "./plugin/host.js";
 export { PluginError, PluginRegistry } from "./plugin/registry.js";
-export type { BootstrapContext, ConfigureContext, CustomProvider, Env, ModelChains, ModelPrice, OcraPlugin, PluginSummary, PostConfigureContext, RuntimeFactory, RuntimeOptions, ToolDefinition, VcsFactory, } from "./plugin/types.js";
+export type { BootstrapContext, ConfigureContext, CustomProvider, Env, ModelPrice, OcraPlugin, PluginSummary, PostConfigureContext, RuntimeFactory, RuntimeOptions, ToolDefinition, VcsFactory, } from "./plugin/types.js";
+export { type OutputFinding, type OutputPriorFinding, type ReportOutput, toReportOutput, } from "./report/output.js";
+export { REPORT_VERSION, reportJsonSchema, reportOutputSchema } from "./report/output-schema.js";
+export type { AgentProvenance, RuleProvenance, RunProvenance } from "./report/provenance.js";
+export { type AnchoringSummary, type CoverageEntry, coverageGaps, type ReviewEvent, type ReviewReport, type TaskOutcome, type TaskStatus, } from "./report/report.js";
 export type { ReviewerDefinition, ReviewerScope } from "./review/reviewer.js";
+export { REVIEW_TOOLS, type ReviewToolName } from "./review/tools.js";
 export type { Language } from "./rules/languages.js";
-export type { RepoRule } from "./rules/repo-rules.js";
+export type { RepoRule, RuleSource, SourcedRule } from "./rules/repo-rules.js";
 export type { RuleSet } from "./rules/rule-set.js";
+export { type AttemptError, type AttemptOutcome, MAX_AGENT_STEPS, RESUME_MESSAGE, withoutSecrets, } from "./runtime/attempt.js";
+export { ChainRunner, type ModelAttempts } from "./runtime/chain-runner.js";
+export { type EffortCapability, type EffortParameter, effortCapability, thinkingBudget, } from "./runtime/effort-capability.js";
+export { type ModelRef, parseModel } from "./runtime/models.js";
+export { parseQuotaError, type QuotaError } from "./runtime/quota.js";
+export { reviewTools } from "./runtime/tools.js";
 export { parseSarifLog, SarifError, type SarifLog } from "./sarif/schema.js";
 export type { ExclusionReason, SelectionPolicy } from "./select/select.js";
+export type { VcsAdapter } from "./vcs.js";
 export type { RefutedFinding } from "./verify/verify.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/index.js

@@ -3,15 +3,26 @@
 // etc/core.api.md records it; a change here updates that report
 // (`npm run api`). What the other workspace packages need beyond this comes
 // from "@open-cr-agent/core/internal", which is not a contract.
-export { CompletionError, isOcraError, OCRA_ERROR_CODES, OcraError, } from "./errors.js";
-export { SpendLimitReached } from "./pipeline/budget.js";
+export { SpendLimitReached } from "./agent/budget.js";
+export { EFFORT_LEVELS, } from "./agent/settings.js";
+export { addUsage, emptyUsage } from "./agent/usage.js";
+export { MODEL_TIERS } from "./contracts.js";
+export { CompletionError, errorMessage, isOcraError, OCRA_ERROR_CODES, OcraError, } from "./errors.js";
+export { proxiedFetch } from "./net/proxied-fetch.js";
 export { AccessDeniedError } from "./pipeline/context.js";
-export { REPORT_VERSION, toReportOutput, } from "./pipeline/output.js";
-export { reportJsonSchema, reportOutputSchema } from "./pipeline/output-schema.js";
-export { coverageGaps, } from "./pipeline/report.js";
 export { review } from "./pipeline/run.js";
 export { agentsMdReviewerPlugin, correctnessReviewerPlugin, docsReviewerPlugin, performanceReviewerPlugin, securityReviewerPlugin, sessionJsonlPlugin, } from "./plugin/builtin.js";
 export { startPlugins } from "./plugin/host.js";
 export { PluginError, PluginRegistry } from "./plugin/registry.js";
+export { toReportOutput, } from "./report/output.js";
+export { REPORT_VERSION, reportJsonSchema, reportOutputSchema } from "./report/output-schema.js";
+export { coverageGaps, } from "./report/report.js";
+export { REVIEW_TOOLS } from "./review/tools.js";
+export { MAX_AGENT_STEPS, RESUME_MESSAGE, withoutSecrets, } from "./runtime/attempt.js";
+export { ChainRunner } from "./runtime/chain-runner.js";
+export { effortCapability, thinkingBudget, } from "./runtime/effort-capability.js";
+export { parseModel } from "./runtime/models.js";
+export { parseQuotaError } from "./runtime/quota.js";
+export { reviewTools } from "./runtime/tools.js";
 export { parseSarifLog, SarifError } from "./sarif/schema.js";
 //# sourceMappingURL=index.js.map

package/dist/internal.d.ts

@@ -1,22 +1,19 @@
+export { AGENT_ROLES } from "./agent/settings.js";
+export { at } from "./at.js";
 export { parseUnifiedDiff } from "./diff/parse.js";
 export { severitySchema, verificationSchema } from "./domain.js";
-export { errorMessage, usageSpent } from "./errors.js";
-export { MEMORY_PATH, parseMemory, serializeMemory } from "./memory/memory.js";
-export { proxiedFetch } from "./net/proxied-fetch.js";
-export { AGENT_ROLES, EFFORT_LEVELS } from "./pipeline/agents.js";
+export { errnoCode, isNotFound, usageSpent } from "./errors.js";
+export { shortHash } from "./hash.js";
+export { MEMORY_PATH, memoryEntrySchema, parseMemory, serializeMemory, } from "./memory/memory.js";
 export { reviewContext } from "./pipeline/context.js";
 export { RISK_TIERS } from "./pipeline/matrix.js";
-export { isUnsafeCodePoint, type PlanOutput, serializeOutput, toPlanOutput, } from "./pipeline/output.js";
+export { MAX_TIMER_MS, REVIEW_DEFAULTS } from "./pipeline/options.js";
+export { PLAN_VERSION, type PlanOutput, planOutputSchema, toPlanOutput, } from "./pipeline/plan-output.js";
 export { previewReview, type ReviewPreview } from "./pipeline/preview.js";
 export { stableHash } from "./pipeline/provenance.js";
 export { newRunId } from "./pipeline/run-id.js";
-export { addUsage, emptyUsage } from "./pipeline/usage.js";
-export { REVIEW_TOOLS } from "./review/tools.js";
+export { readReport } from "./report/read.js";
+export { isUnsafeCodePoint, serializeOutput } from "./report/serialize.js";
 export { repoRuleSchema } from "./rules/repo-rules.js";
-export { type AttemptOutcome, MAX_AGENT_STEPS, RESUME_MESSAGE, withoutSecrets, } from "./runtime/attempt.js";
-export { completeWithFailback, withFailback } from "./runtime/failback.js";
-export { ModelHealth, parseModel } from "./runtime/models.js";
-export { parseQuotaError, type QuotaError, sleep } from "./runtime/quota.js";
-export { MAX_READ_LINES, reviewTools } from "./runtime/tools.js";
-export { defaultSelectionPolicy } from "./select/select.js";
+export { REPORT_FILE } from "./session/jsonl.js";
 //# sourceMappingURL=internal.d.ts.map

package/dist/internal.js

@@ -1,25 +1,22 @@
 // "@open-cr-agent/core/internal": what ocra's own packages share beyond the
 // public API (index.ts). Not a contract: any release may change or remove
 // any of it, and nothing outside this repository should import it.
+export { AGENT_ROLES } from "./agent/settings.js";
+export { at } from "./at.js";
 export { parseUnifiedDiff } from "./diff/parse.js";
 export { severitySchema, verificationSchema } from "./domain.js";
-export { errorMessage, usageSpent } from "./errors.js";
-export { MEMORY_PATH, parseMemory, serializeMemory } from "./memory/memory.js";
-export { proxiedFetch } from "./net/proxied-fetch.js";
-export { AGENT_ROLES, EFFORT_LEVELS } from "./pipeline/agents.js";
+export { errnoCode, isNotFound, usageSpent } from "./errors.js";
+export { shortHash } from "./hash.js";
+export { MEMORY_PATH, memoryEntrySchema, parseMemory, serializeMemory, } from "./memory/memory.js";
 export { reviewContext } from "./pipeline/context.js";
 export { RISK_TIERS } from "./pipeline/matrix.js";
-export { isUnsafeCodePoint, serializeOutput, toPlanOutput, } from "./pipeline/output.js";
+export { MAX_TIMER_MS, REVIEW_DEFAULTS } from "./pipeline/options.js";
+export { PLAN_VERSION, planOutputSchema, toPlanOutput, } from "./pipeline/plan-output.js";
 export { previewReview } from "./pipeline/preview.js";
 export { stableHash } from "./pipeline/provenance.js";
 export { newRunId } from "./pipeline/run-id.js";
-export { addUsage, emptyUsage } from "./pipeline/usage.js";
-export { REVIEW_TOOLS } from "./review/tools.js";
+export { readReport } from "./report/read.js";
+export { isUnsafeCodePoint, serializeOutput } from "./report/serialize.js";
 export { repoRuleSchema } from "./rules/repo-rules.js";
-export { MAX_AGENT_STEPS, RESUME_MESSAGE, withoutSecrets, } from "./runtime/attempt.js";
-export { completeWithFailback, withFailback } from "./runtime/failback.js";
-export { ModelHealth, parseModel } from "./runtime/models.js";
-export { parseQuotaError, sleep } from "./runtime/quota.js";
-export { MAX_READ_LINES, reviewTools } from "./runtime/tools.js";
-export { defaultSelectionPolicy } from "./select/select.js";
+export { REPORT_FILE } from "./session/jsonl.js";
 //# sourceMappingURL=internal.js.map

package/dist/judge/judge.d.ts

@@ -1,7 +1,7 @@
-import type { AgentRuntime, Effort, Usage } from "../contracts.js";
+import { type AgentCallSettings } from "../agent/settings.js";
+import type { AgentRuntime, Usage } from "../contracts.js";
 import type { ChangeRequest, Finding, PriorFinding, RiskTier, Severity, Verdict } from "../domain.js";
 import { type JudgeResponse } from "./prompt.js";
-export declare const JUDGE_TIMEOUT_MS = 180000;
 export interface JudgeDecisions {
     merged: {
         kept: string;
@@ -34,7 +34,7 @@ export interface JudgeOptions {
     tier: RiskTier;
     signal: AbortSignal;
     enabled: boolean;
-    effort?: Effort | undefined;
+    call?: AgentCallSettings | undefined;
     keepDropped?: boolean;
     carried?: readonly PriorFinding[];
 }

package/dist/judge/judge.js

@@ -1,9 +1,10 @@
+import { parseJsonAnswer } from "../agent/json.js";
+import { agentCall } from "../agent/settings.js";
+import { at } from "../at.js";
 import { errorMessage, OcraError, usageSpent } from "../errors.js";
-import { agentCall } from "../pipeline/agents.js";
-import { parseJsonAnswer } from "../pipeline/helpers.js";
 import { buildJudgePrompt, judgeResponseSchema } from "./prompt.js";
 import { decideVerdict, defaultSummary } from "./verdict.js";
-export const JUDGE_TIMEOUT_MS = 180_000;
+const JUDGE_TIMEOUT_MS = 180_000;
 export async function judgeFindings(findings, options) {
     const carried = options.carried ?? [];
     const fallback = (warnings = [], usage = []) => ({
@@ -22,7 +23,7 @@ export async function judgeFindings(findings, options) {
     try {
         const answer = await complete({
             tier: "top",
-            ...agentCall("judge", options.effort),
+            ...agentCall("judge", options.call),
             system: prompt.system,
             user: prompt.user,
             timeoutMs: JUDGE_TIMEOUT_MS,
@@ -69,7 +70,7 @@ export function applyDecisions(findings, response) {
     const decisions = { merged: [], dropped: [], recalibrated: [] };
     const warnings = [];
     const removed = new Set();
-    const isProtected = (i) => protectedFinding(findings[i]);
+    const isProtected = (i) => protectedFinding(at(findings, i));
     for (const group of response.duplicates) {
         const members = [...new Set(group.filter(valid))].filter((i) => !removed.has(i));
         // Merging keeps one member; keep a protected one so it is not merged away.
@@ -82,19 +83,19 @@ export function applyDecisions(findings, response) {
         for (const i of rest)
             removed.add(i);
         decisions.merged.push({
-            kept: findings[keep].fingerprint,
-            merged: rest.map((i) => findings[i].fingerprint),
+            kept: at(findings, keep).fingerprint,
+            merged: rest.map((i) => at(findings, i).fingerprint),
         });
     }
     for (const { index, reason } of response.drop) {
         if (!valid(index) || removed.has(index))
             continue;
         if (isProtected(index)) {
-            warnings.push(`judge tried to drop the confirmed critical finding ${findings[index].fingerprint.slice(0, 8)}; kept it`);
+            warnings.push(`judge tried to drop the confirmed critical finding ${at(findings, index).fingerprint.slice(0, 8)}; kept it`);
             continue;
         }
         removed.add(index);
-        const f = findings[index];
+        const f = at(findings, index);
         decisions.dropped.push({ fingerprint: f.fingerprint, file: f.file, title: f.title, reason });
     }
     const severities = new Map();

package/dist/judge/verdict.d.ts

@@ -1,5 +1,4 @@
 import type { Finding, Severity, Verdict, Verification } from "../domain.js";
-export declare const PATTERN_WARNINGS = 3;
 export interface VerdictInput {
     severity: Severity;
     verification?: Verification;

package/dist/judge/verdict.js

@@ -1,4 +1,4 @@
-export const PATTERN_WARNINGS = 3;
+const PATTERN_WARNINGS = 3;
 // The rubric is code, so the same findings always give the same verdict and
 // a failed judge call cannot change it; it leans towards approval. Only a
 // critical finding the verifier confirmed blocks: one model's unchecked claim

package/dist/memory/memory.d.ts

@@ -11,9 +11,14 @@ export declare const memoryEntrySchema: z.ZodObject<{
 export type MemoryEntry = z.infer<typeof memoryEntrySchema>;
 export declare function parseMemory(json: string): MemoryEntry[];
 export declare function serializeMemory(entries: readonly MemoryEntry[]): string;
-export declare function applyMemory(findings: readonly Finding[], memory: readonly MemoryEntry[]): {
+export type MemorySource = "repository" | "account";
+export type RememberedEntry = MemoryEntry & {
+    source: MemorySource;
+};
+export declare function mergeMemory(repository: readonly MemoryEntry[], account: readonly MemoryEntry[]): RememberedEntry[];
+export declare function applyMemory<E extends MemoryEntry>(findings: readonly Finding[], memory: readonly E[]): {
     kept: Finding[];
-    remembered: MemoryEntry[];
+    remembered: E[];
 };
 export declare function memoryFor(files: readonly string[], memory: readonly MemoryEntry[]): MemoryEntry[];
 //# sourceMappingURL=memory.d.ts.map

package/dist/memory/memory.js

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { OcraError } from "../errors.js";
+import { errorMessage, OcraError } from "../errors.js";
 export const MEMORY_PATH = ".ocra/memory.json";
 const MAX_ENTRIES = 1_000;
 export const memoryEntrySchema = z.object({
@@ -19,7 +19,7 @@ export function parseMemory(json) {
         data = JSON.parse(json);
     }
     catch (error) {
-        throw new OcraError("CONFIG_INVALID", `${MEMORY_PATH} is not valid JSON: ${error.message}`, { cause: error });
+        throw new OcraError("CONFIG_INVALID", `${MEMORY_PATH} is not valid JSON: ${errorMessage(error)}`, { cause: error });
     }
     const parsed = memoryFileSchema.safeParse(data);
     if (!parsed.success)
@@ -29,6 +29,18 @@ export function parseMemory(json) {
 export function serializeMemory(entries) {
     return `${JSON.stringify({ accepted: entries }, null, 2)}\n`;
 }
+// The union of both sources; a fingerprint both list is the repository's.
+export function mergeMemory(repository, account) {
+    const merged = repository.map((e) => ({ ...e, source: "repository" }));
+    const seen = new Set(repository.map((e) => e.fingerprint));
+    for (const e of account) {
+        if (seen.has(e.fingerprint))
+            continue;
+        seen.add(e.fingerprint);
+        merged.push({ ...e, source: "account" });
+    }
+    return merged;
+}
 export function applyMemory(findings, memory) {
     const accepted = new Map(memory.map((e) => [e.fingerprint, e]));
     const kept = [];

package/dist/net/proxied-fetch.js

@@ -5,7 +5,8 @@ import { EnvHttpProxyAgent, fetch as undiciFetch } from "undici";
 // EnvHttpProxyAgent, reading the given environment rather than the
 // process's; without one, Node's fetch is used as it is. undici's fetch and
 // agent are used together so that no object crosses between it and Node's
-// bundled copy (as runtime-opencode's transport does).
+// bundled copy (runtime-opencode's transport keeps its own copy of the
+// adapter on purpose; see there).
 export function proxiedFetch(env) {
     const httpProxy = env.HTTP_PROXY ?? env.http_proxy;
     const httpsProxy = env.HTTPS_PROXY ?? env.https_proxy;

package/dist/pipeline/assemble-report.d.ts

@@ -0,0 +1,22 @@
+import type { PriorReview } from "../domain.js";
+import { type ReviewReport } from "../report/report.js";
+import type { ReviewerDefinition } from "../review/reviewer.js";
+import type { CheckStage } from "./check-stage.js";
+import type { ExecuteStage, StageContext } from "./execute-stage.js";
+import type { FilterStage } from "./filter-stage.js";
+export interface RunFacts {
+    runId: string;
+    reviewers: readonly ReviewerDefinition[];
+    prior: {
+        review?: PriorReview;
+        warning?: string;
+    };
+    scopeNote?: NonNullable<ReviewReport["scope"]> | undefined;
+}
+export interface Stages {
+    executed: ExecuteStage;
+    filtered: FilterStage;
+    checked: CheckStage;
+}
+export declare function assembleReport(run: RunFacts, stages: Stages, context: StageContext): ReviewReport;
+//# sourceMappingURL=assemble-report.d.ts.map

package/dist/pipeline/assemble-report.js

@@ -0,0 +1,99 @@
+import { effortWarnings, resolveAgents } from "../agent/settings.js";
+import { addUsage, emptyUsage, unpricedCalls } from "../agent/usage.js";
+import { summarizeAnchoring } from "../report/report.js";
+import { runProvenance } from "./provenance.js";
+export function assembleReport(run, stages, context) {
+    const report = reportBody(run, stages, context);
+    const { options, plan, budget } = context;
+    const { executed, filtered, checked } = stages;
+    if (checked.judged.decisions)
+        report.judgement = checked.judged.decisions;
+    if (options.limits?.maxCostUsd !== undefined) {
+        const reached = budget.exhausted()
+            ? "total"
+            : executed.reviewLimitReached()
+                ? "review"
+                : undefined;
+        report.spendLimit = { usd: options.limits?.maxCostUsd, ...(reached ? { reached } : {}) };
+    }
+    report.anchoring = summarizeAnchoring(report.findings, executed.relocations.length);
+    const agents = resolveAgents(run.reviewers, options);
+    report.warnings.push(...effortWarnings(agents, options.runtime));
+    if (options.identity?.provenance) {
+        const { runtime, reviewerOverrides } = options;
+        report.provenance = runProvenance(options.identity?.provenance, runtime, run.reviewers, agents, reviewerOverrides, plan.repoRules);
+    }
+    if (run.prior.review) {
+        const { fixed, notReproduced, notRechecked, unchanged, dismissed } = filtered.reconciled;
+        report.rereview = { fixed, notReproduced, notRechecked, unchanged, dismissed };
+    }
+    if (plan.widened) {
+        report.scope = {
+            mode: "full",
+            reason: `the risk tier rose from ${plan.widened.from} to ${plan.widened.to}, which adds reviewers`,
+        };
+    }
+    else if (run.scopeNote)
+        report.scope = run.scopeNote;
+    if (run.prior.warning)
+        report.warnings.push(run.prior.warning);
+    return report;
+}
+function reportBody(run, { executed, filtered, checked }, { plan }) {
+    const { verification, judged } = checked;
+    const calls = [...plan.usage, ...executed.usage(), ...checked.usage];
+    return {
+        runId: run.runId,
+        changeRequest: plan.changeRequest,
+        tier: plan.tier,
+        verdict: judged.verdict,
+        summary: filtered.nothingReviewed
+            ? "Nothing was reviewed: no reviewer covered or finished any selected file."
+            : judged.summary,
+        coverage: filtered.coverage,
+        bundles: plan.bundles.map((b) => ({ label: b.label, files: b.files.map((f) => f.newPath) })),
+        tasks: [...executed.results.map((r) => r.outcome), ...filtered.imported.outcomes],
+        skipped: executed.matrix.skipped,
+        findings: sortFindings(judged.findings),
+        // Counted before the judge: dropping or downgrading a critical nobody
+        // could check must not turn an incomplete run into a clean one.
+        unverifiedCriticals: countMissedCriticals(verification.kept, verification.missed),
+        refuted: verification.refuted,
+        remembered: filtered.remembered,
+        usage: sumUsage(calls),
+        warnings: [
+            ...unpricedWarning(calls),
+            ...plan.warnings,
+            ...executed.warnings,
+            ...filtered.warnings,
+            ...checked.warnings,
+        ],
+    };
+}
+const SEVERITY_ORDER = { critical: 0, warning: 1, suggestion: 2 };
+function sortFindings(findings) {
+    return findings.sort((a, b) => SEVERITY_ORDER[a.severity] - SEVERITY_ORDER[b.severity] ||
+        a.file.localeCompare(b.file) ||
+        (a.lineRange?.start ?? 0) - (b.lineRange?.start ?? 0));
+}
+function unpricedWarning(calls) {
+    const unpriced = unpricedCalls(calls);
+    return unpriced > 0
+        ? [
+            `${unpriced} model call(s) used tokens but reported no cost: their model has no price, so the reported cost and the spend limit do not count them`,
+        ]
+        : [];
+}
+function sumUsage(usages) {
+    return usages.reduce(addUsage, emptyUsage());
+}
+// Low-confidence findings do not count toward the verdict, so their missed
+// verification does not make the run incomplete either.
+function countMissedCriticals(findings, missed) {
+    const set = new Set(missed);
+    return findings.filter((f) => f.severity === "critical" &&
+        !f.lowConfidence &&
+        f.verification === "unchecked" &&
+        set.has(f.fingerprint)).length;
+}
+//# sourceMappingURL=assemble-report.js.map

package/dist/pipeline/check-stage.d.ts

@@ -0,0 +1,13 @@
+import type { Usage } from "../contracts.js";
+import { type JudgeResult } from "../judge/judge.js";
+import { type VerificationResult } from "../verify/verify.js";
+import type { StageContext } from "./execute-stage.js";
+import type { FilterStage } from "./filter-stage.js";
+export interface CheckStage {
+    verification: VerificationResult;
+    judged: JudgeResult;
+    usage: Usage[];
+    warnings: string[];
+}
+export declare function checkStage(filtered: FilterStage, context: StageContext): Promise<CheckStage>;
+//# sourceMappingURL=check-stage.d.ts.map

package/dist/pipeline/check-stage.js

@@ -0,0 +1,70 @@
+import { roleCall } from "../agent/settings.js";
+import { judgeFindings } from "../judge/judge.js";
+import { stillOpen } from "../rereview/reconcile.js";
+import { markUnchecked, verifyFindings } from "../verify/verify.js";
+import { REVIEW_DEFAULTS } from "./options.js";
+// Verify fact-checks the findings, then the judge merges, filters and
+// recalibrates them and gives the verdict.
+export async function checkStage(filtered, context) {
+    const verification = await verify(filtered, context);
+    const judged = await judge(verification, filtered, context);
+    return {
+        verification,
+        judged,
+        usage: [...verification.usage, ...judged.usage],
+        warnings: [...verification.warnings, ...judged.warnings],
+    };
+}
+async function verify({ reconciled }, { options, plan, budget, signal, emit }) {
+    if (options.stages?.verify === false) {
+        return {
+            checked: 0,
+            kept: markUnchecked(reconciled.findings),
+            refuted: [],
+            missed: [],
+            usage: [],
+            warnings: [],
+        };
+    }
+    const verification = await verifyFindings(reconciled.findings, {
+        runtime: options.runtime,
+        diffs: plan.selected,
+        context: plan.context,
+        signal,
+        concurrency: options.limits?.concurrency ?? REVIEW_DEFAULTS.concurrency,
+        budget,
+        call: roleCall("verifier", options),
+    });
+    if (verification.checked > 0) {
+        emit({
+            type: "verification_finished",
+            checked: verification.checked,
+            refuted: verification.refuted,
+        });
+    }
+    return verification;
+}
+async function judge(verification, { reconciled, nothingReviewed }, { options, plan, budget, signal, emit }) {
+    const wanted = options.stages?.judge !== false && verification.kept.length > 0;
+    const affordable = !budget.exhausted();
+    const judged = await judgeFindings(verification.kept, {
+        runtime: options.runtime,
+        changeRequest: plan.changeRequest,
+        tier: plan.tier,
+        signal,
+        call: roleCall("judge", options),
+        enabled: wanted && affordable,
+        keepDropped: options.mode?.ultra === true,
+        carried: stillOpen(reconciled),
+    });
+    if (wanted && !affordable) {
+        judged.warnings.push(`spend limit of $${options.limits?.maxCostUsd} reached: findings were not judged`);
+    }
+    if (!nothingReviewed) {
+        emit(judged.decisions
+            ? { type: "judge_finished", verdict: judged.verdict, judgement: judged.decisions }
+            : { type: "judge_finished", verdict: judged.verdict });
+    }
+    return judged;
+}
+//# sourceMappingURL=check-stage.js.map

package/dist/pipeline/context.d.ts

@@ -1,6 +1,7 @@
-import type { ReviewContext, VcsAdapter } from "../contracts.js";
+import type { ReviewContext } from "../contracts.js";
 import type { FileDiff } from "../domain.js";
 import { OcraError } from "../errors.js";
+import type { VcsAdapter } from "../vcs.js";
 export declare class AccessDeniedError extends OcraError {
     constructor(message: string);
 }

package/dist/pipeline/coverage.d.ts

@@ -1,6 +1,6 @@
+import type { CoverageEntry } from "../report/report.js";
 import type { FileDecision } from "../select/select.js";
 import type { JobResult } from "./execute.js";
 import type { MatrixCell } from "./matrix.js";
-import type { CoverageEntry } from "./report.js";
 export declare function coverageOf(decisions: readonly FileDecision[], results: readonly JobResult[], unchanged: ReadonlySet<string>, limited: readonly MatrixCell[], notStarted: ReadonlySet<string>): CoverageEntry[];
 //# sourceMappingURL=coverage.d.ts.map

package/dist/pipeline/coverage.js

@@ -1,3 +1,4 @@
+import { at } from "../at.js";
 export function coverageOf(decisions, results, unchanged, limited, notStarted) {
     // A file is reviewed when every reviewer assigned to it finished at least
     // one of its tasks: under --ultra one completed sample is enough. A
@@ -24,7 +25,7 @@ export function coverageOf(decisions, results, unchanged, limited, notStarted) {
     }
     const status = new Map();
     for (const [k, completed] of done) {
-        const file = k.split("\0")[1];
+        const file = at(k.split("\0"), 1);
         const now = completed ? "reviewed" : ran.has(k) ? "failed" : "unreviewed";
         const before = status.get(file);
         // failed outranks unreviewed, which outranks reviewed.

package/dist/pipeline/execute-stage.d.ts

@@ -0,0 +1,26 @@
+import { type SpendTracker } from "../agent/budget.js";
+import type { Usage } from "../contracts.js";
+import type { ReviewEvent } from "../report/report.js";
+import type { ReviewerDefinition } from "../review/reviewer.js";
+import { type JobResult } from "./execute.js";
+import { type ReviewMatrix } from "./matrix.js";
+import { type ReviewHooks, type ReviewOptions } from "./options.js";
+import type { ReviewPlan } from "./plan.js";
+export interface StageContext {
+    options: ReviewOptions & ReviewHooks;
+    plan: ReviewPlan;
+    budget: SpendTracker;
+    signal: AbortSignal;
+    emit: (event: ReviewEvent) => void;
+}
+export interface ExecuteStage {
+    matrix: ReviewMatrix;
+    results: JobResult[];
+    notStarted: ReadonlySet<string>;
+    relocations: readonly Usage[];
+    usage(): Usage[];
+    warnings: string[];
+    reviewLimitReached(): boolean;
+}
+export declare function executeStage(reviewers: readonly ReviewerDefinition[], context: StageContext): Promise<ExecuteStage>;
+//# sourceMappingURL=execute-stage.d.ts.map