@open-cr-agent/core 0.1.1 → 0.1.2

package/dist/pipeline/budget.d.ts

@@ -1,5 +1,8 @@
 import type { Usage } from "../contracts.js";
 export declare const REVIEW_BUDGET_SHARE = 0.8;
+export declare class SpendLimitReached extends Error {
+    constructor(maxCostUsd: number);
+}
 export interface SpendTracker {
     reviewExhausted(): boolean;
     exhausted(): boolean;

package/dist/pipeline/budget.js

@@ -2,9 +2,17 @@
 // and Judge, so the run that hits the limit still gets its findings checked.
 // Those stages are one short call per file with findings plus one top-tier
 // call, while every agent step resends a task's whole conversation, so a fifth
-// covers them in typical runs. The reserve also absorbs review tasks that were
-// already running when their share ran out.
+// covers them in typical runs. Review tasks still running when their share
+// runs out are stopped; what they spend while stopping (the step in flight,
+// and whatever the runtime had not reported yet) comes out of the reserve.
 export const REVIEW_BUDGET_SHARE = 0.8;
+// Why running review tasks were stopped.
+export class SpendLimitReached extends Error {
+    constructor(maxCostUsd) {
+        super(`stopped at the spend limit of $${maxCostUsd}`);
+        this.name = "SpendLimitReached";
+    }
+}
 export function spendTracker(maxCostUsd, initial) {
     let spent = initial.reduce((sum, u) => sum + u.costUsd, 0);
     const over = (limit) => maxCostUsd !== undefined && spent >= limit;

package/dist/pipeline/execute.d.ts

@@ -19,6 +19,7 @@ export interface ExecuteOptions {
     relocate?: AnchorContext["relocate"] | undefined;
     plans?: Map<string, Promise<PlannedBundle>>;
     emit: (event: ReviewEvent) => void;
+    onUsage?: ((usage: Usage) => void) | undefined;
     signal: AbortSignal;
 }
 type PlannedBundle = Awaited<ReturnType<typeof planBundle>>;

package/dist/pipeline/execute.js

@@ -43,6 +43,8 @@ export async function runJob(job, plan, options) {
         // The sample that made the call pays for it and reports its warning.
         if (!shared) {
             extraUsage.push(...planned.usage);
+            for (const usage of planned.usage)
+                options.onUsage?.(usage);
             if (planned.warning)
                 extraWarnings.push(planned.warning);
         }
@@ -66,6 +68,7 @@ export async function runJob(job, plan, options) {
         timeoutMs: options.taskTimeoutMs,
     }, options.signal, {
         onProgress: (message) => emit({ type: "task_progress", taskId: job.taskId, message }),
+        onUsage: options.onUsage,
         category: job.reviewer.category,
         abortGraceMs: options.abortGraceMs,
     });

package/dist/pipeline/run.js

@@ -6,7 +6,7 @@ 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 { spendTracker } from "./budget.js";
+import { SpendLimitReached, spendTracker } from "./budget.js";
 import { runJob } from "./execute.js";
 import { dedupeFindings } from "./findings.js";
 import { DEFAULT_MAX_TASKS, planTasks } from "./matrix.js";
@@ -52,6 +52,15 @@ export async function runReview(options) {
                 relocationUsage.push(u);
                 budget.add(u);
             }));
+    // 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,
@@ -62,7 +71,8 @@ export async function runReview(options) {
         ultra: options.ultra === true,
         plans: new Map(),
         emit,
-        signal,
+        onUsage: spend,
+        signal: AbortSignal.any([signal, spendLimit.signal]),
     };
     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.
@@ -71,9 +81,7 @@ export async function runReview(options) {
         if (budget.reviewExhausted()) {
             return skipCell(cell, `spend limit of $${options.maxCostUsd} reached`, emit);
         }
-        const result = await runJob(cell, plan, execute);
-        budget.add(result.usage);
-        return result;
+        return runJob(cell, plan, execute);
     });
     // 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

package/dist/pipeline/task.d.ts

@@ -10,6 +10,7 @@ export interface TaskResult {
 }
 export interface TaskCallbacks {
     onProgress(message: string): void;
+    onUsage?: ((usage: Usage) => void) | undefined;
     category: string;
     abortGraceMs?: number | undefined;
 }

package/dist/pipeline/task.js

@@ -1,5 +1,6 @@
 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);
@@ -30,9 +31,20 @@ export async function executeTask(runtime, spec, runSignal, callbacks) {
         if (signal.aborted) {
             const timedOut = timeout.aborted && !runSignal.aborted;
             result.status = timedOut ? "timed_out" : "cancelled";
-            result.error = timedOut ? `timed out after ${spec.timeoutMs}ms` : "run cancelled";
-            if (iterator)
-                await collectAfterAbort(iterator, pending, result, callbacks);
+            result.error = timedOut
+                ? `timed out after ${spec.timeoutMs}ms`
+                : runSignal.reason instanceof SpendLimitReached
+                    ? runSignal.reason.message
+                    : "run cancelled";
+            const ending = iterator
+                ? await collectAfterAbort(iterator, pending, result, callbacks)
+                : undefined;
+            // The task's last usage report crossed the limit, and it finished
+            // anyway: its review is complete.
+            if (ending === "done" && runSignal.reason instanceof SpendLimitReached) {
+                result.status = "completed";
+                delete result.error;
+            }
             void iterator?.return?.();
         }
         else {
@@ -54,18 +66,19 @@ async function collectAfterAbort(iterator, pending, result, callbacks) {
         for (;;) {
             const event = await untilAborted(next, grace);
             if (event.done)
-                return;
+                return undefined;
             const { value } = event;
             if (value.type === "usage" || value.type === "finding")
                 handle(value, result, callbacks);
             if (value.type === "done" || value.type === "error")
-                return;
+                return value.type;
             next = iterator.next();
         }
     }
     catch {
         // The runtime did not finish within the grace period, or failed: keep
         // what arrived.
+        return undefined;
     }
 }
 function handle(event, result, callbacks) {
@@ -88,9 +101,12 @@ function handle(event, result, callbacks) {
             }
             return false;
         }
-        case "usage":
-            result.usage = addUsage(result.usage, event);
+        case "usage": {
+            const { type: _type, taskId: _taskId, ...usage } = event;
+            result.usage = addUsage(result.usage, usage);
+            callbacks.onUsage?.(usage);
             return false;
+        }
         case "done":
             return true;
         case "error":

package/package.json

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