@open-cr-agent/cli 0.5.0 → 0.6.0

package/dist/commands/review/exit-code.js

@@ -0,0 +1,29 @@
+import { coverageGaps } from "@open-cr-agent/core";
+import { EXIT } from "../../io/exit.js";
+import { forTerminal } from "../../io/terminal.js";
+export function exitCode(report, err) {
+    if (report.tasks.length > 0 && report.tasks.every((t) => t.status !== "completed")) {
+        err.write("[ocra] No review task completed; see the errors above.\n");
+        return EXIT.error;
+    }
+    // Incomplete comes first, even over a blocking verdict: the action lets
+    // exit 1 pass unless fail-on-concerns is set, and a review that missed
+    // files or could not check a critical finding must never pass.
+    const { notReviewed } = coverageGaps(report);
+    if (notReviewed > 0) {
+        err.write(`[ocra] ${notReviewed} selected file(s) were not reviewed; the review is incomplete.\n`);
+        return EXIT.incomplete;
+    }
+    if (report.unverifiedCriticals > 0) {
+        err.write(`[ocra] ${report.unverifiedCriticals} critical finding(s) could not be verified; the review is incomplete.\n`);
+        return EXIT.incomplete;
+    }
+    if (report.verdict !== "significant_concerns")
+        return EXIT.ok;
+    const override = report.changeRequest.override;
+    if (!override)
+        return EXIT.blocking;
+    err.write(`[ocra] The blocking verdict was overridden by ${forTerminal(override.by)}: ${forTerminal(override.reason)}\n`);
+    return EXIT.ok;
+}
+//# sourceMappingURL=exit-code.js.map

package/dist/commands/review/plan-prices.d.ts

@@ -0,0 +1,3 @@
+import type { CustomProvider } from "@open-cr-agent/core";
+export declare function inputPriceOf(providers: Readonly<Record<string, CustomProvider>>): (model: string) => number | undefined;
+//# sourceMappingURL=plan-prices.d.ts.map

package/dist/commands/review/plan-prices.js

@@ -0,0 +1,18 @@
+import { CLOUD_PREFIX } from "@open-cr-agent/cloud-contract";
+// The input prices --plan estimates with, in US dollars per million tokens:
+// a declared provider's; 0 for a model through ocra Cloud, which is not
+// priced; undefined for any other, which only the runtime's catalog prices
+// and a plan, calling nothing, does not read.
+export function inputPriceOf(providers) {
+    return (model) => {
+        const slash = model.indexOf("/");
+        if (slash < 0)
+            return undefined;
+        const provider = model.slice(0, slash);
+        const declared = providers[provider]?.models[model.slice(slash + 1)];
+        if (declared)
+            return declared.input;
+        return provider.startsWith(CLOUD_PREFIX) && !providers[provider] ? 0 : undefined;
+    };
+}
+//# sourceMappingURL=plan-prices.js.map

package/dist/{review → commands/review}/plan-render.js

@@ -1,4 +1,4 @@
-import { forTerminal } from "./terminal.js";
+import { forTerminal } from "../../io/terminal.js";
 const number = new Intl.NumberFormat("en-US");
 export function renderPlan(preview) {
     const lines = [
@@ -20,7 +20,7 @@ export function renderPlan(preview) {
     lines.push("", `Review tasks: ${preview.tasks.length}`);
     const width = Math.max(0, ...preview.tasks.map((t) => t.taskId.length));
     for (const t of preview.tasks) {
-        lines.push(`  ${t.taskId.padEnd(width)}  ~${number.format(t.promptTokens)} prompt tokens${t.planPromptTokens === undefined ? "" : ` + plan ~${number.format(t.planPromptTokens)}`}${t.effort === undefined ? "" : `  effort ${t.effort}`}${t.models === undefined ? "" : `  models ${t.models.join(", ")}`}  ${t.bundle}`);
+        lines.push(`  ${t.taskId.padEnd(width)}  ~${number.format(t.promptTokens)} prompt tokens${t.planPromptTokens === undefined ? "" : ` + plan ~${number.format(t.planPromptTokens)}`}${t.effort === undefined ? "" : `  effort ${t.effort}`}${t.models === undefined ? "" : `  models ${t.models.join(", ")}`}${costOf(t.inputCost)}  ${t.bundle}`);
     }
     if (preview.skipped.length > 0) {
         lines.push("", "Skipped by the review matrix:");
@@ -30,7 +30,27 @@ export function renderPlan(preview) {
     }
     for (const warning of preview.warnings)
         lines.push(`Warning: ${warning}`);
+    if (preview.inputCost)
+        lines.push("", totalCost(preview.inputCost, preview.tasks.length));
     lines.push("", `First prompts: ~${number.format(preview.promptTokens)} input tokens in total${preview.planCalls > 0 ? `, ${preview.planCalls} plan call(s) included` : ""}. This is a floor: agents read files and take several turns, so a run usually uses several times as much, plus verification and judging. No model was called.`);
     return forTerminal(`${lines.join("\n")}\n`);
 }
+function costOf(cost) {
+    if (cost === undefined)
+        return "";
+    if (cost.status === "priced")
+        return `  input ~${usd(cost.usd)}`;
+    return cost.status === "unpriced" ? "  input unpriced" : "  input price unknown";
+}
+function totalCost(total, tasks) {
+    const rest = [
+        total.unpriced > 0 ? `${total.unpriced} unpriced` : "",
+        total.unknown > 0 ? `${total.unknown} of unknown price` : "",
+    ].filter(Boolean);
+    return `Estimated input cost: ~${usd(total.usd)} for the first prompts of ${total.priced} of ${tasks} task(s)${rest.length > 0 ? ` (${rest.join(", ")})` : ""}, at the input price of each chain's first model. Input only: output, later turns, verification and judging are not known before the run.`;
+}
+// Cents hide the size of a small prompt's cost; four decimals keep it.
+function usd(value) {
+    return `$${value.toFixed(value >= 1 ? 2 : 4)}`;
+}
 //# sourceMappingURL=plan-render.js.map

package/dist/commands/review/plan-run.d.ts

@@ -0,0 +1,5 @@
+import type { ReviewArgs } from "./args.js";
+import type { ReviewDeps } from "./deps.js";
+import type { ResolvedRun, ReviewIo } from "./resolve-run.js";
+export declare function planRun(run: ResolvedRun, args: ReviewArgs, io: ReviewIo, deps: ReviewDeps): Promise<number>;
+//# sourceMappingURL=plan-run.d.ts.map

package/dist/commands/review/plan-run.js

@@ -0,0 +1,38 @@
+import { resolve } from "node:path";
+import { previewReview, toPlanOutput } from "@open-cr-agent/core/internal";
+import { EXIT } from "../../io/exit.js";
+import { inputPriceOf } from "./plan-prices.js";
+import { renderPlan } from "./plan-render.js";
+import { safeJson } from "./render.js";
+import { configuredOptions } from "./review-options.js";
+import { accountOf, effectiveSettings, renderSettings, } from "./settings-sources.js";
+// --plan: what the review would do and cost, without calling a model.
+export async function planRun(run, args, io, deps) {
+    const { config } = run;
+    const preview = await previewReview({
+        ...configuredOptions(run, args),
+        vcs: run.vcs,
+        inputPrice: inputPriceOf(config.providers),
+    });
+    const settings = effectiveSettings(run.listed);
+    const rendered = args.format === "json"
+        ? `${safeJson(planJson(preview, settings, run.accountSettings))}\n`
+        : renderPlan(preview) + renderSettings(settings, run.accountSettings);
+    if (args.output === undefined)
+        io.out.write(rendered);
+    else
+        await deps.writeFile(resolve(deps.cwd, args.output), rendered);
+    return EXIT.ok;
+}
+function planJson(preview, settings, account) {
+    return {
+        ...toPlanOutput(preview),
+        settings: settings.map((s) => ({
+            key: s.key,
+            ...("value" in s ? { value: s.value } : {}),
+            source: s.source,
+        })),
+        ...accountOf(account),
+    };
+}
+//# sourceMappingURL=plan-run.js.map

package/dist/commands/review/plan-schema.d.ts

@@ -0,0 +1,97 @@
+import { z } from "zod";
+export declare const cliPlanOutputSchema: 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>;
+    settings: z.ZodArray<z.ZodObject<{
+        key: z.ZodString;
+        value: z.ZodExactOptional<z.ZodUnknown>;
+        source: z.ZodString;
+    }, z.core.$strict>>;
+    accountSettings: z.ZodExactOptional<z.ZodObject<{
+        version: z.ZodNullable<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export type CliPlanOutput = z.output<typeof cliPlanOutputSchema>;
+export declare const PLAN_SCHEMA_ID = "https://ocra.majincheng.com/schema/plan.v1.json";
+export declare function planJsonSchema(): Record<string, unknown>;
+//# sourceMappingURL=plan-schema.d.ts.map

package/dist/commands/review/plan-schema.js

@@ -0,0 +1,34 @@
+import { PLAN_VERSION, planOutputSchema } from "@open-cr-agent/core/internal";
+import { z } from "zod";
+// `ocra review --plan --format json`: core's plan, and where each setting of
+// the review came from (ADR-0027). A contract like the report: a version
+// only gains optional fields, and docs/schema/plan.v1.json is generated from
+// here (npm run schema).
+export const cliPlanOutputSchema = planOutputSchema.extend({
+    settings: z.array(z.strictObject({
+        key: z.string(),
+        // Absent for a default: ocra's own, or the runtime's.
+        value: z.unknown().exactOptional(),
+        source: z.string(),
+    })),
+    // Present when ocra Cloud account settings were layered under the
+    // configuration; null when the account has never saved any.
+    accountSettings: z.strictObject({ version: z.string().nullable() }).exactOptional(),
+});
+export const PLAN_SCHEMA_ID = `https://ocra.majincheng.com/schema/plan.v${PLAN_VERSION}.json`;
+export function planJsonSchema() {
+    const generated = z.toJSONSchema(cliPlanOutputSchema, {
+        target: "draft-2020-12",
+        io: "output",
+        unrepresentable: "any",
+    });
+    const { $schema, ...rest } = generated;
+    return {
+        $schema,
+        $id: PLAN_SCHEMA_ID,
+        title: "ocra review plan",
+        description: `What ocra review --plan --format json writes (version ${PLAN_VERSION}): the files, tasks and estimated prompt sizes of a review, before any model call. A version only gains optional fields; anything else is a new version.`,
+        ...rest,
+    };
+}
+//# sourceMappingURL=plan-schema.js.map

package/dist/{review → commands/review}/progress.d.ts

@@ -1,16 +1,14 @@
 import type { ReviewEvent } from "@open-cr-agent/core";
-export interface Output {
-    write(chunk: string): unknown;
-}
+import type { Output } from "../../io/output.js";
 export interface ProgressOptions {
     heartbeatMs: number;
     now: () => number;
 }
 export declare class ProgressPrinter {
-    private readonly err;
-    private readonly options;
     private lastOutput;
     private readonly timer;
+    private readonly err;
+    private readonly options;
     constructor(err: Output, options: ProgressOptions);
     onEvent(event: ReviewEvent): void;
     stop(): void;

package/dist/{review → commands/review}/progress.js

@@ -1,9 +1,9 @@
-import { forTerminal } from "./terminal.js";
+import { forTerminal } from "../../io/terminal.js";
 export class ProgressPrinter {
-    err;
-    options;
     lastOutput;
     timer;
+    err;
+    options;
     constructor(err, options) {
         this.err = err;
         this.options = options;

package/dist/{review → commands/review}/provenance.d.ts

@@ -1,6 +1,8 @@
 import type { Sampling } from "@open-cr-agent/core";
+import type { CliConfig } from "../../config/cli-config.js";
 import type { ReviewArgs } from "./args.js";
-import type { CliConfig } from "./config.js";
 export declare function requestedSampling(config: CliConfig, args: ReviewArgs): Sampling;
-export declare function configHash(config: CliConfig, args: ReviewArgs): string;
+export declare function configHash(config: CliConfig, args: ReviewArgs, accountSettings?: {
+    version: string | null;
+}): string;
 //# sourceMappingURL=provenance.d.ts.map

package/dist/{review → commands/review}/provenance.js

@@ -16,9 +16,8 @@ export function requestedSampling(config, args) {
 // unset it adds nothing, so configurations that set none keep their hash.
 // The ocra Cloud account settings (ADR-0027) add their version and rules
 // only when they were layered in, so a signed-out run keeps its hash.
-export function configHash(config, args) {
-    // runtimeSet says where the runtime came from, not what ran: the runtime is hashed.
-    const { sampling: _, runtimeSet: _set, providers, extends: shared, effort, roles, rules, accountSettings, ...rest } = config;
+export function configHash(config, args, accountSettings) {
+    const { sampling: _, providers, extends: shared, effort, roles, rules, ...rest } = config;
     const bare = (account) => rules
         .filter((rule) => (rule.source === "account") === account)
         .map(({ path, rule }) => ({ path, rule }));

package/dist/{review → commands/review}/render.js

@@ -1,6 +1,6 @@
 import { coverageGaps, toReportOutput, } from "@open-cr-agent/core";
 import { serializeOutput } from "@open-cr-agent/core/internal";
-import { forTerminal } from "./terminal.js";
+import { forTerminal } from "../../io/terminal.js";
 const SEVERITIES = ["critical", "warning", "suggestion"];
 const VERIFICATION = {
     confirmed: "verified",

package/dist/commands/review/resolve-run.d.ts

@@ -0,0 +1,29 @@
+import { type PluginRegistry, type ReviewerOverrides, type SourcedRule, type VcsAdapter } from "@open-cr-agent/core";
+import type { CloudDeps } from "../../cloud/deps.js";
+import { type ResolvedConfig } from "../../config/cli-config.js";
+import type { Output } from "../../io/output.js";
+import type { ReviewArgs } from "./args.js";
+import type { ReviewDeps } from "./deps.js";
+import { type AccountVersion } from "./settings-sources.js";
+import { type ReviewTarget } from "./target.js";
+export interface ReviewIo {
+    out: Output;
+    err: Output;
+}
+export interface ResolvedRun extends ResolvedConfig {
+    root: string;
+    target: ReviewTarget;
+    warn: (message: string) => void;
+    signedInCloud?: CloudDeps;
+    accountSettings?: AccountVersion;
+    session: {
+        dir: string;
+        id: string;
+    };
+    registry: PluginRegistry;
+    vcs: VcsAdapter;
+    rules: SourcedRule[];
+    overrides: ReviewerOverrides;
+}
+export declare function resolveRun(args: ReviewArgs, io: ReviewIo, deps: ReviewDeps): Promise<ResolvedRun>;
+//# sourceMappingURL=resolve-run.d.ts.map

package/dist/commands/review/resolve-run.js

@@ -0,0 +1,125 @@
+import { sessionJsonlPlugin, startPlugins, } from "@open-cr-agent/core";
+import { newRunId } from "@open-cr-agent/core/internal";
+import { findRepositoryRoot } from "@open-cr-agent/vcs-local/internal";
+import { sessionLostWarning } from "../../cloud/review.js";
+import { accountLayer, fetchAccountSettings } from "../../cloud/settings.js";
+import { cloudEnabled } from "../../cloud/upload.js";
+import { ConfigError, resolveConfig, } from "../../config/cli-config.js";
+import { forTerminal } from "../../io/terminal.js";
+import { loadAccountPlugins } from "../../plugins/account.js";
+import { pluginsDir } from "../../plugins/store.js";
+import { sessionsDir } from "../../session/store.js";
+import { filledByAccount } from "./settings-sources.js";
+import { resolveReviewTarget } from "./target.js";
+export async function resolveRun(args, io, deps) {
+    const root = await findRepositoryRoot(deps.cwd);
+    const warn = (message) => io.err.write(`[ocra] Warning: ${forTerminal(message)}\n`);
+    const target = await resolveReviewTarget(args, {
+        cwd: deps.cwd,
+        root,
+        env: deps.env,
+        warn,
+        ...(deps.fetch ? { fetch: deps.fetch } : {}),
+    });
+    const account = await withAccount(target, deps.cloud, warn);
+    if (args.ultra)
+        account.layers.push({ source: "flag", settings: { ultra: true } });
+    const resolved = resolveConfig(account.layers);
+    const filled = filledByAccount(resolved.listed);
+    if (filled.length > 0) {
+        io.err.write(forTerminal(`[ocra] From your ocra Cloud settings: ${filled.join(", ")}\n`));
+    }
+    const session = { dir: sessionsDir(root), id: newRunId() };
+    const registry = await startRegistry(args, deps, {
+        target,
+        config: resolved.config,
+        account: account.plugins,
+        session,
+        warn,
+    });
+    return {
+        ...resolved,
+        root,
+        target,
+        warn,
+        ...(account.cloud ? { signedInCloud: account.cloud } : {}),
+        ...(account.settings ? { accountSettings: account.settings } : {}),
+        session,
+        registry,
+        vcs: target.createVcs(registry),
+        rules: [
+            ...registry.rules.map((rule) => ({ ...rule, source: "plugin" })),
+            ...resolved.config.rules,
+        ],
+        overrides: reviewerOverrides(resolved.config, args, registry.reviewers.map((r) => r.id)),
+    };
+}
+// The account's settings fill what the repository leaves out (ADR-0027);
+// unreachable, they cost a warning, so a plan still works offline.
+async function withAccount(target, cloudDeps, warn) {
+    const layers = [...target.layers];
+    const none = { plugins: [], pluginSettings: {} };
+    if (!cloudDeps || !(await cloudEnabled(cloudDeps, warn)))
+        return { layers, plugins: none };
+    const account = await fetchAccountSettings(cloudDeps, warn);
+    if (account.kind !== "read") {
+        // Said once here; the rest of the run leaves ocra Cloud alone.
+        if (account.kind !== "signed-out")
+            warn(sessionLostWarning(account));
+        return { layers, plugins: none };
+    }
+    if (!account.settings)
+        return { layers, cloud: cloudDeps, plugins: account.plugins };
+    layers.push(accountLayer(account.settings));
+    return {
+        layers,
+        cloud: cloudDeps,
+        settings: { version: account.settings.version },
+        plugins: account.plugins,
+    };
+}
+// A plan calls no model, writes no session log and imports no runtime: it
+// works without the optional runtime-opencode.
+async function startRegistry(args, deps, run) {
+    const { target, config, warn } = run;
+    const builtins = args.plan
+        ? deps.builtinPlugins.filter((p) => p.name !== sessionJsonlPlugin.name)
+        : [...deps.builtinPlugins, ...(await builtinRuntime(deps.runtimes, config.runtime))];
+    const account = await loadAccountPlugins(run.account, {
+        allowed: target.accountPlugins,
+        configured: config.plugins,
+        taken: [...builtins, ...target.plugins],
+        dir: pluginsDir(deps.env),
+        warn,
+    });
+    // The repository's own settings win; a repository plugin's come from it alone.
+    const pluginSettings = { ...account.settings, ...config.pluginSettings };
+    return startPlugins([...builtins, ...target.plugins, ...account.plugins], {
+        settings: args.plan
+            ? pluginSettings
+            : { ...pluginSettings, [sessionJsonlPlugin.name]: run.session },
+        env: deps.env,
+        warn,
+    });
+}
+// A runtime not built in comes from a plugin of the configuration.
+async function builtinRuntime(runtimes, name) {
+    const load = Object.hasOwn(runtimes, name) ? runtimes[name] : undefined;
+    return load ? [await load()] : [];
+}
+// --reviewers narrows the run to the named reviewers on top of the config.
+function reviewerOverrides(config, args, registered) {
+    if (args.reviewers === undefined)
+        return config.reviewers;
+    const unknown = args.reviewers.filter((id) => !registered.includes(id));
+    if (unknown.length > 0) {
+        throw new ConfigError(`Unknown reviewer(s): ${unknown.join(", ")} (available: ${registered.join(", ")})`);
+    }
+    const overrides = { ...config.reviewers };
+    for (const id of registered) {
+        if (!args.reviewers.includes(id))
+            overrides[id] = { ...overrides[id], enabled: false };
+    }
+    return overrides;
+}
+//# sourceMappingURL=resolve-run.js.map

package/dist/commands/review/review-options.d.ts

@@ -0,0 +1,6 @@
+import type { ReviewOptions } from "@open-cr-agent/core";
+import type { ReviewArgs } from "./args.js";
+import type { ResolvedRun } from "./resolve-run.js";
+export type ConfiguredOptions = Omit<ReviewOptions, "vcs" | "runtime" | "identity" | "sarif" | "accountMemory" | "signal" | "onEvent">;
+export declare function configuredOptions(run: ResolvedRun, args: ReviewArgs): ConfiguredOptions;
+//# sourceMappingURL=review-options.d.ts.map

package/dist/commands/review/review-options.js

@@ -0,0 +1,35 @@
+// What the configuration and the flags decide about a review, mapped once
+// for the review and its --plan preview: minutes become milliseconds, and
+// --max-cost-usd overrides the configured limit.
+export function configuredOptions(run, args) {
+    const { config } = run;
+    const maxCostUsd = args.maxCostUsd ?? config.maxCostUsd;
+    const limits = {
+        ...(config.concurrency !== undefined ? { concurrency: config.concurrency } : {}),
+        ...(config.taskTimeoutMinutes !== undefined
+            ? { taskTimeoutMs: config.taskTimeoutMinutes * 60_000 }
+            : {}),
+        ...(config.runTimeoutMinutes !== undefined
+            ? { runTimeoutMs: config.runTimeoutMinutes * 60_000 }
+            : {}),
+        ...(maxCostUsd !== undefined ? { maxCostUsd } : {}),
+        ...(config.maxTasks !== undefined ? { maxTasks: config.maxTasks } : {}),
+    };
+    return {
+        reviewers: run.registry.reviewers,
+        reviewerOverrides: run.overrides,
+        effort: config.effort,
+        roles: config.roles,
+        models: config.models,
+        rules: run.rules,
+        selection: { include: config.include, exclude: config.exclude },
+        ...(run.target.readTrusted ? { readTrusted: run.target.readTrusted } : {}),
+        limits,
+        stages: {
+            ...(config.verify !== undefined ? { verify: config.verify } : {}),
+            ...(config.judge !== undefined ? { judge: config.judge } : {}),
+        },
+        mode: { ...(run.ultra ? { ultra: true } : {}), ...(args.full ? { full: true } : {}) },
+    };
+}
+//# sourceMappingURL=review-options.js.map

package/dist/{review → commands/review}/runtimes.js

@@ -1,5 +1,5 @@
 import { OcraError } from "@open-cr-agent/core";
-import { VERSION } from "../version.js";
+import { VERSION } from "../../version.js";
 export const BUILTIN_RUNTIMES = {
     opencode: () => loadRuntime("opencode", "@open-cr-agent/runtime-opencode", async () => (await import("@open-cr-agent/runtime-opencode")).opencodeRuntimePlugin),
     direct: () => loadRuntime("direct", "@open-cr-agent/runtime-direct", async () => (await import("@open-cr-agent/runtime-direct")).directRuntimePlugin),

package/dist/{review → commands/review}/sarif-input.d.ts

@@ -1,4 +1,3 @@
 import { type SarifLog } from "@open-cr-agent/core";
-export declare const MAX_SARIF_BYTES: number;
 export declare function loadSarifLogs(paths: readonly string[], cwd: string): Promise<SarifLog[]>;
 //# sourceMappingURL=sarif-input.d.ts.map

package/dist/{review → commands/review}/sarif-input.js

@@ -1,10 +1,10 @@
 import { readFile, stat } from "node:fs/promises";
 import { resolve } from "node:path";
-import { parseSarifLog } from "@open-cr-agent/core";
-import { ConfigError } from "./config.js";
+import { errorMessage, parseSarifLog } from "@open-cr-agent/core";
+import { ConfigError } from "../../config/cli-config.js";
 // A log is untrusted input like everything else that reaches the review; it
 // is bounded before it is parsed.
-export const MAX_SARIF_BYTES = 20 * 1024 * 1024;
+const MAX_SARIF_BYTES = 20 * 1024 * 1024;
 export async function loadSarifLogs(paths, cwd) {
     const logs = [];
     for (const path of paths) {
@@ -20,13 +20,13 @@ export async function loadSarifLogs(paths, cwd) {
         catch (error) {
             if (error instanceof ConfigError)
                 throw error;
-            throw new ConfigError(`--import-sarif ${path}: ${error.message}`);
+            throw new ConfigError(`--import-sarif ${path}: ${errorMessage(error)}`);
         }
         try {
             logs.push(parseSarifLog(text));
         }
         catch (error) {
-            throw new ConfigError(`--import-sarif ${path}: ${error.message}`);
+            throw new ConfigError(`--import-sarif ${path}: ${errorMessage(error)}`);
         }
     }
     return logs;