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

package/dist/services/engineering-knowledge-graph.test.js

@@ -1,76 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildEngineeringKnowledgeGraph } from './engineering-knowledge-graph.js';
-describe('engineering knowledge graph', () => {
-    it('connects code, agent outcomes and cross-repository lessons', () => {
-        const graph = buildEngineeringKnowledgeGraph({
-            repository: { id: 'repo-a', name: 'payments' },
-            dependencyGraph: { version: 1, generatedAt: '', nodes: ['src/a.ts', 'src/b.ts'], edges: [{ from: 'src/a.ts', to: 'src/b.ts' }] },
-            events: [],
-            runs: [{ id: 'run-1', agentId: 'agent-1', startedAt: '', endedAt: '', status: 'success', eventCount: 2, files: ['src/a.ts'], tools: ['check'] }],
-            lessons: [{ id: 'lesson-1', repositoryId: 'repo-b', repositoryName: 'platform', visibility: 'team', state: 'promoted', kind: 'interaction', subject: 'Use bounded retries', evidence: {}, confidence: 0.9, source: 'mcp', createdAt: 1, updatedAt: 1 }],
-            patterns: [{ id: 'pattern-1', name: 'withTransaction', type: 'function', file: 'src/a.ts', usageCount: 8 }],
-            memories: [{ id: 'memory-1', label: 'migration-owner', source: 'project' }],
-        });
-        expect(graph.counts.repository).toBe(2);
-        expect(graph.nodes.some(node => node.type === 'outcome' && node.label === 'success')).toBe(true);
-        expect(graph.edges.some(edge => edge.type === 'imports')).toBe(true);
-        expect(graph.edges.some(edge => edge.type === 'produced')).toBe(true);
-        expect(graph.nodes.some(node => node.type === 'pattern')).toBe(true);
-        expect(graph.nodes.some(node => node.type === 'memory')).toBe(true);
-    });
-    it('represents prevented agent actions as policy evidence', () => {
-        const graph = buildEngineeringKnowledgeGraph({
-            repository: { id: 'repo-a', name: 'payments' },
-            events: [{ id: 'event-1', timestamp: '', type: 'tool_denied', agentId: 'agent-1', outcome: 'rejected', files: [], summary: 'write denied' }],
-            runs: [],
-            lessons: [],
-        });
-        expect(graph.nodes).toContainEqual(expect.objectContaining({ type: 'policy', state: 'active' }));
-        expect(graph.nodes).toContainEqual(expect.objectContaining({ type: 'outcome', state: 'verified' }));
-        expect(graph.edges.some(edge => edge.type === 'protects')).toBe(true);
-    });
-    it('connects issued advice to its run and supporting knowledge', () => {
-        const event = {
-            id: 'event-1', requestId: 'run-1', timestamp: '2026-01-01T00:00:00Z', type: 'tool_response',
-            agentId: 'agent-1', outcome: 'success', files: ['src/a.ts'], summary: 'scope returned',
-            guidance: {
-                kind: 'context-scope',
-                recommendation: 'Read only src/a.ts.',
-                patternRefs: [{ id: 'pattern-1', label: 'withTransaction' }],
-                lessonRefs: [], memoryRefs: [], selectedFiles: ['src/a.ts'], excludedFileCount: 9, conflicts: 0,
-            },
-            telemetry: {
-                candidateTokens: 1200, returnedTokens: 200, candidateFiles: 10, returnedFiles: 1,
-                cacheStatus: 'exact-hit', classification: 'measured estimate',
-            },
-        };
-        const graph = buildEngineeringKnowledgeGraph({
-            repository: { id: 'repo-a', name: 'payments' },
-            dependencyGraph: { version: 1, generatedAt: '', nodes: ['src/a.ts'], edges: [] },
-            events: [event],
-            runs: [{ id: 'run-1', agentId: 'agent-1', startedAt: event.timestamp, endedAt: event.timestamp, status: 'success', eventCount: 1, files: ['src/a.ts'], tools: ['rigour_context_scope'] }],
-            lessons: [],
-            patterns: [{ id: 'pattern-1', name: 'withTransaction', type: 'function', file: 'src/a.ts' }],
-        });
-        expect(graph.nodes).toContainEqual(expect.objectContaining({ type: 'advice', evidence: expect.objectContaining({ avoidedTokens: 1000 }) }));
-        expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'run:run-1', to: 'advice:run-1', type: 'guided' }));
-        expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'pattern:pattern-1', to: 'advice:run-1', type: 'informed' }));
-    });
-    it('shows trusted gateway receipts, simulated denials and capability lineage', () => {
-        const graph = buildEngineeringKnowledgeGraph({
-            repository: { id: 'repo-a', name: 'payments' }, events: [], runs: [], lessons: [],
-            gateway: { mode: 'observe', agentId: 'agent-1', taskId: 'task-1', serverCount: 1, toolCount: 2, chainValid: true, receiptCount: 1 },
-            capabilities: [{ id: 'child', action: 'mcp.call', resource: 'mcp://github/get_issue', expiresAt: Date.now() + 1000, policyHash: 'hash', used: false, issuerId: 'owner', subjectId: 'agent-1', parentCapabilityId: 'parent' }],
-            receipts: [{
-                    version: 1, id: 'receipt-1', repositoryId: 'repo-a', mode: 'observe', decision: 'allow', simulatedDecision: 'deny',
-                    reason: 'would deny', policyHash: 'hash', outcome: 'forwarded', createdAt: '2026-01-01T00:00:00Z', digest: 'digest', signature: 'signature',
-                    action: { version: 1, actorId: 'agent-1', taskId: 'task-1', channel: 'mcp', operation: 'github__get_issue', resource: 'mcp://github/get_issue', environment: 'local', sideEffect: 'read', reversibility: 'high', sensitivity: 'normal', blastRadius: 'single-resource' },
-                    capabilityId: 'child',
-                }],
-        });
-        expect(graph.nodes).toContainEqual(expect.objectContaining({ type: 'gateway', evidence: expect.objectContaining({ chainValid: true }) }));
-        expect(graph.nodes).toContainEqual(expect.objectContaining({ type: 'action', state: 'would deny' }));
-        expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'capability:child', to: 'capability:parent', type: 'delegated_from' }));
-        expect(graph.edges).toContainEqual(expect.objectContaining({ from: 'action:receipt-1', to: 'gateway:rigour-mcp', type: 'routes_through' }));
-    });
-});

package/dist/services/model-pricing.test.d.ts

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

package/dist/services/model-pricing.test.js

@@ -1,44 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { normalizeModelKey, getInputPricePerMillionUsd, computeWeightedInputPricePerMillion, estimateAvoidedContextCostUsd, estimateTokenCostUsd, FALLBACK_INPUT_PRICE_PER_MILLION_USD, } from './model-pricing.js';
-describe('model-pricing', () => {
-    it('resolves Composer 2.5 Standard input pricing', () => {
-        expect(getInputPricePerMillionUsd('Composer 2.5 Standard')).toBe(0.5);
-        expect(normalizeModelKey('composer-2-5-standard')).toBe('composer-2.5-standard');
-    });
-    it('resolves Composer 2.5 Fast input pricing', () => {
-        expect(getInputPricePerMillionUsd('composer-2.5-fast')).toBe(3.0);
-        expect(normalizeModelKey('Composer 2.5 Fast')).toBe('composer-2.5-fast');
-    });
-    it('normalizes aliases with spaces and hyphens', () => {
-        expect(normalizeModelKey('Composer_2.5 FAST')).toBe('composer-2.5-fast');
-        expect(normalizeModelKey('composer 25 standard')).toBe('composer-2.5-standard');
-    });
-    it('uses conservative fallback for unknown models', () => {
-        expect(getInputPricePerMillionUsd('totally-unknown-model')).toBe(FALLBACK_INPUT_PRICE_PER_MILLION_USD);
-    });
-    it('computes mixed-model input-token-weighted pricing', () => {
-        const usages = [
-            { source: 'cursor-admin-api', model: 'composer-2.5-standard', inputTokens: 1000, outputTokens: 0 },
-            { source: 'cursor-admin-api', model: 'composer-2.5-fast', inputTokens: 3000, outputTokens: 0 },
-        ];
-        const weighted = computeWeightedInputPricePerMillion(usages);
-        expect(weighted.inputPricePerMillionUsd).toBeCloseTo(2.375, 3);
-        expect(weighted.pricingBasis).toContain('mixed-model-weighted');
-    });
-    it('prefers observed cost when estimating actual spend is unnecessary', () => {
-        const observed = 4.25;
-        expect(observed).toBeGreaterThan(0);
-    });
-    it('estimates actual token cost when observed cost is absent', () => {
-        const estimated = estimateTokenCostUsd(1_000_000, 0, 'composer-2.5-standard');
-        expect(estimated).toBe(0.5);
-    });
-    it('estimates avoided context using input pricing only', () => {
-        const usages = [
-            { source: 'cursor-admin-api', model: 'composer-2.5-standard', inputTokens: 100, outputTokens: 0 },
-        ];
-        const { costUsd, pricing } = estimateAvoidedContextCostUsd(2_000_000, usages);
-        expect(pricing.inputPricePerMillionUsd).toBe(0.5);
-        expect(costUsd).toBe(1.0);
-    });
-});

package/dist/services/observed-savings.test.d.ts

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

package/dist/services/observed-savings.test.js

@@ -1,37 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { observedSavings, recordAgentActivity, recordHookPayload, recordScopeOffer } from './observed-savings.js';
-let cwd;
-beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'observed-savings-')); });
-afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
-const T = 1_000_000;
-describe('observedSavings', () => {
-    it('counts only scoped files the agent did not read afterwards, less the summary', () => {
-        recordScopeOffer(cwd, [{ path: 'src/a.ts', tokens: 3000 }, { path: 'src/b.ts', tokens: 2000 }], 400, T);
-        recordAgentActivity(cwd, 'Read', path.join(cwd, 'src/a.ts'), T + 60_000); // read anyway
-        recordAgentActivity(cwd, 'Edit', path.join(cwd, 'src/b.ts'), T + 90_000); // an edit is not a read
-        expect(observedSavings(cwd)).toEqual({ scopes: 1, trackedScopes: 1, offeredTokens: 5000, readBackTokens: 3000, avoidedTokens: 1600 });
-    });
-    it('claims nothing for a scope no hook observed, so a missing hook never reads as a saving', () => {
-        recordScopeOffer(cwd, [{ path: 'src/a.ts', tokens: 3000 }], 400, T);
-        expect(observedSavings(cwd)).toMatchObject({ scopes: 1, trackedScopes: 0, avoidedTokens: 0 });
-    });
-    it('ignores activity outside the observation window', () => {
-        recordScopeOffer(cwd, [{ path: 'src/a.ts', tokens: 3000 }], 400, T);
-        recordAgentActivity(cwd, 'Read', 'src/a.ts', T + 2 * 60 * 60 * 1000);
-        expect(observedSavings(cwd).trackedScopes).toBe(0);
-    });
-    it('never claims more than was offered when the summary outweighs unread files', () => {
-        recordScopeOffer(cwd, [{ path: 'src/a.ts', tokens: 100 }], 400, T);
-        recordAgentActivity(cwd, 'Grep', undefined, T + 1000);
-        expect(observedSavings(cwd).avoidedTokens).toBe(0);
-    });
-    it('reads a Claude Code PreToolUse payload: the tool, the file it reads, and its working directory', () => {
-        recordScopeOffer(cwd, [{ path: 'src/a.ts', tokens: 3000 }], 400, T);
-        recordHookPayload({ tool_name: 'Read', tool_input: { file_path: path.join(cwd, 'src/a.ts') }, cwd }, '/elsewhere', T + 1000);
-        recordHookPayload({ hello: 'not a tool call' }, cwd, T + 2000);
-        expect(observedSavings(cwd)).toMatchObject({ trackedScopes: 1, readBackTokens: 3000, avoidedTokens: 0 });
-    });
-});

package/dist/services/score-history.test.d.ts

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

package/dist/services/score-history.test.js

@@ -1,61 +0,0 @@
-import * as fs from 'fs';
-import * as os from 'os';
-import * as path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { getScoreTrend } from './score-history.js';
-describe('getScoreTrend', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'score-history-test-'));
-        fs.mkdirSync(path.join(testDir, '.rigour'));
-    });
-    afterEach(() => {
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    function writeScores(scores) {
-        const entries = scores.map((score, index) => ({
-            timestamp: new Date(index * 1000).toISOString(),
-            status: 'FAIL',
-            score,
-            failureCount: 1,
-            severity_breakdown: {},
-            provenance_breakdown: {},
-        }));
-        fs.writeFileSync(path.join(testDir, '.rigour', 'score-history.jsonl'), entries.map(entry => JSON.stringify(entry)).join('\n') + '\n');
-    }
-    it('labels the displayed rising scores as improving despite a higher older window', () => {
-        writeScores([90, 92, 94, 96, 98, 34, 29, 29, 52, 59]);
-        expect(getScoreTrend(testDir)).toMatchObject({
-            direction: 'improving',
-            delta: -53.4,
-            visibleDelta: 25,
-            recentScores: [34, 29, 29, 52, 59],
-            recentAvg: 41,
-            previousAvg: 94,
-        });
-    });
-    it('labels 41 → 41 → 41 → 41 → 52 as improving', () => {
-        writeScores([41, 41, 41, 41, 52]);
-        expect(getScoreTrend(testDir)).toMatchObject({
-            direction: 'improving',
-            visibleDelta: 11,
-            recentScores: [41, 41, 41, 41, 52],
-        });
-    });
-    it('labels a falling displayed series as degrading', () => {
-        writeScores([80, 75, 70, 64, 59]);
-        expect(getScoreTrend(testDir)).toMatchObject({
-            direction: 'degrading',
-            delta: 0,
-            visibleDelta: -21,
-        });
-    });
-    it('treats small visible changes as stable', () => {
-        writeScores([50, 49, 52, 51, 53]);
-        expect(getScoreTrend(testDir)).toMatchObject({
-            direction: 'stable',
-            delta: 0,
-            visibleDelta: 3,
-        });
-    });
-});

package/dist/smoke.test.d.ts

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

package/dist/smoke.test.js

@@ -1,17 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { GateRunner } from '../src/gates/runner.js';
-describe('GateRunner Smoke Test', () => {
-    it('should initialize with empty config', async () => {
-        const config = {
-            version: 1,
-            commands: {},
-            gates: {
-                max_file_lines: 500,
-                forbid_todos: true,
-                forbid_fixme: true,
-            },
-        };
-        const runner = new GateRunner(config);
-        expect(runner).toBeDefined();
-    });
-});

package/dist/storage/cache-cleanup.test.d.ts

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

package/dist/storage/cache-cleanup.test.js

@@ -1,54 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { cleanContextCache, deadCacheRows } from './cache-cleanup.js';
-import { openDatabase } from './db.js';
-let dir;
-let dbPath;
-async function seed(rows) {
-    const db = (await openDatabase(dbPath));
-    // One transaction: row-at-a-time commits are slow enough on Windows to time the test out.
-    await db.exec('BEGIN');
-    for (const [key, type] of rows) {
-        await db.run(`INSERT INTO context_cache (cache_key, cache_type, repo, branch, dependency_fingerprint, payload_json, payload_tokens, created_at)
-             VALUES (?, ?, 'r', 'main', 'f', ?, 1, 0)`, key, type, JSON.stringify({ padding: 'x'.repeat(2000) }));
-    }
-    await db.exec('COMMIT');
-    await db.close();
-}
-beforeEach(() => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cache-cleanup-')); // a temporary database: never ~/.rigour
-    dbPath = path.join(dir, 'rigour.db');
-});
-// Windows keeps a just-closed SQLite file locked for a moment: retry the removal instead of failing.
-afterEach(() => fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }));
-// Real SQLite files on disk: slower on Windows runners than the 5 s default allows.
-describe('cleanContextCache', { timeout: 30_000 }, () => {
-    it('removes the unread layers, keeps the readable rows and the indexes, and shrinks the file', async () => {
-        await seed([
-            ...Array.from({ length: 200 }, (_, i) => [`static:${i}`, 'static']),
-            ...Array.from({ length: 200 }, (_, i) => [`component:${i}`, 'component']),
-            ['semantic:a', 'semantic'], ['checkpoint:b', 'checkpoint'],
-        ]);
-        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 400 });
-        const report = await cleanContextCache(dbPath, () => Number.MAX_SAFE_INTEGER);
-        expect(report).toMatchObject({ removed: 400, kept: 2, vacuumed: true });
-        expect(report.sizeAfter).toBeLessThan(report.sizeBefore);
-        const db = (await openDatabase(dbPath));
-        expect((await db.all('SELECT cache_key FROM context_cache ORDER BY cache_key')).map(r => r.cache_key)).toEqual(['checkpoint:b', 'semantic:a']);
-        expect((await db.all("SELECT name FROM sqlite_master WHERE tbl_name = 'context_cache' AND type = 'index'")).map(r => r.name)).toContain('idx_context_cache_type');
-        await db.close();
-        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 0 });
-    });
-    it('still removes the rows but leaves the file size alone when the disk lacks room to shrink it', async () => {
-        await seed([['static:1', 'static'], ['semantic:a', 'semantic']]);
-        const report = await cleanContextCache(dbPath, () => 0);
-        expect(report).toMatchObject({ removed: 1, kept: 1, vacuumed: false });
-        expect(report.vacuumSkipped).toContain('free to shrink the file');
-    });
-    it('does nothing when there is nothing to remove', async () => {
-        await seed([['semantic:a', 'semantic']]);
-        expect(await cleanContextCache(dbPath, () => 0)).toMatchObject({ removed: 0, vacuumed: false, vacuumSkipped: 'nothing to remove' });
-    });
-});

package/dist/storage/context-telemetry.test.d.ts

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

package/dist/storage/context-telemetry.test.js

@@ -1,80 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach, vi } from 'vitest';
-import path from 'path';
-import os from 'os';
-import fs from 'fs-extra';
-vi.mock('./db.js', () => ({
-    isSQLiteAvailable: () => false,
-    openDatabase: async () => null,
-    DB_PATH: '/tmp/rigour-test.db',
-    RIGOUR_DIR: '/tmp/.rigour',
-}));
-import { recordContextEvent, recordModelUsage, setContextCacheRecord, getContextCacheRecord, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics, } from './context-telemetry.js';
-describe('context-telemetry storage', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-ctx-telemetry-${Date.now()}`);
-    beforeEach(async () => {
-        await fs.ensureDir(path.join(testCwd, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testCwd);
-    });
-    it('records and retrieves context events via JSON fallback', async () => {
-        const id = await recordContextEvent({
-            taskId: 'task-1',
-            toolName: 'rigour_recall',
-            cacheStatus: 'semantic-hit',
-            candidateTokens: 4000,
-            returnedTokens: 800,
-            deduplicatedTokens: 1200,
-        }, testCwd);
-        expect(id).toMatch(/^evt-/);
-        const events = await getContextEvents('task-1', testCwd);
-        expect(events).toHaveLength(1);
-        expect(events[0].toolName).toBe('rigour_recall');
-        expect(events[0].candidateTokens).toBe(4000);
-        expect(events[0].returnedTokens).toBe(800);
-    });
-    it('records and retrieves model usage via JSON fallback', async () => {
-        await recordModelUsage({
-            taskId: 'cursor-imported',
-            provider: 'cursor',
-            model: 'claude-3-5-sonnet',
-            inputTokens: 12000,
-            outputTokens: 1500,
-            observedCostUsd: 1.25,
-            source: 'cursor-dashboard-csv',
-        }, testCwd);
-        const usages = await getModelUsages(undefined, testCwd);
-        expect(usages).toHaveLength(1);
-        expect(usages[0].inputTokens).toBe(12000);
-        expect(usages[0].source).toBe('cursor-dashboard-csv');
-    });
-    it('stores cache records and increments hit count', async () => {
-        await setContextCacheRecord({
-            cacheKey: 'static:repo:main:file.ts:abc123:v1',
-            cacheType: 'static',
-            repo: 'repo',
-            branch: 'main',
-            dependencyFingerprint: 'dep-1',
-            payloadJson: JSON.stringify({ exports: ['foo'] }),
-            payloadTokens: 42,
-        }, testCwd);
-        const first = await getContextCacheRecord('static:repo:main:file.ts:abc123:v1', testCwd);
-        const second = await getContextCacheRecord('static:repo:main:file.ts:abc123:v1', testCwd);
-        expect(first?.payloadTokens).toBe(42);
-        expect(second?.hitCount).toBe(2);
-    });
-    it('records and retrieves checkpoint metrics via JSON fallback', async () => {
-        await recordCheckpointMetric({
-            checkpointId: 'checkpoint:CTP-1:agent-a:implementation',
-            taskId: 'CTP-1',
-            agentId: 'agent-a',
-            rawStateTokens: 50000,
-            checkpointTokens: 400,
-            replayTokensAvoided: 49600,
-        }, testCwd);
-        const metrics = await getCheckpointMetrics('CTP-1', testCwd);
-        expect(metrics).toHaveLength(1);
-        expect(metrics[0].rawStateTokens).toBe(50000);
-        expect(metrics[0].replayTokensAvoided).toBe(49600);
-    });
-});

package/dist/storage/db.test.d.ts

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

package/dist/storage/db.test.js

@@ -1,46 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { isSQLiteAvailable, openDatabase } from './db.js';
-let dir;
-let db;
-beforeEach(async () => {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'rigour-db-'));
-    db = (await openDatabase(path.join(dir, 'rigour.db')));
-});
-afterEach(async () => {
-    await db?.close();
-    fs.rmSync(dir, { recursive: true, force: true });
-});
-describe('the database (node:sqlite)', () => {
-    it('is built in: no package to install', () => {
-        expect(isSQLiteAvailable()).toBe(true);
-        expect(db).not.toBeNull();
-    });
-    it('stores what callers pass the way sqlite3 did: undefined as NULL, booleans as 1 or 0, a Date as epoch ms', async () => {
-        await db.exec('CREATE TABLE t (a, b, c, d)');
-        const when = new Date('2026-01-02T03:04:05Z');
-        const written = await db.run('INSERT INTO t VALUES (?, ?, ?, ?)', undefined, true, false, when);
-        expect(written).toEqual({ changes: 1, lastID: 1 });
-        const row = await db.get('SELECT * FROM t');
-        expect(row).toEqual({ a: null, b: 1, c: 0, d: when.getTime() });
-        expect(Object.getPrototypeOf(row)).toBe(Object.prototype); // a plain object, as callers spread and compare
-        expect(await db.get('SELECT * FROM t WHERE a = 1')).toBeUndefined();
-    });
-    it('rolls a failed transaction back whole', async () => {
-        await db.exec('CREATE TABLE t (a UNIQUE)');
-        await expect(db.transaction(async (tx) => {
-            await tx.run('INSERT INTO t VALUES (?)', 1);
-            await tx.run('INSERT INTO t VALUES (?)', 1); // violates UNIQUE
-        })).rejects.toThrow(/UNIQUE/);
-        expect(await db.all('SELECT * FROM t')).toEqual([]);
-    });
-    it('opens an existing database again with its schema and data, in WAL mode', async () => {
-        await db.run("INSERT INTO meta (key, value) VALUES ('probe', 'kept')");
-        await db.close();
-        db = (await openDatabase(path.join(dir, 'rigour.db')));
-        expect(await db.get("SELECT value FROM meta WHERE key = 'probe'")).toEqual({ value: 'kept' });
-        expect(await db.get('PRAGMA journal_mode')).toEqual({ journal_mode: 'wal' });
-    });
-});

package/dist/storage/fix-lessons.test.d.ts

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

package/dist/storage/fix-lessons.test.js

@@ -1,61 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-/** An in-memory lessons table, enough for the reads and writes fix lessons make. */
-const db = vi.hoisted(() => ({ rows: new Map(), reset() { this.rows = new Map(); } }));
-vi.mock('./db.js', () => {
-    const store = {
-        run: async (sql, ...p) => {
-            if (sql.includes('INSERT INTO lessons'))
-                db.rows.set(p[0], { id: p[0], state: p[4], subject: p[5], evidence_json: p[6], confidence: p[7] });
-            if (sql.includes('UPDATE lessons')) {
-                const row = db.rows.get(p[4]);
-                if (!['promoted', 'rejected'].includes(row.state))
-                    row.state = p[0];
-                Object.assign(row, { evidence_json: p[1], confidence: Math.max(row.confidence, p[2]) });
-            }
-            return { changes: 1, lastID: 0 };
-        },
-        get: async (sql, ...p) => (sql.includes("kind = 'fix'") ? [...db.rows.values()].find(r => r.subject.slice(0, p[1]) === p[2]) : undefined),
-        all: async () => [],
-        exec: async () => undefined,
-        close: async () => undefined,
-    };
-    return { openDatabase: async () => store };
-});
-vi.mock('./local-encryption.js', () => ({ encryptLocalPayload: async (v) => JSON.stringify(v), decryptLocalPayload: async (v) => JSON.parse(v) }));
-vi.mock('./team-store.js', () => ({ loadTeamConfiguration: async () => null }));
-const { recordFixLessons, fixLessonSubject } = await import('./fix-lessons.js');
-const fix = (id, file) => ({
-    id, file, rule: 'semantic-bugs', title: 'Unbounded read without paging', details: 'Rows read without a limit.', before: 'a', after: 'b', resolvedAt: '2026-10-02T00:00:00Z',
-});
-const lessons = () => [...db.rows.values()];
-beforeEach(() => db.reset());
-describe('recordFixLessons', () => {
-    it('turns a fix into a candidate lesson named after the defect it removed', async () => {
-        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
-        expect(lessons().map(l => [l.subject, l.state])).toEqual([['Fixed before: Unbounded read without paging (semantic-bugs). Rows read without a limit.', 'candidate']]);
-    });
-    it('validates the lesson once fixes of that kind reach a second file, and counts the same fix once', async () => {
-        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
-        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts'), fix('f2', 'src/orders.ts')]);
-        expect(lessons()[0].state).toBe('candidate');
-        await recordFixLessons(process.cwd(), [fix('f3', 'src/invoices.ts')]);
-        expect(lessons()).toHaveLength(1);
-        expect(lessons()[0].state).toBe('validated');
-        expect(JSON.parse(lessons()[0].evidence_json).files).toEqual(['src/orders.ts', 'src/invoices.ts']);
-    });
-    it("never overrides a person's decision to promote or reject", async () => {
-        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
-        lessons()[0].state = 'rejected';
-        await recordFixLessons(process.cwd(), [fix('f2', 'src/invoices.ts')]);
-        expect(lessons()[0].state).toBe('rejected');
-    });
-    it('names a fix whose finding had no title after its rule', () => {
-        expect(fixLessonSubject({ rule: 'hallucinated-imports' })).toBe('Fixed before: hallucinated-imports (hallucinated-imports).');
-    });
-    it('groups fixes of one kind even when their details differ', async () => {
-        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
-        await recordFixLessons(process.cwd(), [{ ...fix('f2', 'src/invoices.ts'), details: 'Invoices read in full to count them.' }]);
-        expect(lessons()).toHaveLength(1);
-        expect(lessons()[0].state).toBe('validated');
-    });
-});

package/dist/storage/lessons.test.d.ts

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

package/dist/storage/lessons.test.js

@@ -1,81 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { openDatabase } from './db.js';
-import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
-import { getRepositoryId } from './lessons.js';
-import { queueLocalLessonsForTeam } from './team-import.js';
-const roots = [];
-afterEach(async () => {
-    vi.unstubAllEnvs();
-    await Promise.all(roots.splice(0).map((root) => fs.remove(root)));
-});
-describe('getRepositoryId', () => {
-    it('uses normalized origin identity instead of a basename', async () => {
-        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-repo-id-'));
-        roots.push(root);
-        await fs.ensureDir(path.join(root, '.git'));
-        await fs.writeFile(path.join(root, '.git', 'config'), '[remote "origin"]\nurl = git@github.com:Rigour-Labs/Rigour.git\n');
-        const first = await getRepositoryId(root);
-        const second = await getRepositoryId(path.join(root, '..', path.basename(root)));
-        expect(first).toBe(second);
-        expect(first).toHaveLength(64);
-    });
-    it('uses the shared origin identity from a linked worktree', async () => {
-        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-worktree-id-'));
-        roots.push(root);
-        const common = path.join(root, 'common');
-        const linkedGit = path.join(common, 'worktrees', 'feature');
-        const worktree = path.join(root, 'checkout');
-        await fs.ensureDir(linkedGit);
-        await fs.ensureDir(worktree);
-        await fs.writeFile(path.join(worktree, '.git'), `gitdir: ${linkedGit}\n`);
-        await fs.writeFile(path.join(linkedGit, 'commondir'), '../..\n');
-        await fs.writeFile(path.join(common, 'config'), '[remote "origin"]\nurl = https://github.com/rigour-labs/rigour.git\n');
-        const regular = path.join(root, 'regular');
-        await fs.ensureDir(path.join(regular, '.git'));
-        await fs.writeFile(path.join(regular, '.git', 'config'), '[remote "origin"]\nurl = git@github.com:Rigour-Labs/Rigour.git\n');
-        expect(await getRepositoryId(worktree)).toBe(await getRepositoryId(regular));
-        expect(await getRepositoryId(worktree)).toHaveLength(64);
-    });
-});
-describe('local lesson team import', () => {
-    it('dry-runs, assigns legacy ownership, and queues each lesson version once', async () => {
-        const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-team-import-'));
-        roots.push(root);
-        await fs.ensureDir(path.join(root, '.git'));
-        await fs.writeFile(path.join(root, '.git', 'config'), '[remote "origin"]\nurl = https://github.com/acme/service.git\n');
-        vi.stubEnv('RIGOUR_ORGANIZATION_ID', 'acme');
-        vi.stubEnv('RIGOUR_TEAM_ID', 'platform');
-        vi.stubEnv('RIGOUR_ACTOR_ID', 'alice');
-        vi.stubEnv('RIGOUR_TEAM_DATABASE_URL', 'postgresql://alice@127.0.0.1/rigour');
-        vi.stubEnv('RIGOUR_LOCAL_CACHE_KEY', Buffer.alloc(32, 7).toString('base64'));
-        const repositoryId = await getRepositoryId(root);
-        const databasePath = path.join(root, 'rigour.db');
-        const db = await openDatabase(databasePath);
-        expect(db).not.toBeNull();
-        const now = Date.now();
-        await db.run(`INSERT INTO lessons (
-                id, repository_id, actor_id, team_id, visibility, state, kind, subject,
-                evidence_json, confidence, source, created_at, updated_at
-            ) VALUES (?, ?, NULL, NULL, 'personal', 'candidate', 'interaction', ?, ?, 0.3, 'mcp', ?, ?)`, 'lesson-legacy', repositoryId, 'Prefer scoped retrieval.', await encryptLocalPayload({ requestId: 'legacy-request' }), now, now);
-        await db.close();
-        const preview = await queueLocalLessonsForTeam([root], { databasePath, dryRun: true });
-        expect(preview).toMatchObject({ matched: 1, eligible: 1, wouldQueue: 1, queued: 0 });
-        const queued = await queueLocalLessonsForTeam([root], { databasePath });
-        expect(queued).toMatchObject({ matched: 1, eligible: 1, wouldQueue: 1, queued: 1 });
-        const existingOutbox = await openDatabase(databasePath);
-        await existingOutbox.run('UPDATE sync_outbox SET id = ? WHERE entity_id = ?', 'outbox-created-by-normal-learning', 'lesson-legacy');
-        await existingOutbox.close();
-        const repeated = await queueLocalLessonsForTeam([root], { databasePath });
-        expect(repeated).toMatchObject({ matched: 1, eligible: 1, wouldQueue: 0, queued: 0, alreadyQueued: 1 });
-        const verified = await openDatabase(databasePath);
-        const lesson = await verified.get('SELECT actor_id, team_id, visibility, state FROM lessons WHERE id = ?', 'lesson-legacy');
-        expect(lesson).toMatchObject({ actor_id: 'alice', team_id: 'platform', visibility: 'personal', state: 'candidate' });
-        const outbox = await verified.get('SELECT payload_json FROM sync_outbox WHERE entity_id = ?', 'lesson-legacy');
-        const payload = await decryptLocalPayload(outbox.payload_json);
-        expect(payload).toMatchObject({ id: 'lesson-legacy', actorId: 'alice', teamId: 'platform', visibility: 'personal', state: 'candidate' });
-        await verified.close();
-    });
-});

package/dist/storage/local-encryption.test.d.ts

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

package/dist/storage/local-encryption.test.js

@@ -1,34 +0,0 @@
-import fs from 'fs-extra';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { loadOrCreateFileKey } from './local-encryption.js';
-const temporaryDirectories = [];
-afterEach(async () => {
-    await Promise.all(temporaryDirectories.splice(0).map(directory => fs.remove(directory)));
-});
-async function temporaryKeyPath() {
-    const directory = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-key-test-'));
-    temporaryDirectories.push(directory);
-    return path.join(directory, 'team-cache.key');
-}
-describe('local encryption key storage', () => {
-    it('returns one key when concurrent processes initialize the same path', async () => {
-        const keyPath = await temporaryKeyPath();
-        const keys = await Promise.all(Array.from({ length: 32 }, () => loadOrCreateFileKey(keyPath)));
-        expect(new Set(keys.map(key => key.toString('base64')))).toHaveLength(1);
-        expect(await fs.readFile(keyPath, 'utf8')).toBe(keys[0].toString('base64'));
-    });
-    it('rejects an invalid existing key without replacing it', async () => {
-        const keyPath = await temporaryKeyPath();
-        await fs.writeFile(keyPath, 'not-a-valid-key', 'utf8');
-        await expect(loadOrCreateFileKey(keyPath)).rejects.toThrow('must contain a base64-encoded 32-byte key');
-        expect(await fs.readFile(keyPath, 'utf8')).toBe('not-a-valid-key');
-    });
-    it('accepts an existing key without base64 padding for backward compatibility', async () => {
-        const keyPath = await temporaryKeyPath();
-        const encodedKey = Buffer.alloc(32, 7).toString('base64').replace(/=+$/, '');
-        await fs.writeFile(keyPath, encodedKey, 'utf8');
-        expect((await loadOrCreateFileKey(keyPath)).equals(Buffer.alloc(32, 7))).toBe(true);
-    });
-});

package/dist/storage/local-memory.test.d.ts

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