@open-cr-agent/core 0.1.0

package/dist/pipeline/helpers.js

@@ -0,0 +1,32 @@
+import { usageSpent } from "../errors.js";
+export const HELPER_TIMEOUT_MS = 60_000;
+// Grouping runs on the runtime's cheapest tier when the runtime supports plain
+// completions; otherwise bundling falls back to per-file review.
+export function runtimeGrouper(runtime, signal, onUsage) {
+    const complete = runtime.complete?.bind(runtime);
+    if (!complete)
+        return undefined;
+    return {
+        async group(prompt) {
+            const result = await complete({ tier: "light", system: prompt.system, user: prompt.user, timeoutMs: HELPER_TIMEOUT_MS }, AbortSignal.any([signal, AbortSignal.timeout(HELPER_TIMEOUT_MS)])).catch((error) => {
+                const spent = usageSpent(error);
+                if (spent)
+                    onUsage(spent);
+                throw error;
+            });
+            onUsage(result.usage);
+            return parseJsonAnswer(result.text);
+        },
+    };
+}
+// Models often wrap JSON in a Markdown fence or add a sentence around it.
+export function parseJsonAnswer(text) {
+    const fenced = /```(?:json)?\s*([\s\S]*?)```/i.exec(text)?.[1];
+    const candidate = (fenced ?? text).trim();
+    const start = candidate.search(/[[{]/);
+    if (start < 0)
+        throw new Error("the model answered without JSON");
+    const end = Math.max(candidate.lastIndexOf("]"), candidate.lastIndexOf("}"));
+    return JSON.parse(candidate.slice(start, end + 1));
+}
+//# sourceMappingURL=helpers.js.map

package/dist/pipeline/index.d.ts

@@ -0,0 +1,9 @@
+export * from "./context.js";
+export * from "./findings.js";
+export * from "./matrix.js";
+export * from "./output.js";
+export * from "./preview.js";
+export * from "./report.js";
+export * from "./run.js";
+export * from "./usage.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/pipeline/index.js

@@ -0,0 +1,9 @@
+export * from "./context.js";
+export * from "./findings.js";
+export * from "./matrix.js";
+export * from "./output.js";
+export * from "./preview.js";
+export * from "./report.js";
+export * from "./run.js";
+export * from "./usage.js";
+//# sourceMappingURL=index.js.map

package/dist/pipeline/matrix.d.ts

@@ -0,0 +1,38 @@
+import type { Bundle } from "../bundle/bundle.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;
+}
+export type ReviewerOverrides = Readonly<Record<string, ReviewerOverride>>;
+export interface MatrixCell {
+    taskId: string;
+    reviewer: ReviewerDefinition;
+    bundle: Bundle;
+}
+export type SkipReason = "disabled" | "below_tier" | "no_matching_files" | "no_guidelines" | "task_limit";
+export interface SkippedCell {
+    reviewer: string;
+    bundle: string;
+    reason: SkipReason;
+}
+export interface ReviewMatrix {
+    cells: MatrixCell[];
+    skipped: SkippedCell[];
+    limited?: MatrixCell[];
+}
+export declare function planMatrix(bundles: readonly Bundle[], reviewers: readonly ReviewerDefinition[], tier: RiskTier, overrides?: ReviewerOverrides, options?: {
+    allTiers?: boolean;
+    hasGuidelines?: boolean;
+}): ReviewMatrix;
+export declare const DEFAULT_MAX_TASKS = 60;
+export interface TaskOptions {
+    ultra?: boolean;
+    maxTasks?: number;
+    hasGuidelines?: boolean;
+}
+export declare function planTasks(bundles: readonly Bundle[], reviewers: readonly ReviewerDefinition[], tier: RiskTier, overrides?: ReviewerOverrides, options?: TaskOptions): ReviewMatrix;
+export declare function rank(tier: RiskTier): number;
+//# sourceMappingURL=matrix.d.ts.map

package/dist/pipeline/matrix.js

@@ -0,0 +1,93 @@
+import picomatch from "picomatch";
+export const RISK_TIERS = ["trivial", "lite", "full"];
+// Deterministic: which reviewer runs on which bundle, so cost grows with the
+// risk of the change instead of bundles × reviewers.
+export function planMatrix(bundles, reviewers, tier, overrides = {}, options = {}) {
+    const cells = [];
+    const skipped = [];
+    const ignores = new Map(reviewers.map((r) => [r.id, ignoreMatcher(r)]));
+    bundles.forEach((bundle, i) => {
+        for (const reviewer of reviewers) {
+            const override = overrides[reviewer.id] ?? {};
+            const skip = (reason) => skipped.push({ reviewer: reviewer.id, bundle: bundle.label, reason });
+            if (override.enabled === false) {
+                skip("disabled");
+                continue;
+            }
+            const minTier = options.allTiers
+                ? "trivial"
+                : (override.minTier ?? reviewer.scope?.minTier ?? "trivial");
+            if (rank(tier) < rank(minTier)) {
+                skip("below_tier");
+                continue;
+            }
+            if (reviewer.scope?.requiresGuidelines && options.hasGuidelines !== true) {
+                skip("no_guidelines");
+                continue;
+            }
+            const ignored = ignores.get(reviewer.id) ?? (() => false);
+            const files = bundle.files.filter((f) => !ignored(f.newPath));
+            if (files.length === 0) {
+                skip("no_matching_files");
+                continue;
+            }
+            cells.push({
+                taskId: `${reviewer.id}-${i + 1}`,
+                reviewer,
+                bundle: files.length === bundle.files.length ? bundle : { ...bundle, files },
+            });
+        }
+    });
+    return { cells, skipped };
+}
+// Every review task is a model conversation, so a change set with hundreds
+// of bundles must not become hundreds of tasks.
+export const DEFAULT_MAX_TASKS = 60;
+// The matrix as it runs: --ultra reviews every cell twice, and past
+// `maxTasks` the least important cells are skipped: second samples first,
+// then reviewers in reverse registration order (correctness first), so
+// every file keeps its first reviewer as long as possible.
+export function planTasks(bundles, reviewers, tier, overrides = {}, options = {}) {
+    const planned = planMatrix(bundles, reviewers, tier, overrides, {
+        allTiers: options.ultra === true,
+        hasGuidelines: options.hasGuidelines === true,
+    });
+    const cells = options.ultra
+        ? planned.cells.flatMap((cell) => [cell, { ...cell, taskId: `${cell.taskId}b` }])
+        : planned.cells;
+    const max = options.maxTasks ?? DEFAULT_MAX_TASKS;
+    if (cells.length <= max)
+        return { cells, skipped: planned.skipped };
+    const order = new Map(reviewers.map((r, i) => [r.id, i]));
+    const priority = (cell, index) => [
+        cell.taskId.endsWith("b") ? 1 : 0,
+        order.get(cell.reviewer.id) ?? reviewers.length,
+        index,
+    ];
+    const ranked = cells
+        .map((cell, index) => ({ cell, key: priority(cell, index) }))
+        .sort((a, b) => a.key[0] - b.key[0] || a.key[1] - b.key[1] || a.key[2] - b.key[2]);
+    const kept = new Set(ranked.slice(0, max).map((r) => r.cell));
+    return {
+        cells: cells.filter((cell) => kept.has(cell)),
+        limited: cells.filter((cell) => !kept.has(cell)),
+        skipped: [
+            ...planned.skipped,
+            ...cells
+                .filter((cell) => !kept.has(cell))
+                .map((cell) => ({
+                reviewer: cell.reviewer.id,
+                bundle: cell.bundle.label,
+                reason: "task_limit",
+            })),
+        ],
+    };
+}
+export function rank(tier) {
+    return RISK_TIERS.indexOf(tier);
+}
+function ignoreMatcher(reviewer) {
+    const globs = reviewer.scope?.ignore ?? [];
+    return globs.length === 0 ? () => false : picomatch([...globs], { dot: true, nocase: true });
+}
+//# sourceMappingURL=matrix.js.map

package/dist/pipeline/output.d.ts

@@ -0,0 +1,69 @@
+import type { Usage } from "../contracts.js";
+import type { ChangeRequest, RiskTier, Severity, Verdict, Verification } from "../domain.js";
+import type { JudgeDecisions } from "../judge/judge.js";
+import type { MemoryEntry } from "../memory/memory.js";
+import type { RefutedFinding } from "../verify/verify.js";
+import type { SkippedCell } from "./matrix.js";
+import type { ReviewPreview } from "./preview.js";
+import type { AnchoringSummary, CoverageEntry, ReviewReport, TaskOutcome } from "./report.js";
+export declare const REPORT_VERSION = 1;
+export interface OutputFinding {
+    fingerprint: string;
+    reviewer: string;
+    category: string;
+    severity: Severity;
+    verification: Verification;
+    file: string;
+    lines?: {
+        start: number;
+        end: number;
+    };
+    inDiff: boolean;
+    status: "new" | "unfixed";
+    title: string;
+    body: string;
+    suggestion?: string;
+    evidence: string[];
+    code: string;
+    lowConfidence?: true;
+}
+export interface OutputPriorFinding {
+    fingerprint: string;
+    title: string;
+    file: string;
+    severity: Severity;
+    verification: Verification;
+}
+export interface ReportOutput {
+    version: typeof REPORT_VERSION;
+    changeRequest: ChangeRequest;
+    tier: RiskTier;
+    verdict: Verdict;
+    summary: string;
+    scope?: ReviewReport["scope"];
+    coverage: CoverageEntry[];
+    findings: OutputFinding[];
+    unverifiedCriticals: number;
+    refuted: RefutedFinding[];
+    remembered: MemoryEntry[];
+    judgement?: JudgeDecisions;
+    rereview?: Record<"fixed" | "notReproduced" | "notRechecked" | "unchanged" | "dismissed", OutputPriorFinding[]>;
+    tasks: TaskOutcome[];
+    skipped: SkippedCell[];
+    bundles: {
+        label: string;
+        files: string[];
+    }[];
+    anchoring?: AnchoringSummary;
+    usage: Usage;
+    warnings: string[];
+}
+export declare function toReportOutput(report: ReviewReport): ReportOutput;
+export declare const PLAN_VERSION = 1;
+export type PlanOutput = {
+    version: typeof PLAN_VERSION;
+} & ReviewPreview;
+export declare function toPlanOutput(preview: ReviewPreview): PlanOutput;
+export declare function isUnsafeCodePoint(code: number): boolean;
+export declare function serializeOutput(value: unknown, indent?: number): string;
+//# sourceMappingURL=output.d.ts.map

package/dist/pipeline/output.js

@@ -0,0 +1,123 @@
+// The published shape of a review: `--format json` and a session's
+// report.json. It is a contract with scripts and CI, so it carries a version
+// and only what a reader can rely on; internal fields (per-run ids, how each
+// finding was anchored, code signatures, platform state) stay out, though the
+// anchoring counts of the whole run are in. Change it
+// only by adding optional fields, or by a new version.
+export const REPORT_VERSION = 1;
+export function toReportOutput(report) {
+    const output = {
+        version: REPORT_VERSION,
+        changeRequest: report.changeRequest,
+        tier: report.tier,
+        verdict: report.verdict,
+        summary: report.summary,
+        coverage: report.coverage,
+        findings: report.findings.map(outputFinding),
+        unverifiedCriticals: report.unverifiedCriticals,
+        refuted: report.refuted,
+        remembered: report.remembered,
+        tasks: report.tasks,
+        skipped: report.skipped,
+        bundles: report.bundles,
+        usage: report.usage,
+        warnings: report.warnings,
+    };
+    if (report.scope)
+        output.scope = report.scope;
+    if (report.judgement)
+        output.judgement = report.judgement;
+    if (report.anchoring)
+        output.anchoring = report.anchoring;
+    if (report.rereview) {
+        const r = report.rereview;
+        output.rereview = {
+            fixed: r.fixed.map(outputPrior),
+            notReproduced: r.notReproduced.map(outputPrior),
+            notRechecked: r.notRechecked.map(outputPrior),
+            unchanged: r.unchanged.map(outputPrior),
+            dismissed: r.dismissed.map(outputPrior),
+        };
+    }
+    return output;
+}
+function outputFinding(f) {
+    const output = {
+        fingerprint: f.fingerprint,
+        reviewer: f.reviewer,
+        category: f.category,
+        severity: f.severity,
+        verification: f.verification ?? "unchecked",
+        file: f.file,
+        inDiff: f.anchor.inDiff,
+        status: f.status === "unfixed" ? "unfixed" : "new",
+        title: f.title,
+        body: f.body,
+        evidence: f.evidence,
+        code: f.existingCode,
+    };
+    if (f.lineRange)
+        output.lines = { start: f.lineRange.start, end: f.lineRange.end };
+    if (f.suggestion !== undefined)
+        output.suggestion = f.suggestion;
+    if (f.lowConfidence)
+        output.lowConfidence = true;
+    return output;
+}
+function outputPrior(f) {
+    return {
+        fingerprint: f.fingerprint,
+        title: f.title,
+        file: f.file,
+        severity: f.severity,
+        verification: f.verification ?? "unchecked",
+    };
+}
+// The published shape of `ocra review --plan --format json`, versioned like
+// the report. The preview is already free of internal fields; the version
+// makes the contract explicit.
+export const PLAN_VERSION = 1;
+export function toPlanOutput(preview) {
+    return {
+        version: PLAN_VERSION,
+        changeRequest: preview.changeRequest,
+        tier: preview.tier,
+        selected: preview.selected,
+        excluded: preview.excluded,
+        bundles: preview.bundles,
+        groupingSkipped: preview.groupingSkipped,
+        tasks: preview.tasks,
+        skipped: preview.skipped,
+        promptTokens: preview.promptTokens,
+        // Added in version 1 without a bump: a new field older readers ignore.
+        planCalls: preview.planCalls,
+        warnings: preview.warnings,
+    };
+}
+// Characters a terminal or an editor acts on: C0 controls but tab and
+// newline, DEL and C1 controls (ANSI and OSC escapes), line and paragraph
+// separators, and bidirectional marks and overrides ("Trojan Source"). One
+// definition for every output: terminal text replaces them, JSON escapes them.
+export function isUnsafeCodePoint(code) {
+    return ((code <= 0x1f && code !== 0x09 && code !== 0x0a) ||
+        (code >= 0x7f && code <= 0x9f) ||
+        code === 0x061c ||
+        code === 0x200e ||
+        code === 0x200f ||
+        code === 0x2028 ||
+        code === 0x2029 ||
+        (code >= 0x202a && code <= 0x202e) ||
+        (code >= 0x2066 && code <= 0x2069));
+}
+// JSON for files and stdout. JSON.stringify escapes C0 controls but not the
+// rest; model and pull request text reaches these files.
+export function serializeOutput(value, indent = 2) {
+    let out = "";
+    for (const char of JSON.stringify(value, null, indent)) {
+        const code = char.codePointAt(0) ?? 0;
+        out +=
+            code > 0x1f && isUnsafeCodePoint(code) ? `\\u${code.toString(16).padStart(4, "0")}` : char;
+    }
+    return out;
+}
+//# sourceMappingURL=output.js.map

package/dist/pipeline/plan.d.ts

@@ -0,0 +1,34 @@
+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 MemoryEntry } from "../memory/memory.js";
+import { type RepoRule } from "../rules/repo-rules.js";
+import { type FileDecision } from "../select/select.js";
+import type { ReviewEvent } from "./report.js";
+import type { ReviewOptions } from "./run.js";
+export declare const GUIDELINES_PATH = "AGENTS.md";
+export interface ReviewPlan {
+    changeRequest: ChangeRequest;
+    decisions: FileDecision[];
+    selected: FileDiff[];
+    tier: RiskTier;
+    bundles: Bundle[];
+    unchanged: ReadonlySet<string>;
+    widened?: {
+        from: RiskTier;
+        to: RiskTier;
+    };
+    context: ReviewContext;
+    guidelines: string | undefined;
+    repoRules: RepoRule[];
+    memory: MemoryEntry[];
+    usage: Usage[];
+    warnings: string[];
+}
+export type PlanOptions = Pick<ReviewOptions, "vcs" | "rules" | "readTrusted" | "selection" | "bundling" | "grouper"> & {
+    runtime?: AgentRuntime;
+    reviewOnly?: ReadonlySet<string>;
+    priorTier?: RiskTier;
+};
+export declare function planReview(options: PlanOptions, emit: (event: ReviewEvent) => void, signal: AbortSignal): Promise<ReviewPlan>;
+//# sourceMappingURL=plan.d.ts.map

package/dist/pipeline/plan.js

@@ -0,0 +1,68 @@
+import { bundleFiles, defaultBundlePolicy } from "../bundle/bundle.js";
+import { MEMORY_PATH, 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 { reviewContext } from "./context.js";
+import { runtimeGrouper } from "./helpers.js";
+import { rank } from "./matrix.js";
+export 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", changeRequest });
+    const diffs = await vcs.getDiff();
+    const decisions = selectFiles(diffs, options.selection ?? defaultSelectionPolicy);
+    const selected = decisions.filter((d) => d.selected).map((d) => d.diff);
+    const tier = triage(selected);
+    emit({
+        type: "files_selected",
+        selected: selected.length,
+        excluded: diffs.length - selected.length,
+        tier,
+    });
+    const [guidelines, fileRules, memoryText] = await Promise.all([
+        readTrusted(GUIDELINES_PATH),
+        loadRepoRules(readTrusted),
+        readTrusted(MEMORY_PATH),
+    ]);
+    const usage = [];
+    const grouper = options.grouper ??
+        (options.runtime ? runtimeGrouper(options.runtime, signal, (u) => usage.push(u)) : undefined);
+    const widened = options.reviewOnly && options.priorTier && rank(tier) > rank(options.priorTier)
+        ? { from: options.priorTier, to: tier }
+        : undefined;
+    const only = widened ? undefined : options.reviewOnly;
+    const inScope = only
+        ? selected.filter((d) => only.has(d.newPath) || only.has(d.oldPath))
+        : selected;
+    const unchanged = new Set(selected.filter((d) => !inScope.includes(d)).map((d) => d.newPath));
+    const bundled = await bundleFiles(inScope, options.bundling ?? defaultBundlePolicy, grouper);
+    emit({
+        type: "files_bundled",
+        strategy: bundled.strategy,
+        bundles: bundled.bundles.length,
+        warnings: bundled.warnings,
+    });
+    return {
+        changeRequest,
+        decisions,
+        selected,
+        tier,
+        bundles: bundled.bundles,
+        unchanged,
+        ...(widened ? { widened } : {}),
+        context: reviewContext(vcs, diffs),
+        guidelines,
+        repoRules: [...(options.rules ?? []), ...fileRules],
+        memory: memoryText === undefined ? [] : parseMemory(memoryText),
+        usage,
+        warnings: bundled.warnings,
+    };
+}
+async function loadRepoRules(read) {
+    const text = await read(REPO_RULES_PATH);
+    return text === undefined ? [] : parseRepoRules(text);
+}
+//# sourceMappingURL=plan.js.map

package/dist/pipeline/pool.d.ts

@@ -0,0 +1,2 @@
+export declare function mapWithConcurrency<T, R>(items: readonly T[], limit: number, worker: (item: T) => Promise<R>): Promise<R[]>;
+//# sourceMappingURL=pool.d.ts.map

package/dist/pipeline/pool.js

@@ -0,0 +1,13 @@
+export async function mapWithConcurrency(items, limit, worker) {
+    const results = new Array(items.length);
+    let next = 0;
+    const runners = Array.from({ length: Math.min(Math.max(limit, 1), items.length) }, async () => {
+        while (next < items.length) {
+            const index = next++;
+            results[index] = await worker(items[index]);
+        }
+    });
+    await Promise.all(runners);
+    return results;
+}
+//# sourceMappingURL=pool.js.map

package/dist/pipeline/preview.d.ts

@@ -0,0 +1,42 @@
+import type { ChangeRequest, RiskTier } from "../domain.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 PlanOptions } from "./plan.js";
+export interface PreviewTask {
+    taskId: string;
+    reviewer: string;
+    bundle: string;
+    files: string[];
+    promptTokens: number;
+    planPromptTokens?: number;
+}
+export interface ReviewPreview {
+    changeRequest: ChangeRequest;
+    tier: RiskTier;
+    selected: string[];
+    excluded: {
+        path: string;
+        reason: Exclude<FileDecision, {
+            selected: true;
+        }>["reason"];
+    }[];
+    bundles: {
+        label: string;
+        files: string[];
+    }[];
+    groupingSkipped: boolean;
+    tasks: PreviewTask[];
+    skipped: SkippedCell[];
+    promptTokens: number;
+    planCalls: number;
+    warnings: string[];
+}
+export type PreviewOptions = Omit<PlanOptions, "runtime"> & {
+    reviewers?: readonly ReviewerDefinition[];
+    reviewerOverrides?: ReviewerOverrides;
+    ultra?: boolean;
+    maxTasks?: number;
+};
+export declare function previewReview(options: PreviewOptions): Promise<ReviewPreview>;
+//# sourceMappingURL=preview.d.ts.map

package/dist/pipeline/preview.js

@@ -0,0 +1,73 @@
+import { defaultBundlePolicy } from "../bundle/bundle.js";
+import { memoryFor } from "../memory/memory.js";
+import { buildReviewPrompt } from "../review/prompt.js";
+import { correctnessReviewer } from "../review/reviewers/correctness.js";
+import { resolveRules } from "../rules/resolve.js";
+import { isLargeBundle } from "./execute.js";
+import { planTasks } from "./matrix.js";
+import { planReview } from "./plan.js";
+// Everything a review would do before its first model call, for free: which
+// files, which tasks, and how large each first prompt is.
+export async function previewReview(options) {
+    const plan = await planReview(options, () => { }, new AbortController().signal);
+    const reviewers = options.reviewers ?? [correctnessReviewer];
+    const planned = planTasks(plan.bundles, reviewers, plan.tier, options.reviewerOverrides, {
+        ultra: options.ultra === true,
+        ...(options.maxTasks !== undefined ? { maxTasks: options.maxTasks } : {}),
+        hasGuidelines: Boolean(plan.guidelines?.trim()),
+    });
+    const { cells } = planned;
+    const plannedBundles = new Set();
+    const tasks = cells.map((cell) => {
+        const files = cell.bundle.files.map((f) => f.newPath);
+        const input = {
+            reviewer: cell.reviewer,
+            changeRequest: plan.changeRequest,
+            changedFiles: plan.selected,
+            bundle: cell.bundle.files,
+            rules: resolveRules(files, plan.repoRules, cell.reviewer.rules),
+            guidelines: plan.guidelines,
+            accepted: memoryFor(files, plan.memory),
+        };
+        const prompt = buildReviewPrompt(input);
+        const task = {
+            taskId: cell.taskId,
+            reviewer: cell.reviewer.id,
+            bundle: cell.bundle.label,
+            files,
+            promptTokens: tokens(prompt),
+        };
+        const key = `${cell.reviewer.id}\0${cell.bundle.label}`;
+        if ((options.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
+            plannedBundles.add(key);
+            task.planPromptTokens = tokens(buildReviewPrompt({ ...input, forPlanning: true }));
+        }
+        return task;
+    });
+    const policy = options.bundling ?? defaultBundlePolicy;
+    return {
+        changeRequest: plan.changeRequest,
+        tier: plan.tier,
+        selected: plan.selected.map((d) => d.newPath),
+        excluded: plan.decisions.flatMap((d) => d.selected ? [] : [{ path: d.diff.newPath, reason: d.reason }]),
+        bundles: plan.bundles.map((b) => ({ label: b.label, files: b.files.map((f) => f.newPath) })),
+        groupingSkipped: options.grouper === undefined && plan.selected.length >= policy.groupingMinFiles,
+        tasks,
+        skipped: planned.skipped,
+        promptTokens: tasks.reduce((sum, t) => sum + t.promptTokens + (t.planPromptTokens ?? 0), 0),
+        planCalls: tasks.filter((t) => t.planPromptTokens !== undefined).length,
+        warnings: [
+            ...plan.warnings,
+            ...(planned.limited?.length
+                ? [
+                    `task limit reached: ${planned.limited.length} review task(s) would be skipped and their files reported as not reviewed`,
+                ]
+                : []),
+        ],
+    };
+}
+// Four characters per token: an estimate, not a tokenizer.
+function tokens(prompt) {
+    return Math.ceil((prompt.system.length + prompt.user.length) / 4);
+}
+//# sourceMappingURL=preview.js.map