@open-cr-agent/core 0.5.0 → 0.6.0

package/dist/pipeline/preview.js

@@ -1,9 +1,9 @@
+import { reviewerCall } from "../agent/settings.js";
 import { defaultBundlePolicy } from "../bundle/bundle.js";
 import { memoryFor } from "../memory/memory.js";
 import { buildReviewPrompt } from "../review/prompt.js";
 import { correctnessReviewer } from "../review/reviewers/correctness.js";
 import { resolveRules } from "../rules/resolve.js";
-import { reviewerCall } from "./agents.js";
 import { isLargeBundle } from "./execute.js";
 import { planTasks } from "./matrix.js";
 import { planReview } from "./plan.js";
@@ -13,8 +13,8 @@ export async function previewReview(options) {
     const plan = await planReview(options, () => { }, new AbortController().signal);
     const reviewers = options.reviewers ?? [correctnessReviewer];
     const planned = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
-        ultra: options.ultra === true,
-        ...(options.maxTasks !== undefined ? { maxTasks: options.maxTasks } : {}),
+        ultra: options.mode?.ultra === true,
+        ...(options.limits?.maxTasks !== undefined ? { maxTasks: options.limits?.maxTasks } : {}),
         hasGuidelines: Boolean(plan.guidelines?.trim()),
     });
     const { cells } = planned;
@@ -45,10 +45,14 @@ export async function previewReview(options) {
         if (models?.length)
             task.models = [...models];
         const key = `${cell.reviewer.id}\0${cell.bundle.label}`;
-        if ((options.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
+        if ((options.mode?.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
             plannedBundles.add(key);
             task.planPromptTokens = tokens(buildReviewPrompt({ ...input, forPlanning: true }));
         }
+        const first = task.models?.[0];
+        if (first !== undefined && options.inputPrice) {
+            task.inputCost = inputCost(first, options.inputPrice(first), task.promptTokens + (task.planPromptTokens ?? 0));
+        }
         return task;
     });
     const policy = options.bundling ?? defaultBundlePolicy;
@@ -63,6 +67,7 @@ export async function previewReview(options) {
         skipped: planned.skipped,
         promptTokens: tasks.reduce((sum, t) => sum + t.promptTokens + (t.planPromptTokens ?? 0), 0),
         planCalls: tasks.filter((t) => t.planPromptTokens !== undefined).length,
+        ...(tasks.some((t) => t.inputCost) ? { inputCost: totalInputCost(tasks) } : {}),
         warnings: [
             ...plan.warnings,
             ...(planned.limited?.length
@@ -73,6 +78,22 @@ export async function previewReview(options) {
         ],
     };
 }
+function inputCost(model, price, promptTokens) {
+    if (price === undefined)
+        return { model, status: "unknown" };
+    if (price === 0)
+        return { model, status: "unpriced" };
+    return { model, status: "priced", usd: (promptTokens * price) / 1_000_000 };
+}
+function totalInputCost(tasks) {
+    const total = { usd: 0, priced: 0, unpriced: 0, unknown: 0 };
+    for (const { inputCost } of tasks) {
+        if (inputCost?.status === "priced")
+            total.usd += inputCost.usd;
+        total[inputCost?.status ?? "unknown"] += 1;
+    }
+    return total;
+}
 // Four characters per token: an estimate, not a tokenizer.
 function tokens(prompt) {
     return Math.ceil((prompt.system.length + prompt.user.length) / 4);

package/dist/pipeline/provenance.d.ts

@@ -1,31 +1,8 @@
-import type { AgentRuntime, AppliedSampling, Effort, ModelTier, Sampling } from "../contracts.js";
+import type { ResolvedAgent, ReviewerOverrides } from "../agent/settings.js";
+import type { AgentRuntime, AppliedSampling, Sampling } from "../contracts.js";
+import type { AgentProvenance, RunProvenance } from "../report/provenance.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
-import type { RuleSource, SourcedRule } from "../rules/repo-rules.js";
-import type { ResolvedAgent } from "./agents.js";
-import type { ReviewerOverrides } from "./matrix.js";
-export interface RunProvenance {
-    ocraVersion: string;
-    promptHash: string;
-    configHash: string;
-    sampling: AppliedSampling;
-    agents?: Record<string, AgentProvenance>;
-    rules?: RuleProvenance[];
-    accountSettings?: {
-        version: string | null;
-    };
-}
-export interface RuleProvenance {
-    path: string[];
-    rule: string;
-    source?: RuleSource;
-}
-export interface AgentProvenance {
-    tier: ModelTier;
-    models?: string[];
-    effort?: Effort;
-    applied?: boolean;
-    notApplied?: (keyof Sampling)[];
-}
+import type { SourcedRule } from "../rules/repo-rules.js";
 export interface ProvenanceInput {
     ocraVersion: string;
     configHash: string;

package/dist/pipeline/provenance.js

@@ -1,6 +1,6 @@
-import { createHash } from "node:crypto";
 import { RELOCATE_SYSTEM_PROMPT } from "../anchor/relocate.js";
 import { GROUPING_SYSTEM_PROMPT } from "../bundle/grouping.js";
+import { shortHash } from "../hash.js";
 import { JUDGE_SYSTEM_PROMPT } from "../judge/prompt.js";
 import { PLAN_SYSTEM_PROMPT } from "../review/plan-phase.js";
 import { buildReviewPrompt } from "../review/prompt.js";
@@ -8,7 +8,7 @@ import { VERIFY_SYSTEM_PROMPT } from "../verify/prompt.js";
 // A short digest of a JSON value, the same whatever order its keys were
 // written in.
 export function stableHash(value) {
-    return createHash("sha256").update(canonicalJson(value)).digest("hex").slice(0, 16);
+    return shortHash(canonicalJson(value));
 }
 function canonicalJson(value) {
     if (Array.isArray(value))

package/dist/pipeline/run.d.ts

@@ -1,51 +1,5 @@
-import type { AnchorContext } from "../anchor/anchor.js";
-import type { BundlePolicy } from "../bundle/bundle.js";
-import type { FileGrouper } from "../bundle/grouping.js";
-import type { AgentRuntime, VcsAdapter } from "../contracts.js";
-import { type MemoryEntry } from "../memory/memory.js";
-import type { ModelChains } from "../plugin/types.js";
-import type { ReviewerDefinition } from "../review/reviewer.js";
-import type { SourcedRule } from "../rules/repo-rules.js";
-import type { SarifLog } from "../sarif/schema.js";
-import type { SelectionPolicy } from "../select/select.js";
-import { type RoleSettings, type TierEfforts } from "./agents.js";
-import { type ReviewerOverrides } from "./matrix.js";
-import { type ProvenanceInput } from "./provenance.js";
-import { type ReviewEvent, type ReviewReport } from "./report.js";
-export { GUIDELINES_PATH } from "./plan.js";
-export interface ReviewOptions {
-    vcs: VcsAdapter;
-    runtime: AgentRuntime;
-    reviewers?: readonly ReviewerDefinition[];
-    reviewerOverrides?: ReviewerOverrides;
-    effort?: TierEfforts;
-    roles?: RoleSettings;
-    models?: ModelChains;
-    rules?: readonly SourcedRule[];
-    readTrusted?: (path: string) => Promise<string | undefined>;
-    accountMemory?: readonly MemoryEntry[];
-    selection?: SelectionPolicy;
-    concurrency?: number;
-    taskTimeoutMs?: number;
-    runTimeoutMs?: number;
-    verify?: boolean;
-    judge?: boolean;
-    maxCostUsd?: number;
-    maxTasks?: number;
-    fullReview?: boolean;
-    ultra?: boolean;
-    sarif?: readonly SarifLog[];
-    runId?: string;
-    provenance?: ProvenanceInput;
-    signal?: AbortSignal;
-    onEvent?: (event: ReviewEvent) => void;
-}
-export interface ReviewHooks {
-    bundling?: BundlePolicy;
-    grouper?: FileGrouper;
-    relocate?: AnchorContext["relocate"] | false;
-    abortGraceMs?: number;
-}
+import type { ReviewReport } from "../report/report.js";
+import { type ReviewHooks, type ReviewOptions } from "./options.js";
 export declare function review(options: ReviewOptions): Promise<ReviewReport>;
 export declare function reviewWithHooks(options: ReviewOptions & ReviewHooks): Promise<ReviewReport>;
 //# sourceMappingURL=run.d.ts.map

package/dist/pipeline/run.js

@@ -1,42 +1,30 @@
-import { runtimeRelocator } from "../anchor/relocate.js";
+import { spendTracker } from "../agent/budget.js";
 import { errorMessage, OcraError } from "../errors.js";
-import { judgeFindings } from "../judge/judge.js";
-import { applyMemory } from "../memory/memory.js";
-import { priorCodePresence } from "../rereview/presence.js";
-import { reconcile, stillOpen } from "../rereview/reconcile.js";
 import { correctnessReviewer } from "../review/reviewers/correctness.js";
-import { markUnchecked, verifyFindings } from "../verify/verify.js";
-import { effortWarnings, resolveAgents, roleCall, } from "./agents.js";
-import { SpendLimitReached, spendTracker } from "./budget.js";
-import { coverageOf } from "./coverage.js";
-import { runJob } from "./execute.js";
-import { dedupeFindings } from "./findings.js";
-import { importSarif } from "./imports.js";
-import { DEFAULT_MAX_TASKS, planTasks } from "./matrix.js";
+import { assembleReport } from "./assemble-report.js";
+import { checkStage } from "./check-stage.js";
+import { executeStage } from "./execute-stage.js";
+import { filterStage } from "./filter-stage.js";
+import { MAX_TIMER_MS, REVIEW_DEFAULTS } from "./options.js";
 import { planReview } from "./plan.js";
-import { mapWithConcurrency } from "./pool.js";
-import { runProvenance } from "./provenance.js";
-import { coverageGaps, summarizeAnchoring, } from "./report.js";
 import { newRunId } from "./run-id.js";
-import { addUsage, emptyUsage, unpricedCalls } from "./usage.js";
-export { GUIDELINES_PATH } from "./plan.js";
-const DEFAULTS = { concurrency: 4, taskTimeoutMs: 10 * 60_000, runTimeoutMs: 25 * 60_000 };
 // The library entry: plan (deterministic stages) → execute (one agent task
-// per cell) → verify → judge → report. The `ocra` command is one caller.
-// The manual's Embedding page says which options are a contract.
+// per cell) → filter (memory, the previous review) → check (verify, judge)
+// → report. The `ocra` command is one caller. The manual's Embedding page
+// says which options are a contract.
 export function review(options) {
     return reviewWithHooks(options);
 }
 export async function reviewWithHooks(options) {
     const emit = options.onEvent ?? (() => { });
-    const timeout = AbortSignal.timeout(options.runTimeoutMs ?? DEFAULTS.runTimeoutMs);
+    const timeout = AbortSignal.timeout(Math.min(options.limits?.runTimeoutMs ?? REVIEW_DEFAULTS.runTimeoutMs, MAX_TIMER_MS));
     const signal = options.signal ? AbortSignal.any([options.signal, timeout]) : timeout;
     const reviewers = options.reviewers ?? [correctnessReviewer];
     if (reviewers.length === 0)
         throw new OcraError("CONFIG_INVALID", "No reviewer is registered");
-    const runId = options.runId ?? newRunId();
+    const runId = options.identity?.runId ?? newRunId();
     const prior = await loadPriorReview(options.vcs);
-    const scope = reviewScope(prior.review, options.fullReview === true);
+    const scope = reviewScope(prior.review, options.mode?.full === true);
     const plan = await planReview(scope.only
         ? {
             ...options,
@@ -45,232 +33,15 @@ export async function reviewWithHooks(options) {
             ...(prior.review?.tier ? { priorTier: prior.review.tier } : {}),
         }
         : { ...options, runId }, emit, signal);
-    const matrix = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
-        ultra: options.ultra === true,
-        ...(options.maxTasks !== undefined ? { maxTasks: options.maxTasks } : {}),
-        hasGuidelines: Boolean(plan.guidelines?.trim()),
-    });
-    const limited = matrix.skipped.filter((s) => s.reason === "task_limit").length;
-    if (limited > 0) {
-        plan.warnings.push(`task limit of ${options.maxTasks ?? DEFAULT_MAX_TASKS} reached: ${limited} review task(s) skipped; their files are reported as not reviewed`);
-    }
-    emit({ type: "matrix_planned", tasks: matrix.cells.length, skipped: matrix.skipped });
-    const relocationUsage = [];
-    const budget = spendTracker(options.maxCostUsd, plan.usage);
-    const relocator = options.relocate === false
-        ? undefined
-        : (options.relocate ??
-            runtimeRelocator(options.runtime, signal, (u) => {
-                relocationUsage.push(u);
-                budget.add(u);
-            }, roleCall("helper", options)));
-    // Tasks report spend while they run, so the one that uses up the review
-    // share stops every task still running, not only the ones not yet started.
-    const spendLimit = new AbortController();
-    const spend = (usage) => {
-        budget.add(usage);
-        if (budget.reviewExhausted() && !spendLimit.signal.aborted) {
-            spendLimit.abort(new SpendLimitReached(options.maxCostUsd ?? 0));
-        }
-    };
-    const execute = {
-        runtime: options.runtime,
-        taskTimeoutMs: options.taskTimeoutMs ?? DEFAULTS.taskTimeoutMs,
-        abortGraceMs: options.abortGraceMs,
-        // Past the spend limit a quote that does not match stays file-level.
-        relocate: relocator &&
-            (async (request) => (budget.exhausted() ? undefined : relocator(request))),
-        ultra: options.ultra === true,
-        plans: new Map(),
-        agents: options,
-        emit,
-        onUsage: spend,
-        signal: AbortSignal.any([signal, spendLimit.signal]),
-    };
-    // Tasks that never started leave their files unreviewed, not failed.
-    const notStarted = new Set();
-    let unaffordable = 0;
-    const results = await mapWithConcurrency(matrix.cells, options.concurrency ?? DEFAULTS.concurrency, async (cell) => {
-        // Once the run is cancelled or timed out, remaining cells are not started.
-        if (signal.aborted) {
-            notStarted.add(cell.taskId);
-            return skipCell(cell, "run cancelled before this task started", emit);
-        }
-        if (budget.reviewExhausted()) {
-            notStarted.add(cell.taskId);
-            unaffordable += 1;
-            return skipCell(cell, `spend limit of $${options.maxCostUsd} reached`, emit);
-        }
-        return runJob(cell, plan, execute);
-    });
-    if (unaffordable > 0) {
-        plan.warnings.push(`spend limit of $${options.maxCostUsd} reached: ${unaffordable} review task(s) did not start; their files are reported as not reviewed`);
-    }
-    // Memory and the previous review filter first, so Verify and Judge are not
-    // paid for findings that will not be reported, and a person's dismissal
-    // keeps a finding out of the verdict whatever the models say.
-    const concurrency = options.concurrency ?? DEFAULTS.concurrency;
-    const imported = options.sarif && options.sarif.length > 0
-        ? await importSarif(options.sarif, plan, emit)
-        : { findings: [], outcomes: [], warnings: [] };
-    const found = dedupeFindings([...results.flatMap((r) => r.findings), ...imported.findings]);
-    const fileCoverage = coverageOf(plan.decisions, results, plan.unchanged, matrix.limited ?? [], notStarted);
-    const remembered = applyMemory(found, plan.memory);
-    const reported = new Set(found.map((f) => f.fingerprint));
-    const priorReview = withoutRemembered(prior.review, plan.memory);
-    const reconciled = reconcile({
-        findings: remembered.kept,
-        reported,
-        prior: priorReview,
-        coverage: fileCoverage,
-        stillPresent: await priorCodePresence(priorReview, reported, plan.context.readFile),
-    });
-    const verification = options.verify === false
-        ? {
-            checked: 0,
-            kept: markUnchecked(reconciled.findings),
-            refuted: [],
-            missed: [],
-            usage: [],
-            warnings: [],
-        }
-        : await verifyFindings(reconciled.findings, {
-            runtime: options.runtime,
-            diffs: plan.selected,
-            context: plan.context,
-            signal,
-            concurrency,
-            budget,
-            call: roleCall("verifier", options),
-        });
-    if (verification.checked > 0) {
-        emit({
-            type: "verification_finished",
-            checked: verification.checked,
-            refuted: verification.refuted,
-        });
-    }
-    const judgeWanted = options.judge !== false && verification.kept.length > 0;
-    const judgeAffordable = !budget.exhausted();
-    const judged = await judgeFindings(verification.kept, {
-        runtime: options.runtime,
-        changeRequest: plan.changeRequest,
-        tier: plan.tier,
-        signal,
-        call: roleCall("judge", options),
-        enabled: judgeWanted && judgeAffordable,
-        keepDropped: options.ultra === true,
-        carried: stillOpen(reconciled),
-    });
-    if (judgeWanted && !judgeAffordable) {
-        judged.warnings.push(`spend limit of $${options.maxCostUsd} reached: findings were not judged`);
-    }
-    const { nothingReviewed } = coverageGaps({
-        coverage: fileCoverage,
-        tasks: results.map((r) => r.outcome),
-    });
-    if (!nothingReviewed) {
-        emit(judged.decisions
-            ? { type: "judge_finished", verdict: judged.verdict, judgement: judged.decisions }
-            : { type: "judge_finished", verdict: judged.verdict });
-    }
-    const calls = [
-        ...plan.usage,
-        ...results.map((r) => r.usage),
-        ...relocationUsage,
-        ...verification.usage,
-        ...judged.usage,
-    ];
-    const report = {
-        runId,
-        changeRequest: plan.changeRequest,
-        tier: plan.tier,
-        verdict: judged.verdict,
-        summary: nothingReviewed
-            ? "Nothing was reviewed: no reviewer covered or finished any selected file."
-            : judged.summary,
-        coverage: fileCoverage,
-        bundles: plan.bundles.map((b) => ({ label: b.label, files: b.files.map((f) => f.newPath) })),
-        tasks: [...results.map((r) => r.outcome), ...imported.outcomes],
-        skipped: 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: remembered.remembered,
-        usage: sumUsage(calls),
-        warnings: [
-            ...unpricedWarning(calls),
-            ...plan.warnings,
-            ...results.flatMap((r) => r.warnings),
-            ...imported.warnings,
-            ...verification.warnings,
-            ...judged.warnings,
-        ],
-    };
-    if (judged.decisions)
-        report.judgement = judged.decisions;
-    if (options.maxCostUsd !== undefined) {
-        const reached = budget.exhausted()
-            ? "total"
-            : spendLimit.signal.aborted || unaffordable > 0
-                ? "review"
-                : undefined;
-        report.spendLimit = { usd: options.maxCostUsd, ...(reached ? { reached } : {}) };
-    }
-    report.anchoring = summarizeAnchoring(report.findings, relocationUsage.length);
-    const agents = resolveAgents(reviewers, options);
-    report.warnings.push(...effortWarnings(agents, options.runtime));
-    if (options.provenance) {
-        const { runtime, reviewerOverrides } = options;
-        report.provenance = runProvenance(options.provenance, runtime, reviewers, agents, reviewerOverrides, plan.repoRules);
-    }
-    if (prior.review) {
-        report.rereview = {
-            fixed: reconciled.fixed,
-            notReproduced: reconciled.notReproduced,
-            notRechecked: reconciled.notRechecked,
-            unchanged: reconciled.unchanged,
-            dismissed: reconciled.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 (scope.note)
-        report.scope = scope.note;
-    if (prior.warning)
-        report.warnings.push(prior.warning);
+    const budget = spendTracker(options.limits?.maxCostUsd, plan.usage);
+    const context = { options, plan, budget, signal, emit };
+    const executed = await executeStage(reviewers, context);
+    const filtered = await filterStage(executed, prior.review, context);
+    const checked = await checkStage(filtered, context);
+    const report = assembleReport({ runId, reviewers, prior, scopeNote: scope.note }, { executed, filtered, checked }, context);
     emit({ type: "run_finished", report });
     return report;
 }
-function skipCell(cell, reason, emit) {
-    const outcome = {
-        taskId: cell.taskId,
-        reviewer: cell.reviewer.id,
-        bundle: cell.bundle.label,
-        files: cell.bundle.files.map((f) => f.newPath),
-        status: "cancelled",
-        error: reason,
-        findings: 0,
-        durationMs: 0,
-        usage: emptyUsage(),
-    };
-    emit({ type: "task_finished", outcome });
-    return { outcome, findings: [], usage: emptyUsage(), warnings: [] };
-}
-// An earlier finding the team has since accepted is no longer open.
-function withoutRemembered(review, memory) {
-    if (!review)
-        return undefined;
-    const accepted = new Set(memory.map((e) => e.fingerprint));
-    // Everything else the earlier review carries (replies, tier, head) stays.
-    return { ...review, findings: review.findings.filter((f) => !accepted.has(f.fingerprint)) };
-}
 // Review only what changed since the earlier review when the platform can
 // tell; otherwise everything, with the reason in the report.
 function reviewScope(review, full) {
@@ -297,30 +68,4 @@ async function loadPriorReview(vcs) {
         return { warning: `could not load the previous review: ${errorMessage(error)}` };
     }
 }
-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=run.js.map

package/dist/pipeline/task.d.ts

@@ -1,6 +1,6 @@
 import type { AgentRuntime, AgentTaskSpec, Usage } from "../contracts.js";
 import { type ReportedFinding } from "../domain.js";
-import type { TaskStatus } from "./report.js";
+import type { TaskStatus } from "../report/report.js";
 export interface TaskFinding {
     reported: ReportedFinding;
     model?: string;
@@ -19,7 +19,5 @@ export interface TaskCallbacks {
     abortGraceMs?: number | undefined;
 }
 export declare function executeTask(runtime: AgentRuntime, spec: AgentTaskSpec, runSignal: AbortSignal, callbacks: TaskCallbacks): Promise<TaskResult>;
-export declare const ABORT_GRACE_MS = 10000;
-export declare const MAX_FINDINGS_PER_TASK = 50;
 export declare function boundFinding(f: ReportedFinding): ReportedFinding;
 //# sourceMappingURL=task.d.ts.map

package/dist/pipeline/task.js

@@ -1,7 +1,7 @@
+import { SpendLimitReached } from "../agent/budget.js";
+import { addUsage, emptyUsage } from "../agent/usage.js";
 import { reportedFindingSchema } from "../domain.js";
 import { errorMessage } from "../errors.js";
-import { SpendLimitReached } from "./budget.js";
-import { addUsage, emptyUsage } from "./usage.js";
 export async function executeTask(runtime, spec, runSignal, callbacks) {
     const timeout = AbortSignal.timeout(spec.timeoutMs);
     const signal = AbortSignal.any([runSignal, timeout]);
@@ -58,7 +58,7 @@ export async function executeTask(runtime, spec, runSignal, callbacks) {
 // have reported findings; a runtime that stops its session delivers them
 // shortly after. Waiting a bounded moment keeps them in the report and in
 // the spend limit, without letting a runtime that ignores the abort hang.
-export const ABORT_GRACE_MS = 10_000;
+const ABORT_GRACE_MS = 10_000;
 async function collectAfterAbort(iterator, pending, result, callbacks) {
     const grace = AbortSignal.timeout(callbacks.abortGraceMs ?? ABORT_GRACE_MS);
     let next = pending ?? iterator.next();
@@ -120,7 +120,7 @@ function handle(event, result, callbacks) {
 }
 // A reviewer steered by the change could flood the pull request with
 // comments or pad them without end; both are bounded.
-export const MAX_FINDINGS_PER_TASK = 50;
+const MAX_FINDINGS_PER_TASK = 50;
 const MAX_TITLE = 300;
 const MAX_TEXT = 4_000;
 const MAX_EVIDENCE = 10;

package/dist/plugin/registry.d.ts

@@ -1,8 +1,9 @@
-import type { AgentRuntime, VcsAdapter } from "../contracts.js";
+import type { AgentRuntime } from "../contracts.js";
 import { OcraError } from "../errors.js";
-import type { ReviewEvent } from "../pipeline/report.js";
+import type { ReviewEvent } from "../report/report.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
 import type { RepoRule } from "../rules/repo-rules.js";
+import type { VcsAdapter } from "../vcs.js";
 import type { PluginSummary, RuntimeFactory, RuntimeOptions, ToolDefinition, VcsFactory } from "./types.js";
 export declare class PluginError extends OcraError {
     constructor(message: string, options?: {
@@ -10,8 +11,6 @@ export declare class PluginError extends OcraError {
     });
 }
 export declare class PluginRegistry {
-    private readonly reservedToolNames;
-    private readonly warn;
     private readonly vcs;
     private readonly runtimes;
     private readonly reviewerMap;
@@ -19,6 +18,8 @@ export declare class PluginRegistry {
     private readonly ruleList;
     private readonly listeners;
     private frozen;
+    private readonly reservedToolNames;
+    private readonly warn;
     constructor(reservedToolNames: ReadonlySet<string>, warn?: (message: string) => void);
     registerVcs(owner: string, name: string, factory: VcsFactory): void;
     registerRuntime(owner: string, name: string, factory: RuntimeFactory): void;

package/dist/plugin/registry.js

@@ -1,5 +1,5 @@
+import { AGENT_ROLES } from "../agent/settings.js";
 import { errorMessage, OcraError } from "../errors.js";
-import { AGENT_ROLES } from "../pipeline/agents.js";
 export class PluginError extends OcraError {
     constructor(message, options) {
         super("PLUGIN_INVALID", message, options);
@@ -7,8 +7,6 @@ export class PluginError extends OcraError {
     }
 }
 export class PluginRegistry {
-    reservedToolNames;
-    warn;
     vcs = new Map();
     runtimes = new Map();
     reviewerMap = new Map();
@@ -16,6 +14,8 @@ export class PluginRegistry {
     ruleList = [];
     listeners = [];
     frozen = false;
+    reservedToolNames;
+    warn;
     constructor(reservedToolNames, warn = () => { }) {
         this.reservedToolNames = reservedToolNames;
         this.warn = warn;

package/dist/plugin/types.d.ts

@@ -1,12 +1,10 @@
 import type { z } from "zod";
-import type { AgentRuntime, ModelTier, ReviewContext, Sampling, VcsAdapter } from "../contracts.js";
-import type { ReviewEvent } from "../pipeline/report.js";
+import type { AgentRuntime, ModelChains, ReviewContext, Sampling } from "../contracts.js";
+import type { ReviewEvent } from "../report/report.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
 import type { RepoRule } from "../rules/repo-rules.js";
+import type { VcsAdapter } from "../vcs.js";
 export type Env = Readonly<Record<string, string | undefined>>;
-export type ModelChains = {
-    [Tier in ModelTier]?: readonly string[];
-};
 export interface RuntimeOptions {
     models: ModelChains;
     agentModels?: Readonly<Record<string, readonly string[]>>;