@rigour-labs/core 6.11.0-rc.1 → 6.11.0-rc.2

package/dist/review/reviewer/settings.d.ts

@@ -35,6 +35,8 @@ export interface ResolvedReviewer {
     judges: 2 | 3;
     escalate: 'always' | 'risk';
     cross_models: Record<string, string>;
+    /** The cheap model per reviewer name for cheap-model-first tiering; empty when it is off (team only). */
+    tiers: Record<string, string>;
     /** Reasoning effort per reviewer name (codex, api). */
     reasoning: Record<string, 'low' | 'medium' | 'high'>;
     /** The API judge, when the team configured one (review.reviewer.api). */

package/dist/review/reviewer/settings.js

@@ -13,7 +13,7 @@ const RANK = { single: 0, cross: 1, full: 2 };
 /** How near a layer is to this run: the nearer wins. */
 const NEAR = { flag: 0, env: 1, user: 2, team: 3 };
 export function resolveReviewer(config, choice = {}, user = loadSettings().reviewer, env = process.env) {
-    const team = config.review?.reviewer ?? { enabled: false, on_push: 'background', reviewers: ['claude'], mode: 'single', models: {}, timeout_ms: 15 * 60_000, panel: 'off', mode_required: false, panel_max_items: 20, dismissals: false, orchestrator: 'off', judges: 2, escalate: 'always', cross_models: {}, judge_env: {}, reasoning: {} };
+    const team = config.review?.reviewer ?? { enabled: false, on_push: 'background', reviewers: ['claude'], mode: 'single', models: {}, timeout_ms: 15 * 60_000, panel: 'off', mode_required: false, panel_max_items: 20, dismissals: false, orchestrator: 'off', judges: 2, escalate: 'always', cross_models: {}, tiers: { cheap: {} }, judge_env: {}, reasoning: {} };
     const refused = [];
     const envMode = parseMode(env.RIGOUR_REVIEWER_MODE);
     const envPanel = parseSwitch(env.RIGOUR_REVIEWER_PANEL);
@@ -78,6 +78,7 @@ export function resolveReviewer(config, choice = {}, user = loadSettings().revie
         judges: floor ? Math.max(team.judges, user?.judges ?? team.judges) : user?.judges ?? team.judges,
         escalate: requiredEscalation(team, user, refused),
         cross_models: team.cross_models,
+        tiers: team.tiers?.cheap ?? {},
         judge_env: team.judge_env ?? {},
         reasoning: team.reasoning ?? {},
         ...(team.api ? { api: team.api } : {}),

package/dist/review/reviewer/store.d.ts

@@ -43,6 +43,8 @@ export interface ReviewCost {
     runs: number;
     /** A verdict reused instead of run: for the same content on another commit (`content`). Runs and actual cost are 0. */
     cache?: 'content';
+    /** The tier the review ran at, when cheap-model-first tiering is on (reviewer/tiering.ts). */
+    tier?: 'cheap' | 'strong';
 }
 /**
  * A verdict, findable by the content it reviewed rather than its commit: a rebase, an amend, a cherry-pick or the same

package/dist/review/reviewer/tiering.d.ts

@@ -0,0 +1,38 @@
+/**
+ * Cheap-model-first tiering (off by default; review.reviewer.tiers.cheap names a cheaper model per judge). Which model
+ * reviews a change is decided BEFORE any run, from facts about the change only: never by a model, and never from a
+ * model's findings. A change with something a cheaper model may miss gets the team's model:
+ *
+ *   a required floor, human reviews to check, open items carried from the last verdict, a migration, a security
+ *   finding from the checks, a declared goal, or a risky changed function (the router's score)
+ *
+ * Anything else gets the cheap model. After the run, the only escalation is an answer that is not a valid verdict: the
+ * one retry the reviewer already makes uses the team's model. What blocks is unchanged: the same evidence contract.
+ *
+ * The rule a tier must keep: on average, a review costs no more than one judge would have. Over the last
+ * TIER_WINDOW reviews tiering ran on, actual cost against what one judge would have been given (the frozen baseline's
+ * dollars per character, else characters); above it, tiering turns itself off and the review record says so.
+ */
+import type { CostBaseline, ReviewCost } from './store.js';
+export interface TierDecision {
+    tier: 'cheap' | 'strong';
+    /** The cheap model, when the tier is cheap. */
+    model?: string;
+    why: string;
+    /** Why tiering turned itself off, when it did. */
+    disabled?: string;
+    /** Why the cheap model's run was retried on the team's model: its answer was not a valid verdict. */
+    escalated?: string;
+}
+export interface TierFacts {
+    required: boolean;
+    humanReviews: number;
+    carried: number;
+    migration: boolean;
+    securityChecks: number;
+    goal: boolean;
+    /** Risky changed functions (the router's score); undefined when it could not score the change. */
+    risky: number | undefined;
+}
+/** The tier for one judge's review; undefined when no cheap model is set for it (tiering is off). */
+export declare function chooseTier(cheap: Record<string, string>, judge: string, facts: TierFacts, costs: ReviewCost[], baseline: CostBaseline | undefined): TierDecision | undefined;

package/dist/review/reviewer/tiering.js

@@ -0,0 +1,43 @@
+/** Recent tiered reviews the self-disable rule reads. */
+const TIER_WINDOW = 20;
+/** Tiered reviews needed before the rule can turn tiering off. */
+const TIER_MIN = 5;
+/** The tier for one judge's review; undefined when no cheap model is set for it (tiering is off). */
+export function chooseTier(cheap, judge, facts, costs, baseline) {
+    const model = cheap[judge];
+    if (!model)
+        return undefined;
+    const disabled = overBudget(costs, baseline);
+    if (disabled)
+        return { tier: 'strong', why: 'tiering turned itself off', disabled };
+    const strong = (why) => ({ tier: 'strong', why });
+    if (facts.required)
+        return strong('a required floor');
+    if (facts.humanReviews > 0)
+        return strong(`${facts.humanReviews} human review(s) to check`);
+    if (facts.carried > 0)
+        return strong(`${facts.carried} open item(s) carried from the last verdict`);
+    if (facts.migration)
+        return strong('the change adds or edits a migration');
+    if (facts.securityChecks > 0)
+        return strong(`${facts.securityChecks} security finding(s) from the checks`);
+    if (facts.goal)
+        return strong('the description declares a goal to check');
+    if (facts.risky === undefined)
+        return strong('the risk router could not score the change');
+    if (facts.risky > 0)
+        return strong(`${facts.risky} risky changed function(s)`);
+    return { tier: 'cheap', model, why: 'no risk signal: the cheap model' };
+}
+/** Why tiering must turn itself off: its recent reviews cost more, on average, than one judge would have. */
+function overBudget(costs, baseline) {
+    const tiered = costs.filter(c => c.tier).slice(-TIER_WINDOW);
+    if (tiered.length < TIER_MIN)
+        return undefined;
+    const rate = baseline?.usdPerChar ?? null;
+    const single = tiered.reduce((sum, c) => sum + c.projectedSingleChars * (rate ?? 1), 0);
+    const actual = tiered.reduce((sum, c) => sum + (rate === null ? c.actualChars : c.actualUsd > 0 ? c.actualUsd : c.actualChars * rate), 0);
+    if (single <= 0 || actual <= single)
+        return undefined;
+    return `the last ${tiered.length} tiered reviews cost ${(actual / single).toFixed(2)}x what one judge would have (${rate === null ? 'characters' : 'dollars'})`;
+}

package/dist/review/reviewer/triage.d.ts

@@ -31,6 +31,8 @@ export interface TriageContext {
 }
 /** Per specialist, the hunks it is for (by index); a specialist absent from the map is not needed. Prior points take the whole change. */
 export declare function triage(hunks: Hunk[], context: TriageContext): Map<string, number[]>;
+/** Whether a file is a migration or a schema (a change a cheaper model may miss the cost of). */
+export declare function isMigration(file: string): boolean;
 /** Whether no model reviews this file (SKIP). */
 export declare function skipped(file: string): boolean;
 export interface Pass {

package/dist/review/reviewer/triage.js

@@ -79,6 +79,10 @@ export function triage(hunks, context) {
         picked.set('prior-points', hunks.map((_, i) => i).filter(i => !skipped(hunks[i].file)));
     return picked;
 }
+/** Whether a file is a migration or a schema (a change a cheaper model may miss the cost of). */
+export function isMigration(file) {
+    return MIGRATION.test(file);
+}
 /** Whether no model reviews this file (SKIP). */
 export function skipped(file) {
     return SKIP.some(pattern => pattern.test(file));

package/dist/review/reviewer/usage.js

@@ -18,6 +18,7 @@ export function reviewerUsage(result, trigger) {
         judges: result.reviewers.length,
         cached: result.cached,
         ...(result.cache ? { cache: result.cache } : {}),
+        ...(mode?.tier ? { tier: mode.tier.tier, tier_disabled: !!mode.tier.disabled, tier_escalated: !!mode.tier.escalated } : {}),
         confirmed: result.items.length,
         disputed: result.disputed.length,
         dropped: result.dropped.length,

package/dist/review/reviewer.d.ts

@@ -2,6 +2,7 @@ import type { Config } from '../types/index.js';
 import { type ReviewerName, type Tokens } from './reviewer/adapters.js';
 import { type Exec, type Progress } from './reviewer/exec.js';
 import { type PanelItem } from './reviewer/panel.js';
+import { type TierDecision } from './reviewer/tiering.js';
 import { type RunChoice, type Source } from './reviewer/settings.js';
 import { type ReviewRecord } from './reviewer/record.js';
 import { type Accounting, type OpenItem, type PriorPoint } from './reviewer/verdict.js';
@@ -136,6 +137,8 @@ export interface ModeRecord {
     refused?: string[];
     /** With escalate: risk, why this review got one judge or all of them. */
     escalation?: string;
+    /** With cheap-model-first tiering on: the tier, why, and whether it turned itself off or escalated (reviewer/tiering.ts). */
+    tier?: TierDecision;
 }
 /** Findings and no verdict stop a push; a skipped review does not, and is reported as owed. */
 export declare function reviewerBlocks(result: ReviewerResult): boolean;

package/dist/review/reviewer.js

@@ -29,7 +29,8 @@ import { mergeImpact } from './reviewer/merge-impact.js';
 import { applyPanel, parseAnswers, runPanel } from './reviewer/panel.js';
 import { crossExamPrompt, deltaBlock, goalStep, mergeBlock, PROMPT_VERSION, renderPrompt } from './reviewer/prompt.js';
 import { BASELINE_MIN_SINGLES, focusBlock, formatLedger, ledger, passLimit, runPasses, SPECIALISTS, SPECIALISTS_KEY, splitNeeds } from './reviewer/orchestrator.js';
-import { MAX_PARTS, parseHunks, planPasses, reviewable, skipped, triage } from './reviewer/triage.js';
+import { isMigration, MAX_PARTS, parseHunks, planPasses, reviewable, skipped, triage } from './reviewer/triage.js';
+import { chooseTier } from './reviewer/tiering.js';
 import { modelGoalItems, parseGoal } from '../goal/goal.js';
 import { resolveSwitch } from '../switches.js';
 import { resolveReviewer } from './reviewer/settings.js';
@@ -224,7 +225,17 @@ async function review(cwd, base, config, exec, progress, options) {
     const previousOpen = scope === 'delta' ? store.readJson(store.openPath(previous.verdict)) ?? [] : undefined;
     const verify = checkoutVerifier(cwd);
     const prior = { approvals: reviews.approvals, inCheckout: checkoutSearch(cwd), changed: changedLinesOf(fullDiff), labels: reviews.labels };
-    const modelFor = (name) => settings.models[name] ?? (name === 'claude' ? settings.model : undefined);
+    // Cheap-model-first (reviewer/tiering.ts): decided before any run, from facts about the change only, for one judge.
+    let tier = reviewers.length === 1 && (modeRecord.ran === 'single' || modeRecord.ran === 'orchestrator')
+        ? chooseTier(settings.tiers, reviewers[0], {
+            required: settings.required.mode || settings.required.panel || orchestrator.required, humanReviews: reviews.count, carried: previousOpen?.length ?? 0,
+            migration: changedFiles.some(isMigration), securityChecks: (options.checks ?? []).filter(c => /\bsecurity\b/i.test(c)).length, goal: goalItems.length > 0, risky: context.risky,
+        }, store.costs(), store.baseline())
+        : undefined;
+    if (tier)
+        modeRecord = { ...modeRecord, tier };
+    const cheapModel = () => (tier?.tier === 'cheap' && !tier.escalated ? tier.model : undefined);
+    const modelFor = (name) => (name === reviewers[0] ? cheapModel() : undefined) ?? settings.models[name] ?? (name === 'claude' ? settings.model : undefined);
     // The record of the review, written beside the verdict once and rebuilt from the same verdict on a cached read.
     // What a judge reads besides the repository and Rigour's inputs, on this machine: on the record, so "the same judge" is a claim it can check.
     const outsideOf = (reviewer) => {
@@ -323,7 +334,7 @@ async function review(cwd, base, config, exec, progress, options) {
         store.recordCost({
             at: new Date().toISOString(), mode: orchestrated ? 'orchestrator' : 'single', lines: size.lines, projectedSingleChars: projectedSingle,
             ...(orchestrated ? { projectedChars: passes.reduce((sum, pass) => sum + shared + pass.diff.length, 0) } : {}),
-            actualChars: tally.chars, actualUsd: spentUsd(), runs: tally.runs,
+            actualChars: tally.chars, actualUsd: spentUsd(), runs: tally.runs, ...(tier ? { tier: tier.tier } : {}),
         });
     };
     // One judge run, by CLI or by API: the same prompt, the same cost accounting, the same trace.
@@ -438,6 +449,11 @@ async function review(cwd, base, config, exec, progress, options) {
                     // No verdict, whether a malformed answer or a run that died, is a slip, not a decision: asked once more, inside the caps.
                     if (!once && (!first.verdict || 'error' in first.verdict) && !overBudget(store.spend(), settings, 1)) {
                         progress(`Rigour reviewer: ${name} gave no ${first.verdict ? 'valid verdict' : 'answer'}; asking once more`);
+                        // The cheap model's slip is the one escalation: the retry runs on the team's model.
+                        if (cheapModel()) {
+                            tier = { ...tier, escalated: 'no valid verdict from the cheap model: retried on the team\'s model' };
+                            modeRecord = { ...modeRecord, tier };
+                        }
                         first = await ask();
                     }
                     return first.verdict ?? { error: `${name}: no answer (exit ${first.run.exitCode}): ${first.run.stderr.trim().slice(-200)}` };

package/dist/switches.d.ts

@@ -301,6 +301,9 @@ export declare const SWITCHES: {
                     judges: 2 | 3;
                     escalate: "always" | "risk";
                     cross_models: Record<string, string>;
+                    tiers: {
+                        cheap: Record<string, string>;
+                    };
                     reasoning: Record<string, "high" | "medium" | "low">;
                     judge_env: Record<string, {
                         unset: string[];
@@ -614,6 +617,9 @@ export declare const SWITCHES: {
                     judges: 2 | 3;
                     escalate: "always" | "risk";
                     cross_models: Record<string, string>;
+                    tiers: {
+                        cheap: Record<string, string>;
+                    };
                     reasoning: Record<string, "high" | "medium" | "low">;
                     judge_env: Record<string, {
                         unset: string[];
@@ -927,6 +933,9 @@ export declare const SWITCHES: {
                     judges: 2 | 3;
                     escalate: "always" | "risk";
                     cross_models: Record<string, string>;
+                    tiers: {
+                        cheap: Record<string, string>;
+                    };
                     reasoning: Record<string, "high" | "medium" | "low">;
                     judge_env: Record<string, {
                         unset: string[];

package/dist/templates/universal-config.js

@@ -305,6 +305,7 @@ export const UNIVERSAL_CONFIG = {
             judges: 2,
             escalate: 'always',
             cross_models: {},
+            tiers: { cheap: {} },
             judge_env: {},
             reasoning: {},
         },

package/dist/types/index.d.ts

@@ -2551,6 +2551,17 @@ export declare const ConfigSchema: z.ZodObject<{
             escalate: z.ZodDefault<z.ZodOptional<z.ZodEnum<["always", "risk"]>>>;
             /** A model per reviewer name for cross-examination (a narrow verification task), e.g. { claude: "haiku" }. */
             cross_models: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            /**
+             * Cheap-model-first (reviewer/tiering.ts), off unless set: a cheaper model per reviewer name for a change with no
+             * risk signal. Experimental: not to be recommended until a backtest shows what the cheap model misses.
+             */
+            tiers: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+                cheap: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>>;
+            }, "strip", z.ZodTypeAny, {
+                cheap: Record<string, string>;
+            }, {
+                cheap?: Record<string, string> | undefined;
+            }>>>;
             /** Reasoning effort per reviewer name where the CLI or API takes one (codex, api): low, medium or high. */
             reasoning: z.ZodDefault<z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodEnum<["low", "medium", "high"]>>>>;
             /**
@@ -2603,6 +2614,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges: 2 | 3;
             escalate: "always" | "risk";
             cross_models: Record<string, string>;
+            tiers: {
+                cheap: Record<string, string>;
+            };
             reasoning: Record<string, "high" | "medium" | "low">;
             judge_env: Record<string, {
                 unset: string[];
@@ -2635,6 +2649,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges?: 2 | 3 | undefined;
             escalate?: "always" | "risk" | undefined;
             cross_models?: Record<string, string> | undefined;
+            tiers?: {
+                cheap?: Record<string, string> | undefined;
+            } | undefined;
             reasoning?: Record<string, "high" | "medium" | "low"> | undefined;
             api?: {
                 model: string;
@@ -2666,6 +2683,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges: 2 | 3;
             escalate: "always" | "risk";
             cross_models: Record<string, string>;
+            tiers: {
+                cheap: Record<string, string>;
+            };
             reasoning: Record<string, "high" | "medium" | "low">;
             judge_env: Record<string, {
                 unset: string[];
@@ -2705,6 +2725,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges?: 2 | 3 | undefined;
             escalate?: "always" | "risk" | undefined;
             cross_models?: Record<string, string> | undefined;
+            tiers?: {
+                cheap?: Record<string, string> | undefined;
+            } | undefined;
             reasoning?: Record<string, "high" | "medium" | "low"> | undefined;
             api?: {
                 model: string;
@@ -3007,6 +3030,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges: 2 | 3;
             escalate: "always" | "risk";
             cross_models: Record<string, string>;
+            tiers: {
+                cheap: Record<string, string>;
+            };
             reasoning: Record<string, "high" | "medium" | "low">;
             judge_env: Record<string, {
                 unset: string[];
@@ -3320,6 +3346,9 @@ export declare const ConfigSchema: z.ZodObject<{
             judges?: 2 | 3 | undefined;
             escalate?: "always" | "risk" | undefined;
             cross_models?: Record<string, string> | undefined;
+            tiers?: {
+                cheap?: Record<string, string> | undefined;
+            } | undefined;
             reasoning?: Record<string, "high" | "medium" | "low"> | undefined;
             api?: {
                 model: string;

package/dist/types/index.js

@@ -458,6 +458,11 @@ export const ConfigSchema = z.object({
             escalate: z.enum(['always', 'risk']).optional().default('always'),
             /** A model per reviewer name for cross-examination (a narrow verification task), e.g. { claude: "haiku" }. */
             cross_models: z.record(ModelName).optional().default({}),
+            /**
+             * Cheap-model-first (reviewer/tiering.ts), off unless set: a cheaper model per reviewer name for a change with no
+             * risk signal. Experimental: not to be recommended until a backtest shows what the cheap model misses.
+             */
+            tiers: z.object({ cheap: z.record(ModelName).optional().default({}) }).optional().default({}),
             /** Reasoning effort per reviewer name where the CLI or API takes one (codex, api): low, medium or high. */
             reasoning: z.record(z.enum(['low', 'medium', 'high'])).optional().default({}),
             /**

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.11.0-rc.1",
+  "version": "6.11.0-rc.2",
   "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22.13"
@@ -75,11 +75,11 @@
     "@anthropic-ai/sdk": "^0.132.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-x64": "6.11.0-rc.1",
-    "@rigour-labs/brain-linux-arm64": "6.11.0-rc.1",
-    "@rigour-labs/brain-linux-x64": "6.11.0-rc.1",
-    "@rigour-labs/brain-darwin-arm64": "6.11.0-rc.1",
-    "@rigour-labs/brain-win-x64": "6.11.0-rc.1"
+    "@rigour-labs/brain-darwin-arm64": "6.11.0-rc.2",
+    "@rigour-labs/brain-linux-x64": "6.11.0-rc.2",
+    "@rigour-labs/brain-linux-arm64": "6.11.0-rc.2",
+    "@rigour-labs/brain-win-x64": "6.11.0-rc.2",
+    "@rigour-labs/brain-darwin-x64": "6.11.0-rc.2"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",