@open-cr-agent/core 0.4.0 → 0.6.0

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;

package/dist/pipeline/execute.js

@@ -1,17 +1,17 @@
+import { reviewerCall } from "../agent/settings.js";
+import { addUsage } from "../agent/usage.js";
 import { anchorFinding } from "../anchor/anchor.js";
 import { memoryFor } from "../memory/memory.js";
 import { findCallers } from "../review/impact.js";
 import { planBundle } from "../review/plan-phase.js";
 import { buildReviewPrompt } from "../review/prompt.js";
 import { resolveRules } from "../rules/resolve.js";
-import { reviewerEffort } from "./agents.js";
 import { toFinding } from "./findings.js";
 import { executeTask } from "./task.js";
-import { addUsage } from "./usage.js";
 // In default mode only bundles large enough that a reviewer's 30 steps may
 // not cover them get a plan phase; --ultra plans every task.
-export const PLAN_MIN_FILES = 5;
-export const PLAN_MIN_PATCH_CHARS = 40_000;
+const PLAN_MIN_FILES = 5;
+const PLAN_MIN_PATCH_CHARS = 40_000;
 export function isLargeBundle(files) {
     const chars = files.reduce((sum, f) => sum + f.patch.length, 0);
     return files.length >= PLAN_MIN_FILES || chars >= PLAN_MIN_PATCH_CHARS;
@@ -20,38 +20,8 @@ export function isLargeBundle(files) {
 export async function runJob(job, plan, options) {
     const { emit } = options;
     const files = job.bundle.files.map((f) => f.newPath);
-    const input = {
-        reviewer: job.reviewer,
-        changeRequest: plan.changeRequest,
-        changedFiles: plan.selected,
-        bundle: job.bundle.files,
-        rules: resolveRules(files, plan.repoRules, job.reviewer.rules),
-        guidelines: plan.guidelines,
-        accepted: memoryFor(files, plan.memory),
-    };
-    const effort = reviewerEffort(job.reviewer, options.agents ?? {});
-    const extraUsage = [];
-    const extraWarnings = [];
-    let prompt = buildReviewPrompt(input);
-    if (options.ultra || isLargeBundle(job.bundle.files)) {
-        const callers = options.ultra ? await findCallers(job.bundle.files, plan.context) : [];
-        const key = `${job.reviewer.id}\0${job.bundle.label}`;
-        const shared = options.plans?.get(key);
-        const planning = shared ??
-            planBundle(options.runtime, job.reviewer, buildReviewPrompt({ ...input, forPlanning: true }), options.signal, effort);
-        if (!shared)
-            options.plans?.set(key, planning);
-        const planned = await planning;
-        // 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);
-        }
-        prompt = buildReviewPrompt({ ...input, callers, plan: planned.plan });
-    }
+    const call = reviewerCall(job.reviewer, options.agents ?? {});
+    const prepared = await preparePrompt(job, plan, options, call);
     emit({
         type: "task_started",
         taskId: job.taskId,
@@ -64,9 +34,9 @@ export async function runJob(job, plan, options) {
         taskId: job.taskId,
         reviewer: job.reviewer.id,
         modelTier: job.reviewer.modelTier,
-        ...(effort === undefined ? {} : { effort }),
-        systemPrompt: prompt.system,
-        userPrompt: prompt.user,
+        ...call,
+        systemPrompt: prepared.prompt.system,
+        userPrompt: prepared.prompt.user,
         context: plan.context,
         timeoutMs: options.taskTimeoutMs,
     }, options.signal, {
@@ -75,7 +45,58 @@ export async function runJob(job, plan, options) {
         category: job.reviewer.category,
         abortGraceMs: options.abortGraceMs,
     });
-    const warnings = [...extraWarnings, ...result.warnings];
+    const anchored = await anchorFindings(job, plan, options, result.findings);
+    const warnings = [...prepared.warnings, ...result.warnings, ...anchored.warnings];
+    const usage = prepared.usage.reduce(addUsage, result.usage);
+    const outcome = {
+        taskId: job.taskId,
+        reviewer: job.reviewer.id,
+        bundle: job.bundle.label,
+        files,
+        status: result.status,
+        findings: anchored.findings.length,
+        durationMs: Date.now() - started,
+        usage,
+    };
+    if (result.error !== undefined)
+        outcome.error = result.error;
+    emit({ type: "task_finished", outcome });
+    return { outcome, findings: anchored.findings, usage, warnings };
+}
+// The review prompt, with a plan phase and, under --ultra, the callers of
+// changed symbols.
+async function preparePrompt(job, plan, options, call) {
+    const files = job.bundle.files.map((f) => f.newPath);
+    const input = {
+        reviewer: job.reviewer,
+        changeRequest: plan.changeRequest,
+        changedFiles: plan.selected,
+        bundle: job.bundle.files,
+        rules: resolveRules(files, plan.repoRules, job.reviewer.rules),
+        guidelines: plan.guidelines,
+        accepted: memoryFor(files, plan.memory),
+    };
+    if (!options.ultra && !isLargeBundle(job.bundle.files)) {
+        return { prompt: buildReviewPrompt(input), usage: [], warnings: [] };
+    }
+    const callers = options.ultra ? await findCallers(job.bundle.files, plan.context) : [];
+    const key = `${job.reviewer.id}\0${job.bundle.label}`;
+    const shared = options.plans?.get(key);
+    const planning = shared ??
+        planBundle(options.runtime, job.reviewer, buildReviewPrompt({ ...input, forPlanning: true }), options.signal, call);
+    if (!shared)
+        options.plans?.set(key, planning);
+    const planned = await planning;
+    const prompt = buildReviewPrompt({ ...input, callers, plan: planned.plan });
+    // The sample that made the call pays for it and reports its warning.
+    if (shared)
+        return { prompt, usage: [], warnings: [] };
+    for (const usage of planned.usage)
+        options.onUsage?.(usage);
+    return { prompt, usage: [...planned.usage], warnings: planned.warning ? [planned.warning] : [] };
+}
+async function anchorFindings(job, plan, options, reportedFindings) {
+    const warnings = [];
     const findings = [];
     const anchorContext = {
         diffs: plan.selected,
@@ -86,9 +107,9 @@ export async function runJob(job, plan, options) {
     // A finding on a file outside the bundle belongs to the task that reviews
     // that file; keeping it would report the same issue once per bundle that
     // happened to read the file.
-    const bundleFiles = new Set(files);
+    const bundleFiles = new Set(job.bundle.files.map((f) => f.newPath));
     let outside = 0;
-    for (const { reported, model } of result.findings) {
+    for (const { reported, model } of reportedFindings) {
         // Relocating a quote on a file outside the bundle would pay for an
         // answer the next check throws away.
         const context = bundleFiles.has(reported.file)
@@ -107,25 +128,11 @@ export async function runJob(job, plan, options) {
         const provenance = model === undefined ? { task: job.taskId } : { task: job.taskId, model };
         const finding = toFinding(reported, job.reviewer.id, provenance, anchor, content);
         findings.push(finding);
-        emit({ type: "finding", taskId: job.taskId, finding });
+        options.emit({ type: "finding", taskId: job.taskId, finding });
     }
     if (outside > 0) {
         warnings.push(`${job.taskId}: dropped ${outside} finding(s) on files outside its bundle`);
     }
-    const usage = extraUsage.reduce(addUsage, result.usage);
-    const outcome = {
-        taskId: job.taskId,
-        reviewer: job.reviewer.id,
-        bundle: job.bundle.label,
-        files,
-        status: result.status,
-        findings: findings.length,
-        durationMs: Date.now() - started,
-        usage,
-    };
-    if (result.error !== undefined)
-        outcome.error = result.error;
-    emit({ type: "task_finished", outcome });
-    return { outcome, findings, usage, warnings };
+    return { findings, warnings };
 }
 //# sourceMappingURL=execute.js.map

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

@@ -0,0 +1,16 @@
+import type { PriorReview } from "../domain.js";
+import { type RememberedEntry } from "../memory/memory.js";
+import { type CoverageEntry } from "../report/report.js";
+import { type Reconciled } from "../rereview/reconcile.js";
+import type { ExecuteStage, StageContext } from "./execute-stage.js";
+import { type SarifImport } from "./imports.js";
+export interface FilterStage {
+    imported: SarifImport;
+    coverage: CoverageEntry[];
+    remembered: RememberedEntry[];
+    reconciled: Reconciled;
+    nothingReviewed: boolean;
+    warnings: string[];
+}
+export declare function filterStage(executed: ExecuteStage, prior: PriorReview | undefined, { options, plan, emit }: StageContext): Promise<FilterStage>;
+//# sourceMappingURL=filter-stage.d.ts.map

package/dist/pipeline/filter-stage.js

@@ -0,0 +1,46 @@
+import { applyMemory } from "../memory/memory.js";
+import { coverageGaps } from "../report/report.js";
+import { priorCodePresence } from "../rereview/presence.js";
+import { reconcile } from "../rereview/reconcile.js";
+import { coverageOf } from "./coverage.js";
+import { dedupeFindings } from "./findings.js";
+import { importSarif } from "./imports.js";
+// 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.
+export async function filterStage(executed, prior, { options, plan, emit }) {
+    const imported = options.sarif && options.sarif.length > 0
+        ? await importSarif(options.sarif, plan, emit)
+        : { findings: [], outcomes: [], warnings: [] };
+    const { results } = executed;
+    const found = dedupeFindings([...results.flatMap((r) => r.findings), ...imported.findings]);
+    const coverage = coverageOf(plan.decisions, results, plan.unchanged, executed.matrix.limited ?? [], executed.notStarted);
+    const remembered = applyMemory(found, plan.memory);
+    const reported = new Set(found.map((f) => f.fingerprint));
+    const priorReview = withoutRemembered(prior, plan.memory);
+    const reconciled = reconcile({
+        findings: remembered.kept,
+        reported,
+        prior: priorReview,
+        coverage,
+        stillPresent: await priorCodePresence(priorReview, reported, plan.context.readFile),
+    });
+    const { nothingReviewed } = coverageGaps({ coverage, tasks: results.map((r) => r.outcome) });
+    return {
+        imported,
+        coverage,
+        remembered: remembered.remembered,
+        reconciled,
+        nothingReviewed,
+        warnings: imported.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)) };
+}
+//# sourceMappingURL=filter-stage.js.map

package/dist/pipeline/findings.js

@@ -1,10 +1,11 @@
-import { createHash, randomUUID } from "node:crypto";
+import { randomUUID } from "node:crypto";
 import { normalizeSnippet } from "../anchor/match.js";
+import { shortHash } from "../hash.js";
 import { quoteSignature } from "../rereview/quote.js";
 const SEVERITY_RANK = { suggestion: 0, warning: 1, critical: 2 };
 export function fingerprint(category, file, existingCode) {
     const key = [category, file, ...normalizeSnippet(existingCode)].join("\n");
-    return createHash("sha256").update(key).digest("hex").slice(0, 16);
+    return shortHash(key);
 }
 // content is the anchored file at head, when the anchor found lines in it.
 export function toFinding(reported, reviewer, provenance, anchor, content) {

package/dist/pipeline/imports.d.ts

@@ -1,7 +1,7 @@
 import type { Finding } from "../domain.js";
+import type { ReviewEvent, TaskOutcome } from "../report/report.js";
 import type { SarifLog } from "../sarif/schema.js";
 import type { ReviewPlan } from "./plan.js";
-import type { ReviewEvent, TaskOutcome } from "./report.js";
 export interface SarifImport {
     findings: Finding[];
     outcomes: TaskOutcome[];

package/dist/pipeline/imports.js

@@ -1,8 +1,8 @@
+import { emptyUsage } from "../agent/usage.js";
 import { anchorFinding } from "../anchor/anchor.js";
 import { sarifCandidates } from "../sarif/candidates.js";
 import { toFinding } from "./findings.js";
 import { boundFinding } from "./task.js";
-import { emptyUsage } from "./usage.js";
 // A hostile log could carry thousands of results on the change.
 export const MAX_IMPORTED_PER_RUN = 200;
 export async function importSarif(logs, plan, emit) {

package/dist/pipeline/matrix.d.ts

@@ -1,15 +1,9 @@
 import { z } from "zod";
+import type { ReviewerOverrides } from "../agent/settings.js";
 import type { Bundle } from "../bundle/bundle.js";
-import type { Effort } from "../contracts.js";
 import type { RiskTier } from "../domain.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
 export declare const RISK_TIERS: readonly RiskTier[];
-export interface ReviewerOverride {
-    enabled?: boolean | undefined;
-    minTier?: RiskTier | undefined;
-    effort?: Effort | undefined;
-}
-export type ReviewerOverrides = Readonly<Record<string, ReviewerOverride>>;
 export interface MatrixCell {
     taskId: string;
     reviewer: ReviewerDefinition;

package/dist/pipeline/options.d.ts

@@ -0,0 +1,65 @@
+import type { ReviewerOverrides, RoleSettings, TierEfforts } from "../agent/settings.js";
+import type { AnchorContext } from "../anchor/anchor.js";
+import type { BundlePolicy } from "../bundle/bundle.js";
+import type { FileGrouper } from "../bundle/grouping.js";
+import type { AgentRuntime, ModelChains } from "../contracts.js";
+import type { MemoryEntry } from "../memory/memory.js";
+import type { ReviewEvent } from "../report/report.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 { VcsAdapter } from "../vcs.js";
+import type { ProvenanceInput } from "./provenance.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?: Partial<SelectionPolicy>;
+    limits?: ReviewLimits;
+    stages?: ReviewStages;
+    mode?: ReviewMode;
+    identity?: RunIdentity;
+    sarif?: readonly SarifLog[];
+    signal?: AbortSignal;
+    onEvent?: (event: ReviewEvent) => void;
+}
+export interface ReviewLimits {
+    concurrency?: number;
+    taskTimeoutMs?: number;
+    runTimeoutMs?: number;
+    maxCostUsd?: number;
+    maxTasks?: number;
+}
+export interface ReviewStages {
+    verify?: boolean;
+    judge?: boolean;
+}
+export interface ReviewMode {
+    full?: boolean;
+    ultra?: boolean;
+}
+export interface RunIdentity {
+    runId?: string;
+    provenance?: ProvenanceInput;
+}
+export interface ReviewHooks {
+    bundling?: BundlePolicy;
+    grouper?: FileGrouper;
+    relocate?: AnchorContext["relocate"] | false;
+    abortGraceMs?: number;
+}
+export declare const REVIEW_DEFAULTS: {
+    readonly concurrency: 4;
+    readonly taskTimeoutMs: number;
+    readonly runTimeoutMs: number;
+};
+export declare const MAX_TIMER_MS: number;
+//# sourceMappingURL=options.d.ts.map

package/dist/pipeline/options.js

@@ -0,0 +1,9 @@
+export const REVIEW_DEFAULTS = {
+    concurrency: 4,
+    taskTimeoutMs: 10 * 60_000,
+    runTimeoutMs: 25 * 60_000,
+};
+// Timers fire at once past 2^31 - 1 ms (about 24.8 days); a longer timeout
+// means no practical limit, so it is cut to the longest one a timer keeps.
+export const MAX_TIMER_MS = 2 ** 31 - 1;
+//# sourceMappingURL=options.js.map

package/dist/pipeline/plan-output.d.ts

@@ -0,0 +1,90 @@
+import { z } from "zod";
+import type { ReviewPreview } from "./preview.js";
+export declare const PLAN_VERSION = 1;
+export declare const planOutputSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    changeRequest: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        baseSha: z.ZodString;
+        headSha: z.ZodString;
+        override: z.ZodExactOptional<z.ZodObject<{
+            by: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    tier: z.ZodEnum<{
+        full: "full";
+        lite: "lite";
+        trivial: "trivial";
+    }>;
+    selected: z.ZodArray<z.ZodString>;
+    excluded: z.ZodArray<z.ZodObject<{
+        path: z.ZodString;
+        reason: z.ZodEnum<{
+            binary: "binary";
+            deleted: "deleted";
+            extension: "extension";
+            generated: "generated";
+            secret: "secret";
+            too_large: "too_large";
+            user_exclude: "user_exclude";
+        }>;
+    }, z.core.$strict>>;
+    bundles: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    groupingSkipped: z.ZodBoolean;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        reviewer: z.ZodString;
+        bundle: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        promptTokens: z.ZodInt;
+        effort: z.ZodExactOptional<z.ZodEnum<{
+            high: "high";
+            low: "low";
+            medium: "medium";
+            minimal: "minimal";
+            none: "none";
+        }>>;
+        models: z.ZodExactOptional<z.ZodArray<z.ZodString>>;
+        planPromptTokens: z.ZodExactOptional<z.ZodInt>;
+        inputCost: z.ZodExactOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+            model: z.ZodString;
+            status: z.ZodLiteral<"priced">;
+            usd: z.ZodNumber;
+        }, z.core.$strict>, z.ZodObject<{
+            model: z.ZodString;
+            status: z.ZodLiteral<"unpriced">;
+        }, z.core.$strict>, z.ZodObject<{
+            model: z.ZodString;
+            status: z.ZodLiteral<"unknown">;
+        }, z.core.$strict>], "status">>;
+    }, z.core.$strict>>;
+    skipped: z.ZodArray<z.ZodObject<{
+        reviewer: z.ZodString;
+        bundle: z.ZodString;
+        reason: z.ZodEnum<{
+            below_tier: "below_tier";
+            disabled: "disabled";
+            no_guidelines: "no_guidelines";
+            no_matching_files: "no_matching_files";
+            task_limit: "task_limit";
+        }>;
+    }, z.core.$strict>>;
+    promptTokens: z.ZodInt;
+    planCalls: z.ZodInt;
+    inputCost: z.ZodExactOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        priced: z.ZodInt;
+        unpriced: z.ZodInt;
+        unknown: z.ZodInt;
+    }, z.core.$strict>>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+export type PlanOutput = z.output<typeof planOutputSchema>;
+export declare function toPlanOutput(preview: ReviewPreview): PlanOutput;
+//# sourceMappingURL=plan-output.d.ts.map