@rigour-labs/core 6.7.8 → 6.7.9

package/dist/review/reviewer/api-judge.d.ts

@@ -12,6 +12,11 @@ export interface ApiJudgeOptions {
     roots: string[];
     reasoning?: Reasoning;
     fetchImpl?: typeof fetch;
+    /** The review's input files, given inline in the first message: a model that never calls a tool still has what it needs. */
+    inputs?: Array<{
+        path: string;
+        text: string;
+    }>;
 }
 export interface ApiJudgeRun {
     exitCode: number;

package/dist/review/reviewer/api-judge.js

@@ -11,6 +11,10 @@ import path from 'path';
 import { execa } from 'execa';
 const SYSTEM = 'You review code with read-only tools. Read the files the task names with read_file (the review inputs are named by absolute path), search the repository with search, read history with git. When you are done, reply with the final answer the task asks for and nothing else.';
 const MAX_RESULT_CHARS = 60_000;
+/** Output tokens a turn may use, reasoning included: a review verdict is long, and a reasoning model's thinking counts against the default budget. */
+const MAX_OUTPUT_TOKENS = 32_000;
+/** Characters of the inputs given inline in the first message; the rest stays in the files, for the tools. */
+const MAX_INLINE_CHARS = 240_000;
 const GIT_ALLOWED = new Set(['log', 'show', 'diff', 'blame', 'grep', 'ls-files', 'rev-parse', 'merge-base']);
 /** Git options that write, or point git at another repository. */
 const GIT_REFUSED = /^(--output|-o$|--git-dir|--work-tree|-C$|--exec-path|-c$|--config-env)/;
@@ -24,7 +28,7 @@ const n = (v) => (typeof v === 'number' && Number.isFinite(v) ? v : 0);
 export async function runApiJudge(prompt, o) {
     const fetchImpl = o.fetchImpl ?? fetch;
     const deadline = Date.now() + o.timeoutMs;
-    const messages = [{ role: 'system', content: SYSTEM }, { role: 'user', content: prompt }];
+    const messages = [{ role: 'system', content: SYSTEM }, { role: 'user', content: withInputs(prompt, o.inputs ?? []) }];
     const usage = { input: 0, cacheRead: 0, cacheWrite: 0, output: 0 };
     const calls = [];
     let cost;
@@ -40,7 +44,7 @@ export async function runApiJudge(prompt, o) {
             response = await fetchImpl(`${o.url.replace(/\/$/, '')}/chat/completions`, {
                 method: 'POST',
                 headers: { 'content-type': 'application/json', authorization: `Bearer ${o.key}` },
-                body: JSON.stringify({ model: o.model, messages, tools: TOOLS, tool_choice: 'auto', ...(o.reasoning ? { reasoning_effort: o.reasoning } : {}) }),
+                body: JSON.stringify({ model: o.model, messages, tools: TOOLS, tool_choice: 'auto', max_tokens: MAX_OUTPUT_TOKENS, ...(o.reasoning ? { reasoning_effort: o.reasoning } : {}) }),
                 signal: controller.signal,
             });
         }
@@ -66,13 +70,22 @@ export async function runApiJudge(prompt, o) {
         usage.output += n(u.completion_tokens);
         if (typeof u.cost === 'number')
             cost = (cost ?? 0) + u.cost;
-        const message = body.choices?.[0]?.message;
+        const choice = body.choices?.[0];
+        // A gateway reports a provider's failure inside the choice, with the choice's finish_reason "error": say what it said.
+        if (choice?.error || body.error)
+            return fail(`the API reported an error: ${JSON.stringify(choice?.error ?? body.error).slice(0, 300)}`);
+        const message = choice?.message;
         if (!message)
             return fail('no choices in the answer');
-        messages.push(message);
+        // Echo back what the API needs to continue (reasoning_details carries a reasoning model's chain), not the reasoning prose.
+        messages.push({ role: 'assistant', content: message.content ?? null, ...(message.tool_calls ? { tool_calls: message.tool_calls } : {}), ...(message.reasoning_details ? { reasoning_details: message.reasoning_details } : {}) });
         const toolCalls = Array.isArray(message.tool_calls) ? message.tool_calls : [];
         if (toolCalls.length === 0) {
-            const answer = { result: String(message.content ?? ''), usage, ...(cost !== undefined ? { cost_usd: cost } : {}), trace: { turns: turn, usage, calls } };
+            const text = String(message.content ?? '').trim();
+            // An empty final message is not an answer: say why (the output budget ran out, a refusal), never report it as one.
+            if (!text)
+                return fail(`an empty answer on turn ${turn} (finish_reason ${String(body.choices?.[0]?.finish_reason ?? 'unknown')}${message.refusal ? `, refusal: ${String(message.refusal).slice(0, 120)}` : ''})`);
+            const answer = { result: text, usage, ...(cost !== undefined ? { cost_usd: cost } : {}), trace: { turns: turn, usage, calls } };
             return { exitCode: 0, stdout: JSON.stringify(answer), stderr: '' };
         }
         for (const call of toolCalls) {
@@ -83,6 +96,22 @@ export async function runApiJudge(prompt, o) {
     }
     return fail(`no answer within ${o.maxTurns} turns`);
 }
+/**
+ * The prompt with the inputs it names appended inline, smallest first so the diff takes what budget is left: a judge
+ * is fed, not left to decide whether to read. What does not fit is cut with a note naming the file to read.
+ */
+function withInputs(prompt, inputs) {
+    if (inputs.length === 0)
+        return prompt;
+    const ordered = [...inputs].sort((a, b) => a.text.length - b.text.length);
+    let left = MAX_INLINE_CHARS;
+    const parts = ordered.map(input => {
+        const text = input.text.length > left ? `${input.text.slice(0, Math.max(0, left))}\n…[cut here: read ${input.path} with read_file for the rest]` : input.text;
+        left = Math.max(0, left - input.text.length);
+        return `### ${input.path}\n${text}`;
+    });
+    return `${prompt}\n\nThe inputs named above, inline (the files are also there for your tools):\n\n${parts.join('\n\n')}`;
+}
 /** One tool call, inside the allowed roots only; the trace names tools as the CLI judges do (Read, Grep, Glob, Bash). */
 async function runTool(call, o) {
     const name = String(call?.function?.name ?? '');

package/dist/review/reviewer/api-judge.test.js

@@ -78,6 +78,27 @@ describe('the API judge', () => {
         const slow = (async (_u, init) => new Promise((_r, reject) => init.signal.addEventListener('abort', () => reject(new Error('aborted')))));
         expect(await runApiJudge('p', options(slow, { timeoutMs: 50 }))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('request failed') });
     });
+    it('fails closed on an empty final message, saying why, and echoes back only what the API needs to continue', async () => {
+        const empty = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '', reasoning: 'thinking…' }, finish_reason: 'length' }], usage: {} }), { status: 200 }));
+        expect(await runApiJudge('p', options(empty))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('an empty answer on turn 1 (finish_reason length)') });
+        const providerError = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '' }, finish_reason: 'error', error: { message: 'Provider returned error', code: 502 } }], usage: {} }), { status: 200 }));
+        expect(await runApiJudge('p', options(providerError))).toMatchObject({ exitCode: 1, stderr: expect.stringContaining('the API reported an error: {"message":"Provider returned error","code":502}') });
+        const { fetchImpl, seen } = model([{ tools: [{ name: 'list_dir', args: { path: '.' } }] }, { text: 'ok' }]);
+        await runApiJudge('p', options(fetchImpl));
+        const echoed = seen[1].messages.find((m) => m.role === 'assistant');
+        expect(Object.keys(echoed).sort()).toEqual(['content', 'role', 'tool_calls']); // no reasoning prose sent back
+        expect(seen[0].max_tokens).toBe(32000);
+    });
+    it('gives the judge its inputs inline, smallest first, the diff cut with a note when the budget runs out', async () => {
+        const { fetchImpl, seen } = model([{ text: 'ok' }]);
+        const inputs = [{ path: '/w/full.diff', text: 'x'.repeat(300_000) }, { path: '/w/pr-description.md', text: 'the description' }, { path: '/w/previous-reviews.md', text: 'the reviews' }];
+        await runApiJudge('review this', options(fetchImpl, { inputs }));
+        const first = seen[0].messages[1].content;
+        expect(first.startsWith('review this\n\nThe inputs named above, inline')).toBe(true);
+        expect(first.indexOf('### /w/previous-reviews.md')).toBeLessThan(first.indexOf('### /w/full.diff')); // smallest first
+        expect(first).toContain('…[cut here: read /w/full.diff with read_file for the rest]');
+        expect(first.length).toBeLessThan(241_000);
+    });
     it('passes the reasoning effort when asked', async () => {
         const { fetchImpl, seen } = model([{ text: 'ok' }]);
         await runApiJudge('p', options(fetchImpl, { reasoning: 'low' }));

package/dist/review/reviewer.js

@@ -208,8 +208,9 @@ async function review(cwd, base, config, exec, progress, options) {
         return none(settings.required.panel || settings.required.mode ? 'unavailable' : 'skipped', over, { reviewers, scope, why, pr: pr?.number });
     const work = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-reviewer-'));
     // One judge run, by CLI or by API: the same prompt, the same cost accounting, the same trace.
+    let inlineInputs = [];
     const runJudge = (name, prompt, model) => name === 'api'
-        ? runApiJudge(prompt, { url: settings.api.url, model: settings.api.model, key: process.env[settings.api.key_env] ?? '', maxTurns: settings.api.max_turns, timeoutMs: settings.timeout_ms, cwd, roots: [cwd, work], ...(settings.reasoning[name] ? { reasoning: settings.reasoning[name] } : {}), ...(options.fetch ? { fetchImpl: options.fetch } : {}) })
+        ? runApiJudge(prompt, { url: settings.api.url, model: settings.api.model, key: process.env[settings.api.key_env] ?? '', maxTurns: settings.api.max_turns, timeoutMs: settings.timeout_ms, cwd, roots: [cwd, work], inputs: inlineInputs, ...(settings.reasoning[name] ? { reasoning: settings.reasoning[name] } : {}), ...(options.fetch ? { fetchImpl: options.fetch } : {}) })
         : exec(installed.get(name).binary, ADAPTERS[name].args(prompt, model, { reasoning: settings.reasoning[name] }), { cwd, timeoutMs: settings.timeout_ms, unset: judgeUnset(name, settings.judge_env) });
     try {
         const file = (name, text) => {
@@ -223,6 +224,7 @@ async function review(cwd, base, config, exec, progress, options) {
         const diffFile = file('full.diff', fullDiff);
         const contextFile = file('team-knowledge.md', context.text);
         const hintsFile = file('hints.txt', options.hints?.trim() || 'none\n');
+        inlineInputs = [[reviewsFile, reviews.markdown], [prBodyFile, body], [diffstatFile, await git(['diff', '--stat', `${baseSha}...HEAD`])], [diffFile, fullDiff], [contextFile, context.text], [hintsFile, options.hints?.trim() || 'none\n']].map(([p, text]) => ({ path: p, text }));
         let delta = '';
         // A reviewer must report on the human reviews, unless every point was settled by the previous verdict and is carried.
         let needsPriorPoints = reviews.count > 0;
@@ -258,13 +260,29 @@ async function review(cwd, base, config, exec, progress, options) {
                     return { run, answer, verdict: run.exitCode === 0 || answer.text.trim() ? parseVerdict(answer.text, needsPriorPoints, name, answer) : undefined };
                 };
                 let first = await ask();
-                // An answer that is not a verdict is a slip, not a decision: asked once more, inside the caps, before the review is unavailable.
-                if (first.verdict && 'error' in first.verdict && !overBudget(store.spend(), settings, 1)) {
-                    progress(`Rigour reviewer: ${name} gave no valid verdict; asking once more`);
+                // No verdict, whether a malformed answer or a run that died, is a slip, not a decision: asked once more, inside the caps.
+                if ((!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`);
                     first = await ask();
                 }
                 return first.verdict ?? { error: `${name}: no answer (exit ${first.run.exitCode}): ${first.run.stderr.trim().slice(-200)}` };
             }));
+            // A judge that gives nothing is replaced by the next one installed, so the boundary stays up: a review ends unavailable only when every judge failed.
+            const spare = candidates.filter(c => installed.has(c) && !reviewers.includes(c));
+            for (let i = 0; i < answers.length; i++) {
+                let answer = answers[i];
+                while ('error' in answer && spare.length && !overBudget(store.spend(), settings, 1)) {
+                    const next = spare.shift();
+                    progress(`Rigour reviewer: ${reviewers[i]} gave no verdict (${answer.error}); ${next} judges instead`);
+                    modeRecord = { ...modeRecord, degraded: `${modeRecord.degraded ? `${modeRecord.degraded}; ` : ''}${reviewers[i]} gave no verdict, ${next} judged instead` };
+                    reviewers[i] = next;
+                    const run = await runJudge(next, prompt, modelFor(next));
+                    const got = ADAPTERS[next].answer(run.stdout);
+                    store.addSpend(1, got.costUsd);
+                    answer = run.exitCode === 0 || got.text.trim() ? parseVerdict(got.text, needsPriorPoints, next, got) : { error: `${next}: no answer (exit ${run.exitCode}): ${run.stderr.trim().slice(-200)}` };
+                }
+                answers[i] = answer;
+            }
             const failed = answers.find(a => 'error' in a);
             if (failed && 'error' in failed)
                 return none('unavailable', failed.error, { reviewers, scope, why, pr: pr?.number });

package/dist/review/reviewer.test.js

@@ -170,7 +170,7 @@ describe('the reviewer', () => {
         expect(hidden.outcome).toBe('passed');
         const shown = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, prior_points: [] }), seen), () => undefined, { pr: 42, reviewsBefore: '2026-10-04', force: true });
         expect(seen.files['previous-reviews.md']).toContain('Review by senior');
-        expect(shown).toMatchObject({ outcome: 'unavailable', reason: 'claude did not report on the human reviews' });
+        expect(shown).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('did not report on the human reviews') });
     });
     it('for a backtest, gives the description as it read at the review, never a later edit', async () => {
         const versions = { lastEditedAt: '2026-10-06T00:00:00Z', body: 'today: refunds are issued by the nightly job', userContentEdits: { totalCount: 3, nodes: [
@@ -200,7 +200,7 @@ describe('the reviewer', () => {
     });
     it('never passes without a verdict: a crash, a malformed answer, an unreadable pull request or no installed reviewer', async () => {
         const crashed = await runReviewer(repo, 'main', config, fakes(() => ({ exitCode: 1, stdout: '', stderr: 'API error' }), seenNow()), () => undefined);
-        expect(crashed).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('claude: no answer (exit 1)') });
+        expect(crashed).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('cursor: no answer (exit 1)'), mode: { degraded: expect.stringContaining('claude gave no verdict, cursor judged instead') } }); // asked twice, then the spare judge, which failed too
         const prose = await runReviewer(repo, 'main', config, fakes(() => 'Looks good to me!', seenNow()), () => undefined);
         expect(prose).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('no valid verdict') });
         const broken = async (command, args, options) => command === 'gh' && args[0] === 'pr' ? { exitCode: 1, stdout: '', stderr: 'HTTP 500' } : fakes(() => '', seenNow())(command, args, options);
@@ -283,16 +283,34 @@ describe('the reviewer', () => {
             delete process.env.TEST_JUDGE_KEY;
         }
     });
+    it('replaces a judge that gives nothing with the next one installed, and says so', async () => {
+        const seen = seenNow();
+        const silent = (async () => new Response(JSON.stringify({ choices: [{ message: { role: 'assistant', content: '' }, finish_reason: 'stop' }], usage: { prompt_tokens: 5, completion_tokens: 0 } }), { status: 200 }));
+        const twoJudges = ConfigSchema.parse({ version: 1, review: { reviewer: { enabled: true, reviewers: ['api', 'claude'], api: { url: 'https://example.test/v1', model: 'silent-model', key_env: 'TEST_JUDGE_KEY' } } } });
+        process.env.TEST_JUDGE_KEY = 'secret';
+        try {
+            const result = await runReviewer(repo, 'main', twoJudges, fakes(() => JSON.stringify(EMPTY), seen), () => undefined, { fetch: silent, force: true });
+            expect(result).toMatchObject({ outcome: 'passed', reviewers: ['claude'], mode: { degraded: expect.stringContaining('api gave no verdict, claude judged instead') } });
+            expect(seen.prompts).toHaveLength(1); // claude ran once, after the api judge's two empty answers
+        }
+        finally {
+            delete process.env.TEST_JUDGE_KEY;
+        }
+    });
     it('asks a judge once more after an answer that is not a verdict, and is unavailable only when the second is not one either', async () => {
         const seen = seenNow();
         let calls = 0;
         const slipOnce = await runReviewer(repo, 'main', config, fakes(() => (++calls === 1 ? '{"prior_points":[], "findings":[{"class"' : JSON.stringify(EMPTY)), seen), () => undefined, { force: true });
         expect(slipOnce.outcome).toBe('passed');
         expect(seen.prompts).toHaveLength(2);
+        let crashes = 0;
+        const crashOnce = seenNow();
+        const recovered = await runReviewer(repo, 'main', config, fakes(() => (++crashes === 1 ? { exitCode: 1, stdout: '', stderr: 'API error' } : JSON.stringify(EMPTY)), crashOnce), () => undefined, { force: true });
+        expect(recovered.outcome).toBe('passed'); // a run that died is asked once more too
         const twice = seenNow();
         const slipTwice = await runReviewer(repo, 'main', config, fakes(() => 'not json', twice), () => undefined, { force: true });
         expect(slipTwice).toMatchObject({ outcome: 'unavailable', reason: expect.stringContaining('no valid verdict') });
-        expect(twice.prompts).toHaveLength(2); // once more, never a loop
+        expect(twice.prompts).toHaveLength(3); // once more, then the spare judge once: never a loop
     });
     it('says what was asked and that nothing ran when a review ends early, with why a judge is missing', async () => {
         const seen = { ...seenNow(), installed: ['claude'] }; // cursor is listed but not installed

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.7.8",
+  "version": "6.7.9",
   "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"
@@ -72,11 +72,11 @@
     "@anthropic-ai/sdk": "^0.30.1",
     "pg": "^8.16.3",
     "openai": "^5.23.2",
-    "@rigour-labs/brain-darwin-arm64": "6.7.8",
-    "@rigour-labs/brain-darwin-x64": "6.7.8",
-    "@rigour-labs/brain-linux-x64": "6.7.8",
-    "@rigour-labs/brain-linux-arm64": "6.7.8",
-    "@rigour-labs/brain-win-x64": "6.7.8"
+    "@rigour-labs/brain-darwin-arm64": "6.7.9",
+    "@rigour-labs/brain-linux-arm64": "6.7.9",
+    "@rigour-labs/brain-linux-x64": "6.7.9",
+    "@rigour-labs/brain-darwin-x64": "6.7.9",
+    "@rigour-labs/brain-win-x64": "6.7.9"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",