@rigour-labs/core 6.6.2 → 6.6.4

package/dist/deep/diff-tests/run.js

@@ -20,6 +20,7 @@ import { loadProjectConfig, programBatches } from '../../semantic/program.js';
 import { ProjectFacts } from '../../semantic/project-facts.js';
 import { changedFunctions, functionName, isExported } from '../changed-functions.js';
 import { safeCalls, testFileSource } from './calls.js';
+import { installedBin } from '../../utils/installed-bin.js';
 const MAX_TARGETS = 5;
 /** A junction on Windows needs no admin rights; elsewhere a plain directory symlink. */
 const DIR_LINK = process.platform === 'win32' ? 'junction' : 'dir';
@@ -115,7 +116,7 @@ async function record(root, head, target, calls, timeoutMs = 120_000) {
     const packageDir = path.join(root, path.relative(head, target.packageDir));
     fs.writeFileSync(testFile, testFileSource(target.runner, target.name, importPath, calls));
     try {
-        const runner = installedRunner(packageDir, root, target.runner);
+        const runner = installedBin(packageDir, root, target.runner);
         const command = runner && `${runner} ${target.runner === 'vitest' ? 'run ' : ''}${path.relative(packageDir, testFile)}`;
         if (!command || evaluateTypedCommand(command).decision !== 'allow')
             return {};
@@ -128,17 +129,6 @@ async function record(root, head, target, calls, timeoutMs = 120_000) {
         fs.rmSync(outFile, { force: true });
     }
 }
-/** The package's own installed runner, never a download: node_modules/.bin up to the repository root. */
-function installedRunner(packageDir, root, runner) {
-    for (let dir = packageDir; dir.startsWith(root); dir = path.dirname(dir)) {
-        const bin = path.join(dir, 'node_modules', '.bin', runner);
-        if (fs.existsSync(bin))
-            return bin;
-        if (dir === root)
-            break;
-    }
-    return undefined;
-}
 /** The base worktree has no installed packages: link the head's node_modules into it. */
 function linkDependencies(head, base) {
     const walk = (dir, depth) => {

package/dist/firewall/firewall.test.js

@@ -6,6 +6,10 @@ describe('typed command firewall', () => {
         expect(ev.decision).toBe('deny');
         expect(ev.ruleId).toBe('shell.no-meta');
     });
+    it('treats a Windows shim as the program it starts, and still denies an unknown one', () => {
+        expect(evaluateTypedCommand('D:\\repo\\node_modules\\.bin\\vitest.cmd run a.test.ts').decision).toBe('allow');
+        expect(evaluateTypedCommand('D:\\tools\\curl.exe https://evil.example').decision).toBe('deny');
+    });
     it('denies unknown binaries including node/npx', () => {
         expect(evaluateTypedCommand('curl https://evil.example').decision).toBe('deny');
         expect(evaluateTypedCommand('node -e "1"').decision).toBe('deny');

package/dist/firewall/trusted-control.js

@@ -1,7 +1,7 @@
 import { createHash, randomUUID } from 'crypto';
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
+import { rigourUserDir } from '../utils/user-state.js';
 import { hashPolicy } from './policy-hash.js';
 function canonicalRepository(cwd) {
     try {
@@ -14,7 +14,7 @@ function canonicalRepository(cwd) {
 export function getRepositoryControlId(cwd) {
     return createHash('sha256').update(canonicalRepository(cwd)).digest('hex').slice(0, 24);
 }
-export function getTrustedControlDir(cwd, controlRoot = path.join(os.homedir(), '.rigour', 'control')) {
+export function getTrustedControlDir(cwd, controlRoot = path.join(rigourUserDir(), 'control')) {
     return path.join(controlRoot, getRepositoryControlId(cwd));
 }
 export function getGatewayPolicyHash(cwd, config) {

package/dist/firewall/typed-command.js

@@ -72,7 +72,8 @@ export function evaluateTypedCommand(command, allowedBins = DEFAULT_ALLOWED_BINS
             timestamp: new Date().toISOString(),
         };
     }
-    const binBase = parsed.bin.split(/[/\\]/).pop() || parsed.bin;
+    // A Windows shim or executable (vitest.cmd, git.exe) is the program it starts.
+    const binBase = (parsed.bin.split(/[/\\]/).pop() || parsed.bin).replace(/\.(cmd|exe|bat)$/i, '');
     if (!allowedBins.has(binBase) && !allowedBins.has(parsed.bin)) {
         return {
             decision: 'deny',

package/dist/gates/logic-drift-git-base.d.ts

@@ -3,5 +3,14 @@ export interface GitLogicBase {
     readAtBase: (file: string) => string | null;
 }
 export declare function isGitWorktree(cwd: string): boolean;
+export interface BranchBase {
+    /** The main branch as found: GITHUB_BASE_REF, else origin/main, main, origin/master, master. */
+    mainRef: string;
+    /** Where the branch left it (merge-base), or HEAD when on main itself. */
+    base: string;
+    onMain: boolean;
+}
+/** The commit a branch is measured against, or null outside a repository or without a main branch. */
+export declare function branchBase(cwd: string): BranchBase | null;
 /** Use a fixed commit for the entire scan; never move the baseline on read. */
 export declare function resolveGitLogicBase(cwd: string): GitLogicBase | null;

package/dist/gates/logic-drift-git-base.js

@@ -10,13 +10,8 @@ function git(cwd, args) {
         return null;
     }
 }
-/** Use a fixed commit for the entire scan; never move the baseline on read. */
-export function resolveGitLogicBase(cwd) {
-    // Git reports the path relative to the worktree root without relying on
-    // platform-specific path casing or Windows short-name expansion.
-    const prefix = git(cwd, ['rev-parse', '--show-prefix']);
-    if (prefix === null || prefix.trim())
-        return null;
+/** The commit a branch is measured against, or null outside a repository or without a main branch. */
+export function branchBase(cwd) {
     const currentBranch = git(cwd, ['symbolic-ref', '--quiet', '--short', 'HEAD'])?.trim();
     const candidates = [
         process.env.GITHUB_BASE_REF ? `refs/remotes/origin/${process.env.GITHUB_BASE_REF}` : '',
@@ -26,11 +21,21 @@ export function resolveGitLogicBase(cwd) {
     const mainRef = candidates.find(ref => git(cwd, ['rev-parse', '--verify', '--quiet', ref])?.trim());
     if (!mainRef)
         return null;
-    const base = currentBranch === 'main' || currentBranch === 'master'
-        ? git(cwd, ['rev-parse', 'HEAD'])?.trim()
-        : git(cwd, ['merge-base', 'HEAD', mainRef])?.trim();
-    if (!base)
+    const onMain = currentBranch === 'main' || currentBranch === 'master';
+    const base = onMain ? git(cwd, ['rev-parse', 'HEAD'])?.trim() : git(cwd, ['merge-base', 'HEAD', mainRef])?.trim();
+    return base ? { mainRef, base, onMain } : null;
+}
+/** Use a fixed commit for the entire scan; never move the baseline on read. */
+export function resolveGitLogicBase(cwd) {
+    // Git reports the path relative to the worktree root without relying on
+    // platform-specific path casing or Windows short-name expansion.
+    const prefix = git(cwd, ['rev-parse', '--show-prefix']);
+    if (prefix === null || prefix.trim())
+        return null;
+    const branch = branchBase(cwd);
+    if (!branch)
         return null;
+    const base = branch.base;
     const diff = git(cwd, ['diff', '--name-only', '-z', '--diff-filter=ACMR', base, '--']);
     if (diff === null)
         return null;

package/dist/gates/runner.d.ts

@@ -9,8 +9,11 @@ export declare class GateRunner {
      * Allows adding custom gates dynamically (SOLID - Open/Closed Principle)
      */
     addGate(gate: Gate): void;
+    /** `record: false` leaves no trace (no local memory, no adaptive history): a comparison run, not a review. */
     run(cwd: string, patterns?: string[], deepOptions?: DeepOptions & {
         onProgress?: (msg: string) => void;
+    }, runOptions?: {
+        record?: boolean;
     }): Promise<Report>;
 }
 /**

package/dist/gates/runner.js

@@ -138,7 +138,8 @@ export class GateRunner {
     addGate(gate) {
         this.gates.push(gate);
     }
-    async run(cwd, patterns, deepOptions) {
+    /** `record: false` leaves no trace (no local memory, no adaptive history): a comparison run, not a review. */
+    async run(cwd, patterns, deepOptions, runOptions = {}) {
         const start = Date.now();
         const failures = [];
         const summary = {};
@@ -309,6 +310,8 @@ export class GateRunner {
                 ...(deepStats ? { deep: deepStats } : {}),
             },
         };
+        if (runOptions.record === false)
+            return report;
         // Store findings + reinforce patterns in local SQLite before returning.
         // CLI commands call process.exit(), so fire-and-forget writes can be dropped.
         try {

package/dist/hooks/index.d.ts

@@ -4,7 +4,7 @@
  */
 export { runHookChecker } from './checker.js';
 export type { CheckerOptions } from './checker.js';
-export { generateHookFiles } from './templates.js';
+export { generateHookFiles, pushGateShell } from './templates.js';
 export type { GeneratedHookFile } from './templates.js';
 export type { HookTool, HookConfig, HookCheckerResult } from './types.js';
 export { DEFAULT_HOOK_CONFIG, FAST_GATE_IDS } from './types.js';
@@ -16,4 +16,4 @@ export { generateDLPHookFiles } from './dlp-templates.js';
 export type { GeneratedDLPHookFile } from './dlp-templates.js';
 export { stopReview, stopMessage, blocksStop, STOP_MAX_ATTEMPTS } from './stop-review.js';
 export type { StopDecision } from './stop-review.js';
-export { recordSessionBaseline, sessionBaseline, nextStopAttempt, clearStopAttempts } from './session-state.js';
+export { recordSessionBaseline, sessionBaseline, nextStopAttempt, clearStopAttempts, workFingerprint, alreadyReviewed, recordReviewed } from './session-state.js';

package/dist/hooks/index.js

@@ -3,7 +3,7 @@
  *
  */
 export { runHookChecker } from './checker.js';
-export { generateHookFiles } from './templates.js';
+export { generateHookFiles, pushGateShell } from './templates.js';
 export { DEFAULT_HOOK_CONFIG, FAST_GATE_IDS } from './types.js';
 // DLP (Data Loss Prevention) — v4.2.0
 export { scanInputForCredentials, formatDLPAlert, createDLPAuditEntry } from './input-validator.js';
@@ -11,4 +11,4 @@ export { recordDLPFeedback, allowLastDLPBlock, writeDLPBlockManifest, getLearned
 export { generateDLPHookFiles } from './dlp-templates.js';
 // Stop review ("before you say done")
 export { stopReview, stopMessage, blocksStop, STOP_MAX_ATTEMPTS } from './stop-review.js';
-export { recordSessionBaseline, sessionBaseline, nextStopAttempt, clearStopAttempts } from './session-state.js';
+export { recordSessionBaseline, sessionBaseline, nextStopAttempt, clearStopAttempts, workFingerprint, alreadyReviewed, recordReviewed } from './session-state.js';

package/dist/hooks/session-state.d.ts

@@ -2,6 +2,15 @@
 export declare function recordSessionBaseline(cwd: string, session: string): void;
 /** The commit the session started from, if it is still in history (a rebase can drop it). */
 export declare function sessionBaseline(cwd: string, session: string): string | undefined;
+/**
+ * The state of the work: HEAD, the uncommitted diff, and the new files with their size and time.
+ * A stop in the same state as the last review (a turn that only read, or only talked) has
+ * nothing new to review, so the agent is not told the same thing again.
+ */
+export declare function workFingerprint(cwd: string, ownOutputs?: string[]): string | undefined;
+/** Whether the work is in the state the last stop review saw. */
+export declare function alreadyReviewed(cwd: string, session: string, fingerprint: string | undefined): boolean;
+export declare function recordReviewed(cwd: string, session: string, fingerprint: string | undefined): void;
 /** This stop's attempt number: blocks so far plus one. */
 export declare function nextStopAttempt(cwd: string, session: string): number;
 /** The agent finished cleanly: the next stop starts counting again. The baseline stays. */

package/dist/hooks/session-state.js

@@ -6,6 +6,7 @@
  *   - attempts: how many times the stop review has blocked this session.
  */
 import { spawnSync } from 'child_process';
+import { createHash } from 'crypto';
 import fs from 'fs';
 import path from 'path';
 import { repoStateDir } from '../utils/user-state.js';
@@ -50,6 +51,42 @@ export function sessionBaseline(cwd, session) {
     const known = spawnSync('git', ['cat-file', '-e', `${baseline}^{commit}`], { cwd });
     return known.status === 0 ? baseline : undefined;
 }
+/**
+ * The state of the work: HEAD, the uncommitted diff, and the new files with their size and time.
+ * A stop in the same state as the last review (a turn that only read, or only talked) has
+ * nothing new to review, so the agent is not told the same thing again.
+ */
+export function workFingerprint(cwd, ownOutputs = DEFAULT_OWN_OUTPUTS) {
+    const run = (args) => spawnSync('git', args, { cwd, encoding: 'utf8', maxBuffer: 64 * 1024 * 1024 });
+    // Rigour's own files change on every review; where a repository does not ignore them, they must not count as work.
+    const pathspec = ['--', '.', ...ownOutputs.map(own => `:(exclude)${own}`)];
+    const head = run(['rev-parse', '--verify', '--quiet', 'HEAD']);
+    const diff = run(['diff', 'HEAD', '--no-color', '--no-ext-diff', ...pathspec]);
+    const untracked = run(['ls-files', '--others', '--exclude-standard', '-z', ...pathspec]);
+    if (diff.status !== 0 || untracked.status !== 0)
+        return undefined;
+    const hash = createHash('sha256').update(head.stdout).update(diff.stdout);
+    for (const file of untracked.stdout.split('\0').filter(Boolean)) {
+        try {
+            const stat = fs.statSync(path.join(cwd, file));
+            hash.update(`${file}\0${stat.size}\0${stat.mtimeMs}\0`);
+        }
+        catch {
+            hash.update(`${file}\0gone\0`);
+        }
+    }
+    return hash.digest('hex');
+}
+/** What a review writes into the repository: its state folder and its reports. */
+const DEFAULT_OWN_OUTPUTS = ['.rigour', 'rigour-report.json', 'rigour-fix-packet.json'];
+/** Whether the work is in the state the last stop review saw. */
+export function alreadyReviewed(cwd, session, fingerprint) {
+    return !!fingerprint && readStore(cwd)[session]?.reviewed === fingerprint;
+}
+export function recordReviewed(cwd, session, fingerprint) {
+    if (fingerprint)
+        update(cwd, session, entry => ({ ...entry, reviewed: fingerprint }));
+}
 /** This stop's attempt number: blocks so far plus one. */
 export function nextStopAttempt(cwd, session) {
     return update(cwd, session, entry => ({ ...entry, attempts: (entry.attempts ?? 0) + 1 })).attempts ?? 1;

package/dist/hooks/stop-review.d.ts

@@ -1,13 +1,18 @@
 /**
- * The "before you say done" review: when an agent is about to stop, review what
- * the session changed (since its baseline commit, or the uncommitted change when
- * none was recorded) and, if it introduced serious findings, tell the agent what
- * to fix instead of letting it finish.
+ * The "before you say done" review: when an agent is about to stop, review the
+ * whole branch against the commit it left main at (committed, uncommitted and new
+ * files alike; on main itself, what the session changed since its baseline) and,
+ * if it introduced serious findings, tell the agent what to fix instead of
+ * letting it finish. A review with nothing to look at says so; it is never
+ * reported as a clean pass.
  *
- * Only findings that deserve it block: critical ones, and high ones that are
- * proven (the semantic engine traced them) or security findings. A high
- * heuristic (a regex that sees `fetch` without `.catch`) is not enough to hold
- * an agent back; callers also cap the number of attempts.
+ * Only findings that deserve it block: critical ones, high ones that are proven
+ * (the semantic engine traced them) or security findings, findings the change added that are
+ * certain from the code alone (MUST_FIX: dead code, offset paging, an unbounded window, a
+ * duplicate function), and on a branch a merge conflict with main or a mention of a file the
+ * branch deleted (review/branch-checks.ts).
+ * A high heuristic (a regex that sees `fetch` without `.catch`) is not enough to
+ * hold an agent back; callers also cap the number of attempts.
  */
 import type { Config, Failure } from '../types/index.js';
 import { type ReviewTaskItem } from '../review/review-task.js';
@@ -20,10 +25,12 @@ export interface StopDecision {
     /** Every finding on changed lines, and the files the review covered (for fix capture). */
     findings: Failure[];
     reviewedFiles: string[];
+    /** What the review was measured against, e.g. `origin/main @ 1a2b3c4` or `uncommitted work`. */
+    against: string;
 }
-/** `since`: the session's baseline commit (session-state.ts); committing after it hides nothing. */
-export declare function stopReview(cwd: string, config: Config, attempt: number, since?: string): Promise<StopDecision>;
+/** `sessionBaseline`: the commit the session started from, used on main (session-state.ts). */
+export declare function stopReview(cwd: string, config: Config, attempt: number, sessionBaseline?: string): Promise<StopDecision>;
 export declare function reviewAckMessage(items: ReviewTaskItem[], attempt: number): string;
-/** Critical, or high and either proven by the semantic engine or a security finding. */
+/** Critical; high and either proven by the semantic engine or a security finding; or a certain, local finding the change added (MUST_FIX). */
 export declare function blocksStop(finding: Failure): boolean;
 export declare function stopMessage(findings: Failure[], attempt: number): string;

package/dist/hooks/stop-review.js

@@ -1,16 +1,30 @@
 import { reviewChange } from '../review/review.js';
 import { buildReviewTask } from '../review/review-task.js';
 import { diffFromGit } from '../review/git-diff.js';
+import { branchBase } from '../gates/logic-drift-git-base.js';
+import { branchFailures } from '../review/branch-checks.js';
 export const STOP_MAX_ATTEMPTS = 3;
 const MAX_LISTED = 8;
-/** `since`: the session's baseline commit (session-state.ts); committing after it hides nothing. */
-export async function stopReview(cwd, config, attempt, since) {
-    const source = since ? { mode: 'since', commit: since } : { mode: 'working' };
+/** The branch since it left main; on main, what the session changed since its baseline (session-state.ts). */
+function stopSource(cwd, sessionBaseline) {
+    const branch = branchBase(cwd);
+    if (branch && !branch.onMain) {
+        return { source: { mode: 'since', commit: branch.base }, against: `${branch.mainRef.replace(/^refs\/(remotes\/|heads\/)/, '')} @ ${branch.base.slice(0, 7)}` };
+    }
+    return sessionBaseline
+        ? { source: { mode: 'since', commit: sessionBaseline }, against: `this session's start @ ${sessionBaseline.slice(0, 7)}` }
+        : { source: { mode: 'working' }, against: 'uncommitted work' };
+}
+/** `sessionBaseline`: the commit the session started from, used on main (session-state.ts). */
+export async function stopReview(cwd, config, attempt, sessionBaseline) {
+    const { source, against } = stopSource(cwd, sessionBaseline);
     const diff = diffFromGit(cwd, source);
     const result = await reviewChange({ cwd, config, diff, source });
-    const blocking = result.findings.filter(blocksStop);
+    const branch = branchBase(cwd);
+    const whole = branch && !branch.onMain ? branchFailures(cwd, branch.base, branch.mainRef, config) : [];
+    const blocking = [...result.findings.filter(blocksStop), ...whole];
     const unreviewed = config.hooks?.require_review_ack ? buildReviewTask(cwd, diff, config.gates.deep?.router).items : [];
-    const reviewed = { findings: result.findings, reviewedFiles: Object.keys(result.changedLines) };
+    const reviewed = { findings: result.findings, reviewedFiles: Object.keys(result.changedLines), against };
     if (blocking.length === 0 && unreviewed.length === 0)
         return { block: false, message: '', blocking: 0, ...reviewed };
     const message = [
@@ -27,10 +41,12 @@ export function reviewAckMessage(items, attempt) {
         ...listed,
     ].join('\n');
 }
-/** Critical, or high and either proven by the semantic engine or a security finding. */
+/** Certain from the code alone, and quick to fix (each measured with no false alarms before it blocks). */
+const MUST_FIX = new Set(['unused-export', 'orphan-file', 'offset-paging', 'unbounded-window', 'duplicate-function']);
+/** Critical; high and either proven by the semantic engine or a security finding; or a certain, local finding the change added (MUST_FIX). */
 export function blocksStop(finding) {
     const severity = (finding.severity || 'medium');
-    if (severity === 'critical')
+    if (severity === 'critical' || MUST_FIX.has(finding.id))
         return true;
     return severity === 'high' && (finding.verified === true || finding.provenance === 'security');
 }
@@ -41,7 +57,7 @@ export function stopMessage(findings, attempt) {
     });
     const more = findings.length > MAX_LISTED ? [`- …and ${findings.length - MAX_LISTED} more (run \`rigour review\`).`] : [];
     return [
-        `Rigour review found ${findings.length} serious issue(s) on the lines you changed (attempt ${attempt} of ${STOP_MAX_ATTEMPTS}).`,
+        `Rigour review found ${findings.length} issue(s) to fix in what this branch changed (attempt ${attempt} of ${STOP_MAX_ATTEMPTS}).`,
         'Fix them before finishing, or explain why a finding is wrong:',
         ...listed,
         ...more,

package/dist/hooks/templates.d.ts

@@ -2,7 +2,7 @@
  * Hook configuration templates for each AI coding tool.
  *
  * Each template generates the tool-native config format:
- * - Claude Code: .claude/settings.json (PostToolUse matcher)
+ * - Claude Code: .claude/settings.json (PostToolUse checks, Stop review, PreToolUse push gate)
  * - Cursor: .cursor/hooks.json (afterFileEdit event)
  * - Cline: .clinerules/hooks/PostToolUse (executable script)
  * - Windsurf: .windsurf/hooks.json (post_write_code event)
@@ -15,6 +15,13 @@
  *
  */
 import type { HookTool } from './types.js';
+/**
+ * The push gate for a Bash hook: a shell check passes every command that is not a git push straight
+ * through, so the agent's other commands never wait for Rigour to start.
+ */
+export declare function pushGateShell(rigourPushCommand: string): string;
+/** The `rigour hooks push` command matching a `rigour hooks check` command, if the checker is the CLI. */
+export declare function pushCommandFor(checkerCommand: string): string | undefined;
 /** The `rigour hooks stop` command matching a `rigour hooks check` command, if the checker is the CLI. */
 export declare function stopCommandFor(checkerCommand: string, tool: 'claude' | 'cursor'): string | undefined;
 export interface GeneratedHookFile {

package/dist/hooks/templates.js

@@ -2,7 +2,7 @@
  * Hook configuration templates for each AI coding tool.
  *
  * Each template generates the tool-native config format:
- * - Claude Code: .claude/settings.json (PostToolUse matcher)
+ * - Claude Code: .claude/settings.json (PostToolUse checks, Stop review, PreToolUse push gate)
  * - Cursor: .cursor/hooks.json (afterFileEdit event)
  * - Cline: .clinerules/hooks/PostToolUse (executable script)
  * - Windsurf: .windsurf/hooks.json (post_write_code event)
@@ -17,6 +17,19 @@
 import { STOP_MAX_ATTEMPTS } from './stop-review.js';
 /** Seconds Claude Code waits for the stop review before letting the agent stop. */
 const STOP_HOOK_TIMEOUT_S = 120;
+/** Seconds Claude Code waits for the push gate: the project's tests and the reviewer can take minutes. */
+const PUSH_HOOK_TIMEOUT_S = 1800;
+/**
+ * The push gate for a Bash hook: a shell check passes every command that is not a git push straight
+ * through, so the agent's other commands never wait for Rigour to start.
+ */
+export function pushGateShell(rigourPushCommand) {
+    return `sh -c 'payload=$(cat); case "$payload" in *git*push*) printf "%s" "$payload" | ${rigourPushCommand.replace(/'/g, `'\\''`)} ;; esac'`;
+}
+/** The `rigour hooks push` command matching a `rigour hooks check` command, if the checker is the CLI. */
+export function pushCommandFor(checkerCommand) {
+    return /\bhooks check$/.test(checkerCommand.trim()) ? pushGateShell(`${checkerCommand.trim().replace(/hooks check$/, 'hooks push')} --stdin`) : undefined;
+}
 /** The `rigour hooks stop` command matching a `rigour hooks check` command, if the checker is the CLI. */
 export function stopCommandFor(checkerCommand, tool) {
     return /\bhooks check$/.test(checkerCommand.trim()) ? `${checkerCommand.trim().replace(/hooks check$/, 'hooks stop')} --tool ${tool}` : undefined;
@@ -52,10 +65,14 @@ function generateClaudeHooks(checkerCommand) {
                     ]
                 }
             ],
-            // Before the agent finishes: review the uncommitted change, as `rigour hooks init` does.
+            // Before the agent finishes: review the branch against main, as `rigour hooks init` does.
             ...(stopCommandFor(checkerCommand, 'claude')
                 ? { Stop: [{ hooks: [{ type: "command", command: stopCommandFor(checkerCommand, 'claude'), timeout: STOP_HOOK_TIMEOUT_S }] }] }
                 : {}),
+            // Before an agent's git push: the push gate.
+            ...(pushCommandFor(checkerCommand)
+                ? { PreToolUse: [{ matcher: "Bash", hooks: [{ type: "command", command: pushCommandFor(checkerCommand), timeout: PUSH_HOOK_TIMEOUT_S }] }] }
+                : {}),
         }
     };
     return [

package/dist/hooks/templates.test.js

@@ -1,5 +1,6 @@
 import { describe, expect, it } from 'vitest';
-import { generateHookFiles, stopCommandFor } from './templates.js';
+import { execFileSync } from 'child_process';
+import { generateHookFiles, pushCommandFor, pushGateShell, stopCommandFor } from './templates.js';
 const CHECKER = 'npx @rigour-labs/cli@6.5.0 hooks check';
 describe('hook templates', () => {
     it('reviews before the agent stops when the checker is the CLI, like `rigour hooks init`', () => {
@@ -8,6 +9,16 @@ describe('hook templates', () => {
         const cursor = JSON.parse(generateHookFiles('cursor', CHECKER).find(f => f.path.endsWith('hooks.json')).content);
         expect(cursor.hooks.stop[0]).toEqual({ command: 'npx @rigour-labs/cli@6.5.0 hooks stop --tool cursor', loop_limit: 3 });
     });
+    it("gates the agent's git push when the checker is the CLI", () => {
+        const claude = JSON.parse(generateHookFiles('claude', CHECKER)[0].content);
+        expect(claude.hooks.PreToolUse[0]).toEqual({ matcher: 'Bash', hooks: [{ type: 'command', command: expect.stringContaining('npx @rigour-labs/cli@6.5.0 hooks push --stdin'), timeout: 1800 }] });
+        expect(pushCommandFor('node ./my-checker.js')).toBeUndefined();
+    });
+    it.skipIf(process.platform === 'win32')('starts the push gate only for a command that mentions git push', () => {
+        const run = (command) => execFileSync('sh', ['-c', pushGateShell('cat > /dev/null; echo gated; exit 2').replace(/^sh -c /, '').slice(1, -1)], { input: JSON.stringify({ tool_input: { command } }), encoding: 'utf8', stdio: ['pipe', 'pipe', 'pipe'] });
+        expect(run('npm test')).toBe('');
+        expect(() => run('git push -u origin main')).toThrow(); // the gate's exit 2 reaches the agent
+    });
     it('adds no stop hook for a checker that is not the CLI', () => {
         expect(stopCommandFor('node ./my-checker.js', 'claude')).toBeUndefined();
         const claude = JSON.parse(generateHookFiles('claude', 'node ./my-checker.js')[0].content);

package/dist/index.d.ts

@@ -20,6 +20,10 @@ export { isGeneratedFile } from './review/generated-files.js';
 export { countUsage, durationBucket, flushDailyUsage, isTelemetryEnabled, readTelemetryState, setTelemetryEnabled, shouldAskTelemetry, telemetryToken, trackUsage } from './telemetry/telemetry.js';
 export { buildReviewTask, type ReviewTask, type ReviewTaskItem } from './review/review-task.js';
 export { buildQualityReceipt, receiptReport, type QualityReceipt, type ReceiptGap, type ReceiptOptions } from './review/receipt.js';
+export { runToolchain, type ToolResult, type ToolStatus } from './review/toolchain.js';
+export { branchFailures, mergeConflicts, staleReferences } from './review/branch-checks.js';
+export { runReviewer, reviewerBlocks, type ReviewerResult, type ReviewerVerdict } from './review/reviewer.js';
+export { branchBase, type BranchBase } from './gates/logic-drift-git-base.js';
 export { acknowledgeReview, type ReviewAck, type AckResult } from './review/review-ack.js';
 export { exportReviewed, readLedger, reviewedKeys, isReviewed, recordReview, REVIEWED_FILE, type LedgerEntry, type ReviewedKey, type ReviewVerdict } from './review/ledger.js';
 export { rankChangedFunctions, scoreRisk, functionHash, findFunction, type FunctionRisk, type RiskSignals } from './deep/risk.js';

package/dist/index.js

@@ -20,6 +20,10 @@ export { isGeneratedFile } from './review/generated-files.js';
 export { countUsage, durationBucket, flushDailyUsage, isTelemetryEnabled, readTelemetryState, setTelemetryEnabled, shouldAskTelemetry, telemetryToken, trackUsage } from './telemetry/telemetry.js';
 export { buildReviewTask } from './review/review-task.js';
 export { buildQualityReceipt, receiptReport } from './review/receipt.js';
+export { runToolchain } from './review/toolchain.js';
+export { branchFailures, mergeConflicts, staleReferences } from './review/branch-checks.js';
+export { runReviewer, reviewerBlocks } from './review/reviewer.js';
+export { branchBase } from './gates/logic-drift-git-base.js';
 export { acknowledgeReview } from './review/review-ack.js';
 export { exportReviewed, readLedger, reviewedKeys, isReviewed, recordReview, REVIEWED_FILE } from './review/ledger.js';
 export { rankChangedFunctions, scoreRisk, functionHash, findFunction } from './deep/risk.js';

package/dist/review/baseline.d.ts

@@ -0,0 +1,16 @@
+import type { Config, Failure } from '../types/index.js';
+import type { DiffSource } from './git-diff.js';
+/** The commit the change is measured against, or undefined when there is none (a bare diff, a repository without commits). */
+export declare function baseCommit(cwd: string, source: DiffSource | undefined): string | undefined;
+export interface BaseRun {
+    failures: Failure[];
+    /** Changed files the base did not have. */
+    added: Set<string>;
+}
+/** The rules' findings on the repository at `commit`, with the files the change adds as they are now; records nothing. */
+export declare function baseFindings(cwd: string, config: Config, commit: string, files: string[]): Promise<BaseRun>;
+/** Split head findings into those the change introduced and those the base already had. */
+export declare function splitIntroduced(head: Failure[], base: BaseRun): {
+    introduced: Failure[];
+    preexisting: Failure[];
+};

package/dist/review/baseline.js

@@ -0,0 +1,96 @@
+/**
+ * Findings a change did not introduce.
+ *
+ * A function that was already too complex, or a file that already broke a naming convention, is
+ * reported on every review that touches it, and a reviewer learns to skip Rigour's output. The
+ * same rules run on the repository as it was at the base (`git archive`, read-only, into a temporary
+ * folder; about half a second for a few thousand files), so rules that look across the whole
+ * repository see the same picture on both sides. A finding the base already had is counted instead
+ * of reported, even when the change moved its numbers (a function at complexity 105 that reaches
+ * 109 is the same old problem). Files the change adds are copied in as they are now, so both sides
+ * look at the same set of files; findings in those files always count as introduced. Model
+ * findings are never compared: the model reviews only the change.
+ */
+import { spawnSync } from 'child_process';
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { GateRunner } from '../gates/runner.js';
+import { normalizeScopePatterns } from '../utils/scope.js';
+/** The commit the change is measured against, or undefined when there is none (a bare diff, a repository without commits). */
+export function baseCommit(cwd, source) {
+    if (!source)
+        return undefined;
+    const rev = source.mode === 'base' ? git(cwd, ['merge-base', source.base, 'HEAD'])
+        : source.mode === 'since' ? git(cwd, ['rev-parse', '--verify', `${source.commit}^{commit}`])
+            : git(cwd, ['rev-parse', '--verify', 'HEAD']);
+    return rev?.trim() || undefined;
+}
+/** The rules' findings on the repository at `commit`, with the files the change adds as they are now; records nothing. */
+export async function baseFindings(cwd, config, commit, files) {
+    const dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-base-'));
+    try {
+        extractTree(cwd, commit, dir);
+        const added = new Set(files.filter(file => !fs.existsSync(path.join(dir, file))));
+        for (const file of added)
+            copyCurrent(cwd, file, dir);
+        if (added.size === files.length)
+            return { failures: [], added };
+        const modules = path.join(cwd, 'node_modules');
+        if (fs.existsSync(modules))
+            fs.symlinkSync(modules, path.join(dir, 'node_modules'), 'junction');
+        const report = await new GateRunner(config).run(dir, await normalizeScopePatterns(dir, files), undefined, { record: false });
+        return { failures: report.failures, added };
+    }
+    finally {
+        fs.rmSync(dir, { recursive: true, force: true, maxRetries: 3 });
+    }
+}
+/** Split head findings into those the change introduced and those the base already had. */
+export function splitIntroduced(head, base) {
+    const remaining = new Map();
+    for (const f of base.failures)
+        remaining.set(identity(f), (remaining.get(identity(f)) ?? 0) + 1);
+    const introduced = [];
+    const preexisting = [];
+    for (const f of head) {
+        const key = identity(f);
+        const left = remaining.get(key) ?? 0;
+        if (left > 0 && !base.added.has(f.files?.[0] ?? '')) {
+            remaining.set(key, left - 1);
+            preexisting.push(f);
+        }
+        else {
+            introduced.push(f);
+        }
+    }
+    return { introduced, preexisting };
+}
+/** A finding without the numbers that move when unrelated lines are added: line numbers, counts, scores. */
+function identity(f) {
+    const strip = (text) => (text ?? '').replace(/\d+/g, '#');
+    return [f.id, f.files?.[0] ?? '', strip(f.title), strip(f.details)].join('\u0000');
+}
+/** The tree at `commit`, written into `dir` (through a tar file: no buffer limit, and tar ships with Windows 10+). */
+function extractTree(cwd, commit, dir) {
+    const archive = path.join(dir, '.rigour-base.tar');
+    const made = spawnSync('git', ['archive', '--format=tar', '-o', archive, commit], { cwd });
+    if (made.status !== 0)
+        throw new Error(`git archive ${commit} failed: ${String(made.stderr).trim()}`);
+    const unpacked = spawnSync('tar', ['-xf', archive, '-C', dir]);
+    fs.rmSync(archive, { force: true });
+    if (unpacked.status !== 0)
+        throw new Error(`tar failed: ${String(unpacked.stderr).trim()}`);
+}
+function copyCurrent(cwd, file, dir) {
+    const source = path.join(cwd, file);
+    if (!fs.existsSync(source))
+        return;
+    const target = path.join(dir, file);
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.copyFileSync(source, target);
+}
+function git(cwd, args) {
+    const result = spawnSync('git', args, { cwd, encoding: 'utf8' });
+    return result.status === 0 ? result.stdout : undefined;
+}

package/dist/review/baseline.test.d.ts

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