@open-cr-agent/core 0.5.0 → 0.6.0

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 { reviewerCall } 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 call = reviewerCall(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, call);
-        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 prepared = await preparePrompt(job, plan, options, call);
     emit({
         type: "task_started",
         taskId: job.taskId,
@@ -65,8 +35,8 @@ export async function runJob(job, plan, options) {
         reviewer: job.reviewer.id,
         modelTier: job.reviewer.modelTier,
         ...call,
-        systemPrompt: prompt.system,
-        userPrompt: prompt.user,
+        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,16 +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;
-    models?: readonly string[] | 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

package/dist/pipeline/plan-output.js

@@ -0,0 +1,109 @@
+import { z } from "zod";
+import { EFFORT_LEVELS } from "../agent/settings.js";
+import { riskTierSchema } from "../domain.js";
+import { changeRequestSchema, skippedCellSchema } from "../report/output-schema.js";
+import { exclusionReasonSchema } from "../select/select.js";
+// The published shape of `ocra review --plan --format json` without what
+// the CLI adds (where each setting came from), versioned like the report: a
+// version only gains optional fields. The type is derived from the schema,
+// and the CLI publishes the JSON Schema of the whole output.
+export const PLAN_VERSION = 1;
+const inputCostSchema = z.discriminatedUnion("status", [
+    z.strictObject({ model: z.string(), status: z.literal("priced"), usd: z.number() }),
+    z.strictObject({ model: z.string(), status: z.literal("unpriced") }),
+    z.strictObject({ model: z.string(), status: z.literal("unknown") }),
+]);
+const planTaskSchema = z.strictObject({
+    taskId: z.string(),
+    reviewer: z.string(),
+    bundle: z.string(),
+    files: z.array(z.string()),
+    promptTokens: z.int().nonnegative(),
+    effort: z.enum(EFFORT_LEVELS).exactOptional(),
+    models: z.array(z.string()).exactOptional(),
+    planPromptTokens: z.int().nonnegative().exactOptional(),
+    inputCost: inputCostSchema.exactOptional(),
+});
+export const planOutputSchema = z.strictObject({
+    version: z.literal(PLAN_VERSION),
+    changeRequest: changeRequestSchema,
+    tier: riskTierSchema,
+    selected: z.array(z.string()),
+    excluded: z.array(z.strictObject({ path: z.string(), reason: exclusionReasonSchema })),
+    bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
+    groupingSkipped: z.boolean(),
+    tasks: z.array(planTaskSchema),
+    skipped: z.array(skippedCellSchema),
+    promptTokens: z.int().nonnegative(),
+    // Added in version 1 without a bump: a new field older readers ignore.
+    planCalls: z.int().nonnegative(),
+    // Added in version 1 without a bump, like planCalls.
+    inputCost: z
+        .strictObject({
+        usd: z.number(),
+        priced: z.int().nonnegative(),
+        unpriced: z.int().nonnegative(),
+        unknown: z.int().nonnegative(),
+    })
+        .exactOptional(),
+    warnings: z.array(z.string()),
+});
+export function toPlanOutput(preview) {
+    const { changeRequest: c, inputCost } = preview;
+    return {
+        version: PLAN_VERSION,
+        changeRequest: {
+            id: c.id,
+            title: c.title,
+            description: c.description,
+            baseSha: c.baseSha,
+            headSha: c.headSha,
+            ...(c.override ? { override: { by: c.override.by, reason: c.override.reason } } : {}),
+        },
+        tier: preview.tier,
+        selected: [...preview.selected],
+        excluded: preview.excluded.map((e) => ({ path: e.path, reason: e.reason })),
+        bundles: preview.bundles.map((b) => ({ label: b.label, files: [...b.files] })),
+        groupingSkipped: preview.groupingSkipped,
+        tasks: preview.tasks.map(planTask),
+        skipped: preview.skipped.map((s) => ({
+            reviewer: s.reviewer,
+            bundle: s.bundle,
+            reason: s.reason,
+        })),
+        promptTokens: preview.promptTokens,
+        planCalls: preview.planCalls,
+        ...(inputCost
+            ? {
+                inputCost: {
+                    usd: inputCost.usd,
+                    priced: inputCost.priced,
+                    unpriced: inputCost.unpriced,
+                    unknown: inputCost.unknown,
+                },
+            }
+            : {}),
+        warnings: [...preview.warnings],
+    };
+}
+function planTask(t) {
+    const cost = t.inputCost;
+    return {
+        taskId: t.taskId,
+        reviewer: t.reviewer,
+        bundle: t.bundle,
+        files: [...t.files],
+        promptTokens: t.promptTokens,
+        ...(t.effort === undefined ? {} : { effort: t.effort }),
+        ...(t.models ? { models: [...t.models] } : {}),
+        ...(t.planPromptTokens === undefined ? {} : { planPromptTokens: t.planPromptTokens }),
+        ...(cost
+            ? {
+                inputCost: cost.status === "priced"
+                    ? { model: cost.model, status: cost.status, usd: cost.usd }
+                    : { model: cost.model, status: cost.status },
+            }
+            : {}),
+    };
+}
+//# sourceMappingURL=plan-output.js.map

package/dist/pipeline/plan.d.ts

@@ -2,11 +2,10 @@ import { type Bundle } from "../bundle/bundle.js";
 import type { AgentRuntime, ReviewContext, Usage } from "../contracts.js";
 import type { ChangeRequest, FileDiff, RiskTier } from "../domain.js";
 import { type RememberedEntry } from "../memory/memory.js";
+import type { ReviewEvent } from "../report/report.js";
 import { type SourcedRule } from "../rules/repo-rules.js";
 import { type FileDecision } from "../select/select.js";
-import type { ReviewEvent } from "./report.js";
-import type { ReviewHooks, ReviewOptions } from "./run.js";
-export declare const GUIDELINES_PATH = "AGENTS.md";
+import type { ReviewHooks, ReviewOptions } from "./options.js";
 export interface ReviewPlan {
     changeRequest: ChangeRequest;
     decisions: FileDecision[];

package/dist/pipeline/plan.js

@@ -1,21 +1,21 @@
+import { roleCall } from "../agent/settings.js";
 import { bundleFiles, defaultBundlePolicy } from "../bundle/bundle.js";
+import { runtimeGrouper } from "../bundle/runtime-grouper.js";
 import { MEMORY_PATH, mergeMemory, parseMemory } from "../memory/memory.js";
 import { parseRepoRules, REPO_RULES_PATH, } from "../rules/repo-rules.js";
 import { defaultSelectionPolicy, selectFiles } from "../select/select.js";
 import { triage } from "../triage.js";
-import { roleCall } from "./agents.js";
 import { reviewContext } from "./context.js";
-import { runtimeGrouper } from "./helpers.js";
 import { rank } from "./matrix.js";
 import { newRunId } from "./run-id.js";
-export const GUIDELINES_PATH = "AGENTS.md";
+const GUIDELINES_PATH = "AGENTS.md";
 export async function planReview(options, emit, signal) {
     const { vcs } = options;
     const readTrusted = options.readTrusted ?? ((path) => vcs.readFile(path));
     const changeRequest = await vcs.getChangeRequest();
     emit({ type: "run_started", runId: options.runId ?? newRunId(), changeRequest });
     const diffs = await vcs.getDiff();
-    const decisions = selectFiles(diffs, options.selection ?? defaultSelectionPolicy);
+    const decisions = selectFiles(diffs, { ...defaultSelectionPolicy, ...options.selection });
     const selected = decisions.filter((d) => d.selected).map((d) => d.diff);
     const tier = triage(selected);
     emit({

package/dist/pipeline/preview.d.ts

@@ -1,9 +1,8 @@
 import type { Effort } from "../contracts.js";
 import type { ChangeRequest, RiskTier } from "../domain.js";
-import type { ModelChains } from "../plugin/types.js";
-import type { ReviewerDefinition } from "../review/reviewer.js";
 import type { FileDecision } from "../select/select.js";
-import { type ReviewerOverrides, type SkippedCell } from "./matrix.js";
+import { type SkippedCell } from "./matrix.js";
+import type { ReviewOptions } from "./options.js";
 import { type PlanOptions } from "./plan.js";
 export interface PreviewTask {
     taskId: string;
@@ -14,7 +13,19 @@ export interface PreviewTask {
     planPromptTokens?: number;
     effort?: Effort;
     models?: string[];
+    inputCost?: InputCost;
 }
+type InputCost = {
+    model: string;
+    status: "priced";
+    usd: number;
+} | {
+    model: string;
+    status: "unpriced";
+} | {
+    model: string;
+    status: "unknown";
+};
 export interface ReviewPreview {
     changeRequest: ChangeRequest;
     tier: RiskTier;
@@ -34,14 +45,17 @@ export interface ReviewPreview {
     skipped: SkippedCell[];
     promptTokens: number;
     planCalls: number;
+    inputCost?: {
+        usd: number;
+        priced: number;
+        unpriced: number;
+        unknown: number;
+    };
     warnings: string[];
 }
-export type PreviewOptions = Omit<PlanOptions, "runtime"> & {
-    reviewers?: readonly ReviewerDefinition[];
-    reviewerOverrides?: ReviewerOverrides;
-    ultra?: boolean;
-    maxTasks?: number;
-    models?: ModelChains;
+export type PreviewOptions = Omit<PlanOptions, "runtime"> & Omit<ReviewOptions, "vcs" | "runtime"> & {
+    inputPrice?: (model: string) => number | undefined;
 };
 export declare function previewReview(options: PreviewOptions): Promise<ReviewPreview>;
+export {};
 //# sourceMappingURL=preview.d.ts.map