@rigour-labs/core 6.8.0 → 6.8.1

package/dist/semantic/origins.test.js

@@ -1,77 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import ts from 'typescript';
-import { afterEach, describe, expect, it } from 'vitest';
-import { forEachNode, symbolOf } from './ast.js';
-import { originsOf } from './origins.js';
-import { programBatches } from './program.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-/** Program over `files`; returns the checker and a finder for `probe(<expr>)` arguments in main.ts. */
-function setup(files) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'origins-'));
-    for (const [name, body] of Object.entries(files))
-        fs.writeFileSync(path.join(dir, name), body);
-    const [program] = [...programBatches([path.join(dir, 'main.ts')], { strict: true, noEmit: true })];
-    const checker = program.getTypeChecker();
-    const main = program.getSourceFile(path.join(dir, 'main.ts'));
-    const probe = () => {
-        let found;
-        forEachNode(main, (n) => {
-            if (ts.isCallExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === 'probe')
-                found = n.arguments[0];
-        });
-        return found;
-    };
-    const kinds = () => originsOf(checker, probe()).map(o => o.kind === 'call' ? `call:${o.node.expression.getText()}` : o.kind === 'param' ? `param:${o.index}` : o.kind);
-    return { kinds };
-}
-const PRELUDE = 'declare function probe(v: unknown): void;\ndeclare function a(): number;\ndeclare function b(): number;\n';
-describe('originsOf', () => {
-    it('follows const initializers and let reassignments', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}let x = a();\nif (Math.random()) x = b();\nconst y = x;\nprobe(y);\n` });
-        expect(kinds().sort()).toEqual(['call:a', 'call:b']);
-    });
-    it('maps an element of Promise.all([...]) to the matching call', async () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}async function f() {\n  const [first, second] = await Promise.all([a(), b()]);\n  probe(second);\n  return first;\n}\n` });
-        expect(kinds()).toEqual(['call:b']);
-    });
-    it('reads a destructured property from an object literal', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}const obj = { left: a(), right: b() };\nconst { right } = obj;\nprobe(right);\n` });
-        expect(kinds()).toEqual(['call:b']);
-    });
-    it('keeps both sides of ?? and of a conditional', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}const v = Math.random() > 0.5 ? a() : (b() ?? a());\nprobe(v);\n` });
-        expect(kinds().sort()).toEqual(['call:a', 'call:a', 'call:b']);
-    });
-    it('reports a parameter with its index', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}function f(first: number, second: number) {\n  probe(second);\n  return first;\n}\n` });
-        expect(kinds()).toEqual(['param:1']);
-    });
-    it('follows imports across files to the declaration', () => {
-        const { kinds } = setup({
-            'lib.ts': 'export const shared = Math.max(1, 2);\n',
-            'main.ts': `${PRELUDE}import { shared } from './lib';\nprobe(shared);\n`,
-        });
-        expect(kinds()).toEqual(['call:Math.max']);
-    });
-    it('stays unknown for an import that does not resolve', () => {
-        const { kinds } = setup({ 'main.ts': `${PRELUDE}import { missing } from './nowhere';\nprobe(missing);\n` });
-        expect(kinds()).toEqual(['unknown']);
-    });
-});
-describe('symbolOf', () => {
-    it('resolves the name in a shorthand property to the variable it reads', () => {
-        dir = fs.mkdtempSync(path.join(os.tmpdir(), 'origins-'));
-        fs.writeFileSync(path.join(dir, 'main.ts'), "const headers = { 'x-token': 't' };\nexport const init = { headers };\n");
-        const [program] = [...programBatches([path.join(dir, 'main.ts')], { strict: true, noEmit: true })];
-        const main = program.getSourceFile(path.join(dir, 'main.ts'));
-        let shorthand;
-        forEachNode(main, (n) => { if (ts.isShorthandPropertyAssignment(n))
-            shorthand = n; });
-        const decl = symbolOf(program.getTypeChecker(), shorthand.name)?.valueDeclaration;
-        expect(decl && ts.isVariableDeclaration(decl) && decl.name.getText()).toBe('headers');
-    });
-});

package/dist/semantic/project-facts.test.d.ts

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

package/dist/semantic/project-facts.test.js

@@ -1,45 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { ProjectFacts } from './project-facts.js';
-let root;
-afterEach(() => { if (root)
-    fs.rmSync(root, { recursive: true, force: true }); root = undefined; });
-function write(files) {
-    root = fs.mkdtempSync(path.join(os.tmpdir(), 'project-facts-'));
-    for (const [name, text] of Object.entries(files)) {
-        fs.mkdirSync(path.dirname(path.join(root, name)), { recursive: true });
-        fs.writeFileSync(path.join(root, name), text);
-    }
-    return root;
-}
-describe('ProjectFacts', () => {
-    it('reads the nearest package.json, so each monorepo package is judged by its own', () => {
-        const dir = write({
-            'package.json': JSON.stringify({ name: 'root', devDependencies: { vite: '^5.0.0' } }),
-            'packages/ui/package.json': JSON.stringify({ name: '@x/ui', peerDependencies: { 'solid-js': '^1.8.0' } }),
-            'packages/ui/src/a.tsx': '',
-        });
-        const facts = new ProjectFacts(dir);
-        expect(facts.declares('packages/ui/src/a.tsx', 'solid-js')).toBe(true);
-        expect(facts.declares('packages/ui/src/a.tsx', 'vite')).toBe(false);
-        expect(facts.majorVersion('packages/ui/src/a.tsx', 'solid-js')).toBe(1);
-        expect(facts.packageName('packages/ui/src/a.tsx')).toBe('@x/ui');
-        expect(facts.packageDir('packages/ui/src/a.tsx')).toBe(path.join(dir, 'packages/ui'));
-    });
-    it('never reads a manifest above cwd', () => {
-        const dir = write({ 'package.json': JSON.stringify({ dependencies: { react: '^19.0.0' } }), 'app/src/a.tsx': '' });
-        const facts = new ProjectFacts(path.join(dir, 'app'));
-        expect(facts.dependencies('src/a.tsx').size).toBe(0);
-        expect(facts.packageDir('src/a.tsx')).toBeUndefined();
-    });
-    it('resolves compiler options through tsconfig extends', () => {
-        const dir = write({
-            'tsconfig.base.json': JSON.stringify({ compilerOptions: { stripInternal: true } }),
-            'pkg/tsconfig.json': JSON.stringify({ extends: '../tsconfig.base.json' }),
-            'pkg/src/a.ts': '',
-        });
-        expect(new ProjectFacts(dir).compilerOptions('pkg/src/a.ts').stripInternal).toBe(true);
-    });
-});

package/dist/semantic/sites/call-sites.test.d.ts

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

package/dist/semantic/sites/call-sites.test.js

@@ -1,46 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, describe, expect, it } from 'vitest';
-import { exportCallSites } from './export.js';
-let dir;
-afterEach(() => { if (dir)
-    fs.rmSync(dir, { recursive: true, force: true }); dir = undefined; });
-function sites(code) {
-    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'call-sites-'));
-    fs.writeFileSync(path.join(dir, 'main.ts'), code);
-    return exportCallSites(dir, ['main.ts']).map(s => [s.function, s.callee, s.ordinal, s.handledBy]);
-}
-const DECLS = 'declare function a(): Promise<number>;\ndeclare function b(): Promise<number>;\n';
-describe('findCallSites', () => {
-    it('reports awaited calls and says how each handles failure', () => {
-        expect(sites(`${DECLS}
-export async function load() {
-  const x = await a();
-  try { await b(); } catch { return 0; }
-  const y = await a().catch(() => 0);
-  return x + y;
-}`)).toEqual([
-            ['load', 'a', 0, null],
-            ['load', 'b', 0, 'try'],
-            ['load', 'a', 1, 'call'],
-        ]);
-    });
-    it('treats each element of Promise.all as a site, and allSettled as handled', () => {
-        expect(sites(`${DECLS}
-export async function both() {
-  const [x, y] = await Promise.all([a(), b()]);
-  const settled = await Promise.allSettled([a()]);
-  return [x, y, settled];
-}`)).toEqual([
-            ['both', 'a', 0, null],
-            ['both', 'b', 0, null],
-            ['both', 'a', 1, 'all-settled'],
-        ]);
-    });
-    it('counts a callee that catches and returns as handled', () => {
-        expect(sites(`${DECLS}
-async function safeA() { try { return await a(); } catch { return 0; } }
-export async function use() { return await safeA(); }`)).toContainEqual(['use', 'safeA', 0, 'call']);
-    });
-});

package/dist/services/adaptive-thresholds.test.d.ts

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

package/dist/services/adaptive-thresholds.test.js

@@ -1,53 +0,0 @@
-import { describe, it, expect, beforeEach, afterEach } from 'vitest';
-import { recordGateRun, getQualityTrend, clearAdaptiveHistory, } from './adaptive-thresholds.js';
-import * as fs from 'fs';
-import * as path from 'path';
-import * as os from 'os';
-describe('AdaptiveThresholds', () => {
-    let testDir;
-    beforeEach(() => {
-        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'adaptive-test-'));
-    });
-    afterEach(() => {
-        clearAdaptiveHistory(testDir);
-        fs.rmSync(testDir, { recursive: true, force: true });
-    });
-    describe('historical tracking', () => {
-        it('should record gate runs', () => {
-            recordGateRun(testDir, 5, 2, 10);
-            recordGateRun(testDir, 6, 1, 5);
-            const historyPath = path.join(testDir, '.rigour', 'adaptive-history.json');
-            expect(fs.existsSync(historyPath)).toBe(true);
-            const history = JSON.parse(fs.readFileSync(historyPath, 'utf-8'));
-            expect(history.runs).toHaveLength(2);
-        });
-        it('should return stable trend for new projects', () => {
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('stable');
-        });
-        it('should detect improving trend', () => {
-            // Baseline: 15 runs with high failures (with variance for valid std dev)
-            for (let i = 0; i < 15; i++) {
-                recordGateRun(testDir, 3, 5, 15 + (i % 5) * 3); // 15,18,21,24,27 repeating
-            }
-            // Recent: 5 runs with very low failures (clear improvement)
-            for (let i = 0; i < 5; i++) {
-                recordGateRun(testDir, 7, 0, 1);
-            }
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('improving');
-        });
-        it('should detect degrading trend', () => {
-            // Baseline: 15 runs with low failures (with variance for valid std dev)
-            for (let i = 0; i < 15; i++) {
-                recordGateRun(testDir, 7, 1, 1 + (i % 3)); // 1,2,3 repeating
-            }
-            // Recent: 5 runs with high failures (clear degradation)
-            for (let i = 0; i < 5; i++) {
-                recordGateRun(testDir, 3, 5, 25);
-            }
-            const trend = getQualityTrend(testDir);
-            expect(trend).toBe('degrading');
-        });
-    });
-});

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

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

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

@@ -1,69 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { buildAgentRuns, normalizeAgentEvent, normalizeAgentEvents } from './agent-history.js';
-describe('agent history', () => {
-    it('normalizes incomplete historical records without dropping them', () => {
-        const event = normalizeAgentEvent({ type: 'tool_error', arguments: { files: ['src/a.ts'] } });
-        expect(event.agentId).toBe('unknown-agent');
-        expect(event.outcome).toBe('error');
-        expect(event.files).toEqual(['src/a.ts']);
-    });
-    it('groups events into stable runs and retains outcomes', () => {
-        const events = [
-            normalizeAgentEvent({ id: '1', sessionId: 's1', agentId: 'a1', timestamp: '2026-01-01T00:00:00Z', tool: 'read' }),
-            normalizeAgentEvent({ id: '2', sessionId: 's1', agentId: 'a1', timestamp: '2026-01-01T00:01:00Z', type: 'completed', files: ['src/a.ts'] }),
-        ];
-        expect(buildAgentRuns(events)).toMatchObject([{ id: 's1', eventCount: 2, status: 'success', files: ['src/a.ts'] }]);
-    });
-    it('normalizes guidance safely and builds an honest impact receipt', () => {
-        const events = [normalizeAgentEvent({
-                id: 'response-1', requestId: 'request-1', agentId: 'agent-1', timestamp: '2026-01-01T00:00:00Z',
-                type: 'tool_response', status: 'success',
-                guidance: {
-                    kind: 'context-scope',
-                    recommendation: 'Read only the two evidence-backed files.',
-                    patternRefs: [{ id: 'p1', label: 'withTransaction' }, { bad: true }],
-                    lessonRefs: [{ id: 'l1', label: 'Bound retries' }],
-                    selectedFiles: ['src/a.ts', 42],
-                    excludedFileCount: 18,
-                },
-                telemetry: {
-                    candidateTokens: 2400,
-                    returnedTokens: 400,
-                    candidateFiles: 20,
-                    returnedFiles: 2,
-                    cacheStatus: 'exact-hit',
-                    classification: 'measured estimate',
-                },
-            })];
-        expect(events[0].guidance?.selectedFiles).toEqual(['src/a.ts']);
-        expect(buildAgentRuns(events)[0].impact).toMatchObject({
-            guidanceCount: 1,
-            knowledgeItems: 2,
-            avoidedTokens: 2000,
-            excludedFiles: 18,
-            cacheHits: 1,
-        });
-    });
-    it('ignores malformed guidance rather than breaking legacy history', () => {
-        const event = normalizeAgentEvent({ guidance: { kind: 'context-scope', recommendation: 42 }, telemetry: 'bad' });
-        expect(event.guidance).toBeUndefined();
-        expect(event.telemetry).toBeUndefined();
-    });
-});
-describe('normalizeAgentEvents', () => {
-    it('carries request identity into the matching response', () => {
-        const events = normalizeAgentEvents([
-            {
-                type: 'tool_call', requestId: 'request-1', tool: 'rigour_checkpoint',
-                timestamp: '2026-09-10T00:00:00Z',
-                arguments: { agentId: 'agent-a', taskId: 'task-a', filesChanged: ['src/a.ts'] },
-            },
-            {
-                type: 'tool_response', requestId: 'request-1', tool: 'rigour_checkpoint', status: 'success',
-                timestamp: '2026-09-10T00:00:01Z',
-            },
-        ]);
-        expect(events[1]).toMatchObject({ agentId: 'agent-a', taskId: 'task-a', files: ['src/a.ts'] });
-        expect(buildAgentRuns(events)).toHaveLength(1);
-    });
-});

package/dist/services/context-scope-summary.test.d.ts

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

package/dist/services/context-scope-summary.test.js

@@ -1,17 +0,0 @@
-import fs from 'fs';
-import os from 'os';
-import path from 'path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { getContextScopeSummary } from './context-telemetry-service.js';
-let root;
-beforeEach(() => { root = fs.mkdtempSync(path.join(os.tmpdir(), 'scope-summary-')); });
-afterEach(() => fs.rmSync(root, { recursive: true, force: true }));
-describe('getContextScopeSummary', () => {
-    it('counts rule files and skips a rules directory such as .clinerules/', async () => {
-        fs.mkdirSync(path.join(root, '.clinerules'));
-        fs.writeFileSync(path.join(root, '.clinerules', 'rigour.md'), 'rules');
-        fs.writeFileSync(path.join(root, 'CLAUDE.md'), 'Use small PRs.');
-        const summary = await getContextScopeSummary(root);
-        expect(summary.alwaysOnRuleTokens).toBeGreaterThan(0);
-    });
-});

package/dist/services/context-telemetry-service.test.d.ts

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

package/dist/services/context-telemetry-service.test.js

@@ -1,182 +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 { getTaskContextStats, getTaskCostStats, getCacheStats, importCursorUsageCsv, importCursorUsageJson, getContextScopeSummary, getCheckpointSummary, estimateTokenCount, } from './context-telemetry-service.js';
-import { recordContextEvent, recordCheckpointMetric } from '../storage/context-telemetry.js';
-describe('context-telemetry-service', () => {
-    const testCwd = path.join(os.tmpdir(), `rigour-ctx-service-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    const taskId = `task-${Date.now()}`;
-    beforeEach(async () => {
-        await fs.ensureDir(path.join(testCwd, '.rigour'));
-    });
-    afterEach(async () => {
-        await fs.remove(testCwd);
-    });
-    it('returns zeroed stats when no telemetry exists for task', async () => {
-        const stats = await getTaskContextStats(taskId, testCwd);
-        expect(stats.retrievals).toBe(0);
-        expect(stats.candidateTokens).toBe(0);
-        expect(stats.potentialAvoidedTokens).toBe(0);
-        expect(stats.isEstimated).toBe(true);
-    });
-    it('calculates avoided context from recorded events', async () => {
-        await recordContextEvent({
-            taskId,
-            toolName: 'rigour_check_pattern',
-            cacheStatus: 'exact-hit',
-            candidateTokens: 10000,
-            returnedTokens: 2000,
-            deduplicatedTokens: 3000,
-        }, testCwd);
-        const stats = await getTaskContextStats(taskId, testCwd);
-        expect(stats.retrievals).toBe(1);
-        expect(stats.potentialAvoidedTokens).toBe(8000);
-        expect(stats.repeatedReadsPrevented).toBeGreaterThan(0);
-        expect(stats.deduplicatedTokens).toBe(3000);
-        expect(stats.isEstimated).toBe(false);
-    });
-    it('aggregates cache performance from events', async () => {
-        const cacheTaskId = `${taskId}-cache`;
-        await recordContextEvent({
-            taskId: cacheTaskId,
-            toolName: 'rigour_recall',
-            cacheStatus: 'exact-hit',
-            candidateTokens: 1000,
-            returnedTokens: 200,
-        }, testCwd);
-        await recordContextEvent({
-            taskId: cacheTaskId,
-            toolName: 'rigour_context_explain',
-            cacheStatus: 'miss',
-            candidateTokens: 500,
-            returnedTokens: 500,
-        }, testCwd);
-        const events = await import('../storage/context-telemetry.js').then(m => m.getContextEvents(cacheTaskId, testCwd));
-        const cache = await getCacheStats(testCwd);
-        const taskHits = events.filter(e => e.cacheStatus === 'exact-hit').length;
-        const taskMisses = events.filter(e => e.cacheStatus === 'miss').length;
-        expect(taskHits).toBe(1);
-        expect(taskMisses).toBe(1);
-        expect(cache.hitRate).toBe(0.5);
-        expect(cache.isEstimated).toBe(false);
-    });
-    it('imports CSV usage and marks cost stats as observed', async () => {
-        const csv = `Date,Model,Input Tokens,Output Tokens,Cost
-2026-08-05,claude-3-5-sonnet,510000,62000,4.83`;
-        const imported = await importCursorUsageCsv(csv, testCwd);
-        expect(imported).toBe(1);
-        const cost = await getTaskCostStats('cursor-imported', testCwd);
-        expect(cost.actual.inputTokens).toBe(510000);
-        expect(cost.actual.costUsd).toBe(4.83);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.classification).toBe('observed');
-    });
-    it('deduplicates CSV rows on re-import', async () => {
-        const csv = `Date,Model,Input Tokens,Output Tokens,Cost
-2026-08-05,claude-3-5-sonnet,1000,100,1.00`;
-        expect(await importCursorUsageCsv(csv, testCwd)).toBe(1);
-        expect(await importCursorUsageCsv(csv, testCwd)).toBe(0);
-    });
-    it('imports JSON usage records', async () => {
-        const jsonTaskId = `${taskId}-json-${Math.random().toString(36).slice(2)}`;
-        const imported = await importCursorUsageJson([{
-                taskId: jsonTaskId,
-                inputTokens: 2500,
-                outputTokens: 300,
-                observedCostUsd: 0.42,
-                model: 'gpt-4o',
-            }], testCwd);
-        expect(imported).toBe(1);
-        const cost = await getTaskCostStats(jsonTaskId, testCwd);
-        expect(cost.actual.inputTokens).toBe(2500);
-    });
-    it('imports Admin API JSON events with chargedCents and dedupes against sync IDs', async () => {
-        const adminEvent = {
-            timestamp: '1750979225854',
-            conversationId: 'conv-dedupe',
-            model: 'composer-2.5-standard',
-            chargedCents: 42.5,
-            tokenUsage: { inputTokens: 100, outputTokens: 50 },
-        };
-        expect(await importCursorUsageJson([adminEvent], testCwd)).toBe(1);
-        expect(await importCursorUsageJson([adminEvent], testCwd)).toBe(0);
-        const cost = await getTaskCostStats('conv-dedupe', testCwd);
-        expect(cost.actual.costUsd).toBeCloseTo(0.425, 3);
-        expect(cost.actual.isEstimated).toBe(false);
-    });
-    it('summarizes agent scope overlap from session file', async () => {
-        await fs.writeJson(path.join(testCwd, '.rigour', 'agent-session.json'), {
-            agents: [
-                { agentId: 'agent-a', taskScope: ['src/api/**'] },
-                { agentId: 'agent-b', taskScope: ['src/api/**', 'tests/**'] },
-            ],
-        });
-        const scope = await getContextScopeSummary(testCwd);
-        expect(scope.activeAgentCount).toBe(2);
-        expect(scope.overlappingScopesResolved).toBeGreaterThan(0);
-    });
-    it('estimates governance rule token overhead from AGENTS.md', async () => {
-        await fs.writeFile(path.join(testCwd, 'AGENTS.md'), '# Agent rules\n'.repeat(40));
-        const scope = await getContextScopeSummary(testCwd);
-        expect(scope.alwaysOnRuleTokens).toBe(estimateTokenCount('# Agent rules\n'.repeat(40)));
-    });
-    it('aggregates checkpoint compression metrics', async () => {
-        const cpTaskId = `${taskId}-cp`;
-        await recordCheckpointMetric({
-            checkpointId: `checkpoint:${cpTaskId}:a1:phase`,
-            taskId: cpTaskId,
-            agentId: 'a1',
-            rawStateTokens: 10000,
-            checkpointTokens: 500,
-            replayTokensAvoided: 9500,
-        }, testCwd);
-        const summary = await getCheckpointSummary(cpTaskId, testCwd);
-        expect(summary.checkpointCount).toBe(1);
-        expect(summary.rawStateTokens).toBe(10000);
-        expect(summary.compressionRatio).toBe(20);
-        expect(summary.replayTokensAvoided).toBe(9500);
-    });
-    it('marks observed cost from usages and estimates avoided cost by model', async () => {
-        const jsonTaskId = `${taskId}-composer-${Math.random().toString(36).slice(2)}`;
-        await importCursorUsageJson([{
-                id: `json-composer-${jsonTaskId}`,
-                taskId: jsonTaskId,
-                inputTokens: 2_000_000,
-                outputTokens: 0,
-                observedCostUsd: 1.25,
-                model: 'composer-2.5-standard',
-                source: 'cursor-admin-api',
-            }], testCwd);
-        await recordContextEvent({
-            taskId: jsonTaskId,
-            toolName: 'rigour_context_scope',
-            cacheStatus: 'miss',
-            candidateTokens: 3_000_000,
-            returnedTokens: 1_000_000,
-        }, testCwd);
-        const cost = await getTaskCostStats(jsonTaskId, testCwd);
-        expect(cost.actual.isEstimated).toBe(false);
-        expect(cost.actual.costUsd).toBe(1.25);
-        expect(cost.estimated.isEstimated).toBe(true);
-        expect(cost.estimated.inputPricePerMillionUsd).toBe(0.5);
-        expect(cost.estimated.estimatedCostAvoidedUsd).toBeGreaterThan(0);
-    });
-    it('does not combine retrieval and checkpoint counterfactuals', async () => {
-        const id = `${taskId}-separate-${Math.random().toString(36).slice(2)}`;
-        await recordContextEvent({ taskId: id, toolName: 'rigour_context_scope', cacheStatus: 'miss', candidateTokens: 5000, returnedTokens: 1000 }, testCwd);
-        await recordCheckpointMetric({ checkpointId: `${id}-cp`, taskId: id, agentId: 'a1', rawStateTokens: 9000, checkpointTokens: 1000, replayTokensAvoided: 8000 }, testCwd);
-        const cost = await getTaskCostStats(id, testCwd);
-        expect(cost.estimated.retrievalAvoidedTokens).toBe(4000);
-        expect(cost.estimated.checkpointReplayAvoidedTokens).toBe(8000);
-        expect(cost.estimated.potentialContextAvoided).toBe(4000);
-        expect(cost.estimated.categoriesAreAdditive).toBe(false);
-        expect(cost.estimated.retrievalAvoidedCostRangeUsd?.max).toBeGreaterThan(cost.estimated.retrievalAvoidedCostRangeUsd?.min ?? 0);
-    });
-});

package/dist/services/cursor-usage-sync.test.d.ts

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