@rigour-labs/core 6.6.6 → 6.7.1

package/dist/review/reviewer/store.js

@@ -8,6 +8,10 @@
 import fs from 'fs';
 import path from 'path';
 import { GH_TIMEOUT_MS } from './exec.js';
+/** The local calendar day, as a team's "per day" means it. */
+function localDay(at = new Date()) {
+    return `${at.getFullYear()}-${String(at.getMonth() + 1).padStart(2, '0')}-${String(at.getDate()).padStart(2, '0')}`;
+}
 export class VerdictStore {
     dir;
     constructor(dir) {
@@ -46,7 +50,45 @@ export class VerdictStore {
         const previous = this.branchState(branch);
         this.writeJson(this.branchFile(branch), { ...state, chain: state.mode === 'delta' ? (previous?.chain ?? 0) + 1 : 0, at: new Date().toISOString() });
     }
-    /** The branch's record (`json`), the background reviewer's `pid` and `log`. */
+    /** Today's spend, summed from the day's append-only log (one line per run or batch of runs). */
+    spend(day = localDay()) {
+        let text = '';
+        try {
+            text = fs.readFileSync(this.spendFile(day), 'utf8');
+        }
+        catch {
+            return { runs: 0, usd: 0 };
+        }
+        return text.split('\n').filter(Boolean).reduce((sum, line) => {
+            try {
+                const entry = JSON.parse(line);
+                return { runs: sum.runs + (Number(entry.runs) || 0), usd: sum.usd + (Number(entry.usd) || 0) };
+            }
+            catch {
+                return sum;
+            }
+        }, { runs: 0, usd: 0 });
+    }
+    /** Adds runs and reported dollars to today's log: an append, so the background reviewer and a person's run never lose each other's count. */
+    addSpend(runs, usd, day = localDay()) {
+        fs.mkdirSync(path.join(this.dir, 'spend'), { recursive: true });
+        fs.appendFileSync(this.spendFile(day), `${JSON.stringify({ runs, ...(usd ? { usd } : {}), at: new Date().toISOString() })}\n`);
+    }
+    spendFile(day) {
+        return path.join(this.dir, 'spend', `${day}.jsonl`);
+    }
+    /** The decision a verdict led to (what blocks, what is disputed or a note), kept so the same commit is not decided again. */
+    decidedPath(verdictPath) {
+        return verdictPath.replace(/\.json$/, '.decided.json');
+    }
+    /** A review on the branch that ended without a verdict, and why: what the status shows instead of "no verdict yet". */
+    recordAttempt(branch, attempt) {
+        this.writeJson(this.branchFile(branch, 'attempt'), attempt);
+    }
+    attempt(branch) {
+        return this.readJson(this.branchFile(branch, 'attempt'));
+    }
+    /** The branch's record (`json`), its last attempt without a verdict (`attempt`), the background reviewer's `pid` and `log`. */
     branchFile(branch, kind = 'json') {
         return path.join(this.dir, 'branches', `${branch.replace(/[^A-Za-z0-9._-]/g, '_')}.${kind}`);
     }

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

@@ -0,0 +1,2 @@
+import type { ReviewerResult } from '../reviewer.js';
+export declare function reviewerUsage(result: ReviewerResult, trigger: string): Record<string, unknown>;

package/dist/review/reviewer/usage.js

@@ -0,0 +1,28 @@
+/**
+ * What the reviewer did, as anonymous opt-in telemetry (TELEMETRY.md): counts and buckets only, never code, file
+ * names, finding text or ids. It answers whether anyone turns the panel on, what actually runs, and what it costs.
+ */
+import { costBucket } from '../../telemetry/telemetry.js';
+export function reviewerUsage(result, trigger) {
+    const mode = result.mode;
+    return {
+        outcome: result.outcome,
+        trigger,
+        scope: result.scope,
+        asked: mode?.asked,
+        ran: mode?.ran,
+        source: mode?.source,
+        degraded: !!mode?.degraded,
+        escalation: mode?.escalation ? (mode.ran === 'single' ? 'one-judge' : 'all-judges') : undefined,
+        refused: mode?.refused?.length ?? 0,
+        judges: result.reviewers.length,
+        cached: result.cached,
+        confirmed: result.items.length,
+        disputed: result.disputed.length,
+        dropped: result.dropped.length,
+        notes: result.notes.length,
+        dismissed: result.dismissed.length,
+        runs: result.runs,
+        cost_bucket: costBucket(result.costUsd),
+    };
+}

package/dist/review/reviewer/usage.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/review/reviewer/usage.test.js

@@ -0,0 +1,14 @@
+import { describe, expect, it } from 'vitest';
+import { reviewerUsage } from './usage.js';
+const item = { id: 'abcdef0123', kind: 'finding', class: 'correctness', file: 'src/secret-path.ts', line: 2, issue: 'private text' };
+describe('reviewer usage telemetry', () => {
+    it('reports counts and buckets only: never file names, finding text or ids', () => {
+        const result = { outcome: 'findings', items: [item], unverified: [], resolved: [], answerInReply: [], notes: [], disputed: [item, item], dropped: [], dismissed: [], reviewers: ['claude', 'codex', 'cursor'], scope: 'delta', cached: false, costUsd: 0.7, runs: 5,
+            mode: { asked: 'panel', ran: 'panel', source: 'team', escalation: '2 risky changed function(s)' } };
+        const usage = reviewerUsage(result, 'push');
+        expect(usage).toEqual({ outcome: 'findings', trigger: 'push', scope: 'delta', asked: 'panel', ran: 'panel', source: 'team', degraded: false, escalation: 'all-judges', refused: 0, judges: 3, cached: false, confirmed: 1, disputed: 2, dropped: 0, notes: 0, dismissed: 0, runs: 5, cost_bucket: '$0.50-2' });
+        const text = JSON.stringify(usage);
+        for (const leak of ['secret-path', 'private text', 'abcdef0123'])
+            expect(text).not.toContain(leak);
+    });
+});

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

@@ -1,3 +1,5 @@
+import type { Spend, Tokens } from './adapters.js';
+import type { PanelItem } from './panel.js';
 export interface PriorPoint {
     point: string;
     review?: string;
@@ -57,6 +59,7 @@ export interface Finding {
     line?: number;
     issue: string;
     why?: string;
+    consequence?: string;
     reviewer?: string;
 }
 export interface Verdict {
@@ -73,10 +76,17 @@ export interface Verdict {
     }>;
     reviewer?: string;
     cost_usd?: number;
+    tokens?: Tokens;
     reviewers?: Array<{
         reviewer: string;
         cost_usd?: number;
+        tokens?: Tokens;
     }>;
+    /** With a panel: every judge's own item ids, and the panel's decision on each finding (reviewer/panel.ts). */
+    panel?: {
+        judgeItemIds: string[];
+        items: PanelItem[];
+    };
 }
 export interface OpenItem {
     id: string;
@@ -86,6 +96,8 @@ export interface OpenItem {
     line?: number;
     issue: string;
     evidence?: string;
+    /** For a finding: the wrong outcome or the cost. A finding without one is a note, never a block. */
+    consequence?: string;
     reviewer?: string;
     /** In delta mode, how the item reached this verdict. */
     status?: 'carried' | 'not accounted for';
@@ -93,7 +105,7 @@ export interface OpenItem {
 /** Checks a file (and a line) against the checkout; an item that fails cannot block. */
 export type Verify = (file: string, line: number | undefined) => boolean;
 /** The verdict in a reviewer's answer, or why it is not one. `needsPriorPoints`: a human review exists and none of its points is carried. */
-export declare function parseVerdict(text: string, needsPriorPoints: boolean, reviewer: string, costUsd: number | undefined): {
+export declare function parseVerdict(text: string, needsPriorPoints: boolean, reviewer: string, spend: Spend): {
     verdict: Verdict;
 } | {
     error: string;
@@ -120,6 +132,8 @@ export interface Accounting {
     }>;
     /** Prior points the human marked non-blocking and the code still leaves open: for the reply. */
     answerInReply: PriorPoint[];
+    /** Findings with no wrong outcome and no cost (an opinion): shown, never a block, however many judges agree. */
+    notes: OpenItem[];
 }
 /** Everything the reviewers reported blocks; in delta mode, previous open items carry unless resolved with evidence. */
 export declare function account(verdict: Verdict, previousOpen: OpenItem[] | undefined, verify: Verify): Accounting;

package/dist/review/reviewer/verdict.js

@@ -11,7 +11,7 @@ import { createHash } from 'crypto';
 const SHAPE = ['prior_points', 'reads', 'findings'];
 const LISTS = ['redundant', 'scans', 'merge_impact', 'carried', 'resolved_previous'];
 /** The verdict in a reviewer's answer, or why it is not one. `needsPriorPoints`: a human review exists and none of its points is carried. */
-export function parseVerdict(text, needsPriorPoints, reviewer, costUsd) {
+export function parseVerdict(text, needsPriorPoints, reviewer, spend) {
     const parsed = verdictIn(text);
     if (!parsed || !SHAPE.every(key => Array.isArray(parsed[key])))
         return { error: `${reviewer}: no valid verdict (${text.slice(0, 200).replace(/\s+/g, ' ')})` };
@@ -20,7 +20,7 @@ export function parseVerdict(text, needsPriorPoints, reviewer, costUsd) {
     for (const key of LISTS)
         if (!Array.isArray(parsed[key]))
             parsed[key] = [];
-    return { verdict: { ...parsed, reviewer, ...(costUsd !== undefined ? { cost_usd: costUsd } : {}) } };
+    return { verdict: { ...parsed, reviewer, ...(spend.costUsd !== undefined ? { cost_usd: spend.costUsd } : {}), ...(spend.tokens ? { tokens: spend.tokens } : {}) } };
 }
 /** The whole answer, a fenced block, or the last object that starts with "prior_points" (a model sometimes writes a summary around it). */
 function verdictIn(text) {
@@ -65,7 +65,7 @@ export function mergeVerdicts(parts) {
         findings: tagged(part => part.findings),
         carried: parts.flatMap(part => part.carried),
         resolved_previous: parts.length === 1 ? parts[0].resolved_previous : parts[0].resolved_previous.filter(x => parts.every(part => part.resolved_previous.some(y => y.id === x.id))),
-        reviewers: parts.map(part => ({ reviewer: part.reviewer ?? '?', ...(part.cost_usd !== undefined ? { cost_usd: part.cost_usd } : {}) })),
+        reviewers: parts.map(part => ({ reviewer: part.reviewer ?? '?', ...(part.cost_usd !== undefined ? { cost_usd: part.cost_usd } : {}), ...(part.tokens ? { tokens: part.tokens } : {}) })),
     };
 }
 /**
@@ -132,8 +132,18 @@ export function account(verdict, previousOpen, verify) {
         if (m.holds === false)
             add({ id: id('correctness', m.call_site, m.symbol), kind: 'merge', class: 'correctness', file: m.call_site.split(':')[0], line: Number(m.call_site.split(':')[1]) || undefined, issue: `${m.symbol} from ${m.main_file} changed in main: ${m.why}`, reviewer: m.reviewer });
     }
-    for (const f of verdict.findings)
-        add({ id: id(f.class, f.file, f.issue), kind: 'finding', class: f.class, file: f.file, line: f.line, issue: f.issue, evidence: f.why, reviewer: f.reviewer });
+    const notes = [];
+    const stillOpen = new Set((previousOpen ?? []).map(item => item.id));
+    for (const f of verdict.findings) {
+        const item = { id: id(f.class, f.file, f.issue), kind: 'finding', class: f.class, file: f.file, line: f.line, issue: f.issue, evidence: f.why, ...(f.consequence?.trim() ? { consequence: f.consequence.trim() } : {}), reviewer: f.reviewer };
+        // An opinion is a finding the judge said has no consequence: an empty one. A missing field fails closed, and an
+        // item already open from the last round stays open until it is resolved with evidence.
+        const opinion = typeof f.consequence === 'string' && !f.consequence.trim() && !stillOpen.has(item.id);
+        if (!opinion)
+            add(item);
+        else if (!notes.some(n => n.id === item.id))
+            notes.push(item);
+    }
     const resolved = [];
     if (previousOpen) {
         const evidence = new Map(verdict.resolved_previous.filter(r => r?.id && r.evidence).map(r => [r.id, r.evidence]));
@@ -146,11 +156,11 @@ export function account(verdict, previousOpen, verify) {
             }
         }
     }
-    return { open, unverified, resolved, answerInReply };
+    return { open, unverified, resolved, answerInReply, notes };
 }
 export function itemLine(item) {
     const where = item.file ? ` ${item.file}${item.line ? `:${item.line}` : ''}` : '';
     const by = item.reviewer ? ` (${item.reviewer})` : '';
     const status = item.status ? `, ${item.status}` : '';
-    return `[${item.class}${status}]${by}${where} ${item.issue}${item.evidence ? `\n      ${item.evidence}` : ''}`;
+    return `[${item.class}${status}]${by}${where} ${item.issue}${item.consequence ? `\n      consequence: ${item.consequence}` : ''}${item.evidence ? `\n      ${item.evidence}` : ''}`;
 }

package/dist/review/reviewer.d.ts

@@ -1,6 +1,8 @@
 import type { Config } from '../types/index.js';
-import { type ReviewerName } from './reviewer/adapters.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 RunChoice, type Source } from './reviewer/settings.js';
 import { type Accounting, type OpenItem, type PriorPoint } from './reviewer/verdict.js';
 export { defaultExec, githubEnv, parseJsonArrays, type Exec, type Progress } from './reviewer/exec.js';
 export { itemLine, type OpenItem } from './reviewer/verdict.js';
@@ -12,12 +14,18 @@ export interface ReviewerOptions {
     reviewsBefore?: string;
     /** At push the ready-pull-request rule applies; a review command or a backtest always reviews. */
     trigger?: 'push' | 'review' | 'backtest';
-    /** Two vendors, verdicts merged: the step before requesting a human review. */
+    /** Two vendors over the whole branch, never a delta: the step before requesting a human review. */
     full?: boolean;
+    /** This run's own choice of mode and panel, the nearest layer of the settings (reviewer/settings.ts). */
+    choice?: RunChoice;
     /** Review again even when a verdict for these inputs is cached. */
     force?: boolean;
     /** Deterministic hints (a nested scan, a property that only leaves through serialisation): candidates for the reviewer to confirm. */
     hints?: string;
+    /** What Rigour's checks already found on this change: settled, so no judge spends a turn finding it again. */
+    checks?: string[];
+    /** Where the team's state lives (.rigour: dismissals, reviewed functions) when cwd is a worktree that lacks it. */
+    stateRoot?: string;
     /** The branch the commit was pushed from, when reviewing it in a detached worktree (background.ts). */
     branch?: string;
 }
@@ -31,17 +39,52 @@ export interface ReviewerResult {
     resolved: Accounting['resolved'];
     /** Non-blocking human points still open: answered in the reply, not held against the push. */
     answerInReply: PriorPoint[];
+    /** Findings with no wrong outcome and no cost: shown, never a block. */
+    notes: OpenItem[];
+    /** Panel findings without a majority: shown, never a block, not carried to the next round. */
+    disputed: OpenItem[];
+    /** Panel findings refuted with evidence: logged, never a block. */
+    dropped: OpenItem[];
+    /** Findings the team dismissed as not a bug (`rigour dismiss <id>`), raised again: shown, never a block. */
+    dismissed: OpenItem[];
+    /** The panel's decision on every finding, with each judge's call: what a later re-scoring fits on. */
+    panel?: PanelItem[];
     /** Why there is no verdict (unavailable) or why none was sought (skipped). */
     reason?: string;
     reviewers: ReviewerName[];
     scope?: 'full' | 'delta';
     why?: string;
     costUsd?: number;
+    /** Tokens every run reported, summed: the only measure of a CLI that reports no dollars (Codex). */
+    tokens?: Tokens;
+    /** Whether the team lets people dismiss these findings (review.reviewer.dismissals). */
+    dismissable?: boolean;
+    /** Agent runs behind this verdict: one per judge, plus each cross-examination. */
+    runs?: number;
+    /** The mode asked for, the one that ran, where the choice came from, and why it ran with fewer judges. */
+    mode?: ModeRecord;
     cached: boolean;
     /** The latest human review it worked from (`<login>, <date> (<n> reviews)`). */
     previousReview?: string;
     pr?: number;
 }
+export interface ModeRecord {
+    asked: 'single' | 'cross' | 'full' | 'panel';
+    ran: 'single' | 'cross' | 'full' | 'panel';
+    source: Source;
+    /** Why fewer judges ran than were asked for. */
+    degraded?: string;
+    /** Nearer choices that were not applied, such as a user turning off a panel the team requires. */
+    refused?: string[];
+    /** With escalate: risk, why this review got one judge or all of them. */
+    escalation?: string;
+}
 /** Findings and no verdict stop a push; a skipped review does not, and is reported as owed. */
 export declare function reviewerBlocks(result: ReviewerResult): boolean;
+/** The reviewer, and one anonymous usage event for what it did (only when the person opted in to telemetry). */
 export declare function runReviewer(cwd: string, base: string, config: Config, exec?: Exec, progress?: Progress, options?: ReviewerOptions): Promise<ReviewerResult>;
+/**
+ * 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 declare function pushReviewSkip(cwd: string, branch: string, head: string, config: Config, exec?: Exec): Promise<string | undefined>;