@rigour-labs/cli 6.8.0 → 6.8.1

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

@@ -1,68 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { printReviewer, reviewerJson } from './review-reviewer.js';
-let out;
-beforeEach(() => {
-    out = [];
-    vi.spyOn(console, 'log').mockImplementation((...args) => void out.push(args.join(' ')));
-});
-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 }], 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'] } });
-        const text = out.join('\n');
-        expect(text).toContain('panel asked (user), single ran: 3 judges asked, claude could run (not installed: codex)');
-        expect(text).toContain('mode single (flag) refused');
-        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).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' }], shown: { blocking: 1, should_fix: 0 }, dropped: [{ id: 'x1' }] });
-    });
-    it('offers "not a bug" only where the team allows dismissals', () => {
-        printReviewer({ ...base, dismissable: false });
-        expect(out.join('\n')).not.toContain('rigour dismiss');
-    });
-});
-describe('rigour review --status', () => {
-    it('runs in a repository with no verdict yet, instead of crashing on the branch lookup', async () => {
-        const { execFileSync } = await import('child_process');
-        const fs = await import('fs');
-        const os = await import('os');
-        const path = await import('path');
-        const { printStatus } = await import('./review-reviewer.js');
-        const repo = fs.mkdtempSync(path.join(os.tmpdir(), 'status-'));
-        execFileSync('git', ['init', '-q', '-b', 'main'], { cwd: repo });
-        execFileSync('git', ['-c', 'user.email=t@example.com', '-c', 'user.name=t', '-c', 'commit.gpgsign=false', 'commit', '-q', '--allow-empty', '-m', 'init'], { cwd: repo });
-        const log = vi.spyOn(console, 'log').mockImplementation(() => undefined);
-        try {
-            expect(await printStatus(repo, true)).toBe(0);
-            expect(JSON.parse(String(log.mock.calls[0][0]))).toMatchObject({ branch: 'main' });
-        }
-        finally {
-            log.mockRestore();
-            fs.rmSync(repo, { recursive: true, force: true });
-        }
-    });
-});

package/dist/commands/review-scope.test.d.ts

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

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

@@ -1,43 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-const fixScope = vi.fn();
-vi.mock('@rigour-labs/core', async (original) => ({ ...(await original()), fixScope }));
-const { printScope } = await import('./review-scope.js');
-let dir;
-let out;
-const SCOPE = { pr: 42, review: { id: 4, login: 'senior', submittedAt: '2026-10-03', commit: 'abcdef0123456789' }, cited: ['src/job.ts'], changed: ['src/job.ts', 'src/other.ts'], extra: ['src/other.ts'] };
-beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-scope-'));
-    out = [];
-    vi.spyOn(console, 'log').mockImplementation((...args) => void out.push(args.join(' ')));
-    fixScope.mockReset();
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    fs.rmSync(dir, { recursive: true, force: true });
-});
-describe('rigour review --scope', () => {
-    it('names the files no point cited and fails', async () => {
-        fixScope.mockResolvedValue({ scope: SCOPE });
-        expect(await printScope(dir, { scope: '42', scopeReview: '4' })).toBe(1);
-        expect(fixScope).toHaveBeenCalledWith(dir, expect.objectContaining({ pr: 42, review: 4 }));
-        const text = out.join('\n');
-        expect(text).toContain("Fix round since senior's review of abcdef012 (pull request 42): 2 files changed, 1 file cited.");
-        expect(text).toContain('✘ 1 file no point of the review cited');
-        expect(text).toContain('  src/other.ts');
-    });
-    it('passes when the round stayed in scope, and answers in JSON', async () => {
-        fixScope.mockResolvedValue({ scope: { ...SCOPE, extra: [] } });
-        expect(await printScope(dir, { scope: true, json: true })).toBe(0);
-        expect(fixScope).toHaveBeenCalledWith(dir, expect.objectContaining({ pr: undefined, review: undefined }));
-        expect(JSON.parse(out.join('\n'))).toMatchObject({ status: 'PASS', pr: 42, extra: [] });
-    });
-    it('is not a pass when it could not tell, and refuses a pull request that is not a number', async () => {
-        fixScope.mockResolvedValue({ error: 'pull request 42 has no review by a person yet' });
-        expect(await printScope(dir, { scope: true })).toBe(3);
-        expect(out.join('\n')).toContain("⚠ Could not check the fix round's scope: pull request 42 has no review by a person yet");
-        await expect(printScope(dir, { scope: 'feature' })).rejects.toThrow('--scope takes a number, not "feature"');
-    });
-});

package/dist/commands/review-stats.test.d.ts

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

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

@@ -1,19 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { appendAgentEvent } from '@rigour-labs/core';
-import { reviewStatsCommand } from './review-stats.js';
-describe('rigour review-stats', () => {
-    let dir;
-    afterEach(() => { if (dir)
-        fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; vi.restoreAllMocks(); });
-    it('reports the loop from the local event log as JSON', () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'review-stats-'));
-        appendAgentEvent(dir, { type: 'stop_review', session: 's', blocked: true });
-        appendAgentEvent(dir, { type: 'stop_review', session: 's', blocked: false });
-        const log = vi.spyOn(console, 'log').mockImplementation(() => { });
-        reviewStatsCommand(dir, { json: true });
-        expect(JSON.parse(String(log.mock.calls[0][0]))).toMatchObject({ stopChecks: 2, stopBlocks: 1, blockedStopsFollowedThrough: 1 });
-    });
-});

package/dist/commands/review-stdin.test.d.ts

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

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

@@ -1,21 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { readsStdinDiff } from './review.js';
-const stat = (kind) => ({
-    isFIFO: () => kind === 'fifo',
-    isFile: () => kind === 'file',
-});
-describe('readsStdinDiff', () => {
-    it('reads a piped or redirected diff when no other source is named', () => {
-        expect(readsStdinDiff({}, stat('fifo'))).toBe(true); // git diff | rigour review
-        expect(readsStdinDiff({}, stat('file'))).toBe(true); // rigour review < change.patch
-    });
-    it('never waits on a socket or terminal an agent left open', () => {
-        expect(readsStdinDiff({}, stat('socket'))).toBe(false);
-        expect(readsStdinDiff({}, stat('tty'))).toBe(false);
-        expect(readsStdinDiff({}, undefined)).toBe(false);
-    });
-    it('ignores stdin once --base or --files names the change', () => {
-        expect(readsStdinDiff({ base: 'origin/main' }, stat('fifo'))).toBe(false);
-        expect(readsStdinDiff({ files: 'src/a.ts' }, stat('file'))).toBe(false);
-    });
-});

package/dist/commands/review-summary.test.d.ts

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

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

@@ -1,46 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { splitByChangedLines } from '@rigour-labs/core';
-import { buildCiReviewSummary, renderGithubSummary } from './review-summary.js';
-function failure(id, severity, file, line, details) {
-    return { id, title: id, details, hint: details, severity, provenance: 'traditional', files: [file], line };
-}
-describe('GitHub change review summary', () => {
-    it('prioritizes severe findings and never includes raw secret-bearing messages', () => {
-        const failures = [
-            failure('style-drift', 'low', 'src/a.ts', 3, 'ordinary style'),
-            failure('security-patterns', 'critical', 'src/shell.ts', 8, 'API_KEY=secret-value-that-must-not-appear'),
-            failure('logic-drift', 'medium', 'src/logic.ts', 5, 'changed operator'),
-        ];
-        const summary = buildCiReviewSummary(failures, 5, { 'src/a.ts': new Set([3]), 'src/shell.ts': new Set([8]) });
-        const markdown = renderGithubSummary(summary);
-        expect(summary.findings.map(item => item.rule)).toEqual(['security-patterns', 'logic-drift', 'style-drift']);
-        expect(summary.severity).toEqual({ critical: 1, high: 0, medium: 1, low: 1 });
-        expect(summary.excluded_outside_changed_lines).toBe(2);
-        expect(summary.changed_lines).toBe(2);
-        expect(markdown).toContain('Trace the input and sink');
-        expect(markdown).not.toContain('secret-value-that-must-not-appear');
-    });
-    it('caps output and escapes untrusted path text', () => {
-        const failures = Array.from({ length: 8 }, (_, i) => failure('style-drift', 'low', `src/bad\`\n${i}.ts`, i + 1, 'untrusted'));
-        const summary = buildCiReviewSummary(failures, 8, {});
-        const markdown = renderGithubSummary(summary);
-        expect(summary.findings).toHaveLength(5);
-        expect(summary.truncated).toBe(3);
-        expect(markdown).not.toContain('bad`');
-        expect(markdown).toContain('3 more finding(s)');
-    });
-    it('does not imply a clean repository when changed lines pass', () => {
-        const markdown = renderGithubSummary(buildCiReviewSummary([], 20, {}));
-        expect(markdown).toContain('No findings on changed lines');
-        expect(markdown).toContain('does not assess the full repository');
-    });
-    it('abstains from attributing file-level findings to changed line one', () => {
-        const withLine = failure('security-patterns', 'high', 'src/a.ts', 5, 'specific line');
-        const fileLevel = { ...failure('AST_COMPLEXITY', 'medium', 'src/a.ts', 1, 'whole file'), line: undefined };
-        const split = splitByChangedLines([withLine, fileLevel], { 'src/a.ts': new Set([1, 5]) });
-        expect(split.findings).toEqual([withLine]);
-        expect(split.fileFindings).toEqual([fileLevel]);
-        const summary = buildCiReviewSummary(split.findings, 2, { 'src/a.ts': new Set([1, 5]) }, split.fileFindings.length + split.unlocated);
-        expect(renderGithubSummary(summary)).toContain('file-level finding(s) lacked a changed-line location');
-    });
-});

package/dist/commands/review-task.test.d.ts

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

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

@@ -1,47 +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 { reviewAckCommand, reviewExportCommand, reviewTaskCommand } from './review-task.js';
-let repo;
-let out;
-const git = (...args) => execFileSync('git', ['-C', repo, ...args], { encoding: 'utf8' });
-beforeEach(() => {
-    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'cli-review-task-'));
-    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, 'README.md'), 'x\n');
-    git('add', '-A');
-    git('commit', '-qm', 'init');
-    fs.writeFileSync(path.join(repo, 'sync.ts'), "export async function syncOrders(db, rows) {\n  await db.from('orders').upsert(rows);\n}\n");
-    out = [];
-    vi.spyOn(console, 'log').mockImplementation((...args) => { out.push(args.join(' ')); });
-    vi.spyOn(console, 'error').mockImplementation((...args) => { out.push(args.join(' ')); });
-});
-afterEach(() => {
-    vi.restoreAllMocks();
-    process.exitCode = undefined;
-    fs.rmSync(repo, { recursive: true, force: true });
-});
-describe('review-task, review-ack, review-export', () => {
-    it('lists the risky function, records a human review, and exports it', async () => {
-        await reviewTaskCommand(repo, { json: true });
-        expect(JSON.parse(out.join('\n')).items).toEqual([expect.objectContaining({ file: 'sync.ts', function: 'syncOrders' })]);
-        reviewAckCommand(repo, 'sync.ts', 'syncOrders', { verdict: 'no_issue', note: 'rows are one page; key is the order id' });
-        expect(out.at(-1)).toContain('Recorded: sync.ts syncOrders (no_issue)');
-        out = [];
-        await reviewTaskCommand(repo, {});
-        expect(out.join('\n')).toContain('No risky changed function waiting for review (1 already reviewed)');
-        reviewExportCommand(repo);
-        const exported = JSON.parse(fs.readFileSync(path.join(repo, '.rigour', 'reviewed.json'), 'utf8'));
-        expect(exported.entries).toEqual([expect.objectContaining({ file: 'sync.ts', function: 'syncOrders', reviewer: 'human', verdict: 'no_issue' })]);
-    });
-    it('rejects an acknowledgement without a real note, with a failing exit code', () => {
-        reviewAckCommand(repo, 'sync.ts', 'syncOrders', { verdict: 'no_issue', note: 'ok' });
-        expect(out.at(-1)).toContain('Not recorded: note must say what was checked');
-        expect(process.exitCode).toBe(1);
-    });
-});

package/dist/commands/scan-rules.test.d.ts

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

package/dist/commands/scan-rules.test.js

@@ -1,29 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { scanRulesCommand } from './scan-rules.js';
-describe('rigour scan-rules', () => {
-    let dir;
-    afterEach(() => { if (dir)
-        fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; vi.restoreAllMocks(); });
-    function scan(files, rules) {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'scan-rules-'));
-        for (const [name, text] of Object.entries(files))
-            fs.writeFileSync(path.join(dir, name), text);
-        const out = [];
-        vi.spyOn(process.stdout, 'write').mockImplementation((chunk) => { out.push(String(chunk)); return true; });
-        scanRulesCommand(dir, Object.keys(files).filter(f => f.endsWith('.ts')), { rules });
-        return out.join('').trim().split('\n').filter(Boolean).map(line => JSON.parse(line));
-    }
-    it('runs only the named rules and prints one JSON line per finding', () => {
-        const code = "export function setup(fn: () => void) {\n  window.addEventListener('a', fn);\n  addEventListener('b', fn);\n}\n"
-            + "// @ts-expect-error internal\nexport const r = (e: any) => e[Symbol.for('lib.internal.x')];\n";
-        expect(scan({ 'a.ts': code }, 'env/bare-browser-global')).toEqual([
-            { rule: 'env/bare-browser-global', file: 'a.ts', line: 3, severity: 'medium', message: expect.stringContaining('addEventListener') },
-        ]);
-    });
-    it('rejects an unknown rule id rather than scanning nothing', () => {
-        expect(() => scan({ 'a.ts': 'export {};\n' }, 'no/such-rule')).toThrow('Unknown rule(s): no/such-rule');
-    });
-});

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

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

package/dist/commands/scan.test.js

@@ -1,64 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import fs from 'fs-extra';
-import path from 'path';
-import os from 'os';
-import { scanCommand } from './scan.js';
-describe('scanCommand', () => {
-    let testDir;
-    beforeEach(async () => {
-        testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-scan-test-'));
-        vi.spyOn(process, 'exit').mockImplementation(() => undefined);
-        vi.spyOn(console, 'log').mockImplementation(() => { });
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    afterEach(async () => {
-        await fs.remove(testDir);
-        vi.restoreAllMocks();
-    });
-    it('runs in zero-config mode without rigour.yml', async () => {
-        await fs.writeJson(path.join(testDir, 'package.json'), { name: 'scan-zero-config-test' });
-        await fs.writeFile(path.join(testDir, 'index.js'), "import fake from 'totally-fake-package';\nconsole.log(fake);\n");
-        await expect(scanCommand(testDir, [], {})).resolves.not.toThrow();
-        expect(process.exit).toHaveBeenCalled();
-        expect(await fs.pathExists(path.join(testDir, 'rigour-report.json'))).toBe(true);
-    }, 30_000);
-    it('uses provided config path when passed', async () => {
-        await fs.writeFile(path.join(testDir, 'app.js'), "export const ok = 42;\n");
-        await fs.writeFile(path.join(testDir, 'scan-config.yml'), `
-version: 1
-gates:
-  required_files: []
-  forbid_todos: false
-  forbid_fixme: false
-  context:
-    enabled: false
-  environment:
-    enabled: false
-  retry_loop_breaker:
-    enabled: false
-  security:
-    enabled: false
-  duplication_drift:
-    enabled: false
-  hallucinated_imports:
-    enabled: false
-  inconsistent_error_handling:
-    enabled: false
-  context_window_artifacts:
-    enabled: false
-  promise_safety:
-    enabled: false
-  phantom_apis:
-    enabled: false
-  deprecated_apis:
-    enabled: false
-  test_quality:
-    enabled: false
-output:
-  report_path: scan-report.json
-`);
-        await expect(scanCommand(testDir, [], { config: 'scan-config.yml' })).resolves.not.toThrow();
-        expect(process.exit).toHaveBeenCalledWith(0);
-        expect(await fs.pathExists(path.join(testDir, 'scan-report.json'))).toBe(true);
-    }, 30_000);
-});

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

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

package/dist/commands/skills.test.js

@@ -1,56 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { installSkills, skillsDoctor } from './skills.js';
-describe('Rigour skills', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-skills-'));
-        vi.spyOn(console, 'log').mockImplementation(() => undefined);
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-        vi.restoreAllMocks();
-    });
-    it('installs native Codex skills with valid discovery metadata', async () => {
-        await installSkills(testDir, ['context'], { target: 'codex' });
-        const filePath = path.join(testDir, '.agents', 'skills', 'rigour-context', 'SKILL.md');
-        const content = fs.readFileSync(filePath, 'utf-8');
-        expect(content).toContain('name: rigour-context');
-        expect(content).toContain('rigour_context_scope');
-        expect(content).toContain('repository-wide scan');
-    });
-    it('installs focused Cursor commands instead of a global rule', async () => {
-        await installSkills(testDir, ['verify'], { target: 'cursor' });
-        const filePath = path.join(testDir, '.cursor', 'commands', 'rigour-verify.md');
-        const content = fs.readFileSync(filePath, 'utf-8');
-        expect(content).toContain('rigour_check');
-        expect(content).toContain('rigour_get_fix_packet');
-        expect(content).not.toContain('alwaysApply');
-    });
-    it('keeps an existing playbook unless force is requested', async () => {
-        const filePath = path.join(testDir, '.cursor', 'commands', 'rigour-context.md');
-        fs.mkdirSync(path.dirname(filePath), { recursive: true });
-        fs.writeFileSync(filePath, 'team customisation');
-        await installSkills(testDir, ['context'], { target: 'cursor' });
-        expect(fs.readFileSync(filePath, 'utf-8')).toBe('team customisation');
-        await installSkills(testDir, ['context'], { target: 'cursor', force: true });
-        expect(fs.readFileSync(filePath, 'utf-8')).toContain('rigour_context_scope');
-    });
-    it('supports a no-write preview and portable playbooks', async () => {
-        await installSkills(testDir, ['handoff'], { target: 'universal', dryRun: true });
-        expect(fs.existsSync(path.join(testDir, 'docs', 'rigour-skills', 'rigour-handoff.md'))).toBe(false);
-        await installSkills(testDir, ['handoff'], { target: 'universal' });
-        const content = fs.readFileSync(path.join(testDir, 'docs', 'rigour-skills', 'rigour-handoff.md'), 'utf-8');
-        expect(content).toContain('portable Rigour playbook');
-        expect(content).toContain('rigour_handoff_accept');
-    });
-    it('reports missing and installed targets through doctor', async () => {
-        await skillsDoctor(testDir);
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('missing'));
-        await installSkills(testDir, ['all'], { target: 'all' });
-        await skillsDoctor(testDir);
-        expect(console.log).toHaveBeenCalledWith(expect.stringContaining('All Rigour playbooks are installed'));
-    });
-});

package/dist/commands/studio-activity.test.d.ts

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

package/dist/commands/studio-activity.test.js

@@ -1,47 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { aboutAnotherRepository, buildActivity, groupSessions, readableFunction } from './studio-activity.js';
-describe('buildActivity', () => {
-    it('turns the record into sentences, newest first, and leaves raw tool traffic out', () => {
-        const items = buildActivity({
-            events: [
-                { type: 'hook_check', timestamp: '2026-10-09T10:00:00Z', files: ['src/pay.ts'], findings: [{ message: 'Stripe API key detected in code' }] },
-                { type: 'tool_call', timestamp: '2026-10-09T10:01:00Z', tool: 'rigour_recall' },
-                { type: 'stop_review', timestamp: '2026-10-09T10:03:00Z', blocked: true, blocking: 1 },
-                { type: 'lessons_served', timestamp: '2026-10-09T10:04:00Z', via: 'recall', lessons: ['Amounts are cents'] },
-            ],
-            ledger: [{ file: 'src/refund.ts', function: 'issueRefund', hash: 'h', reviewer: 'agent', verdict: 'fixed', note: 'Read the row under lock.', at: '2026-10-09T10:05:00Z' }],
-            stories: [{ id: 's', at: '2026-10-09T10:02:00Z', stage: 'edit', file: 'src/pay.ts', rule: 'security-patterns', title: 'Stripe API key detected in code', diff: [] }],
-        });
-        expect(items.map(i => i.text)).toEqual([
-            'Fixed `issueRefund` in src/refund.ts',
-            'Told the agent 1 lesson before it wrote',
-            'Kept the agent working: 1 problem left when it tried to finish',
-            'Fixed: Stripe API key detected in code',
-            'Stopped an edit to src/pay.ts: Stripe API key detected in code',
-        ]);
-    });
-    it('names unnamed functions the way people do', () => {
-        expect(readableFunction('<anonymous>@17', 'src/proxy.test.ts')).toBe('the test at line 17');
-        expect(readableFunction('<anonymous>@4', 'src/a.ts')).toBe('the function at line 4');
-        expect(readableFunction('loadDiagnosis', 'src/a.ts')).toBe('`loadDiagnosis`');
-    });
-    it('groups activity into sessions, with fixes up front and routine items folded', () => {
-        const item = (at, kind, text = 'x') => ({ at, kind, text });
-        const sessions = groupSessions([
-            item('2026-10-09T12:00:00Z', 'reviewed', 'Reviewed `a` in a.ts: no issue'),
-            item('2026-10-09T11:50:00Z', 'reviewed', 'Fixed `b` in b.ts'),
-            item('2026-10-09T11:40:00Z', 'checked'),
-            item('2026-10-09T08:00:00Z', 'stopped'),
-        ]);
-        expect(sessions).toHaveLength(2);
-        expect(sessions[0].counts).toMatchObject({ reviewed: 2, reviewedFixed: 1, checked: 1 });
-        expect(sessions[0].highlights.map(i => i.text)).toEqual(['Fixed `b` in b.ts']);
-        expect(sessions[0].rest).toHaveLength(2);
-        expect(sessions[1].highlights).toHaveLength(1);
-    });
-    it("leaves out old edit events that were about another repository's files", () => {
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['/work/other/src/a.ts'] }, ['/work/app'])).toBe(true);
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['/work/app/src/a.ts'] }, ['/work/app'])).toBe(false);
-        expect(aboutAnotherRepository({ type: 'hook_check', files: ['src/a.ts'] }, ['/work/app'])).toBe(false);
-    });
-});

package/dist/commands/studio-checkouts.test.d.ts

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

package/dist/commands/studio-checkouts.test.js

@@ -1,23 +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 { checkoutRoots } from './studio-checkouts.js';
-let repo;
-beforeEach(() => {
-    repo = fs.realpathSync.native(fs.mkdtempSync(path.join(os.tmpdir(), 'checkouts-')));
-    execFileSync('git', ['init', '-q', repo]);
-    execFileSync('git', ['-C', repo, '-c', 'user.email=t@example.com', '-c', 'user.name=t', 'commit', '-q', '--allow-empty', '-m', 'init']);
-    fs.mkdirSync(path.join(repo, '.rigour'));
-});
-afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
-describe('checkoutRoots', () => {
-    it('lists each checkout once, however the folder is spelled', () => {
-        const tree = path.join(repo, 'wt');
-        execFileSync('git', ['-C', repo, 'worktree', 'add', '-q', tree]);
-        fs.mkdirSync(path.join(tree, '.rigour'));
-        // git reports these folders with forward slashes; started from a trailing-slash path
-        expect(checkoutRoots(repo + path.sep)).toEqual([repo, fs.realpathSync.native(tree)]);
-    });
-});

package/dist/commands/studio-context.test.d.ts

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

package/dist/commands/studio-context.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAgentContext } from './studio-context.js';
-const now = new Date('2026-10-09T12:00:00Z');
-const t = (iso) => Date.parse(iso);
-describe('buildAgentContext', () => {
-    it('sums what agents were given this week: focused files, recalls, lessons, reuse', () => {
-        const ctx = buildAgentContext({
-            now,
-            context: [
-                { toolName: 'rigour_context_scope', cacheStatus: 'none', candidateFiles: 180, returnedFiles: 6, candidateTokens: 90000, returnedTokens: 4000, createdAt: t('2026-10-08T00:00:00Z') },
-                { toolName: 'rigour_context_scope', cacheStatus: 'none', candidateFiles: 180, returnedFiles: 4, candidateTokens: 90000, returnedTokens: 3000, createdAt: t('2026-09-01T00:00:00Z') },
-                { toolName: 'rigour_recall', cacheStatus: 'none', candidateTokens: 0, returnedTokens: 200, createdAt: t('2026-10-07T00:00:00Z') },
-            ],
-            events: [
-                { type: 'lessons_served', timestamp: '2026-10-07T00:00:00Z', lessons: ['a', 'b'] },
-                { type: 'reuse_suggested', timestamp: '2026-10-08T00:00:00Z', planned: 'formatMoney', existing: 'formatCents in src/lib/money.ts:12', action: 'BLOCK' },
-            ],
-        });
-        expect(ctx.week).toEqual({
-            scopes: 1, filesConsidered: 180, filesReturned: 6, tokensConsidered: 90000, tokensReturned: 4000, recalls: 1, lessonsTold: 2,
-            reuse: [{ at: '2026-10-08T00:00:00Z', planned: 'formatMoney', existing: 'formatCents in src/lib/money.ts:12', action: 'BLOCK' }],
-        });
-        expect(ctx.weeks.at(-1)).toMatchObject({ scopes: 1, filesReturned: 6, filesConsidered: 180, recalls: 1, lessonsTold: 2, reuse: 1 });
-        expect(ctx.weeks.reduce((n, w) => n + w.scopes, 0)).toBe(2); // September 1 is inside the 8 weeks
-    });
-});

package/dist/commands/studio-contracts.test.d.ts

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

package/dist/commands/studio-contracts.test.js

@@ -1,8 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { resolveStudioVersion } from './studio-contracts.js';
-describe('resolveStudioVersion', () => {
-    it('prefers the released CLI version used to serve Studio', () => {
-        expect(resolveStudioVersion('6.2.1', '5.4.0')).toBe('6.2.1');
-        expect(resolveStudioVersion(undefined, '6.2.0')).toBe('6.2.0');
-    });
-});

package/dist/commands/studio-guard.test.d.ts

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

package/dist/commands/studio-guard.test.js

@@ -1,24 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { createStudioGuard, refuseStudioRequest, STUDIO_KEY_HEADER, studioLaunchUrl } from './studio-guard.js';
-const guard = createStudioGuard([3000, 3001]);
-const req = (method, headers) => ({ method, headers });
-describe('Studio request guard', () => {
-    it('serves reads only to its own loopback host, so a rebound DNS name cannot read files', () => {
-        expect(refuseStudioRequest(req('GET', { host: '127.0.0.1:3000' }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('GET', { host: 'localhost:3001' }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('GET', { host: 'attacker.example:3000' }), guard)).toBe('unknown host');
-        expect(refuseStudioRequest(req('GET', {}), guard)).toBe('unknown host');
-    });
-    it('accepts a write only with the launch key and no foreign origin', () => {
-        const host = { host: '127.0.0.1:3000' };
-        expect(refuseStudioRequest(req('POST', { ...host, [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('POST', { ...host, origin: 'http://127.0.0.1:3000', [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBeNull();
-        expect(refuseStudioRequest(req('POST', host), guard)).toContain('missing studio key');
-        expect(refuseStudioRequest(req('DELETE', { ...host, [STUDIO_KEY_HEADER]: 'x'.repeat(48) }), guard)).toContain('wrong studio key');
-        expect(refuseStudioRequest(req('POST', { ...host, origin: 'https://evil.example', [STUDIO_KEY_HEADER]: guard.launchKey }), guard)).toBe('cross-origin write');
-    });
-    it('puts the key in the fragment, which the browser never sends to a server', () => {
-        expect(studioLaunchUrl('http://127.0.0.1:3000', guard)).toBe(`http://127.0.0.1:3000/#key=${guard.launchKey}`);
-        expect(createStudioGuard([3000]).launchKey).not.toBe(guard.launchKey);
-    });
-});

package/dist/commands/studio-learned-rules.test.d.ts

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

package/dist/commands/studio-learned-rules.test.js

@@ -1,31 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { saveLearnedRule } from '@rigour-labs/core';
-import { loadStudioLearnedRules } from './studio-learned-rules.js';
-const base = {
-    version: 1, message: 'm', severity: 'medium',
-    source: { commit: 'abc12345', file: 'src/http.ts', function: 'post' },
-    validation: { firesBefore: 1, firesAfter: 0, maxHits: 3, repoHits: ['src/other.ts:4'] },
-};
-describe('loadStudioLearnedRules', () => {
-    let cwd;
-    afterEach(() => { if (cwd)
-        fs.rmSync(cwd, { recursive: true, force: true }); cwd = undefined; });
-    it('describes each rule by what it requires and where it applies', () => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'studio-learned-'));
-        saveLearnedRule(cwd, { ...base, id: 'require-option-redirect-aaaa1111', pattern: { template: 'require-option', callee: { level: 'declaration', key: 'src/http.ts#Deps.fetch' }, argIndex: 1, property: 'redirect' } });
-        saveLearnedRule(cwd, { ...base, id: 'require-guard-cache-control-bbbb2222', pattern: { template: 'require-guard', callee: { level: 'text', key: 'Response.json' }, property: 'cache-control', guard: 'stepsAvailable', appliesWhenArgsMention: false, scope: { file: 'src/route.ts', fn: 'GET>respond' } } });
-        const rules = loadStudioLearnedRules(cwd);
-        expect(rules.map(r => [r.requirement, r.appliesTo])).toEqual([
-            ['`cache-control` conditional on `stepsAvailable`', 'regression guard for GET>respond in src/route.ts'],
-            ['`redirect` in argument 2', 'declaration src/http.ts#Deps.fetch'],
-        ]);
-        expect(rules[1].validation.repoHits).toEqual(['src/other.ts:4']);
-    });
-    it('is empty for a repository without learned rules', () => {
-        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'studio-learned-'));
-        expect(loadStudioLearnedRules(cwd)).toEqual([]);
-    });
-});

package/dist/commands/studio-learning.test.d.ts

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