@open-cr-agent/core 0.1.2 → 0.2.0

package/dist/pipeline/output.d.ts

@@ -55,6 +55,7 @@ export interface ReportOutput {
         files: string[];
     }[];
     anchoring?: AnchoringSummary;
+    spendLimit?: ReviewReport["spendLimit"];
     usage: Usage;
     warnings: string[];
 }

package/dist/pipeline/output.js

@@ -29,6 +29,8 @@ export function toReportOutput(report) {
         output.judgement = report.judgement;
     if (report.anchoring)
         output.anchoring = report.anchoring;
+    if (report.spendLimit)
+        output.spendLimit = report.spendLimit;
     if (report.rereview) {
         const r = report.rereview;
         output.rereview = {

package/dist/pipeline/report.d.ts

@@ -13,7 +13,10 @@ export type CoverageEntry = {
     status: "excluded";
     reason: ExclusionReason;
 };
-export declare function coverageGaps(coverage: readonly CoverageEntry[]): {
+export declare function coverageGaps(run: {
+    coverage: readonly CoverageEntry[];
+    tasks: readonly Pick<TaskOutcome, "status">[];
+}): {
     notReviewed: number;
     nothingReviewed: boolean;
 };
@@ -60,6 +63,10 @@ export interface ReviewReport {
         dismissed: PriorFinding[];
     };
     anchoring?: AnchoringSummary;
+    spendLimit?: {
+        usd: number;
+        reached?: "review" | "total";
+    };
     usage: Usage;
     warnings: string[];
 }

package/dist/pipeline/report.js

@@ -1,11 +1,14 @@
 // How much of the selection this run actually reviewed. Every surface (exit
 // code, terminal, pull request summary) reads it from here, so none of them
 // can call a run that reviewed nothing "approved".
-export function coverageGaps(coverage) {
-    const notReviewed = coverage.filter((c) => c.status === "failed" || c.status === "unreviewed").length;
+export function coverageGaps(run) {
+    const notReviewed = run.coverage.filter((c) => c.status === "failed" || c.status === "unreviewed").length;
     // Unchanged files were reviewed by an earlier run, and their findings and
     // verdict carry over: a re-review whose new files all failed still has them.
-    const reviewed = coverage.some((c) => c.status === "reviewed" || c.status === "unchanged");
+    // A file stays failed while any of its reviewers failed, so a reviewer that
+    // finished its tasks has still reviewed something (#263).
+    const reviewed = run.coverage.some((c) => c.status === "reviewed" || c.status === "unchanged") ||
+        run.tasks.some((t) => t.status === "completed");
     return { notReviewed, nothingReviewed: notReviewed > 0 && !reviewed };
 }
 export function summarizeAnchoring(findings, relocationCalls) {

package/dist/pipeline/run.js

@@ -13,7 +13,7 @@ import { DEFAULT_MAX_TASKS, planTasks } from "./matrix.js";
 import { planReview } from "./plan.js";
 import { mapWithConcurrency } from "./pool.js";
 import { coverageGaps, summarizeAnchoring, } from "./report.js";
-import { addUsage, emptyUsage } from "./usage.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 };
 // Plan (deterministic stages) → execute (one agent task per cell) → report.
@@ -74,21 +74,31 @@ export async function runReview(options) {
         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)
+        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 found = dedupeFindings(results.flatMap((r) => r.findings));
-    const fileCoverage = coverage(plan.decisions, results, plan.unchanged, matrix.limited ?? []);
+    const fileCoverage = coverage(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);
@@ -137,12 +147,22 @@ export async function runReview(options) {
     if (judgeWanted && !judgeAffordable) {
         judged.warnings.push(`spend limit of $${options.maxCostUsd} reached: findings were not judged`);
     }
-    const { nothingReviewed } = coverageGaps(fileCoverage);
+    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 = {
         changeRequest: plan.changeRequest,
         tier: plan.tier,
@@ -160,14 +180,9 @@ export async function runReview(options) {
         unverifiedCriticals: countMissedCriticals(verification.kept, verification.missed),
         refuted: verification.refuted,
         remembered: remembered.remembered,
-        usage: sumUsage([
-            ...plan.usage,
-            ...results.map((r) => r.usage),
-            ...relocationUsage,
-            ...verification.usage,
-            ...judged.usage,
-        ]),
+        usage: sumUsage(calls),
         warnings: [
+            ...unpricedWarning(calls),
             ...plan.warnings,
             ...results.flatMap((r) => r.warnings),
             ...verification.warnings,
@@ -176,6 +191,14 @@ export async function runReview(options) {
     };
     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);
     if (prior.review) {
         report.rereview = {
@@ -247,18 +270,20 @@ async function loadPriorReview(vcs) {
         return { warning: `could not load the previous review: ${errorMessage(error)}` };
     }
 }
-function coverage(decisions, results, unchanged, limited) {
+function coverage(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
-    // reviewer whose task failed makes the file "failed"; one the task limit
-    // never started makes it "unreviewed".
+    // reviewer whose task failed makes the file "failed"; one whose task never
+    // started (the task or spend limit, a cancelled run) makes it "unreviewed".
     const done = new Map();
     const ran = new Set();
     const key = (reviewer, file) => `${reviewer}\0${file}`;
     for (const { outcome } of results) {
+        const started = !notStarted.has(outcome.taskId);
         for (const file of outcome.files) {
             const k = key(outcome.reviewer, file);
-            ran.add(k);
+            if (started)
+                ran.add(k);
             done.set(k, done.get(k) === true || outcome.status === "completed");
         }
     }
@@ -294,6 +319,14 @@ function sortFindings(findings) {
         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());
 }

package/dist/pipeline/usage.d.ts

@@ -1,4 +1,5 @@
 import type { Usage } from "../contracts.js";
 export declare function emptyUsage(): Usage;
 export declare function addUsage(total: Usage, next: Usage): Usage;
+export declare function unpricedCalls(usages: readonly Usage[]): number;
 //# sourceMappingURL=usage.d.ts.map

package/dist/pipeline/usage.js

@@ -10,4 +10,10 @@ export function addUsage(total, next) {
         costUsd: total.costUsd + next.costUsd,
     };
 }
+// Calls that used tokens but cost nothing: their model has no price (a
+// declared model priced at 0, or one missing from the pricing catalog), so
+// reported cost and the spend limit cannot count them.
+export function unpricedCalls(usages) {
+    return usages.filter((u) => u.inputTokens + u.outputTokens > 0 && u.costUsd === 0).length;
+}
 //# sourceMappingURL=usage.js.map

package/dist/plugin/types.d.ts

@@ -11,6 +11,17 @@ export interface RuntimeOptions {
     models: ModelChains;
     tools: readonly ToolDefinition[];
     env: Env;
+    providers?: Readonly<Record<string, CustomProvider>>;
+}
+export interface CustomProvider {
+    baseUrl: string;
+    apiKeyEnv?: string;
+    models: Readonly<Record<string, ModelPrice>>;
+}
+export interface ModelPrice {
+    input: number;
+    output: number;
+    cachedInput?: number;
 }
 export type VcsFactory = (options: unknown) => VcsAdapter;
 export type RuntimeFactory = (options: RuntimeOptions) => AgentRuntime;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-cr-agent/core",
-  "version": "0.1.2",
+  "version": "0.2.0",
   "description": "Domain types, review pipeline stages and plugin contracts for Open-CR-Agent",
   "keywords": [
     "code-review",