@open-cr-agent/core 0.2.0 → 0.4.0

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

@@ -0,0 +1,345 @@
+import { z } from "zod";
+import { type ReportOutput } from "./output.js";
+export declare const outputFindingSchema: z.ZodObject<{
+    fingerprint: z.ZodString;
+    reviewer: z.ZodString;
+    category: z.ZodString;
+    severity: z.ZodEnum<{
+        critical: "critical";
+        suggestion: "suggestion";
+        warning: "warning";
+    }>;
+    verification: z.ZodEnum<{
+        confirmed: "confirmed";
+        uncertain: "uncertain";
+        unchecked: "unchecked";
+    }>;
+    file: z.ZodString;
+    lines: z.ZodOptional<z.ZodObject<{
+        start: z.ZodInt;
+        end: z.ZodInt;
+    }, z.core.$strict>>;
+    inDiff: z.ZodBoolean;
+    status: z.ZodEnum<{
+        new: "new";
+        unfixed: "unfixed";
+    }>;
+    title: z.ZodString;
+    body: z.ZodString;
+    suggestion: z.ZodOptional<z.ZodString>;
+    evidence: z.ZodArray<z.ZodString>;
+    code: z.ZodString;
+    lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        task: z.ZodString;
+        model: z.ZodOptional<z.ZodString>;
+    }, z.core.$strict>>;
+}, z.core.$strict>;
+export declare const reportOutputSchema: z.ZodObject<{
+    version: z.ZodLiteral<1>;
+    runId: z.ZodOptional<z.ZodString>;
+    changeRequest: z.ZodObject<{
+        id: z.ZodString;
+        title: z.ZodString;
+        description: z.ZodString;
+        baseSha: z.ZodString;
+        headSha: z.ZodString;
+        override: z.ZodOptional<z.ZodObject<{
+            by: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>;
+    tier: z.ZodEnum<{
+        full: "full";
+        lite: "lite";
+        trivial: "trivial";
+    }>;
+    verdict: z.ZodEnum<{
+        approved: "approved";
+        approved_with_comments: "approved_with_comments";
+        minor_issues: "minor_issues";
+        significant_concerns: "significant_concerns";
+    }>;
+    summary: z.ZodString;
+    scope: z.ZodOptional<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        mode: z.ZodLiteral<"incremental">;
+        since: z.ZodString;
+    }, z.core.$strict>, z.ZodObject<{
+        mode: z.ZodLiteral<"full">;
+        reason: z.ZodString;
+    }, z.core.$strict>], "mode">>;
+    coverage: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodEnum<{
+            failed: "failed";
+            reviewed: "reviewed";
+            unchanged: "unchanged";
+            unreviewed: "unreviewed";
+        }>;
+    }, z.core.$strict>, z.ZodObject<{
+        path: z.ZodString;
+        status: z.ZodLiteral<"excluded">;
+        reason: z.ZodEnum<{
+            binary: "binary";
+            deleted: "deleted";
+            extension: "extension";
+            generated: "generated";
+            secret: "secret";
+            too_large: "too_large";
+            user_exclude: "user_exclude";
+        }>;
+    }, z.core.$strict>], "status">>;
+    findings: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        reviewer: z.ZodString;
+        category: z.ZodString;
+        severity: z.ZodEnum<{
+            critical: "critical";
+            suggestion: "suggestion";
+            warning: "warning";
+        }>;
+        verification: z.ZodEnum<{
+            confirmed: "confirmed";
+            uncertain: "uncertain";
+            unchecked: "unchecked";
+        }>;
+        file: z.ZodString;
+        lines: z.ZodOptional<z.ZodObject<{
+            start: z.ZodInt;
+            end: z.ZodInt;
+        }, z.core.$strict>>;
+        inDiff: z.ZodBoolean;
+        status: z.ZodEnum<{
+            new: "new";
+            unfixed: "unfixed";
+        }>;
+        title: z.ZodString;
+        body: z.ZodString;
+        suggestion: z.ZodOptional<z.ZodString>;
+        evidence: z.ZodArray<z.ZodString>;
+        code: z.ZodString;
+        lowConfidence: z.ZodOptional<z.ZodLiteral<true>>;
+        provenance: z.ZodOptional<z.ZodObject<{
+            task: z.ZodString;
+            model: z.ZodOptional<z.ZodString>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    unverifiedCriticals: z.ZodInt;
+    refuted: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        file: z.ZodString;
+        title: z.ZodString;
+        reason: z.ZodString;
+    }, z.core.$strict>>;
+    remembered: z.ZodArray<z.ZodObject<{
+        fingerprint: z.ZodString;
+        file: z.ZodString;
+        title: z.ZodString;
+        reason: z.ZodString;
+        added: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    judgement: z.ZodOptional<z.ZodObject<{
+        merged: z.ZodArray<z.ZodObject<{
+            kept: z.ZodString;
+            merged: z.ZodArray<z.ZodString>;
+        }, z.core.$strict>>;
+        dropped: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            file: z.ZodString;
+            title: z.ZodString;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+        recalibrated: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            from: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            to: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            reason: z.ZodString;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    rereview: z.ZodOptional<z.ZodObject<{
+        fixed: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        notReproduced: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        notRechecked: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        unchanged: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+        dismissed: z.ZodArray<z.ZodObject<{
+            fingerprint: z.ZodString;
+            title: z.ZodString;
+            file: z.ZodString;
+            severity: z.ZodEnum<{
+                critical: "critical";
+                suggestion: "suggestion";
+                warning: "warning";
+            }>;
+            verification: z.ZodEnum<{
+                confirmed: "confirmed";
+                uncertain: "uncertain";
+                unchecked: "unchecked";
+            }>;
+        }, z.core.$strict>>;
+    }, z.core.$strict>>;
+    tasks: z.ZodArray<z.ZodObject<{
+        taskId: z.ZodString;
+        reviewer: z.ZodString;
+        bundle: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+        status: z.ZodEnum<{
+            cancelled: "cancelled";
+            completed: "completed";
+            failed: "failed";
+            timed_out: "timed_out";
+        }>;
+        error: z.ZodOptional<z.ZodString>;
+        findings: z.ZodInt;
+        durationMs: z.ZodNumber;
+        usage: z.ZodObject<{
+            inputTokens: z.ZodNumber;
+            outputTokens: z.ZodNumber;
+            reasoningTokens: z.ZodNumber;
+            cachedTokens: z.ZodNumber;
+            costUsd: z.ZodNumber;
+        }, z.core.$strict>;
+    }, 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>>;
+    bundles: z.ZodArray<z.ZodObject<{
+        label: z.ZodString;
+        files: z.ZodArray<z.ZodString>;
+    }, z.core.$strict>>;
+    anchoring: z.ZodOptional<z.ZodObject<{
+        byMethod: z.ZodRecord<z.ZodEnum<{
+            cross_file: "cross_file";
+            file: "file";
+            file_level: "file_level";
+            hunk: "hunk";
+            relocated: "relocated";
+        }>, z.ZodInt>;
+        ambiguous: z.ZodInt;
+        relocationCalls: z.ZodInt;
+    }, z.core.$strict>>;
+    spendLimit: z.ZodOptional<z.ZodObject<{
+        usd: z.ZodNumber;
+        reached: z.ZodOptional<z.ZodEnum<{
+            review: "review";
+            total: "total";
+        }>>;
+    }, z.core.$strict>>;
+    provenance: z.ZodOptional<z.ZodObject<{
+        ocraVersion: z.ZodString;
+        promptHash: z.ZodString;
+        configHash: z.ZodString;
+        sampling: z.ZodObject<{
+            temperature: z.ZodOptional<z.ZodNumber>;
+            seed: z.ZodOptional<z.ZodInt>;
+            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                seed: "seed";
+                temperature: "temperature";
+            }>>>;
+        }, z.core.$strict>;
+        agents: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            tier: z.ZodEnum<{
+                light: "light";
+                standard: "standard";
+                top: "top";
+            }>;
+            effort: z.ZodOptional<z.ZodEnum<{
+                high: "high";
+                low: "low";
+                medium: "medium";
+                minimal: "minimal";
+                none: "none";
+            }>>;
+            applied: z.ZodOptional<z.ZodBoolean>;
+            notApplied: z.ZodOptional<z.ZodArray<z.ZodEnum<{
+                seed: "seed";
+                temperature: "temperature";
+            }>>>;
+        }, z.core.$strict>>>;
+    }, z.core.$strict>>;
+    usage: z.ZodObject<{
+        inputTokens: z.ZodNumber;
+        outputTokens: z.ZodNumber;
+        reasoningTokens: z.ZodNumber;
+        cachedTokens: z.ZodNumber;
+        costUsd: z.ZodNumber;
+    }, z.core.$strict>;
+    warnings: z.ZodArray<z.ZodString>;
+}, z.core.$strict>;
+type OutputFromSchema = z.output<typeof reportOutputSchema>;
+export declare function asSchemaOutput(output: ReportOutput): OutputFromSchema;
+export declare const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
+export declare function reportJsonSchema(): Record<string, unknown>;
+export {};
+//# sourceMappingURL=output-schema.d.ts.map

package/dist/pipeline/output-schema.js

@@ -0,0 +1,181 @@
+import { z } from "zod";
+import { anchorMethodSchema, riskTierSchema, severitySchema, verdictSchema, verificationSchema, } from "../domain.js";
+import { memoryEntrySchema } from "../memory/memory.js";
+import { exclusionReasonSchema } from "../select/select.js";
+import { EFFORT_LEVELS } from "./agents.js";
+import { skipReasonSchema } from "./matrix.js";
+import { REPORT_VERSION } from "./output.js";
+import { taskStatusSchema } from "./report.js";
+// The JSON report as a schema: what `toReportOutput` writes, no more. Every
+// object is strict, so a field added to the output without a schema change
+// fails the tests, and the published JSON Schema (docs/schema/report.v1.json)
+// is generated from here, never written by hand.
+const usageSchema = z.strictObject({
+    inputTokens: z.number(),
+    outputTokens: z.number(),
+    reasoningTokens: z.number(),
+    cachedTokens: z.number(),
+    costUsd: z.number(),
+});
+const changeRequestSchema = z.strictObject({
+    id: z.string(),
+    title: z.string(),
+    description: z.string(),
+    baseSha: z.string(),
+    headSha: z.string(),
+    override: z.strictObject({ by: z.string(), reason: z.string() }).optional(),
+});
+const coverageEntrySchema = z.discriminatedUnion("status", [
+    z.strictObject({
+        path: z.string(),
+        status: z.enum(["reviewed", "failed", "unreviewed", "unchanged"]),
+    }),
+    z.strictObject({
+        path: z.string(),
+        status: z.literal("excluded"),
+        reason: exclusionReasonSchema,
+    }),
+]);
+const linesSchema = z.strictObject({ start: z.int().positive(), end: z.int().positive() });
+export const outputFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    reviewer: z.string(),
+    category: z.string(),
+    severity: severitySchema,
+    verification: verificationSchema,
+    file: z.string(),
+    lines: linesSchema.optional(),
+    inDiff: z.boolean(),
+    status: z.enum(["new", "unfixed"]),
+    title: z.string(),
+    body: z.string(),
+    suggestion: z.string().optional(),
+    evidence: z.array(z.string()),
+    code: z.string(),
+    lowConfidence: z.literal(true).optional(),
+    provenance: z.strictObject({ task: z.string(), model: z.string().optional() }).optional(),
+});
+const outputPriorFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    title: z.string(),
+    file: z.string(),
+    severity: severitySchema,
+    verification: verificationSchema,
+});
+const refutedFindingSchema = z.strictObject({
+    fingerprint: z.string(),
+    file: z.string(),
+    title: z.string(),
+    reason: z.string(),
+});
+const judgeDecisionsSchema = z.strictObject({
+    merged: z.array(z.strictObject({ kept: z.string(), merged: z.array(z.string()) })),
+    dropped: z.array(z.strictObject({
+        fingerprint: z.string(),
+        file: z.string(),
+        title: z.string(),
+        reason: z.string(),
+    })),
+    recalibrated: z.array(z.strictObject({
+        fingerprint: z.string(),
+        from: severitySchema,
+        to: severitySchema,
+        reason: z.string(),
+    })),
+});
+const taskOutcomeSchema = z.strictObject({
+    taskId: z.string(),
+    reviewer: z.string(),
+    bundle: z.string(),
+    files: z.array(z.string()),
+    status: taskStatusSchema,
+    error: z.string().optional(),
+    findings: z.int().nonnegative(),
+    durationMs: z.number(),
+    usage: usageSchema,
+});
+const skippedCellSchema = z.strictObject({
+    reviewer: z.string(),
+    bundle: z.string(),
+    reason: skipReasonSchema,
+});
+const anchoringSummarySchema = z.strictObject({
+    byMethod: z.record(anchorMethodSchema, z.int().nonnegative()),
+    ambiguous: z.int().nonnegative(),
+    relocationCalls: z.int().nonnegative(),
+});
+const scopeSchema = z.discriminatedUnion("mode", [
+    z.strictObject({ mode: z.literal("incremental"), since: z.string() }),
+    z.strictObject({ mode: z.literal("full"), reason: z.string() }),
+]);
+const priorList = z.array(outputPriorFindingSchema);
+const samplingSchema = z.strictObject({
+    temperature: z.number().optional(),
+    seed: z.int().optional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+});
+const agentProvenanceSchema = z.strictObject({
+    tier: z.enum(["top", "standard", "light"]),
+    effort: z.enum(EFFORT_LEVELS).optional(),
+    applied: z.boolean().optional(),
+    notApplied: z.array(z.enum(["temperature", "seed"])).optional(),
+});
+const provenanceSchema = z.strictObject({
+    ocraVersion: z.string(),
+    promptHash: z.string(),
+    configHash: z.string(),
+    sampling: samplingSchema,
+    agents: z.record(z.string(), agentProvenanceSchema).optional(),
+});
+export const reportOutputSchema = z.strictObject({
+    version: z.literal(REPORT_VERSION),
+    runId: z.string().optional(),
+    changeRequest: changeRequestSchema,
+    tier: riskTierSchema,
+    verdict: verdictSchema,
+    summary: z.string(),
+    scope: scopeSchema.optional(),
+    coverage: z.array(coverageEntrySchema),
+    findings: z.array(outputFindingSchema),
+    unverifiedCriticals: z.int().nonnegative(),
+    refuted: z.array(refutedFindingSchema),
+    remembered: z.array(memoryEntrySchema),
+    judgement: judgeDecisionsSchema.optional(),
+    rereview: z
+        .strictObject({
+        fixed: priorList,
+        notReproduced: priorList,
+        notRechecked: priorList,
+        unchanged: priorList,
+        dismissed: priorList,
+    })
+        .optional(),
+    tasks: z.array(taskOutcomeSchema),
+    skipped: z.array(skippedCellSchema),
+    bundles: z.array(z.strictObject({ label: z.string(), files: z.array(z.string()) })),
+    anchoring: anchoringSummarySchema.optional(),
+    spendLimit: z
+        .strictObject({ usd: z.number(), reached: z.enum(["review", "total"]).optional() })
+        .optional(),
+    provenance: provenanceSchema.optional(),
+    usage: usageSchema,
+    warnings: z.array(z.string()),
+});
+export function asSchemaOutput(output) {
+    return output;
+}
+export const REPORT_SCHEMA_ID = "https://ocra.majincheng.com/schema/report.v1.json";
+// JSON Schema (draft 2020-12) for `--format json` and a session's
+// report.json, for validators and code generators outside this codebase.
+export function reportJsonSchema() {
+    const generated = z.toJSONSchema(reportOutputSchema, { target: "draft-2020-12", io: "output" });
+    const { $schema, ...rest } = generated;
+    return {
+        $schema,
+        $id: REPORT_SCHEMA_ID,
+        title: "ocra review report",
+        description: `The report ocra writes with --format json and as a session's report.json (version ${REPORT_VERSION}). A version only gains optional fields; anything else is a new version.`,
+        ...rest,
+    };
+}
+//# sourceMappingURL=output-schema.js.map

package/dist/pipeline/output.d.ts

@@ -5,6 +5,7 @@ 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 { RunProvenance } from "./provenance.js";
 import type { AnchoringSummary, CoverageEntry, ReviewReport, TaskOutcome } from "./report.js";
 export declare const REPORT_VERSION = 1;
 export interface OutputFinding {
@@ -26,6 +27,10 @@ export interface OutputFinding {
     evidence: string[];
     code: string;
     lowConfidence?: true;
+    provenance?: {
+        task: string;
+        model?: string;
+    };
 }
 export interface OutputPriorFinding {
     fingerprint: string;
@@ -36,6 +41,7 @@ export interface OutputPriorFinding {
 }
 export interface ReportOutput {
     version: typeof REPORT_VERSION;
+    runId?: string;
     changeRequest: ChangeRequest;
     tier: RiskTier;
     verdict: Verdict;
@@ -56,6 +62,7 @@ export interface ReportOutput {
     }[];
     anchoring?: AnchoringSummary;
     spendLimit?: ReviewReport["spendLimit"];
+    provenance?: RunProvenance;
     usage: Usage;
     warnings: string[];
 }

package/dist/pipeline/output.js

@@ -8,6 +8,7 @@ export const REPORT_VERSION = 1;
 export function toReportOutput(report) {
     const output = {
         version: REPORT_VERSION,
+        runId: report.runId,
         changeRequest: report.changeRequest,
         tier: report.tier,
         verdict: report.verdict,
@@ -31,6 +32,8 @@ export function toReportOutput(report) {
         output.anchoring = report.anchoring;
     if (report.spendLimit)
         output.spendLimit = report.spendLimit;
+    if (report.provenance)
+        output.provenance = report.provenance;
     if (report.rereview) {
         const r = report.rereview;
         output.rereview = {
@@ -64,6 +67,10 @@ function outputFinding(f) {
         output.suggestion = f.suggestion;
     if (f.lowConfidence)
         output.lowConfidence = true;
+    output.provenance =
+        f.provenance.model === undefined
+            ? { task: f.provenance.task }
+            : { task: f.provenance.task, model: f.provenance.model };
     return output;
 }
 function outputPrior(f) {

package/dist/pipeline/plan.d.ts

@@ -5,7 +5,7 @@ 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";
+import type { ReviewHooks, ReviewOptions } from "./run.js";
 export declare const GUIDELINES_PATH = "AGENTS.md";
 export interface ReviewPlan {
     changeRequest: ChangeRequest;
@@ -25,7 +25,8 @@ export interface ReviewPlan {
     usage: Usage[];
     warnings: string[];
 }
-export type PlanOptions = Pick<ReviewOptions, "vcs" | "rules" | "readTrusted" | "selection" | "bundling" | "grouper"> & {
+export type PlanOptions = Pick<ReviewOptions & ReviewHooks, "vcs" | "rules" | "readTrusted" | "selection" | "bundling" | "grouper" | "effort" | "roles"> & {
+    runId?: string;
     runtime?: AgentRuntime;
     reviewOnly?: ReadonlySet<string>;
     priorTier?: RiskTier;

package/dist/pipeline/plan.js

@@ -3,15 +3,17 @@ 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 { roleEffort } 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";
 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 });
+    emit({ type: "run_started", runId: options.runId ?? newRunId(), changeRequest });
     const diffs = await vcs.getDiff();
     const decisions = selectFiles(diffs, options.selection ?? defaultSelectionPolicy);
     const selected = decisions.filter((d) => d.selected).map((d) => d.diff);
@@ -29,7 +31,9 @@ export async function planReview(options, emit, signal) {
     ]);
     const usage = [];
     const grouper = options.grouper ??
-        (options.runtime ? runtimeGrouper(options.runtime, signal, (u) => usage.push(u)) : undefined);
+        (options.runtime
+            ? runtimeGrouper(options.runtime, signal, (u) => usage.push(u), roleEffort("helper", options))
+            : undefined);
     const widened = options.reviewOnly && options.priorTier && rank(tier) > rank(options.priorTier)
         ? { from: options.priorTier, to: tier }
         : undefined;

package/dist/pipeline/preview.d.ts

@@ -1,3 +1,4 @@
+import type { Effort } from "../contracts.js";
 import type { ChangeRequest, RiskTier } from "../domain.js";
 import type { ReviewerDefinition } from "../review/reviewer.js";
 import type { FileDecision } from "../select/select.js";
@@ -10,6 +11,7 @@ export interface PreviewTask {
     files: string[];
     promptTokens: number;
     planPromptTokens?: number;
+    effort?: Effort;
 }
 export interface ReviewPreview {
     changeRequest: ChangeRequest;

package/dist/pipeline/preview.js

@@ -3,6 +3,7 @@ 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 { reviewerEffort } from "./agents.js";
 import { isLargeBundle } from "./execute.js";
 import { planTasks } from "./matrix.js";
 import { planReview } from "./plan.js";
@@ -37,6 +38,9 @@ export async function previewReview(options) {
             files,
             promptTokens: tokens(prompt),
         };
+        const effort = reviewerEffort(cell.reviewer, options);
+        if (effort !== undefined)
+            task.effort = effort;
         const key = `${cell.reviewer.id}\0${cell.bundle.label}`;
         if ((options.ultra || isLargeBundle(cell.bundle.files)) && !plannedBundles.has(key)) {
             plannedBundles.add(key);