@rigour-labs/cli 6.7.5 → 6.7.6

package/dist/commands/review-post.d.ts

@@ -1,3 +1,12 @@
+/**
+ * `rigour review-post`: post a `rigour review --json` report on a pull request.
+ *
+ * The PR bot is the safety net behind the pre-PR review, so it stays quiet:
+ * at most `--max-comments` inline comments (default 2), the most severe
+ * first, each posted once across pushes, and one summary comment that is
+ * edited in place on every push rather than re-posted.
+ */
+import { type ReviewRecord } from '@rigour-labs/core';
 /** Who posts with the workflow's GITHUB_TOKEN. Another identity (an app, a PAT) sets RIGOUR_BOT_LOGIN. */
 export declare const DEFAULT_BOT_LOGIN = "github-actions[bot]";
 export interface ReportFinding {
@@ -29,6 +38,10 @@ export interface ReviewReport {
     dismissed?: number;
     control_files_changed?: string[];
     receipt?: ReportReceipt;
+    /** The reviewer's part of `rigour review --json`, when it ran: its record is what the summary shows. */
+    reviewer?: {
+        record?: ReviewRecord | null;
+    };
 }
 /** The quality receipt as `rigour review --json` writes it (review-receipt.ts). */
 export interface ReportReceipt {

package/dist/commands/review-post.js

@@ -6,6 +6,7 @@
  * first, each posted once across pushes, and one summary comment that is
  * edited in place on every push rather than re-posted.
  */
+import { recordLines } from '@rigour-labs/core';
 import crypto from 'crypto';
 import fs from 'fs';
 const SUMMARY_MARKER = '<!-- rigour:summary -->';
@@ -78,6 +79,8 @@ export function summaryBody(report, total, inline, alreadyPosted) {
         lines.push('', `${report.context_findings.length} note(s) elsewhere in changed files (not blocking).`);
     if (report.receipt && report.receipt.functions > 0)
         lines.push('', ...receiptLines(report.receipt));
+    if (report.reviewer?.record)
+        lines.push('', ...recordLines(report.reviewer.record));
     if (report.dismissed)
         lines.push('', `${report.dismissed} finding(s) on changed lines were dismissed as not a bug (.rigour/dismissed.json).`);
     if (report.control_files_changed?.length) {

package/dist/commands/review-post.test.js

@@ -1,5 +1,6 @@
+import { buildRecord } from '@rigour-labs/core';
 import { describe, expect, it } from 'vitest';
-import { findingKey, postReview, rankFindings, receiptLines } from './review-post.js';
+import { findingKey, postReview, rankFindings, receiptLines, summaryBody } from './review-post.js';
 const target = { token: 't', repo: 'acme/app', pr: 7, sha: 'abc123' };
 const BOT = { login: 'github-actions[bot]' };
 function finding(over) {
@@ -53,6 +54,18 @@ const report = {
     ],
     deep: { model: 'anthropic/claude-sonnet-5.5', cost_usd: 0.0421, router: { routed: 3, functions: 11, already_reviewed: 2 } },
 };
+describe('the summary with a review record', () => {
+    it('carries the record: blocks, should-fixes, counts, judges and the hash', () => {
+        const record = buildRecord({ head: 'abcdef0123456789', base: '0123456789abcdef', scope: 'full', verdict: { prior_points: [], redundant: [], reads: [], scans: [], merge_impact: [], findings: [], carried: [], resolved_previous: [] },
+            accounted: { open: [{ id: 'i1', kind: 'finding', class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock' }], advisory: [], unverified: [], notes: [], resolved: [], answerInReply: [], disputed: [], dismissed: [] },
+            judges: [{ reviewer: 'claude', cost_usd: 0.5 }], lessonsServed: 0, humanReviews: 0 });
+        const body = summaryBody({ ...report, reviewer: { record } }, 1, 1, 0);
+        expect(body).toContain('**Review record** · 1 blocking · 0 should-fix');
+        expect(body).toContain('- **Blocking** `src/job.ts:2` returns before the lock');
+        expect(body).toContain(`Integrity \`${record.integrity.slice(0, 16)}\``);
+        expect(summaryBody(report, 1, 1, 0)).not.toContain('Review record');
+    });
+});
 describe('rankFindings', () => {
     it('puts severity first, then the most provable source', () => {
         expect(rankFindings(report.failures).map(f => f.gate)).toEqual(['Leak', 'Race', 'NoLine', 'Style']);

package/dist/commands/review-reviewer.d.ts

@@ -2,6 +2,8 @@ import { type Config, type ReviewerResult, type ReviewResult, type RunChoice } f
 /** The base a branch review runs against: the one named, else where the branch left main. */
 export declare function reviewerBase(cwd: string, named: string | undefined): string | undefined;
 export declare function reviewerFor(cwd: string, base: string | undefined, config: Config, full: boolean, choice: RunChoice, review: ReviewResult): Promise<ReviewerResult>;
-export declare function printReviewer(result: ReviewerResult): void;
+export declare function printReviewer(result: ReviewerResult, options?: {
+    notes?: boolean;
+}): void;
 export declare function reviewerJson(result: ReviewerResult): Record<string, unknown>;
 export declare function printStatus(cwd: string, json: boolean): Promise<number>;

package/dist/commands/review-reviewer.js

@@ -14,10 +14,12 @@ export function reviewerBase(cwd, named) {
 }
 export async function reviewerFor(cwd, base, config, full, choice, review) {
     if (!base)
-        return { outcome: 'unavailable', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], disputed: [], dropped: [], dismissed: [], reason: 'no base to review against: pass --base, or fetch the main branch', reviewers: [], cached: false };
+        return { outcome: 'unavailable', items: [], unverified: [], resolved: [], answerInReply: [], notes: [], advisory: [], disputed: [], dropped: [], dismissed: [], reason: 'no base to review against: pass --base, or fetch the main branch', reviewers: [], cached: false };
     return runReviewer(cwd, base, config, undefined, undefined, { trigger: 'review', full, choice, ...reviewerInputs(review) });
 }
-export function printReviewer(result) {
+/** Verified should-fixes shown in full before the rest fold into a count. */
+const ADVISORY_SHOWN = 5;
+export function printReviewer(result, options = {}) {
     const who = result.reviewers.length ? result.reviewers.join(' + ') : 'no reviewer';
     console.log(chalk.bold('\n  Reviewer') + chalk.dim(`  ${who}${result.scope ? `, ${result.scope}${result.why ? ` (${result.why})` : ''}` : ''}${result.previousReview ? `; previous review: ${result.previousReview}` : '; no previous human review'}`));
     printMode(result);
@@ -36,18 +38,33 @@ export function printReviewer(result) {
         if (item.kind !== 'prior' && result.dismissable)
             console.log(chalk.dim(`        not a bug? rigour dismiss ${item.id} --reason "…"`));
     }
-    for (const item of result.disputed)
-        console.log(chalk.yellow(`  disputed, never blocks (no majority)  ${itemLine(item)}`));
-    for (const item of result.notes)
-        console.log(chalk.dim(`  note, never blocks (no wrong outcome or cost named)  ${itemLine(item)}`));
-    for (const item of result.dismissed)
-        console.log(chalk.dim(`  dismissed earlier as not a bug  ${itemLine(item)}`));
-    if (result.dropped.length)
-        console.log(chalk.dim(`  ${result.dropped.length} finding(s) refuted with evidence by the other judges (--json lists them)`));
-    for (const item of result.unverified)
-        console.log(chalk.dim(`  unverified (names code the checkout does not have)  ${itemLine(item)}`));
+    // What is shown gets the same discipline as what blocks: blocks in full, verified should-fixes capped, the rest one count.
+    const shown = result.advisory.slice(0, options.notes ? undefined : ADVISORY_SHOWN);
+    for (const item of shown)
+        console.log(chalk.yellow(`  should fix (verified, never blocks)  ${itemLine(item)}`));
     for (const point of result.answerInReply)
         console.log(chalk.dim(`  answer in the reply  ${point.point}${point.evidence ? `\n            ${point.evidence}` : ''}`));
+    const folded = [
+        [result.advisory.length - shown.length, 'more should-fix'], [result.notes.length, 'working note'], [result.disputed.length, 'disputed'],
+        [result.unverified.length, 'unverified'], [result.dismissed.length, 'dismissed earlier'], [result.dropped.length, 'refuted by the other judges'],
+    ].filter(([n]) => n > 0);
+    if (options.notes) {
+        for (const item of result.disputed)
+            console.log(chalk.dim(`  disputed, never blocks (no majority)  ${itemLine(item)}`));
+        for (const item of result.notes)
+            console.log(chalk.dim(`  note, never blocks (a working step, or no wrong outcome named)  ${itemLine(item)}`));
+        for (const item of result.dismissed)
+            console.log(chalk.dim(`  dismissed earlier as not a bug  ${itemLine(item)}`));
+        for (const item of result.unverified)
+            console.log(chalk.dim(`  unverified (a quote or a file the checkout does not have)  ${itemLine(item)}`));
+    }
+    else if (folded.length) {
+        console.log(chalk.dim(`  Also seen, never blocking: ${folded.map(([n, what]) => `${n} ${what}${n === 1 || what.startsWith('more') || what === 'disputed' || what === 'unverified' ? '' : 's'}`).join(', ')} (rigour review --reviewer --notes lists them)`));
+    }
+    if (result.rules?.checked)
+        console.log(chalk.dim(`  repository rules answered: ${result.rules.checked} (${result.rules.broken} broken, ${result.rules.followed} followed, ${result.rules.notApplicable} not applicable)`));
+    if (result.record && result.recordPath)
+        console.log(chalk.dim(`  record: ${result.recordPath} (integrity ${result.record.integrity.slice(0, 16)})`));
     const tokens = result.tokens ? `, ${(result.tokens.input + result.tokens.output).toLocaleString('en-US')} tokens` : '';
     const cost = `${result.costUsd !== undefined ? `, $${result.costUsd.toFixed(2)}` : ''}${tokens}`;
     console.log(`  ${result.items.length} open item(s)${result.cached ? chalk.dim(' (cached for this commit)') : cost}\n`);
@@ -76,6 +93,8 @@ export function reviewerJson(result) {
         resolved: result.resolved,
         answer_in_reply: result.answerInReply,
         notes: result.notes,
+        advisory: result.advisory,
+        shown: { blocking: result.items.length, should_fix: Math.min(result.advisory.length, ADVISORY_SHOWN), folded: result.advisory.length - Math.min(result.advisory.length, ADVISORY_SHOWN) + result.notes.length + result.disputed.length + result.unverified.length + result.dismissed.length + result.dropped.length },
         disputed: result.disputed,
         dropped: result.dropped,
         dismissed: result.dismissed,
@@ -85,6 +104,7 @@ export function reviewerJson(result) {
         tokens: result.tokens ?? null,
         cached: result.cached,
         previous_review: result.previousReview ?? null,
+        record: result.record ?? null,
         pr: result.pr ?? null,
     };
 }

package/dist/commands/review-reviewer.test.js

@@ -9,7 +9,7 @@ afterEach(() => {
     vi.restoreAllMocks();
 });
 const LOCK = { id: 'abcdef0123', kind: 'finding', class: 'correctness', file: 'src/job.ts', line: 2, issue: 'returns before the lock', consequence: 'two runs send the same email', reviewer: 'claude+codex' };
-const base = { outcome: 'findings', items: [LOCK], unverified: [], resolved: [], answerInReply: [], notes: [{ ...LOCK, id: 'n1', issue: 'could be shorter', consequence: undefined }], disputed: [{ ...LOCK, id: 'd1', issue: 'maybe slow' }], dropped: [{ ...LOCK, id: 'x1' }], dismissed: [], reviewers: ['claude', 'codex'], scope: 'full', cached: false, dismissable: true, costUsd: 0.42, tokens: { input: 26565, output: 24 } };
+const base = { outcome: 'findings', items: [LOCK], unverified: [], resolved: [], answerInReply: [], notes: [{ ...LOCK, id: 'n1', issue: 'could be shorter', consequence: undefined }], advisory: [], disputed: [{ ...LOCK, id: 'd1', issue: 'maybe slow' }], dropped: [{ ...LOCK, id: 'x1' }], dismissed: [], reviewers: ['claude', 'codex'], scope: 'full', cached: false, dismissable: true, costUsd: 0.42, tokens: { input: 26565, output: 24 } };
 describe('the reviewer as the CLI prints it', () => {
     it('shows what ran against what was asked, why, what was refused, and only confirmed findings as open', () => {
         printReviewer({ ...base, mode: { asked: 'panel', ran: 'single', source: 'user', degraded: '3 judges asked, claude could run (not installed: codex)', refused: ['mode single (flag) refused: rigour.yml sets review.reviewer.panel: required'] } });
@@ -19,13 +19,26 @@ describe('the reviewer as the CLI prints it', () => {
         expect(text).toContain('OPEN');
         expect(text).toContain('consequence: two runs send the same email');
         expect(text).toContain('not a bug? rigour dismiss abcdef0123');
-        expect(text).toContain('disputed, never blocks (no majority)');
-        expect(text).toContain('note, never blocks');
-        expect(text).toContain('1 finding(s) refuted with evidence by the other judges');
+        expect(text).not.toContain('disputed, never blocks'); // folded: what is shown gets the discipline of what blocks
+        expect(text).toMatch(/Also seen, never blocking: .*1 working note.*1 disputed.*1 refuted by the other judges.*--notes lists them/);
         expect(text).toContain('1 open item(s), $0.42, 26,589 tokens'); // a Codex judge reports tokens, not dollars
     });
+    it('shows at most five verified should-fixes, folds the rest, and lists everything with --notes', () => {
+        const advisory = Array.from({ length: 6 }, (_, i) => ({ ...LOCK, id: `s${i}`, issue: `should fix ${i}` }));
+        printReviewer({ ...base, advisory });
+        const text = out.join('\n');
+        expect(text.match(/should fix \(verified, never blocks\)/g)).toHaveLength(5);
+        expect(text).toContain('1 more should-fix');
+        out = [];
+        printReviewer({ ...base, advisory }, { notes: true });
+        const all = out.join('\n');
+        expect(all.match(/should fix \(verified, never blocks\)/g)).toHaveLength(6);
+        expect(all).toContain('disputed, never blocks (no majority)');
+        expect(all).toContain('note, never blocks');
+        expect(all).not.toContain('Also seen, never blocking');
+    });
     it('returns every decision in JSON', () => {
-        expect(reviewerJson({ ...base, mode: { asked: 'panel', ran: 'panel', source: 'team' } })).toMatchObject({ blocks: true, mode: { ran: 'panel' }, disputed: [{ id: 'd1' }], notes: [{ id: 'n1' }], dropped: [{ id: 'x1' }] });
+        expect(reviewerJson({ ...base, mode: { asked: 'panel', ran: 'panel', source: 'team' } })).toMatchObject({ blocks: true, mode: { ran: 'panel' }, disputed: [{ id: 'd1' }], notes: [{ id: 'n1' }], shown: { blocking: 1, should_fix: 0 }, dropped: [{ id: 'x1' }] });
     });
     it('offers "not a bug" only where the team allows dismissals', () => {
         printReviewer({ ...base, dismissable: false });

package/dist/commands/review.js

@@ -161,7 +161,7 @@ async function print(result, options, receipt, reviewer, context, checked) {
     }
     printHuman(result, { ...context, receipt, all: options.all, notes: options.notes, showReceipt: options.receipt });
     if (reviewer)
-        printReviewer(reviewer);
+        printReviewer(reviewer, { notes: options.notes });
 }
 function scopeOf(options) {
     if (options.diff)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/cli",
-  "version": "6.7.5",
+  "version": "6.7.6",
   "description": "Code review that happens while your agent writes: deterministic checks on the lines it changed, quiet unless it can prove a defect, and learning from your team's fixes and dismissals. Works with Claude Code, Cursor, Codex, Cline and Windsurf.",
   "engines": {
     "node": ">=22.13"
@@ -56,13 +56,13 @@
     "inquirer": "9.2.16",
     "ora": "^8.0.1",
     "yaml": "^2.8.2",
-    "@rigour-labs/core": "6.7.5"
+    "@rigour-labs/core": "6.7.6"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",
     "@types/inquirer": "9.0.7",
     "@types/node": "^25.0.3",
-    "@rigour-labs/studio": "6.7.5"
+    "@rigour-labs/studio": "6.7.6"
   },
   "scripts": {
     "build": "tsc && pnpm bundle-studio",