@rigour-labs/cli 6.7.10 → 6.8.1-rc.1

package/dist/commands/demo.test.js

@@ -1,59 +0,0 @@
-/**
- * Tests for the demo command — all modes: default, --hooks, --cinematic.
- */
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { demoCommand } from './demo.js';
-describe('demoCommand', () => {
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    let consoleSpy;
-    beforeEach(() => {
-        consoleSpy = vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-        vi.spyOn(process.stdout, 'write').mockImplementation(() => true);
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('should run default demo without errors', async () => {
-        await expect(demoCommand({})).resolves.not.toThrow();
-    }, 30_000);
-    it('should run with --hooks flag', async () => {
-        await expect(demoCommand({ hooks: true, speed: 'fast' })).resolves.not.toThrow();
-        // Should show hooks simulation
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('hooks');
-    }, 30_000);
-    it('should run with --cinematic flag at fast speed', async () => {
-        await expect(demoCommand({ cinematic: true, speed: 'fast' })).resolves.not.toThrow();
-        // Cinematic mode should show the before/after flow
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('fix');
-    }, 60_000);
-    it('should produce FAIL status on demo project', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('FAIL');
-    }, 30_000);
-    it('should generate fix packet and audit report', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('Fix packet generated');
-        expect(allOutput).toContain('Audit report exported');
-    }, 30_000);
-    it('should show score bars in output', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        // Score bars use block characters
-        expect(allOutput).toContain('/100');
-    }, 30_000);
-    it('should show whitepaper link in cinematic closing', async () => {
-        await demoCommand({ cinematic: true, speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('zenodo.org');
-    }, 60_000);
-    it('should show hooks init command in closing', async () => {
-        await demoCommand({ speed: 'fast' });
-        const allOutput = consoleSpy.mock.calls.map((c) => c.join(' ')).join('\n');
-        expect(allOutput).toContain('hooks init');
-    }, 30_000);
-});

package/dist/commands/doctor.test.d.ts

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

package/dist/commands/doctor.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { detectInstallKind, hasVersionShadowing } from './doctor.js';
-describe('doctor helpers', () => {
-    it('classifies Homebrew paths', () => {
-        expect(detectInstallKind('/opt/homebrew/bin/rigour')).toBe('homebrew');
-        expect(detectInstallKind('/usr/local/bin/rigour')).toBe('homebrew');
-        expect(detectInstallKind('/opt/homebrew/Cellar/rigour/4.0.5/bin/rigour')).toBe('homebrew');
-    });
-    it('classifies npm/global node_modules paths', () => {
-        expect(detectInstallKind('/opt/homebrew/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
-        expect(detectInstallKind('/Users/test/.nvm/versions/node/v22.0.0/lib/node_modules/@rigour-labs/cli/dist/cli.js')).toBe('npm');
-    });
-    it('returns unknown for unrelated paths', () => {
-        expect(detectInstallKind('/usr/bin/rigour')).toBe('unknown');
-    });
-    it('detects version shadowing only when versions differ', () => {
-        expect(hasVersionShadowing(['4.0.5', '4.0.5'])).toBe(false);
-        expect(hasVersionShadowing(['4.0.5', '2.0.0'])).toBe(true);
-    });
-});

package/dist/commands/exit-codes.test.d.ts

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

package/dist/commands/exit-codes.test.js

@@ -1,20 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { exitCodeFor, EXIT_FAIL, EXIT_INTERNAL_ERROR, EXIT_PASS } from './exit-codes.js';
-const report = (status, deepStatus) => ({
-    status,
-    stats: { duration_ms: 1, ...(deepStatus ? { deep: { enabled: true, status: deepStatus } } : {}) },
-});
-describe('exitCodeFor', () => {
-    it('maps PASS and FAIL to 0 and 1', () => {
-        expect(exitCodeFor(report('PASS'))).toBe(EXIT_PASS);
-        expect(exitCodeFor(report('FAIL'))).toBe(EXIT_FAIL);
-    });
-    it('exits 3 when deep analysis was requested but did not run', () => {
-        expect(exitCodeFor(report('FAIL', 'error'))).toBe(EXIT_INTERNAL_ERROR);
-        expect(exitCodeFor(report('PASS', 'error'))).toBe(EXIT_INTERNAL_ERROR);
-    });
-    it('keeps the normal code for completed or partial deep runs', () => {
-        expect(exitCodeFor(report('PASS', 'ok'))).toBe(EXIT_PASS);
-        expect(exitCodeFor(report('FAIL', 'partial'))).toBe(EXIT_FAIL);
-    });
-});

package/dist/commands/export-training-sites.test.d.ts

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

package/dist/commands/export-training-sites.test.js

@@ -1,25 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { exportTrainingSitesCommand } from './export-training-sites.js';
-describe('rigour export-training-sites', () => {
-    let repo;
-    afterEach(() => { if (repo)
-        fs.rmSync(repo, { recursive: true, force: true }); repo = undefined; vi.restoreAllMocks(); });
-    it('writes one JSON line per awaited call in tracked source files, skipping tests', () => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'sites-cli-'));
-        execFileSync('git', ['init', '-q'], { cwd: repo });
-        fs.mkdirSync(path.join(repo, 'src'));
-        fs.writeFileSync(path.join(repo, 'src/load.ts'), 'declare function get(): Promise<number>;\nexport async function load() { return await get(); }\n');
-        fs.writeFileSync(path.join(repo, 'src/load.test.ts'), 'declare function get(): Promise<number>;\nexport async function t() { return await get(); }\n');
-        execFileSync('git', ['add', '-A'], { cwd: repo });
-        const out = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
-        exportTrainingSitesCommand(repo, []);
-        const sites = out.join('').trim().split('\n').map(line => JSON.parse(line));
-        expect(sites).toEqual([expect.objectContaining({ file: 'src/load.ts', function: 'load', callee: 'get', ordinal: 0, handledBy: null, line: 2 })]);
-        expect(sites[0].source).toContain('return await get()');
-    });
-});

package/dist/commands/hooks-check-repos.test.d.ts

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

package/dist/commands/hooks-check-repos.test.js

@@ -1,33 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { groupFilesByRepo, hookFindings } from './hooks-check-repos.js';
-let base;
-const repo = (name) => {
-    const dir = path.join(base, name);
-    fs.mkdirSync(path.join(dir, 'src'), { recursive: true });
-    execFileSync('git', ['init', '-q', dir]);
-    return fs.realpathSync.native(dir);
-};
-beforeEach(() => { base = fs.mkdtempSync(path.join(os.tmpdir(), 'hook-repos-')); });
-afterEach(() => fs.rmSync(base, { recursive: true, force: true }));
-describe('groupFilesByRepo', () => {
-    it("checks each file in its own repository, not the session's", () => {
-        const app = repo('app');
-        const lib = repo('lib');
-        const groups = groupFilesByRepo(app, ['src/a.ts', path.join(lib, 'src/b.ts')]);
-        expect(groups).toEqual([{ root: app, files: ['src/a.ts'] }, { root: lib, files: ['src/b.ts'] }]);
-    });
-});
-describe('hookFindings', () => {
-    it('keeps code findings and drops findings about the write itself', () => {
-        const result = { status: 'fail', duration_ms: 1, failures: [
-                { gate: 'security-patterns', file: 'src/a.ts', message: 'Hard-coded secret', severity: 'critical', line: 3 },
-                { gate: 'file-guard', file: '.rigour/dismissed.json', message: 'BLOCKED', severity: 'critical' },
-                { gate: 'file-size', file: 'src/big.ts', message: 'Too long', severity: 'low' },
-            ] };
-        expect(hookFindings(result)).toEqual([expect.objectContaining({ id: 'security-patterns', title: 'Hard-coded secret', files: ['src/a.ts'], line: 3 })]);
-    });
-});

package/dist/commands/hooks-git.test.d.ts

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

package/dist/commands/hooks-git.test.js

@@ -1,64 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { fileURLToPath } from 'url';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { gitPushGateCommand, installGitPushHook, selfTestCommand, selfTestGitPushHook } from './hooks-git.js';
-let repo;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' }).trim();
-const bin = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '../../dist/bin.js');
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'git-hook-'));
-    git('init', '-q', '-b', 'main');
-    git('config', 'user.email', 't@example.com');
-    git('config', 'user.name', 't');
-    git('config', 'commit.gpgsign', 'false');
-    git('config', 'core.hooksPath', '.git/hooks'); // a machine-wide hooks path must not reach the test
-    fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 1;\n');
-    fs.writeFileSync(path.join(repo, 'rigour.yml'), 'version: 1\ngates:\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-});
-afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-describe('the git pre-push hook', () => {
-    it('is installed where git looks, once, and completes a hook another tool owns instead of replacing it', () => {
-        const first = installGitPushHook(repo, 'npx --yes @rigour-labs/cli@9.9.9');
-        expect(first.action).toBe('installed');
-        const text = fs.readFileSync(first.path, 'utf8');
-        expect(text).toContain('exec npx --yes @rigour-labs/cli@9.9.9 hooks push --git "$@"');
-        if (process.platform !== 'win32')
-            expect(fs.statSync(first.path).mode & 0o111).toBeTruthy(); // no execute bit on Windows
-        expect(installGitPushHook(repo, 'npx --yes @rigour-labs/cli@9.9.9').action).toBe('present');
-        git('config', 'core.hooksPath', '.husky');
-        fs.mkdirSync(path.join(repo, '.husky'));
-        fs.writeFileSync(path.join(repo, '.husky/pre-push'), '#!/bin/sh\nnpm test\n');
-        const appended = installGitPushHook(repo, 'rigour');
-        expect(appended).toMatchObject({ action: 'appended', path: path.join(repo, '.husky/pre-push') });
-        expect(fs.readFileSync(appended.path, 'utf8')).toBe('#!/bin/sh\nnpm test\n\n# Rigour push gate (rigour hooks init): the same gate for every tool and the terminal.\nrigour hooks push --git "$@" || exit $?\n');
-        expect(installGitPushHook(repo, 'rigour').action).toBe('present');
-        expect(installGitPushHook(path.join(os.tmpdir()), 'rigour').action).toBe('no repository');
-        // A hooks directory outside the repository belongs to whoever set it: named, never written.
-        const elsewhere = fs.mkdtempSync(path.join(os.tmpdir(), 'global-hooks-'));
-        fs.writeFileSync(path.join(elsewhere, 'pre-push'), '#!/bin/sh\nexit 0\n');
-        git('config', 'core.hooksPath', elsewhere);
-        expect(installGitPushHook(repo, 'rigour')).toEqual({ path: path.join(elsewhere, 'pre-push'), action: 'managed elsewhere' });
-        expect(fs.readFileSync(path.join(elsewhere, 'pre-push'), 'utf8')).toBe('#!/bin/sh\nexit 0\n');
-        fs.rmSync(elsewhere, { recursive: true, force: true });
-    });
-    it('refuses a push from a tree with uncommitted changes to tracked files, and lets a branch deletion through', async () => {
-        const refs = `refs/heads/main ${git('rev-parse', 'HEAD')} refs/heads/main 0000000000000000000000000000000000000000\n`;
-        fs.writeFileSync(path.join(repo, 'a.ts'), 'export const a = 2;\n');
-        const dirty = await gitPushGateCommand(refs, repo);
-        expect(dirty.exitCode).toBe(1);
-        expect(dirty.message).toContain('uncommitted changes to tracked files');
-        expect(dirty.message).toContain(' M a.ts');
-        const deletion = await gitPushGateCommand('(delete) 0000000000000000000000000000000000000000 refs/heads/old 1234567890123456789012345678901234567890\n', repo);
-        expect(deletion).toEqual({ exitCode: 0, message: '' });
-    });
-    it('holds under a real git push: a change the gate must refuse is refused, the fix lands, read from the remote', async () => {
-        const result = await selfTestGitPushHook(selfTestCommand(bin));
-        expect(result.steps.join('\n')).toContain('was refused');
-        expect(result).toMatchObject({ ok: true });
-    }, 120_000);
-});

package/dist/commands/hooks-push.test.d.ts

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

package/dist/commands/hooks-push.test.js

@@ -1,86 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { hooksPushCommand, isPush, pushTarget } from './hooks-push.js';
-describe('push command parsing', () => {
-    it('acts on a real push only', () => {
-        expect(isPush('git push -u origin feature')).toBe(true);
-        expect(isPush('cd app && git -C . push')).toBe(true);
-        expect(isPush('git push --dry-run')).toBe(false);
-        expect(isPush('git status && npm test')).toBe(false);
-        expect(isPush('echo "do not git pushx"')).toBe(false);
-        expect(isPush('claude -p review --disallowedTools "Bash(git push:*)"')).toBe(false); // text inside an argument
-        expect(isPush('npm test && git push origin main')).toBe(true);
-        expect(isPush('git -C "/work/my app" push')).toBe(true);
-    });
-    it('finds the repository the push runs in', () => {
-        expect(pushTarget('cd /work/app && git push')).toBe('/work/app');
-        expect(pushTarget('git -C "/work/my app" push')).toBe('/work/my app');
-        expect(pushTarget('git push')).toBeUndefined();
-    });
-});
-describe('rigour hooks push', () => {
-    let repo;
-    const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-    const write = (rel, body) => {
-        fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-        fs.writeFileSync(path.join(repo, rel), body);
-    };
-    const push = (command = 'git push') => hooksPushCommand(JSON.stringify({ cwd: repo, tool_input: { command } }), '/');
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'push-gate-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        write('.gitignore', '.rigour/\nnode_modules/\n');
-        write('src/main.ts', "import { used } from './util';\nconsole.log(used);\n");
-        write('src/util.ts', 'export const used = 1;\n');
-        write('package.json', '{"scripts":{"start":"node src/main.ts"}}\n');
-        write('rigour.yml', 'version: 1\ngates:\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-        git('checkout', '-q', '-b', 'feature');
-    });
-    afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); });
-    it('lets any other command, and a clean branch, through', async () => {
-        expect(await push('npm test')).toEqual({ exitCode: 0, message: '' });
-        write('src/util.ts', 'export const used = 2;\n');
-        git('commit', '-qam', 'tweak');
-        expect(await push()).toEqual({ exitCode: 0, message: '' });
-    });
-    it('blocks a push when a check could not run: a TypeScript project whose program cannot be built', async () => {
-        write('tsconfig.json', '{"extends":"./.generated/tsconfig.json"}\n');
-        write('src/util.ts', 'export const used = 2;\n');
-        git('add', '-A');
-        git('commit', '-qm', 'typed change, broken config');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('- typed-checks-unavailable could not run: ');
-        expect(result.message).toContain('.generated/tsconfig.json');
-    });
-    it('blocks a push that adds an export nothing uses, saying where', async () => {
-        write('src/util.ts', 'export const used = 1;\nexport const forgotten = 2;\n');
-        git('commit', '-qam', 'add forgotten');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('Push blocked');
-        expect(result.message).toContain('src/util.ts:2 Unused export');
-    });
-    it("blocks a push the project's own formatter rejects, and keeps the output in a log", async () => {
-        const bin = path.join(repo, 'node_modules', '.bin');
-        fs.mkdirSync(bin, { recursive: true });
-        fs.writeFileSync(path.join(bin, 'prettier.js'), "console.log('[warn] src/util.ts'); process.exit(1);\n");
-        fs.writeFileSync(path.join(bin, 'prettier'), '#!/bin/sh\nexec node "$(dirname "$0")/prettier.js" "$@"\n', { mode: 0o755 });
-        fs.writeFileSync(path.join(bin, 'prettier.cmd'), '@node "%~dp0\\prettier.js" %*\r\n');
-        write('src/util.ts', 'export const used =   3;\n');
-        git('commit', '-qam', 'unformatted');
-        const result = await push();
-        expect(result.exitCode).toBe(2);
-        expect(result.message).toContain('- format failed: prettier --check');
-        const log = result.message.match(/full output: (\S+)\)/)[1];
-        expect(fs.readFileSync(log, 'utf8')).toContain('[warn] src/util.ts');
-    });
-});

package/dist/commands/hooks-stop.test.d.ts

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

package/dist/commands/hooks-stop.test.js

@@ -1,165 +0,0 @@
-import { execFileSync } from 'child_process';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { recordSessionBaseline } from '@rigour-labs/core';
-import { hooksStopCommand } from './hooks-stop.js';
-// A credential header on a redirect-following request: a proven (verified) high finding.
-const LEAKY = "export async function notify(endpoint: string, signature: string) {\n  return fetch(endpoint, { method: 'POST', headers: { 'x-hook-signature': signature } });\n}\n";
-// Only a heuristic finding (fetch without error handling), not proven.
-const HEURISTIC = "export async function load(url: string) {\n  return fetch(url);\n}\n";
-describe('rigour hooks stop', () => {
-    let repo;
-    const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-    const write = (rel, body) => {
-        fs.mkdirSync(path.dirname(path.join(repo, rel)), { recursive: true });
-        fs.writeFileSync(path.join(repo, rel), body);
-    };
-    beforeEach(() => {
-        repo = fs.mkdtempSync(path.join(os.tmpdir(), 'stop-hook-'));
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        write('rigour.yml', 'version: 1\ngates:\n  semantic_bugs:\n    enabled: true\n  unused_exports:\n    block: true\n'); // this team blocks on dead code
-        write('.gitignore', '.rigour/\n');
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-    });
-    afterEach(() => { fs.rmSync(repo, { recursive: true, force: true }); vi.restoreAllMocks(); });
-    it('keeps Claude working on a proven finding, then gives up after three attempts', async () => {
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 's1' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first.decision).toBe('block');
-        expect(first.reason).toContain('src/notify.ts:2');
-        expect(first.reason).toContain('attempt 1 of 3');
-        for (const n of [1, 2]) {
-            write('src/notify.ts', `${LEAKY}// attempt ${n}\n`); // the agent edits, still leaking
-            await hooksStopCommand('claude', payload, '/');
-        }
-        write('src/notify.ts', `${LEAKY}// attempt 3\n`);
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-    });
-    it('sends Cursor a follow-up message, and stops following up at the loop limit', async () => {
-        write('src/notify.ts', LEAKY);
-        const reply = JSON.parse(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'completed', loop_count: 0 }), '/'));
-        expect(reply.followup_message).toContain('src/notify.ts:2');
-        expect(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'completed', loop_count: 3 }), '/')).toBe('');
-        expect(await hooksStopCommand('cursor', JSON.stringify({ cwd: repo, status: 'aborted' }), '/')).toBe('');
-    });
-    it('asks once, at the end of the task, about what the team learned that applies to the change', async () => {
-        const lesson = { id: 'l1', text: 'Time out every fetch the loader makes.', file: 'src/load.ts', symbols: ['load'], state: 'verified', evidence: [{ pr: 7, comment: 'c1', author: 'senior' }, { pr: 9, comment: 'c2', author: 'senior' }], createdAt: '2026-01-01', updatedAt: '2026-01-01' };
-        write('.rigour/review-lessons.json', JSON.stringify({ version: 1, lessons: [lesson, { ...lesson, id: 'l2', text: 'Unrelated lesson about billing.', file: 'src/billing.ts', symbols: ['charge'] }] }));
-        write('src/load.ts', HEURISTIC);
-        write('src/main.ts', "import { load } from './load';\nvoid load('/');\n");
-        const payload = JSON.stringify({ cwd: repo, session_id: 'teach' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first.decision).toBe('block');
-        expect(first.reason).toContain('src/load.ts: Time out every fetch the loader makes. (acted on in PR #7, #9)');
-        expect(first.reason).not.toContain('billing');
-        write('src/load.ts', `${HEURISTIC}// the agent checked it\n`);
-        expect(await hooksStopCommand('claude', payload, '/')).toBe(''); // asked once: never a loop
-    });
-    it('lets the agent stop when only heuristic findings remain', async () => {
-        write('src/load.ts', HEURISTIC);
-        write('src/main.ts', "import { load } from './load';\nvoid load('/');\n");
-        write('package.json', '{"scripts":{"start":"node src/main.ts"}}\n'); // wired in: not dead code
-        expect(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's2' }), '/')).toBe('');
-    });
-    it('says once when the review cannot run, then lets the agent stop', async () => {
-        const notARepo = fs.mkdtempSync(path.join(os.tmpdir(), 'stop-hook-norepo-'));
-        vi.spyOn(process.stderr, 'write').mockImplementation(() => true);
-        const payload = JSON.stringify({ cwd: notARepo, session_id: 'broken' });
-        const first = JSON.parse(await hooksStopCommand('claude', payload, '/'));
-        expect(first).toMatchObject({ decision: 'block' });
-        expect(first.reason).toContain('Rigour could not review this change');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-        fs.rmSync(notARepo, { recursive: true, force: true });
-    });
-    it('still reviews what the session committed', async () => {
-        recordSessionBaseline(repo, 's3');
-        write('src/notify.ts', LEAKY);
-        git('add', '-A');
-        git('commit', '-qm', 'hide it in a commit');
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's3' }), '/'));
-        expect(reply.reason).toContain('src/notify.ts:2');
-    });
-    it('reviews the whole branch, including commits made before the session started', async () => {
-        git('checkout', '-q', '-b', 'feature');
-        write('src/notify.ts', LEAKY);
-        git('add', '-A');
-        git('commit', '-qm', 'earlier work on the branch');
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'branch' }), '/'));
-        expect(reply.reason).toContain('src/notify.ts:2');
-    });
-    it('says there was nothing to review instead of passing silently', async () => {
-        git('checkout', '-q', '-b', 'empty');
-        const said = [];
-        vi.spyOn(process.stderr, 'write').mockImplementation((chunk) => { said.push(String(chunk)); return true; });
-        expect(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'empty' }), '/')).toBe('');
-        expect(said.join('')).toContain('nothing to review against main @');
-    });
-    it('holds the agent back on an export the branch added that nothing uses', async () => {
-        git('checkout', '-q', '-b', 'dead');
-        write('src/util.ts', 'export const used = 1;\nexport const forgotten = 2;\n');
-        write('src/main.ts', "import { used } from './util';\nconsole.log(used);\n");
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 'dead' }), '/'));
-        expect(reply.reason).toContain('src/util.ts:2 Unused export');
-    });
-    it('does not repeat itself after a turn that changed nothing, and reviews again after an edit', async () => {
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 'quiet' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe(''); // a read-only turn: already said
-        write('src/notify.ts', LEAKY + '// touched\n');
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-    });
-    it("does not count Rigour's own files as new work where the repository does not ignore them", async () => {
-        write('.gitignore', ''); // a repository that does not ignore .rigour/ or the report
-        git('add', '-A');
-        git('commit', '-qm', 'ignore nothing');
-        write('src/notify.ts', LEAKY);
-        const payload = JSON.stringify({ cwd: repo, session_id: 'own-files' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        write('rigour-report.json', '{"rewritten":true}\n'); // what a review leaves behind
-        write('.rigour/scan-cache.json', '{}\n');
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-    });
-    it('ignores an attempt counter written into the workspace', async () => {
-        write('.rigour/stop-hook.json', JSON.stringify({ s4: 3 }));
-        write('src/notify.ts', LEAKY);
-        const reply = JSON.parse(await hooksStopCommand('claude', JSON.stringify({ cwd: repo, session_id: 's4' }), '/'));
-        expect(reply.reason).toContain('attempt 1 of 3');
-    });
-});
-describe('the agent fix loop', () => {
-    it('turns an agent fix to a stop-hook finding into a validated rule', async () => {
-        const { learnCommand } = await import('./learn.js');
-        const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'agent-loop-'));
-        const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-        git('init', '-q', '-b', 'main');
-        git('config', 'user.email', 't@example.com');
-        git('config', 'user.name', 't');
-        git('config', 'commit.gpgsign', 'false');
-        fs.writeFileSync(path.join(repo, '.gitignore'), '.rigour/\n');
-        git('add', '-A');
-        git('commit', '-qm', 'init');
-        fs.mkdirSync(path.join(repo, 'src'));
-        fs.writeFileSync(path.join(repo, 'src/notify.ts'), LEAKY);
-        fs.writeFileSync(path.join(repo, 'package.json'), '{"scripts":{"notify":"node src/notify.ts"}}\n'); // wired in: not dead code
-        const payload = JSON.stringify({ cwd: repo, session_id: 'loop' });
-        expect(JSON.parse(await hooksStopCommand('claude', payload, '/')).decision).toBe('block');
-        fs.writeFileSync(path.join(repo, 'src/notify.ts'), LEAKY.replace("{ method: 'POST',", "{ method: 'POST', redirect: 'manual',"));
-        expect(await hooksStopCommand('claude', payload, '/')).toBe('');
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        await learnCommand(repo, undefined, { agentFixes: true });
-        const rules = fs.readdirSync(path.join(repo, '.rigour', 'rules'));
-        expect(rules).toHaveLength(1);
-        expect(JSON.parse(fs.readFileSync(path.join(repo, '.rigour', 'rules', rules[0]), 'utf8')).pattern)
-            .toMatchObject({ template: 'require-option', property: 'redirect', value: 'manual' });
-        expect(fs.readdirSync(path.join(repo, '.rigour', 'agent-fixes', 'resolved'))).toEqual([]);
-        fs.rmSync(repo, { recursive: true, force: true });
-    });
-});

package/dist/commands/hooks.test.d.ts

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