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

package/dist/services/cursor-usage-sync.test.js

@@ -1,173 +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('../storage/db.js', () => ({
-    isSQLiteAvailable: () => false,
-    openDatabase: async () => null,
-    DB_PATH: '/tmp/rigour-test.db',
-    RIGOUR_DIR: '/tmp/.rigour',
-}));
-import { fetchCursorUsageFromAdminApi, syncCursorUsageFromAdminApi, getTaskCostStats, } from './context-telemetry-service.js';
-import { getModelUsages } from '../storage/context-telemetry.js';
-import { centsToUsd, normalizeCursorUsageEvent } from './cursor-usage-normalizer.js';
-import { CURSOR_FILTERED_USAGE_URL } from './cursor-usage-client.js';
-function buildUsageEvent(overrides = {}) {
-    return {
-        timestamp: '1750979225854',
-        userEmail: 'dev@example.com',
-        conversationId: 'conv-1',
-        model: 'composer-2.5-standard',
-        isTokenBasedCall: true,
-        tokenUsage: {
-            inputTokens: 100,
-            outputTokens: 50,
-            cacheWriteTokens: 10,
-            cacheReadTokens: 20,
-            totalCents: 12.5,
-        },
-        chargedCents: 15.25,
-        ...overrides,
-    };
-}
-describe('cursor admin usage sync', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-cursor-sync-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    const apiKey = 'test-cursor-admin-key';
-    beforeEach(async () => {
-        await fs.ensureDir(path.join(testCwd, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testCwd);
-        vi.restoreAllMocks();
-    });
-    it('imports a single-page response with basic auth header', async () => {
-        const fetchImpl = vi.fn(async (_url, init) => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent()],
-                pagination: { hasNextPage: false, currentPage: 1 },
-            }),
-        }));
-        const imported = await fetchCursorUsageFromAdminApi({
-            cwd: testCwd,
-            apiKey,
-            fetchImpl,
-        });
-        expect(imported).toBe(1);
-        expect(fetchImpl).toHaveBeenCalledTimes(1);
-        const [, init] = fetchImpl.mock.calls[0];
-        expect(init.method).toBe('POST');
-        expect(init.headers.Authorization).toBe(`Basic ${Buffer.from(`${apiKey}:`, 'utf8').toString('base64')}`);
-        expect(init.headers['Content-Type']).toBe('application/json');
-        const body = JSON.parse(init.body);
-        expect(body.pageSize).toBeGreaterThan(0);
-        expect(body.startDate).toBeLessThan(body.endDate);
-    });
-    it('paginates until hasNextPage is false', async () => {
-        let page = 0;
-        const fetchImpl = vi.fn(async () => {
-            page += 1;
-            return {
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    usageEvents: [buildUsageEvent({ conversationId: `conv-${page}` })],
-                    pagination: { hasNextPage: page < 2, currentPage: page },
-                }),
-            };
-        });
-        const result = await syncCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(result.importedCount).toBe(2);
-        expect(result.totalEvents).toBe(2);
-        expect(fetchImpl).toHaveBeenCalledTimes(2);
-    });
-    it('converts cents to USD and stores token fields', async () => {
-        const normalized = normalizeCursorUsageEvent(buildUsageEvent());
-        expect(normalized?.usage.observedCostUsd).toBe(centsToUsd(15.25));
-        expect(normalized?.usage.inputTokens).toBe(100);
-        expect(normalized?.usage.outputTokens).toBe(50);
-        expect(normalized?.usage.cachedInputTokens).toBe(20);
-        expect(normalized?.usage.cacheWriteTokens).toBe(10);
-        expect(normalized?.usage.source).toBe('cursor-admin-api');
-    });
-    it('deduplicates repeated syncs', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent()],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        const first = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        const second = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(first).toBe(1);
-        expect(second).toBe(0);
-        const usages = await getModelUsages(undefined, testCwd);
-        expect(usages.filter(u => u.source === 'cursor-admin-api')).toHaveLength(1);
-    });
-    it('surfaces actionable non-2xx errors without exposing the API key', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: false,
-            status: 401,
-            text: async () => `Unauthorized for key ${apiKey}`,
-        }));
-        await expect(fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl })).rejects.toThrow(/401/);
-        await expect(fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl })).rejects.not.toThrow(apiKey);
-    });
-    it('skips malformed events and handles partial fields', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [
-                    null,
-                    { model: 'composer-2.5-fast', chargedCents: 5 },
-                    buildUsageEvent(),
-                ],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        const imported = await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        expect(imported).toBe(2);
-    });
-    it('marks observed cost stats from imported admin API events', async () => {
-        const fetchImpl = vi.fn(async () => ({
-            ok: true,
-            status: 200,
-            json: async () => ({
-                usageEvents: [buildUsageEvent({ conversationId: 'cost-task' })],
-                pagination: { hasNextPage: false },
-            }),
-        }));
-        await fetchCursorUsageFromAdminApi({ cwd: testCwd, apiKey, fetchImpl });
-        const cost = await getTaskCostStats('cost-task', testCwd);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.costUsd).toBeGreaterThan(0);
-        expect(cost.actual.pricingBasis).toBe('observed-cursor-charged-cents');
-    });
-    it('targets the filtered usage events endpoint', () => {
-        expect(CURSOR_FILTERED_USAGE_URL).toBe('https://api.cursor.com/teams/filtered-usage-events');
-    });
-    it('errors when pagination exceeds the defensive page limit', async () => {
-        let page = 0;
-        const fetchImpl = vi.fn(async () => {
-            page += 1;
-            return {
-                ok: true,
-                status: 200,
-                json: async () => ({
-                    usageEvents: [buildUsageEvent({ conversationId: `conv-page-${page}` })],
-                    pagination: { hasNextPage: true, currentPage: page },
-                }),
-            };
-        });
-        await expect(fetchCursorUsageFromAdminApi({
-            cwd: testCwd,
-            apiKey,
-            fetchImpl,
-            maxPages: 2,
-        })).rejects.toThrow(/truncated after 2 pages/);
-    });
-});

package/dist/services/engineering-knowledge-graph.test.d.ts

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

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 {};