@rigour-labs/core 6.6.6 → 6.7.1

package/dist/review/reviewer.js

@@ -25,8 +25,13 @@ import { ADAPTERS, isReviewerName, resolveAdapter, selectReviewers, vendorsOf }
 import { defaultExec, GH_TIMEOUT_MS, githubEnv } from './reviewer/exec.js';
 import { findPullRequest, ghFor, humanReviews, linesChanged, mergesBaseIn, rulesText, sha } from './reviewer/inputs.js';
 import { mergeImpact } from './reviewer/merge-impact.js';
-import { deltaBlock, mergeBlock, PROMPT_VERSION, renderPrompt } from './reviewer/prompt.js';
+import { applyPanel, parseAnswers, runPanel } from './reviewer/panel.js';
+import { crossExamPrompt, deltaBlock, mergeBlock, PROMPT_VERSION, renderPrompt } from './reviewer/prompt.js';
+import { resolveReviewer } from './reviewer/settings.js';
 import { VerdictStore } from './reviewer/store.js';
+import { trackUsage } from '../telemetry/telemetry.js';
+import { reviewerUsage } from './reviewer/usage.js';
+import { buildContext, dismissedAs, readReviewDismissals, relatedDocs } from './reviewer/context.js';
 import { account, carryResolved, evidenceTouched, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
 export { defaultExec, githubEnv, parseJsonArrays } from './reviewer/exec.js';
 export { itemLine } from './reviewer/verdict.js';
@@ -37,20 +42,33 @@ export function reviewerBlocks(result) {
 const PROGRESS_EVERY_MS = 60_000;
 const MAX_DELTAS = 4;
 const MAX_DELTA_LINES = 400;
+/** The reviewer, and one anonymous usage event for what it did (only when the person opted in to telemetry). */
 export async function runReviewer(cwd, base, config, exec = defaultExec, progress = message => process.stderr.write(`${message}\n`), options = {}) {
-    const settings = config.review?.reviewer ?? { enabled: false, on_push: 'background', reviewers: ['claude'], mode: 'single', models: {}, timeout_ms: 15 * 60_000 };
+    const result = await review(cwd, base, config, exec, progress, options);
+    await trackUsage('reviewer_completed', reviewerUsage(result, options.trigger ?? (options.reviewsBefore ? 'backtest' : 'review')));
+    return result;
+}
+async function review(cwd, base, config, exec, progress, options) {
+    const settings = resolveReviewer(config, { ...options.choice, ...(options.full ? { mode: 'full' } : {}) });
     const trigger = options.trigger ?? (options.reviewsBefore ? 'backtest' : 'review');
     const git = async (args) => (await exec('git', args, { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout.trim();
     const head = await git(['rev-parse', 'HEAD']);
     const baseSha = await git(['rev-parse', `${base}^{commit}`]);
     const branch = options.branch ?? await git(['rev-parse', '--abbrev-ref', 'HEAD']);
     const repoRoot = (await git(['rev-parse', '--show-toplevel'])) || cwd;
-    const none = (outcome, reason, extra = {}) => ({ outcome, items: [], unverified: [], resolved: [], answerInReply: [], reason, reviewers: [], cached: false, ...extra });
+    let attempts;
+    // A review that ends without a verdict says why where the person looks (status, Studio, MCP), not only in a log.
+    const none = (outcome, reason, extra = {}) => {
+        if (attempts && branch !== 'HEAD')
+            attempts.recordAttempt(branch, { head, outcome, reason, at: new Date().toISOString() });
+        return { outcome, items: [], unverified: [], resolved: [], answerInReply: [], notes: [], disputed: [], dropped: [], dismissed: [], reason, reviewers: [], cached: false, ...extra };
+    };
     if (!head || !baseSha)
         return none('unavailable', `not a repository, or ${base} is unknown`);
     const store = await VerdictStore.open(cwd, exec);
     if (!store)
         return none('unavailable', 'no git directory to keep verdicts in');
+    attempts = store;
     const candidates = settings.reviewers.filter(isReviewerName);
     const installed = new Map();
     for (const name of candidates) {
@@ -59,11 +77,14 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             installed.set(name, found);
     }
     const authors = vendorsOf(await git(['log', '--format=%(trailers:key=Co-Authored-By,valueonly)%(trailers:key=Co-authored-by,valueonly)', `${baseSha}..HEAD`]));
-    const mode = options.full ? 'full' : settings.mode;
-    const reviewers = selectReviewers(candidates, mode, authors, new Set(installed.keys()));
+    const mode = settings.mode;
+    let reviewers = selectReviewers(candidates, mode, authors, new Set(installed.keys()), settings.judges);
     if (reviewers.length === 0)
         return none('unavailable', `no reviewer installed: ${candidates.map(n => ADAPTERS[n].binary).join(', ') || 'review.reviewer.reviewers is empty'}`);
-    const reviewerVersions = reviewers.map(name => `${name} ${installed.get(name).version}`).join(';');
+    let modeRecord = modeRan(settings, reviewers, candidates, installed);
+    if (reviewers.length < 2 && mode === 'full' && (settings.required.panel || settings.required.mode)) {
+        return none('unavailable', `rigour.yml requires two reviewers from different vendors, and ${modeRecord.degraded}`, { reviewers, mode: modeRecord });
+    }
     const gh = ghFor(cwd, exec, await githubEnv(cwd, config.review?.github_account ?? process.env.RIGOUR_GITHUB_ACCOUNT, exec));
     const found = await findPullRequest(gh, branch, head, options.pr);
     if (found.error)
@@ -81,11 +102,41 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             return none('unavailable', read.error, { reviewers, pr: pr.number });
         reviews = read.reviews;
     }
+    const stateRoot = options.stateRoot ?? cwd;
+    // Dismissals count only where the team allows them; otherwise the file, if any, is ignored.
+    const dismissals = settings.dismissals ? readReviewDismissals(stateRoot) : [];
     const body = pr?.body || '(no pull request description)\n';
     const rules = rulesText(cwd);
+    const previous = branch !== 'HEAD' ? store.branchState(branch) : undefined;
+    // The same commit, asked again with the same settings and reviews (the background run, then the person): the verdict it already has.
+    const inputsKey = sha([PROMPT_VERSION, rules, body, reviews.key, JSON.stringify([settings.mode, settings.panel, settings.judges, settings.escalate, settings.panel_max_items, settings.cross_models, settings.models, candidates]), [...installed].map(([n, i]) => `${n} ${i.version}`).join(';')]);
+    if (!options.force && previous?.head === head && previous.inputsKey === inputsKey && fs.existsSync(store.decidedPath(previous.verdict))) {
+        const verdict = store.readJson(previous.verdict);
+        const decided = store.readJson(store.decidedPath(previous.verdict));
+        if (verdict && decided)
+            return result(redismiss(decided, dismissals), verdict, verdict.inputs?.reviewers ?? reviewers, previous.mode, 'same commit and inputs as the last verdict', true, reviews, pr, verdict.inputs?.mode ?? modeRecord, settings.dismissals);
+    }
+    // What the team already knows, for every judge; built once, and its risk count decides escalation.
+    const fullDiff = (await exec('git', ['diff', `${baseSha}...HEAD`], { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout;
+    const previousIsAncestor = !!previous && previous.head !== head && fs.existsSync(previous.verdict) && (await exec('git', ['merge-base', '--is-ancestor', previous.head, 'HEAD'], { cwd, timeoutMs: GH_TIMEOUT_MS })).exitCode === 0;
+    const sincePrevious = previousIsAncestor ? new Set((await git(['diff', '--name-only', `${previous.head}..HEAD`])).split('\n').filter(Boolean)) : new Set();
+    const changedFiles = [...fullDiff.matchAll(/^diff --git a\/.* b\/(.*)$/gm)].map(m => m[1]);
+    const context = buildContext({
+        cwd, stateRoot, dismissals, diff: fullDiff, router: config.gates.deep?.router, touched: sincePrevious, checks: options.checks ?? [],
+        previousPanel: previousIsAncestor ? store.readJson(previous.verdict)?.panel?.items : undefined,
+        docs: await relatedDocs(cwd, changedFiles, exec),
+    });
+    // escalate: risk. More judges only where a second opinion can change the outcome; the --full hard stop always gets them.
+    if (settings.escalate === 'risk' && reviewers.length > 1 && !options.full) {
+        const escalation = escalationFor(reviews.count, context.risky);
+        if (!escalation.escalate)
+            reviewers = reviewers.slice(0, 1);
+        modeRecord = { ...modeRecord, ...(escalation.escalate ? {} : { ran: 'single' }), escalation: escalation.why };
+    }
+    const reviewerVersions = reviewers.map(name => `${name} ${installed.get(name).version}`).join(';');
+    // What changes the instructions themselves; the context pack changes with every commit, so it is in the fingerprint, not here.
     const rulesHash = sha([reviewerVersions, PROMPT_VERSION, rules, body, reviews.key]);
     // Full or delta.
-    const previous = branch !== 'HEAD' ? store.branchState(branch) : undefined;
     const mergedBase = await mergesBaseIn(cwd, baseSha, exec);
     let scope = 'full';
     let why;
@@ -93,7 +144,7 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
         why = 'full review requested';
     else if (!previous || !fs.existsSync(previous.verdict))
         why = `no earlier verdict on ${branch}`;
-    else if ((await exec('git', ['merge-base', '--is-ancestor', previous.head, 'HEAD'], { cwd, timeoutMs: GH_TIMEOUT_MS })).exitCode !== 0)
+    else if (previous.head !== head && !previousIsAncestor)
         why = `last reviewed commit ${previous.head.slice(0, 9)} is not an ancestor (rebase or amend)`;
     else if (mergedBase)
         why = `HEAD merges ${base}`;
@@ -112,16 +163,19 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
         why = `since ${previous.head.slice(0, 9)}`;
     }
     const previousVerdictText = scope === 'delta' ? fs.readFileSync(previous.verdict, 'utf8') : '';
-    const fingerprint = sha([head, baseSha, scope, reviewerVersions, PROMPT_VERSION, rules, body, reviews.key, previousVerdictText]);
+    const fingerprint = sha([head, baseSha, scope, modeRecord.ran, context.key, inputsKey, reviewerVersions, previousVerdictText]);
     const verdictFile = store.verdictPath(head, fingerprint);
     const openFile = store.openPath(verdictFile);
     const previousOpen = scope === 'delta' ? store.readJson(store.openPath(previous.verdict)) ?? [] : undefined;
     const verify = verifier(cwd);
     if (!options.force && fs.existsSync(verdictFile) && fs.existsSync(openFile)) {
         const verdict = store.readJson(verdictFile);
-        const accounted = account(verdict, previousOpen, verify);
-        return result(accounted, verdict, reviewers, scope, why, true, reviews, pr);
+        return result(decide(verdict, previousOpen, verify, dismissals), verdict, reviewers, scope, why, true, reviews, pr, modeRecord, settings.dismissals);
     }
+    // The daily caps, before any judge starts: a cached or reused verdict above cost nothing and never reaches here.
+    const over = overBudget(store.spend(), settings, reviewers.length);
+    if (over)
+        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-'));
     try {
         const file = (name, text) => {
@@ -132,7 +186,8 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
         const reviewsFile = file('previous-reviews.md', reviews.markdown);
         const prBodyFile = file('pr-description.md', body);
         const diffstatFile = file('diffstat.txt', await git(['diff', '--stat', `${baseSha}...HEAD`]));
-        const diffFile = file('full.diff', (await exec('git', ['diff', `${baseSha}...HEAD`], { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout);
+        const diffFile = file('full.diff', fullDiff);
+        const contextFile = file('team-knowledge.md', context.text);
         const hintsFile = file('hints.txt', options.hints?.trim() || 'none\n');
         let delta = '';
         // A reviewer must report on the human reviews, unless every point was settled by the previous verdict and is carried.
@@ -142,8 +197,7 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             const commitsFile = file('delta-commits.txt', await git(['log', '--format=%h %s', `${previous.head}..HEAD`]));
             const deltaDiffFile = file('delta.diff', (await exec('git', ['diff', `${previous.head}..HEAD`], { cwd, timeoutMs: GH_TIMEOUT_MS })).stdout);
             // Human points the previous verdict resolved, whose files the new commits leave alone, are not judged again.
-            const touchedFiles = new Set((await git(['diff', '--name-only', `${previous.head}..HEAD`])).split('\n').filter(Boolean));
-            const settled = (store.readJson(previous.verdict)?.prior_points ?? []).filter(p => p.resolved && !evidenceTouched(p.evidence, touchedFiles));
+            const settled = (store.readJson(previous.verdict)?.prior_points ?? []).filter(p => p.resolved && !evidenceTouched(p.evidence, sincePrevious));
             const settledFile = file('previous-resolved.json', JSON.stringify(settled, null, 2));
             delta = deltaBlock(previous.head, previous.verdict, previousOpenFile, commitsFile, deltaDiffFile, settledFile);
             if (settled.length)
@@ -154,20 +208,21 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             const impact = await mergeImpact(cwd, await git(['merge-base', 'HEAD^1', 'HEAD^2']), 'HEAD^2', 'HEAD', exec);
             merge = mergeBlock(base, impact ? file('merge-impact.md', impact) : undefined);
         }
-        const prompt = renderPrompt({ repoRoot, branch, head: head.slice(0, 9), base, baseSha, mode: scope, reviewsFile, humanCount: reviews.count, prBodyFile, diffstatFile, diffFile, hintsFile, deltaBlock: delta, mergeBlock: merge });
+        const prompt = renderPrompt({ repoRoot, branch, head: head.slice(0, 9), base, baseSha, mode: scope, reviewsFile, humanCount: reviews.count, prBodyFile, diffstatFile, diffFile, hintsFile, contextFile, deltaBlock: delta, mergeBlock: merge });
         progress(`Rigour reviewer: reviewing ${head.slice(0, 9)} against ${base} (${scope}: ${why}; ${reviews.count} human review(s), written by ${[...authors].join(', ') || 'a person'}) with ${reviewers.join(', ')}`);
+        const modelFor = (name) => settings.models[name] ?? (name === 'claude' ? settings.model : undefined);
         const started = Date.now();
         const ticker = setInterval(() => progress(`Rigour reviewer: still working (${Math.round((Date.now() - started) / 60_000)} min)`), PROGRESS_EVERY_MS);
         let parts;
         try {
             const answers = await Promise.all(reviewers.map(async (name) => {
                 const adapter = ADAPTERS[name];
-                const model = settings.models[name] ?? (name === 'claude' ? settings.model : undefined);
-                const run = await exec(installed.get(name).binary, adapter.args(prompt, model), { cwd, timeoutMs: settings.timeout_ms });
+                const run = await exec(installed.get(name).binary, adapter.args(prompt, modelFor(name)), { cwd, timeoutMs: settings.timeout_ms });
                 progress(`Rigour reviewer: ${name} finished in ${Math.round((Date.now() - started) / 1000)}s (exit ${run.exitCode})`);
                 const answer = adapter.answer(run.stdout);
+                store.addSpend(1, answer.costUsd); // every run counts against the caps, an answer or not
                 return run.exitCode === 0 || answer.text.trim()
-                    ? parseVerdict(answer.text, needsPriorPoints, name, answer.costUsd)
+                    ? parseVerdict(answer.text, needsPriorPoints, name, answer)
                     : { error: `${name}: no answer (exit ${run.exitCode}): ${run.stderr.trim().slice(-200)}` };
             }));
             const failed = answers.find(a => 'error' in a);
@@ -179,19 +234,115 @@ export async function runReviewer(cwd, base, config, exec = defaultExec, progres
             clearInterval(ticker);
         }
         const merged = mergeVerdicts(parts); // one part too: every item is tagged with who found it
-        const touched = scope === 'delta' ? new Set((await git(['diff', '--name-only', `${previous.head}..HEAD`])).split('\n').filter(Boolean)) : new Set();
-        const verdict = scope === 'delta' ? carryResolved(merged, store.readJson(previous.verdict), touched) : merged;
-        const accounted = account(verdict, previousOpen, verify);
-        store.writeJson(verdictFile, { ...verdict, inputs: { head, base: baseSha, scope, why, reviewers, versions: reviewerVersions, authors: [...authors], fingerprint, human_reviews: reviews.count, reviews_before: options.reviewsBefore ?? null, since: previous?.head ?? null, at: new Date().toISOString() } });
+        const touched = scope === 'delta' ? sincePrevious : new Set();
+        let verdict = scope === 'delta' ? carryResolved(merged, store.readJson(previous.verdict), touched) : merged;
+        if (modeRecord.ran === 'panel' && parts.length > 1) {
+            // Each judge's own blocking items, unmerged: the panel groups them into findings and decides each one.
+            const judgeItems = parts.map(part => account({ ...part, prior_points: [], carried: [], resolved_previous: [] }, undefined, verify).open);
+            const previousPanel = scope === 'delta' ? store.readJson(previous.verdict)?.panel : undefined;
+            const cross = [];
+            let reserved = 0;
+            const items = await runPanel({
+                judges: parts.map(part => part.reviewer),
+                items: judgeItems,
+                // Only what judges actually disagreed on: a finding parked by the item cap was never asked.
+                previousDisputed: (previousPanel?.items ?? []).filter(d => d.status === 'disputed' && d.cross?.length).map(d => d.item),
+                evidenced: text => evidenceNames(text).some(([file, line]) => verify(file, line)),
+                touched,
+                maxItems: settings.panel_max_items,
+                // Judges cross-examine at the same time: a run is reserved when allowed, so together they never pass the cap.
+                capped: () => {
+                    const spent = store.spend();
+                    const reason = overBudget({ ...spent, runs: spent.runs + reserved }, settings, 1);
+                    if (!reason)
+                        reserved++;
+                    return reason;
+                },
+                ask: async (judge, asked) => {
+                    const name = judge;
+                    const run = await exec(installed.get(name).binary, ADAPTERS[name].args(crossExamPrompt(repoRoot, head.slice(0, 9), diffFile, asked), settings.cross_models[name] ?? modelFor(name)), { cwd, timeoutMs: settings.timeout_ms });
+                    const answer = ADAPTERS[name].answer(run.stdout);
+                    store.addSpend(1, answer.costUsd);
+                    reserved--;
+                    cross.push({ reviewer: `${name} cross-exam`, ...(answer.costUsd !== undefined ? { cost_usd: answer.costUsd } : {}), ...(answer.tokens ? { tokens: answer.tokens } : {}) });
+                    progress(`Rigour reviewer: ${name} cross-examined ${asked.length} finding(s) (exit ${run.exitCode})`);
+                    return parseAnswers(answer.text);
+                },
+            });
+            verdict = { ...verdict, panel: { judgeItemIds: judgeItems.flat().map(item => item.id), items }, reviewers: [...(verdict.reviewers ?? []), ...cross] };
+        }
+        const accounted = decide(verdict, previousOpen, verify, dismissals);
+        store.writeJson(verdictFile, { ...verdict, inputs: { head, base: baseSha, scope, why, mode: modeRecord, reviewers, versions: reviewerVersions, authors: [...authors], fingerprint, human_reviews: reviews.count, reviews_before: options.reviewsBefore ?? null, since: previous?.head ?? null, at: new Date().toISOString() } });
         store.writeJson(openFile, accounted.open);
+        store.writeJson(store.decidedPath(verdictFile), accounted);
         if (branch !== 'HEAD')
-            store.recordBranch(branch, { head, verdict: verdictFile, mode: scope, rulesHash, reviewsKey: reviews.key });
-        return result(accounted, verdict, reviewers, scope, why, false, reviews, pr);
+            store.recordBranch(branch, { head, verdict: verdictFile, mode: scope, rulesHash, reviewsKey: reviews.key, inputsKey });
+        return result(accounted, verdict, reviewers, scope, why, false, reviews, pr, modeRecord, settings.dismissals);
     }
     finally {
         fs.rmSync(work, { recursive: true, force: true });
     }
 }
+/** The accounting a verdict leads to: with a panel, only what it confirmed blocks; a finding the team dismissed never blocks. */
+function decide(verdict, previousOpen, verify, dismissals) {
+    const accounted = account(verdict, previousOpen, verify);
+    // An item an earlier round confirmed stays open until it is resolved with evidence, whatever this panel says of it.
+    const earlier = new Set((previousOpen ?? []).map(item => item.id));
+    const decided = verdict.panel
+        ? applyPanel(accounted, new Set(verdict.panel.judgeItemIds.filter(id => !earlier.has(id))), verdict.panel.items.filter(d => !earlier.has(d.item.id)))
+        : { ...accounted, disputed: [], dropped: [] };
+    return redismiss({ ...decided, dismissed: [] }, dismissals);
+}
+/** A finding the team dismissed leaves what blocks, now: at decision time and when a stored decision is read again. */
+function redismiss(decided, dismissals) {
+    const dismissed = decided.open.filter(item => dismissedAs(item, dismissals));
+    return dismissed.length ? { ...decided, open: decided.open.filter(item => !dismissed.includes(item)), dismissed: [...decided.dismissed, ...dismissed] } : decided;
+}
+/** Every `file:line` an answer quotes. */
+function evidenceNames(text) {
+    return [...text.matchAll(/([\w./-]+\.[A-Za-z0-9]+):(\d+)/g)].map(m => [m[1], Number(m[2])]);
+}
+/** Why the caps leave no room for `planned` more runs today, or nothing when they do. */
+function overBudget(spent, caps, planned) {
+    if (caps.max_runs_per_day !== undefined && spent.runs + planned > caps.max_runs_per_day)
+        return `the daily run cap is reached: ${spent.runs} of ${caps.max_runs_per_day} agent runs used today in this repository, and this needs ${planned} more (review.reviewer.max_runs_per_day)`;
+    if (caps.max_usd_per_day !== undefined && spent.usd >= caps.max_usd_per_day)
+        return `the daily cost cap is reached: $${spent.usd.toFixed(2)} of $${caps.max_usd_per_day.toFixed(2)} reported today in this repository (review.reviewer.max_usd_per_day)`;
+    return undefined;
+}
+/** Whether a risk-escalated review adds judges: a human review exists, or the router finds a risky changed function. */
+function escalationFor(humanReviews, risky) {
+    if (humanReviews > 0)
+        return { escalate: true, why: `${humanReviews} human review(s) to check` };
+    if (risky === undefined)
+        return { escalate: true, why: 'the risk router could not score this change, so every judge reviews it' };
+    return risky > 0
+        ? { escalate: true, why: `${risky} risky changed function(s)` }
+        : { escalate: false, why: 'no risky changed function and no human review: one judge (review.reviewer.escalate: risk)' };
+}
+/** The mode asked for and the one the installed reviewers allow: a panel or full review needs two vendors. */
+function modeRan(settings, reviewers, candidates, installed) {
+    const asked = settings.panel ? 'panel' : settings.mode;
+    const refused = settings.refused.length ? { refused: settings.refused } : {};
+    const source = settings.panel ? settings.source.panel : settings.source.mode;
+    if (settings.mode !== 'full' || reviewers.length >= settings.judges)
+        return { asked, ran: asked, source, ...refused };
+    const missing = candidates.filter(name => !installed.has(name)).map(name => ADAPTERS[name].binary);
+    const degraded = `${settings.judges} judges asked, ${reviewers.join(' and ')} could run (${missing.length ? `not installed: ${missing.join(', ')}` : 'no other vendor in review.reviewer.reviewers'})`;
+    return { asked, ran: reviewers.length > 1 ? asked : 'single', source, degraded, ...refused };
+}
+/**
+ * Before any checkout or typed review: whether this push gets a model review at all (an open, ready
+ * pull request, `on_push`). The background job asks first, so a push nobody will read costs one lookup.
+ */
+export async function pushReviewSkip(cwd, branch, head, config, exec = defaultExec) {
+    const settings = resolveReviewer(config);
+    const gh = ghFor(cwd, exec, await githubEnv(cwd, config.review?.github_account ?? process.env.RIGOUR_GITHUB_ACCOUNT, exec));
+    const found = await findPullRequest(gh, branch, head, undefined);
+    if (found.error)
+        return undefined; // the review itself reports a lookup that failed, as unavailable
+    return skipReason(settings.on_push, branch, found.pr);
+}
 /** Why no model is asked at this push: `review.reviewer.on_push` and whether someone will read the push (an open, non-draft pull request). */
 function skipReason(onPush, branch, pr) {
     if (onPush === 'off')
@@ -221,18 +372,28 @@ function verifier(cwd) {
         return length >= 0 && (line === undefined || line <= length);
     };
 }
-function result(accounted, verdict, reviewers, scope, why, cached, reviews, pr) {
+function result(accounted, verdict, reviewers, scope, why, cached, reviews, pr, mode, dismissable) {
     const cost = (verdict.reviewers ?? []).map(r => r.cost_usd).filter((c) => typeof c === 'number');
+    const used = (verdict.reviewers ?? []).map(r => r.tokens).filter((t) => !!t);
     return {
         outcome: accounted.open.length ? 'findings' : 'passed',
         items: accounted.open,
         unverified: accounted.unverified,
         resolved: accounted.resolved,
         answerInReply: accounted.answerInReply,
+        notes: accounted.notes,
+        disputed: accounted.disputed,
+        dropped: accounted.dropped,
+        dismissed: accounted.dismissed,
+        ...(verdict.panel ? { panel: verdict.panel.items } : {}),
         reviewers,
         scope,
         why,
         ...(cost.length ? { costUsd: cost.reduce((a, b) => a + b, 0) } : {}),
+        ...(used.length ? { tokens: used.reduce((a, b) => ({ input: a.input + b.input, output: a.output + b.output }), { input: 0, output: 0 }) } : {}),
+        runs: (verdict.reviewers ?? []).length,
+        mode,
+        dismissable,
         cached,
         ...(reviews.label ? { previousReview: reviews.label } : {}),
         ...(pr ? { pr: pr.number } : {}),

package/dist/review/reviewer.test.js

@@ -5,6 +5,8 @@ import path from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { ConfigSchema } from '../types/index.js';
 import { reviewerBlocks, runReviewer } from './reviewer.js';
+import { dismissReviewerFinding } from './reviewer/context.js';
+import { reviewStatus } from './reviewer/background.js';
 import { selectReviewers, vendorsOf } from './reviewer/adapters.js';
 import { account, carryResolved, mergeVerdicts, parseVerdict } from './reviewer/verdict.js';
 let repo;
@@ -46,17 +48,19 @@ function fakes(answer, seen, pr = PR) {
         if (args[0] === '--version')
             return (seen.installed ?? ['claude', 'cursor-agent']).includes(binary) ? { exitCode: 0, stdout: `${seen.versions?.[command] ?? '1.0.0'}\n`, stderr: '' } : { exitCode: 127, stdout: '', stderr: 'not found' };
         seen.ran.push(command);
+        (seen.args ??= []).push(args);
         const name = binary === 'claude' ? 'claude' : binary === 'cursor-agent' ? 'cursor' : 'codex';
-        const prompt = binary === 'cursor-agent' ? args[args.length - 1] : args[args.indexOf('-p') + 1];
+        const prompt = binary === 'claude' ? args[args.indexOf('-p') + 1] : args[args.length - 1];
         seen.prompts.push(prompt);
         // Paths as the prompt names them, on either separator (Windows writes `D:\...`).
-        for (const match of prompt.matchAll(/(\S+(?:previous-reviews\.md|pr-description\.md|full\.diff|hints\.txt|previous-open\.json|delta\.diff|previous-resolved\.json))/g)) {
+        for (const match of prompt.matchAll(/(\S+(?:previous-reviews\.md|pr-description\.md|full\.diff|hints\.txt|previous-open\.json|delta\.diff|previous-resolved\.json|team-knowledge\.md))/g)) {
             seen.files[path.basename(match[1])] = fs.readFileSync(match[1], 'utf8');
         }
         const reply = answer(name);
         if (typeof reply !== 'string')
             return reply;
-        return { exitCode: 0, stdout: binary === 'claude' ? JSON.stringify({ result: reply, total_cost_usd: 1.5 }) : JSON.stringify({ result: reply }), stderr: '' };
+        const stdout = binary === 'claude' ? JSON.stringify({ result: reply, total_cost_usd: 1.5 }) : binary === 'codex' ? JSON.stringify({ type: 'item.completed', item: { text: reply } }) : JSON.stringify({ result: reply });
+        return { exitCode: 0, stdout, stderr: '' };
     };
 }
 const seenNow = () => ({ prompts: [], files: {}, ghArgs: [], ran: [] });
@@ -111,16 +115,17 @@ describe('the reviewer', () => {
     });
     it('caches the verdict per commit and inputs, so the same push is free, and the next commit gets a delta review that carries what is not accounted for', async () => {
         const seen = seenNow();
-        const open = JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock', why: 'x' }] });
-        const first = await runReviewer(repo, 'main', config, fakes(() => open, seen), () => undefined);
+        const open = JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock', consequence: 'a second run reads stale rows', why: 'x' }] });
+        const first = await runReviewer(repo, 'main', config, fakes(() => open, seen), () => undefined, { checks: ['src/job.ts:1 Unused export `job`'] });
         expect(first.items).toHaveLength(1);
-        const again = await runReviewer(repo, 'main', config, fakes(() => open, seen), () => undefined);
+        const again = await runReviewer(repo, 'main', config, fakes(() => open, seen), () => undefined, { checks: ['src/job.ts:1 Unused export `job`'] });
         expect(again.cached).toBe(true);
         expect(seen.prompts).toHaveLength(1);
         expect(fs.readdirSync(repo).sort()).toEqual(['.git', 'a.ts', 'src']); // nothing written to the working tree
         fs.writeFileSync(path.join(repo, 'src/job.ts'), 'export function job() {\n    return 2;\n}\n');
         git('commit', '-qam', 'tweak');
-        const delta = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, prior_points: [], carried: [], resolved_previous: [] }), seen), () => undefined);
+        // What the checks found changed with the commit: the context changes, the instructions do not, so it is still a delta.
+        const delta = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, prior_points: [], carried: [], resolved_previous: [] }), seen), () => undefined, { checks: ['src/job.ts:2 Unused export `other`'] });
         expect(delta.scope).toBe('delta');
         expect(seen.prompts[1]).toContain('DELTA MODE');
         expect(seen.files['delta.diff']).toContain('-    return 1;');
@@ -133,7 +138,7 @@ describe('the reviewer', () => {
     });
     it('resolves a previous item only with evidence, and never blocks on an item that names code the checkout does not have', async () => {
         const seen = seenNow();
-        const first = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock' }, { class: 'dead-code', file: 'src/ghost.ts', line: 1, issue: 'unused' }, { class: 'dead-code', file: '', issue: 'somewhere, no file named' }] }), seen), () => undefined);
+        const first = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock', consequence: 'a second run reads stale rows' }, { class: 'dead-code', file: 'src/ghost.ts', line: 1, issue: 'unused', consequence: 'a second run reads stale rows' }, { class: 'dead-code', file: '', issue: 'somewhere, no file named', consequence: 'a second run reads stale rows' }] }), seen), () => undefined);
         expect(first.items.map(i => i.file)).toEqual(['src/job.ts']);
         expect(first.unverified.map(i => i.file)).toEqual(['src/ghost.ts', '']); // a slip and a finding with no place to check: shown, never a block
         const id = first.items[0].id;
@@ -179,7 +184,7 @@ describe('the reviewer', () => {
     });
     it('in full mode runs two vendors and resolves a human point only when both say so', async () => {
         const seen = seenNow();
-        const by = (name) => JSON.stringify({ ...EMPTY, prior_points: [{ point: 'lock before read', severity: 'blocking', resolved: name === 'claude', evidence: 'src/job.ts:2' }], findings: name === 'cursor' ? [{ class: 'dead-code', file: 'a.ts', line: 1, issue: 'a is unused' }] : [] });
+        const by = (name) => JSON.stringify({ ...EMPTY, prior_points: [{ point: 'lock before read', severity: 'blocking', resolved: name === 'claude', evidence: 'src/job.ts:2' }], findings: name === 'cursor' ? [{ class: 'dead-code', file: 'a.ts', line: 1, issue: 'a is unused', consequence: 'a second run reads stale rows' }] : [] });
         const result = await runReviewer(repo, 'main', config, fakes(by, seen), () => undefined, { full: true });
         expect(result.reviewers).toEqual(['claude', 'cursor']);
         expect(result.items.map(i => [i.kind, i.reviewer])).toEqual([['prior', 'cursor'], ['finding', 'cursor']]);
@@ -211,10 +216,10 @@ describe('verdicts', () => {
     it('finds the verdict when the reviewer wraps it in a summary or a code fence, and refuses prose', () => {
         const verdict = JSON.stringify(EMPTY);
         for (const text of [`## Summary\nAll checked.\n\n\`\`\`json\n${verdict}\n\`\`\`\nDone.`, `Notes first.\n${verdict}\nThat is all {see above}.`]) {
-            expect(parseVerdict(text, true, 'claude', undefined)).toMatchObject({ verdict: { prior_points: [{ point: 'lock before read' }], reviewer: 'claude' } });
+            expect(parseVerdict(text, true, 'claude', {})).toMatchObject({ verdict: { prior_points: [{ point: 'lock before read' }], reviewer: 'claude' } });
         }
-        expect(parseVerdict('Looks good to me!', false, 'claude', undefined)).toMatchObject({ error: expect.stringContaining('no valid verdict') });
-        expect(parseVerdict(JSON.stringify({ ...EMPTY, prior_points: [] }), true, 'claude', undefined)).toEqual({ error: 'claude did not report on the human reviews' });
+        expect(parseVerdict('Looks good to me!', false, 'claude', {})).toMatchObject({ error: expect.stringContaining('no valid verdict') });
+        expect(parseVerdict(JSON.stringify({ ...EMPTY, prior_points: [] }), true, 'claude', {})).toEqual({ error: 'claude did not report on the human reviews' });
     });
     it('turns reads, scans, redundancy and merge impact into open items with stable ids, and answers non-blocking points in the reply', () => {
         const verdict = {
@@ -248,3 +253,113 @@ describe('verdicts', () => {
         expect(carryResolved({ ...EMPTY, prior_points: [{ point: 'Lock before read', resolved: false }] }, previous, new Set()).prior_points).toHaveLength(2);
     });
 });
+describe('a panel of judges', () => {
+    const panelConfig = (reviewer) => ConfigSchema.parse({ version: 1, review: { github_account: 'reviewer-account', reviewer: { enabled: true, reviewers: ['claude', 'cursor', 'codex'], mode: 'full', panel: 'on', ...reviewer } } });
+    const LOCK = { class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock is taken', consequence: 'two runs send the same email' };
+    const LONE = { class: 'dead-code', file: 'src/job.ts', line: 1, issue: 'job is exported and never called', consequence: 'a reader treats it as the contract' };
+    const OPINION = { class: 'duplication', file: 'src/job.ts', line: 2, issue: 'could be one line shorter', consequence: '' };
+    it('confirms what a majority raised, drops what the others refute with evidence, and never blocks on an opinion', async () => {
+        installFake(bins[0], 'codex');
+        const seen = { ...seenNow(), installed: ['claude', 'cursor-agent', 'codex'] };
+        const reply = (name) => {
+            const prompt = seen.prompts.at(-1) ?? '';
+            if (prompt.includes('The other\nreviewer raised')) {
+                const ids = [...prompt.matchAll(/"id": "([0-9a-f]+)"/g)].map(m => m[1]);
+                return JSON.stringify({ answers: ids.map(id => ({ id, call: 'refute', evidence: `src/job.ts:1 ${name}: job is imported by the runner` })) });
+            }
+            if (name === 'codex')
+                return JSON.stringify({ ...EMPTY, findings: [LONE] });
+            return JSON.stringify({ ...EMPTY, findings: name === 'claude' ? [LOCK, OPINION] : [{ ...LOCK, line: 3, issue: 'the lock is taken only after it returns' }] });
+        };
+        const result = await runReviewer(repo, 'main', panelConfig({ judges: 3, cross_models: { claude: 'claude-haiku-4-5' } }), fakes(reply, seen), () => undefined);
+        expect(result.reviewers).toEqual(['claude', 'cursor', 'codex']);
+        expect(result.mode).toMatchObject({ asked: 'panel', ran: 'panel', source: 'team' });
+        expect(result.items.map(i => [i.issue, i.reviewer])).toEqual([[LOCK.issue, 'claude+cursor']]);
+        expect(result.dropped.map(i => i.issue)).toEqual([LONE.issue]);
+        expect(result.notes.map(i => i.issue)).toEqual([OPINION.issue]);
+        expect(seen.prompts).toHaveLength(5); // three blind reviews, then claude and cursor each cross-examine codex's lone finding once
+        expect(result.panel?.find(d => d.item.issue === LONE.issue)).toMatchObject({ judges: ['codex'], calls: { codex: 'raised', claude: 'refute', cursor: 'refute' }, status: 'dropped' });
+        expect(result.costUsd).toBe(3); // claude's review and claude's cross-examination
+        const claudeCalls = (seen.args ?? []).filter((_, i) => path.basename(seen.ran[i]).startsWith('claude'));
+        expect(claudeCalls.map(a => a.includes('claude-haiku-4-5'))).toEqual([false, true]); // the cheaper model for the cross-examination only
+    });
+    it('runs one judge and says why when only one vendor is installed, and is unavailable when the team requires the panel', async () => {
+        const seen = seenNow();
+        const reply = () => JSON.stringify({ ...EMPTY, findings: [LOCK] });
+        const fallback = await runReviewer(repo, 'main', panelConfig({ reviewers: ['claude', 'codex'] }), fakes(reply, seen), () => undefined);
+        expect(fallback.mode).toMatchObject({ asked: 'panel', ran: 'single', degraded: expect.stringContaining('not installed: codex') });
+        expect(fallback.items.map(i => i.issue)).toEqual([LOCK.issue]);
+        const required = await runReviewer(repo, 'main', panelConfig({ reviewers: ['claude', 'codex'], panel: 'required' }), fakes(reply, seenNow()), () => undefined);
+        expect(required.outcome).toBe('unavailable');
+        expect(required.reason).toContain('rigour.yml requires two reviewers');
+    });
+    it('keeps to the daily caps: a review past the run cap is skipped, or unavailable when the team requires the reviewer', async () => {
+        const reply = () => JSON.stringify({ ...EMPTY, findings: [LOCK] });
+        const skipped = await runReviewer(repo, 'main', panelConfig({ max_runs_per_day: 1 }), fakes(reply, seenNow()), () => undefined);
+        expect(skipped.outcome).toBe('skipped');
+        expect(skipped.reason).toContain('the daily run cap is reached: 0 of 1 agent runs used today in this repository, and this needs 2 more');
+        const required = await runReviewer(repo, 'main', panelConfig({ max_runs_per_day: 1, panel: 'required' }), fakes(reply, seenNow()), () => undefined);
+        expect(required.outcome).toBe('unavailable');
+    });
+    it('counts every run, stops new reviews at the cost cap, and leaves a cross-examination past the run cap disputed', async () => {
+        const seen = seenNow();
+        const lone = { class: 'dead-code', file: 'src/job.ts', line: 1, issue: 'job is exported and never called', consequence: 'a reader treats it as the contract' };
+        const reply = (name) => JSON.stringify({ ...EMPTY, findings: name === 'claude' ? [LOCK] : [{ ...LOCK, line: 3, issue: 'the lock is taken only after it returns' }, lone] });
+        // Two judges fit in a cap of 2; the cross-examination of cursor's lone finding would be a third run.
+        const result = await runReviewer(repo, 'main', panelConfig({ max_runs_per_day: 2 }), fakes(reply, seen), () => undefined);
+        expect(seen.prompts).toHaveLength(2);
+        expect(result.items.map(i => i.issue)).toEqual([LOCK.issue]);
+        expect(result.panel?.find(d => d.item.issue === lone.issue)).toMatchObject({ status: 'disputed', note: expect.stringContaining('the daily run cap is reached') });
+        // claude reported $1.50: a cost cap of $1 lets no new review start today.
+        const capped = await runReviewer(repo, 'main', panelConfig({ max_usd_per_day: 1 }), fakes(reply, seenNow()), () => undefined, { force: true });
+        expect(capped).toMatchObject({ outcome: 'skipped', reason: expect.stringContaining('the daily cost cap is reached: $1.50 of $1.00') });
+    });
+    it('escalates on risk: one judge for a change with no risky function and no human review', async () => {
+        const seen = seenNow();
+        const result = await runReviewer(repo, 'main', panelConfig({ escalate: 'risk' }), fakes(() => JSON.stringify(EMPTY), seen, null), () => undefined);
+        expect(result.mode).toMatchObject({ asked: 'panel', ran: 'single', escalation: expect.stringContaining('no risky changed function') });
+        expect(seen.prompts).toHaveLength(1);
+        const full = await runReviewer(repo, 'main', panelConfig({ escalate: 'risk' }), fakes(() => JSON.stringify(EMPTY), seenNow(), null), () => undefined, { full: true, force: true });
+        expect(full.mode?.ran).toBe('panel'); // the --full hard stop always gets every judge
+    });
+});
+describe('what the team already knows', () => {
+    const allowing = ConfigSchema.parse({ version: 1, review: { github_account: 'reviewer-account', reviewer: { enabled: true, reviewers: ['claude', 'cursor'], dismissals: true } } });
+    it('refuses a dismissal unless the team allows them: fix the code, or the reviewer', async () => {
+        const first = await runReviewer(repo, 'main', allowing, fakes(() => JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock is taken', consequence: 'two runs send the same email' }] }), seenNow()), () => undefined);
+        expect((await dismissReviewerFinding(repo, first.items[0].id, 'the runner holds a lock', false)).error).toContain('this team does not dismiss reviewer findings');
+        expect(fs.existsSync(path.join(repo, '.rigour/dismissed-review-items.json'))).toBe(false);
+    });
+    it('a dismissed finding reaches the next judge as settled, and a re-worded repeat never blocks', async () => {
+        fs.mkdirSync(path.join(repo, 'docs'));
+        fs.writeFileSync(path.join(repo, 'docs/jobs.md'), 'The job runner (src/job.ts) takes the lock first.\n');
+        git('add', '-A');
+        git('commit', '-qm', 'docs');
+        const finding = { class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock is taken', consequence: 'two runs send the same email' };
+        const first = await runReviewer(repo, 'main', allowing, fakes(() => JSON.stringify({ ...EMPTY, findings: [finding] }), seenNow()), () => undefined);
+        expect(first.outcome).toBe('findings');
+        expect(await dismissReviewerFinding(repo, 'abcdef0123', 'not one of ours', true)).toEqual({ error: 'no open reviewer finding abcdef0123 on feature: run `rigour review --reviewer` and copy the id it shows' });
+        expect((await dismissReviewerFinding(repo, first.items[0].id, 'the runner holds a lock one level up', true)).item?.issue).toBe('returns before the lock is taken');
+        expect((await reviewStatus(repo, 'feature'))?.last?.open).toEqual([]); // not work any more, right away
+        const seen = seenNow();
+        // The same commit again: no new run; the stored decision is reused, with the dismissal applied.
+        const reused = await runReviewer(repo, 'main', allowing, fakes(() => JSON.stringify(EMPTY), seenNow()), () => undefined);
+        expect(reused).toMatchObject({ cached: true, outcome: 'passed' });
+        expect(reused.dismissed.map(i => i.issue)).toEqual(['returns before the lock is taken']);
+        // A fresh review: the judge is told it is settled, and a re-worded repeat does not block either.
+        const again = await runReviewer(repo, 'main', allowing, fakes(() => JSON.stringify({ ...EMPTY, findings: [{ ...finding, issue: 'returns before the lock is taken, so it races' }] }), seen), () => undefined, { force: true });
+        expect(again.cached).toBe(false);
+        expect(again.outcome).toBe('passed');
+        expect(again.dismissed.map(i => i.issue)).toEqual(['returns before the lock is taken, so it races']);
+        expect(seen.files['team-knowledge.md']).toContain('dismissed as not a bug by t@example.com: src/job.ts:2 [correctness] returns before the lock is taken (reason: the runner holds a lock one level up)');
+        expect(seen.files['team-knowledge.md']).toContain('docs/jobs.md (names src/job.ts');
+        const told = seenNow();
+        await runReviewer(repo, 'main', allowing, fakes(() => JSON.stringify(EMPTY), told), () => undefined, { force: true, checks: ['src/job.ts:1 Unused export `job`'] });
+        expect(told.files['team-knowledge.md']).toContain("## Already found by Rigour's checks: they block on their own, so do not report them again\n- src/job.ts:1 Unused export `job`");
+    });
+    it('fails closed: a finding whose judge left out the consequence still blocks', async () => {
+        const result = await runReviewer(repo, 'main', config, fakes(() => JSON.stringify({ ...EMPTY, findings: [{ class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock' }] }), seenNow()), () => undefined);
+        expect(result.items.map(i => i.issue)).toEqual(['returns before the lock']);
+        expect(result.notes).toEqual([]);
+    });
+});

package/dist/review/test-files.d.ts

@@ -1,2 +1,6 @@
-/** A test file, by the conventions test runners use. */
+/**
+ * A test file, by the conventions test runners use: by name (`x.test.ts`, `x.spec.ts`, `x.e2e.ts`,
+ * tsd's `x.test-d.ts`) or by folder (`test/`, `tests/`, `__tests__/`, `__mocks__/`, `e2e/`, tsd's
+ * `test-d/`). The one definition every review check uses, so they never disagree about a file.
+ */
 export declare function isTestFile(file: string): boolean;

package/dist/review/test-files.js

@@ -1,4 +1,8 @@
-/** A test file, by the conventions test runners use. */
+/**
+ * A test file, by the conventions test runners use: by name (`x.test.ts`, `x.spec.ts`, `x.e2e.ts`,
+ * tsd's `x.test-d.ts`) or by folder (`test/`, `tests/`, `__tests__/`, `__mocks__/`, `e2e/`, tsd's
+ * `test-d/`). The one definition every review check uses, so they never disagree about a file.
+ */
 export function isTestFile(file) {
-    return /\.(test|spec|e2e)\.[cm]?[jt]sx?$/.test(file) || /(^|\/)(__tests__|tests?|e2e)\//.test(file);
+    return /\.(test|spec|e2e|test-d)\.[cm]?[jt]sx?$/.test(file) || /(^|\/)(__tests__|__mocks__|tests?|test-d|e2e)\//.test(file);
 }

package/dist/review/toolchain.js

@@ -4,12 +4,13 @@
  * the moment that matters (before a push) so nobody has to remember. Only tools the project
  * installed are run (node_modules/.bin, never a download). A tool the project never declared is
  * skipped and said so; one declared in package.json but not installed FAILS, since a checkout
- * without its dependencies cannot prove anything about the change. A tool configured under
- * `commands:` is left to that command, which every review already runs.
+ * without its dependencies cannot prove anything about the change. A tool the team configured
+ * under `commands:` is run as that command instead, as written (whole project, not per file).
  */
 import { execa } from 'execa';
 import fs from 'fs';
 import path from 'path';
+import { splitCommand } from '../utils/command-line.js';
 import { installedBin } from '../utils/installed-bin.js';
 import { onChangedLines, overlayUnavailable, writeOverlayConfig } from './lint-overlay.js';
 import { ownOutputs } from './unused-exports.js';
@@ -27,7 +28,13 @@ export async function runToolchain(cwd, changedFiles, config, changedLines = {})
     const configured = config.commands ?? {};
     const results = [];
     const run = async (tool, step) => {
-        results.push(configured[tool] ? { tool, status: 'skipped', command: `commands.${tool} runs it` } : await step());
+        const command = configured[tool];
+        if (!command)
+            results.push(await step());
+        else {
+            const { bin, args } = splitCommand(command);
+            results.push(await once(tool, cwd, bin, args));
+        }
     };
     await run('format', () => formatCheck(cwd, files.filter(file => FORMATTED.test(file))));
     await run('lint', () => lint(cwd, code));