@open-cr-agent/core 0.5.0 → 0.6.0

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 { errnoCode, isNotFound, usageSpent } from "./errors.js";
+export { shortHash } from "./hash.js";
 export { MEMORY_PATH, memoryEntrySchema, parseMemory, serializeMemory, } from "./memory/memory.js";
-export { proxiedFetch } from "./net/proxied-fetch.js";
-export { AGENT_ROLES, EFFORT_LEVELS } from "./pipeline/agents.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 { callChain, 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 { errnoCode, isNotFound, usageSpent } from "./errors.js";
+export { shortHash } from "./hash.js";
 export { MEMORY_PATH, memoryEntrySchema, parseMemory, serializeMemory, } from "./memory/memory.js";
-export { proxiedFetch } from "./net/proxied-fetch.js";
-export { AGENT_ROLES, EFFORT_LEVELS } from "./pipeline/agents.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 { callChain, 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,8 +1,7 @@
+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 AgentCallSettings } from "../pipeline/agents.js";
 import { type JudgeResponse } from "./prompt.js";
-export declare const JUDGE_TIMEOUT_MS = 180000;
 export interface JudgeDecisions {
     merged: {
         kept: string;

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 = []) => ({
@@ -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.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)

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

package/dist/pipeline/execute-stage.js

@@ -0,0 +1,104 @@
+import { SpendLimitReached } from "../agent/budget.js";
+import { mapWithConcurrency } from "../agent/pool.js";
+import { roleCall } from "../agent/settings.js";
+import { emptyUsage } from "../agent/usage.js";
+import { runtimeRelocator } from "../anchor/relocate.js";
+import { runJob } from "./execute.js";
+import { DEFAULT_MAX_TASKS, planTasks } from "./matrix.js";
+import { MAX_TIMER_MS, REVIEW_DEFAULTS } from "./options.js";
+// One agent task per (bundle, reviewer) cell of the matrix, within the task
+// limit, the run's signal and the review share of the spend limit.
+export async function executeStage(reviewers, context) {
+    const { options, plan, emit } = context;
+    const matrix = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
+        ultra: options.mode?.ultra === true,
+        ...(options.limits?.maxTasks !== undefined ? { maxTasks: options.limits?.maxTasks } : {}),
+        hasGuidelines: Boolean(plan.guidelines?.trim()),
+    });
+    const warnings = [];
+    const limited = matrix.skipped.filter((s) => s.reason === "task_limit").length;
+    if (limited > 0) {
+        warnings.push(`task limit of ${options.limits?.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 relocations = [];
+    const spendLimit = new AbortController();
+    const execute = executeOptions(context, relocations, spendLimit);
+    const notStarted = new Set();
+    let unaffordable = 0;
+    const results = await mapWithConcurrency(matrix.cells, options.limits?.concurrency ?? REVIEW_DEFAULTS.concurrency, async (cell) => {
+        // Once the run is cancelled or timed out, remaining cells are not started.
+        if (context.signal.aborted) {
+            notStarted.add(cell.taskId);
+            return skipCell(cell, "run cancelled before this task started", emit);
+        }
+        if (context.budget.reviewExhausted()) {
+            notStarted.add(cell.taskId);
+            unaffordable += 1;
+            return skipCell(cell, `spend limit of $${options.limits?.maxCostUsd} reached`, emit);
+        }
+        return runJob(cell, plan, execute);
+    });
+    if (unaffordable > 0) {
+        warnings.push(`spend limit of $${options.limits?.maxCostUsd} reached: ${unaffordable} review task(s) did not start; their files are reported as not reviewed`);
+    }
+    warnings.push(...results.flatMap((r) => r.warnings));
+    return {
+        matrix,
+        results,
+        notStarted,
+        relocations,
+        usage: () => [...results.map((r) => r.usage), ...relocations],
+        warnings,
+        reviewLimitReached: () => spendLimit.signal.aborted || unaffordable > 0,
+    };
+}
+function executeOptions({ options, budget, signal, emit }, relocations, spendLimit) {
+    const relocator = relocatorOf(options, signal, (u) => {
+        relocations.push(u);
+        budget.add(u);
+    });
+    return {
+        runtime: options.runtime,
+        taskTimeoutMs: Math.min(options.limits?.taskTimeoutMs ?? REVIEW_DEFAULTS.taskTimeoutMs, MAX_TIMER_MS),
+        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.mode?.ultra === true,
+        plans: new Map(),
+        agents: options,
+        emit,
+        // 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.
+        onUsage: (usage) => {
+            budget.add(usage);
+            if (budget.reviewExhausted() && !spendLimit.signal.aborted) {
+                spendLimit.abort(new SpendLimitReached(options.limits?.maxCostUsd ?? 0));
+            }
+        },
+        signal: AbortSignal.any([signal, spendLimit.signal]),
+    };
+}
+function relocatorOf(options, signal, onUsage) {
+    if (options.relocate === false)
+        return undefined;
+    return (options.relocate ??
+        runtimeRelocator(options.runtime, signal, onUsage, roleCall("helper", options)));
+}
+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: [] };
+}
+//# sourceMappingURL=execute-stage.js.map

package/dist/pipeline/execute.d.ts

@@ -1,11 +1,11 @@
+import { type AgentSettings } from "../agent/settings.js";
 import { type AnchorContext } from "../anchor/anchor.js";
 import type { AgentRuntime, Usage } from "../contracts.js";
 import type { Finding } from "../domain.js";
+import type { ReviewEvent, TaskOutcome } from "../report/report.js";
 import { planBundle } from "../review/plan-phase.js";
-import { type AgentSettings } from "./agents.js";
 import type { MatrixCell } from "./matrix.js";
 import type { ReviewPlan } from "./plan.js";
-import type { ReviewEvent, TaskOutcome } from "./report.js";
 export interface JobResult {
     outcome: TaskOutcome;
     findings: Finding[];
@@ -25,8 +25,6 @@ export interface ExecuteOptions {
     agents?: AgentSettings;
 }
 type PlannedBundle = Awaited<ReturnType<typeof planBundle>>;
-export declare const PLAN_MIN_FILES = 5;
-export declare const PLAN_MIN_PATCH_CHARS = 40000;
 export declare function isLargeBundle(files: readonly {
     patch: string;
 }[]): boolean;