@rigour-labs/core 5.5.4 → 6.1.0-beta.1

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

@@ -17,6 +17,7 @@ export interface TaskContextStats {
     potentialAvoidedTokens: number;
     cacheHitRate: number;
     repeatedReadsPrevented: number;
+    deduplicatedTokens: number;
     checkpointReplayAvoided: number;
     isEstimated: boolean;
 }
@@ -26,15 +27,35 @@ export interface TaskCostStats {
         outputTokens: number;
         costUsd: number;
         source: string;
+        models: string[];
         isEstimated: boolean;
         pricingBasis?: string;
+        classification: 'observed' | 'modelled estimate' | 'unavailable';
+        observedCoverage: number;
     };
     estimated: {
+        /** Compatibility alias: retrieval-only avoided tokens. */
         potentialContextAvoided: number;
+        /** Compatibility alias: retrieval-only avoided cost. */
         estimatedCostAvoidedUsd: number;
+        retrievalAvoidedTokens: number;
+        retrievalAvoidedCostUsd: number;
+        checkpointReplayAvoidedTokens: number;
+        checkpointReplayAvoidedCostUsd: number;
+        retrievalAvoidedCostRangeUsd?: {
+            min: number;
+            max: number;
+        };
+        checkpointReplayAvoidedCostRangeUsd?: {
+            min: number;
+            max: number;
+        };
+        categoriesAreAdditive: false;
         isEstimated: boolean;
         inputPricePerMillionUsd?: number;
         pricingBasis?: string;
+        pricingSource: string;
+        pricingEffectiveDate: string;
     };
 }
 export interface CachePerformanceStats {

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

@@ -8,7 +8,7 @@ import fs from 'fs-extra';
 import path from 'path';
 import { getContextEvents, getModelUsages, getCheckpointMetrics, recordModelUsage, } from '../storage/index.js';
 import { getCursorApiKey } from '../settings.js';
-import { estimateAvoidedContextCostUsd, estimateTokenCostUsd, computeWeightedInputPricePerMillion, } from './model-pricing.js';
+import { estimateAvoidedContextCostUsd, estimateTokenCostUsd, computeWeightedInputPricePerMillion, MODEL_PRICING_EFFECTIVE_DATE, MODEL_PRICING_SOURCE, } from './model-pricing.js';
 import { fetchCursorUsagePages } from './cursor-usage-client.js';
 import { CURSOR_ADMIN_API_SOURCE, centsToUsd, isCursorAdminApiEvent, normalizeCursorUsageEvent } from './cursor-usage-normalizer.js';
 /** Heuristic token counter (~4 chars per token for code/text) */
@@ -46,6 +46,7 @@ export async function getTaskContextStats(taskId, cwd) {
     let returnedTokens = 0;
     let cacheHits = 0;
     let repeatedReads = 0;
+    let deduplicatedTokens = 0;
     for (const e of events) {
         candidateTokens += e.candidateTokens || 0;
         returnedTokens += e.returnedTokens || 0;
@@ -53,6 +54,7 @@ export async function getTaskContextStats(taskId, cwd) {
             cacheHits++;
         }
         const deduped = e.deduplicatedTokens ?? 0;
+        deduplicatedTokens += deduped;
         if (deduped > 0) {
             repeatedReads += Math.ceil(deduped / 500);
         }
@@ -68,6 +70,7 @@ export async function getTaskContextStats(taskId, cwd) {
         potentialAvoidedTokens,
         cacheHitRate,
         repeatedReadsPrevented: repeatedReads,
+        deduplicatedTokens,
         checkpointReplayAvoided,
         isEstimated: retrievals === 0,
     };
@@ -83,10 +86,13 @@ export async function getTaskCostStats(taskId, cwd) {
     let observedCostUsd = 0;
     let primarySource = 'estimated';
     const hasObservedUsage = usages.length > 0;
+    let observedUsageCount = 0;
     for (const u of usages) {
         actualInputTokens += u.inputTokens || 0;
         actualOutputTokens += u.outputTokens || 0;
         observedCostUsd += u.observedCostUsd || 0;
+        if ((u.observedCostUsd || 0) > 0)
+            observedUsageCount++;
         if (u.source && u.source !== 'estimated') {
             primarySource = u.source;
         }
@@ -103,23 +109,46 @@ export async function getTaskCostStats(taskId, cwd) {
     else if (hasObservedCost) {
         actualPricingBasis = 'observed-cursor-charged-cents';
     }
-    const totalPotentialAvoided = stats.potentialAvoidedTokens + stats.checkpointReplayAvoided;
-    const avoidedPricing = estimateAvoidedContextCostUsd(totalPotentialAvoided, usages);
+    const retrievalPricing = estimateAvoidedContextCostUsd(stats.potentialAvoidedTokens, usages);
+    const checkpointPricing = estimateAvoidedContextCostUsd(stats.checkpointReplayAvoided, usages);
+    const unknownPricing = retrievalPricing.pricing.pricingBasis.includes('fallback');
+    const range = (tokens) => ({
+        min: parseFloat(((tokens / 1_000_000) * 0.15).toFixed(4)),
+        max: parseFloat(((tokens / 1_000_000) * 15).toFixed(4)),
+    });
     return {
         actual: {
             inputTokens: actualInputTokens,
             outputTokens: actualOutputTokens,
             costUsd: parseFloat(actualCostUsd.toFixed(4)),
             source: primarySource,
+            models: Array.from(new Set(usages.map(usage => usage.model).filter((model) => Boolean(model)))),
             isEstimated: actualIsEstimated,
             pricingBasis: actualPricingBasis,
+            classification: hasObservedCost
+                ? 'observed'
+                : hasObservedUsage
+                    ? 'modelled estimate'
+                    : 'unavailable',
+            observedCoverage: usages.length > 0
+                ? parseFloat((observedUsageCount / usages.length).toFixed(2))
+                : 0,
         },
         estimated: {
-            potentialContextAvoided: totalPotentialAvoided,
-            estimatedCostAvoidedUsd: avoidedPricing.costUsd,
+            potentialContextAvoided: stats.potentialAvoidedTokens,
+            estimatedCostAvoidedUsd: retrievalPricing.costUsd,
+            retrievalAvoidedTokens: stats.potentialAvoidedTokens,
+            retrievalAvoidedCostUsd: retrievalPricing.costUsd,
+            checkpointReplayAvoidedTokens: stats.checkpointReplayAvoided,
+            checkpointReplayAvoidedCostUsd: checkpointPricing.costUsd,
+            retrievalAvoidedCostRangeUsd: unknownPricing ? range(stats.potentialAvoidedTokens) : undefined,
+            checkpointReplayAvoidedCostRangeUsd: unknownPricing ? range(stats.checkpointReplayAvoided) : undefined,
+            categoriesAreAdditive: false,
             isEstimated: true,
-            inputPricePerMillionUsd: avoidedPricing.pricing.inputPricePerMillionUsd,
-            pricingBasis: avoidedPricing.pricing.pricingBasis,
+            inputPricePerMillionUsd: retrievalPricing.pricing.inputPricePerMillionUsd,
+            pricingBasis: retrievalPricing.pricing.pricingBasis,
+            pricingSource: MODEL_PRICING_SOURCE,
+            pricingEffectiveDate: MODEL_PRICING_EFFECTIVE_DATE,
         },
     };
 }

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

@@ -39,6 +39,7 @@ describe('context-telemetry-service', () => {
         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 () => {
@@ -75,6 +76,7 @@ describe('context-telemetry-service', () => {
         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
@@ -166,4 +168,15 @@ describe('context-telemetry-service', () => {
         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/engineering-knowledge-graph.d.ts

@@ -0,0 +1,55 @@
+import type { DependencyGraph } from '../context/dependency-graph.js';
+import type { LessonRecord } from '../storage/lessons.js';
+import type { AgentHistoryEvent, AgentRun } from './agent-history.js';
+export type KnowledgeNodeType = 'repository' | 'file' | 'agent' | 'task' | 'run' | 'advice' | 'pattern' | 'memory' | 'lesson' | 'policy' | 'outcome';
+export interface KnowledgeNode {
+    id: string;
+    type: KnowledgeNodeType;
+    label: string;
+    detail?: string;
+    state?: string;
+    repositoryId?: string;
+    weight: number;
+    evidence?: Record<string, unknown>;
+}
+export interface KnowledgeEdge {
+    id: string;
+    from: string;
+    to: string;
+    type: 'contains' | 'imports' | 'performed' | 'belongs_to' | 'touched' | 'produced' | 'resulted_in' | 'defined_in' | 'protects' | 'remembered' | 'guided' | 'informed';
+}
+export interface EngineeringKnowledgeGraph {
+    schemaVersion: 1;
+    generatedAt: string;
+    nodes: KnowledgeNode[];
+    edges: KnowledgeEdge[];
+    truncated: boolean;
+    counts: Record<string, number>;
+}
+interface GraphInput {
+    repository: {
+        id: string;
+        name: string;
+    };
+    dependencyGraph?: DependencyGraph | null;
+    events: AgentHistoryEvent[];
+    runs: AgentRun[];
+    lessons: LessonRecord[];
+    patterns?: Array<{
+        id: string;
+        name: string;
+        type: string;
+        file: string;
+        description?: string;
+        usageCount?: number;
+    }>;
+    memories?: Array<{
+        id: string;
+        label: string;
+        detail?: string;
+        source?: string;
+    }>;
+    maxFiles?: number;
+}
+export declare function buildEngineeringKnowledgeGraph(input: GraphInput): EngineeringKnowledgeGraph;
+export {};

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

@@ -0,0 +1,177 @@
+function shortPath(value) {
+    const parts = value.split('/');
+    return parts.length > 3 ? `…/${parts.slice(-3).join('/')}` : value;
+}
+function shortLabel(value, limit = 72) {
+    return value.length > limit ? `${value.slice(0, limit - 1)}…` : value;
+}
+export function buildEngineeringKnowledgeGraph(input) {
+    const nodes = new Map();
+    const edges = new Map();
+    const addNode = (node) => nodes.set(node.id, node);
+    const addEdge = (from, to, type) => {
+        const id = `${type}:${from}:${to}`;
+        edges.set(id, { id, from, to, type });
+    };
+    const repoId = `repository:${input.repository.id}`;
+    addNode({ id: repoId, type: 'repository', label: input.repository.name, detail: input.repository.id, repositoryId: input.repository.id, weight: 10 });
+    const eventFiles = new Set(input.events.flatMap(event => event.files));
+    const graph = input.dependencyGraph;
+    const degree = new Map();
+    for (const edge of graph?.edges ?? []) {
+        degree.set(edge.from, (degree.get(edge.from) ?? 0) + 1);
+        degree.set(edge.to, (degree.get(edge.to) ?? 0) + 1);
+    }
+    const maxFiles = input.maxFiles ?? 180;
+    const selectedFiles = [...(graph?.nodes ?? [])]
+        .sort((a, b) => Number(eventFiles.has(b)) - Number(eventFiles.has(a)) || (degree.get(b) ?? 0) - (degree.get(a) ?? 0))
+        .slice(0, maxFiles);
+    const selected = new Set(selectedFiles);
+    for (const file of selectedFiles) {
+        const id = `file:${file}`;
+        addNode({ id, type: 'file', label: shortPath(file), detail: file, repositoryId: input.repository.id, weight: Math.min(8, 1 + (degree.get(file) ?? 0)) });
+        addEdge(repoId, id, 'contains');
+    }
+    for (const edge of graph?.edges ?? []) {
+        if (selected.has(edge.from) && selected.has(edge.to))
+            addEdge(`file:${edge.from}`, `file:${edge.to}`, 'imports');
+    }
+    for (const run of input.runs.slice(0, 100)) {
+        const agentId = `agent:${run.agentId}`;
+        const runId = `run:${run.id}`;
+        addNode({ id: agentId, type: 'agent', label: run.agentId, weight: 5 });
+        addNode({ id: runId, type: 'run', label: run.taskId ?? run.id, detail: `${run.eventCount} events`, state: run.status, weight: 4 });
+        addEdge(agentId, runId, 'performed');
+        addEdge(runId, repoId, 'belongs_to');
+        if (run.taskId) {
+            const taskId = `task:${run.taskId}`;
+            addNode({ id: taskId, type: 'task', label: run.taskId, weight: 4 });
+            addEdge(runId, taskId, 'belongs_to');
+        }
+        for (const file of run.files)
+            if (selected.has(file))
+                addEdge(runId, `file:${file}`, 'touched');
+        if (run.status !== 'active' && run.status !== 'unknown') {
+            const outcomeId = `outcome:${run.id}:${run.status}`;
+            addNode({ id: outcomeId, type: 'outcome', label: run.status, state: run.status, weight: 3 });
+            addEdge(runId, outcomeId, 'resulted_in');
+        }
+    }
+    for (const lesson of input.lessons.slice(0, 150)) {
+        const lessonId = `lesson:${lesson.id}`;
+        addNode({
+            id: lessonId,
+            type: 'lesson',
+            label: lesson.subject,
+            detail: `${lesson.visibility} · ${lesson.state} · ${Math.round(lesson.confidence * 100)}%`,
+            state: lesson.state,
+            repositoryId: lesson.repositoryId,
+            weight: 4,
+        });
+        const sourceRepo = lesson.repositoryId === input.repository.id ? repoId : `repository:${lesson.repositoryId}`;
+        if (!nodes.has(sourceRepo))
+            addNode({ id: sourceRepo, type: 'repository', label: lesson.repositoryName ?? `Repository ${lesson.repositoryId.slice(0, 8)}`, detail: lesson.repositoryId, repositoryId: lesson.repositoryId, weight: 7 });
+        addEdge(sourceRepo, lessonId, 'produced');
+    }
+    for (const pattern of [...(input.patterns ?? [])]
+        .sort((a, b) => (b.usageCount ?? 0) - (a.usageCount ?? 0))
+        .slice(0, 120)) {
+        const patternId = `pattern:${pattern.id}`;
+        addNode({
+            id: patternId,
+            type: 'pattern',
+            label: pattern.name,
+            detail: `${pattern.type} · ${pattern.description || pattern.file}`,
+            repositoryId: input.repository.id,
+            weight: Math.min(8, 2 + Math.sqrt((pattern.usageCount ?? 0) + 1)),
+        });
+        const fileId = `file:${pattern.file}`;
+        addEdge(nodes.has(fileId) ? fileId : repoId, patternId, nodes.has(fileId) ? 'defined_in' : 'contains');
+    }
+    for (const memory of (input.memories ?? []).slice(0, 100)) {
+        const memoryId = `memory:${memory.id}`;
+        addNode({
+            id: memoryId,
+            type: 'memory',
+            label: memory.label,
+            detail: `${memory.source ?? 'local'} · ${memory.detail ?? 'retained memory'}`,
+            repositoryId: input.repository.id,
+            weight: 3,
+        });
+        addEdge(repoId, memoryId, 'remembered');
+    }
+    for (const event of input.events) {
+        if (!event.guidance)
+            continue;
+        const day = event.timestamp.slice(0, 10);
+        const runKey = event.sessionId ?? event.taskId ?? event.requestId ?? `${event.agentId}:${day}`;
+        const runId = `run:${runKey}`;
+        if (!nodes.has(runId))
+            continue;
+        const adviceId = `advice:${event.requestId ?? event.id}`;
+        const telemetry = event.telemetry;
+        const avoidedTokens = Math.max(0, (telemetry?.candidateTokens ?? 0) - (telemetry?.returnedTokens ?? 0));
+        const knowledgeItems = event.guidance.patternRefs.length + event.guidance.lessonRefs.length + event.guidance.memoryRefs.length;
+        addNode({
+            id: adviceId,
+            type: 'advice',
+            label: shortLabel(event.guidance.recommendation),
+            detail: `${event.guidance.kind} · ${knowledgeItems} knowledge items · ${avoidedTokens} tokens avoided`,
+            state: telemetry?.classification ?? 'measured estimate',
+            repositoryId: input.repository.id,
+            weight: Math.min(8, 3 + Math.sqrt(knowledgeItems + 1)),
+            evidence: {
+                recommendation: event.guidance.recommendation,
+                candidateTokens: telemetry?.candidateTokens ?? 0,
+                returnedTokens: telemetry?.returnedTokens ?? 0,
+                avoidedTokens,
+                candidateFiles: telemetry?.candidateFiles ?? 0,
+                returnedFiles: telemetry?.returnedFiles ?? 0,
+                excludedFiles: event.guidance.excludedFileCount,
+                cacheStatus: telemetry?.cacheStatus ?? 'none',
+                classification: telemetry?.classification ?? 'measured estimate',
+            },
+        });
+        addEdge(runId, adviceId, 'guided');
+        for (const reference of event.guidance.patternRefs) {
+            const sourceId = `pattern:${reference.id}`;
+            if (nodes.has(sourceId))
+                addEdge(sourceId, adviceId, 'informed');
+        }
+        for (const reference of event.guidance.lessonRefs) {
+            const sourceId = `lesson:${reference.id}`;
+            if (nodes.has(sourceId))
+                addEdge(sourceId, adviceId, 'informed');
+        }
+        for (const reference of event.guidance.memoryRefs) {
+            const sourceId = `memory:${reference.id}`;
+            if (nodes.has(sourceId))
+                addEdge(sourceId, adviceId, 'informed');
+        }
+    }
+    const prevented = input.events.filter(event => event.outcome === 'rejected');
+    if (prevented.length > 0) {
+        const policyId = 'policy:rigour-firewall';
+        const outcomeId = 'outcome:prevented-actions';
+        addNode({ id: policyId, type: 'policy', label: 'Rigour transaction firewall', detail: 'Deterministic mediation boundary', state: 'active', weight: 8 });
+        addNode({ id: outcomeId, type: 'outcome', label: `${prevented.length} prevented actions`, detail: 'Rejected before unsafe execution', state: 'verified', weight: Math.min(10, 4 + prevented.length) });
+        addEdge(policyId, repoId, 'protects');
+        addEdge(policyId, outcomeId, 'produced');
+    }
+    const counts = [...nodes.values()].reduce((result, node) => {
+        result[node.type] = (result[node.type] ?? 0) + 1;
+        return result;
+    }, {});
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        nodes: [...nodes.values()],
+        edges: [...edges.values()],
+        truncated: (graph?.nodes.length ?? 0) > selectedFiles.length
+            || input.runs.length > 100
+            || input.lessons.length > 150
+            || (input.patterns?.length ?? 0) > 120
+            || (input.memories?.length ?? 0) > 100,
+        counts,
+    };
+}

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

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

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

@@ -0,0 +1,59 @@
+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' }));
+    });
+});

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

@@ -3,6 +3,8 @@
  * Observed Cursor costs always take precedence; these rates estimate when absent.
  */
 import type { ModelUsage } from '../storage/context-telemetry.js';
+export declare const MODEL_PRICING_SOURCE = "Rigour versioned model registry";
+export declare const MODEL_PRICING_EFFECTIVE_DATE = "2026-08-01";
 export interface ModelPricingTier {
     label: string;
     inputPerMillionUsd: number;

package/dist/services/model-pricing.js

@@ -2,6 +2,8 @@
  * Model-aware input pricing for context cost telemetry.
  * Observed Cursor costs always take precedence; these rates estimate when absent.
  */
+export const MODEL_PRICING_SOURCE = 'Rigour versioned model registry';
+export const MODEL_PRICING_EFFECTIVE_DATE = '2026-08-01';
 /** Per-million-token USD rates. Input rates drive avoided-context estimates. */
 export const MODEL_PRICING = {
     'composer-2.5-standard': {

package/dist/services/system-health.d.ts

@@ -0,0 +1,34 @@
+import { getTeamModeStatus } from '../storage/team-store.js';
+export interface SystemHealth {
+    schemaVersion: 1;
+    generatedAt: string;
+    index: {
+        status: string;
+        patterns: number;
+        files: number;
+        updatedAt?: string;
+    };
+    graph: {
+        status: string;
+        nodes: number;
+        edges: number;
+        updatedAt?: string;
+    };
+    semantic: {
+        status: string;
+        provider: 'local' | 'pgvector';
+        message?: string;
+    };
+    caches: {
+        status: string;
+        layers: Record<'static' | 'component' | 'semantic' | 'checkpoint', number>;
+    };
+    learning: {
+        status: string;
+        total: number;
+        observations: number;
+        states: Record<string, number>;
+    };
+    storage: Awaited<ReturnType<typeof getTeamModeStatus>>;
+}
+export declare function getSystemHealth(cwd: string): Promise<SystemHealth>;

package/dist/services/system-health.js

@@ -0,0 +1,53 @@
+import fs from 'fs-extra';
+import path from 'path';
+import { getAutomaticIndexStatus } from '../context/automatic-index.js';
+import { getDefaultIndexPath, loadPatternIndex } from '../pattern-index/indexer.js';
+import { listContextCacheRecords } from '../storage/context-telemetry.js';
+import { countInteractionEvidence, listLessons } from '../storage/lessons.js';
+import { getTeamModeStatus } from '../storage/team-store.js';
+export async function getSystemHealth(cwd) {
+    const [automatic, index, cacheRecords, lessons, observations, storage, graph] = await Promise.all([
+        getAutomaticIndexStatus(cwd),
+        loadPatternIndex(getDefaultIndexPath(cwd)).catch(() => null),
+        listContextCacheRecords({ limit: 10_000 }, cwd).catch(() => []),
+        listLessons(cwd, 10_000).catch(() => []),
+        countInteractionEvidence(cwd).catch(() => 0),
+        getTeamModeStatus(),
+        fs.readJson(path.join(cwd, '.rigour', 'dependency-graph.json')).catch(() => null),
+    ]);
+    const layers = { static: 0, component: 0, semantic: 0, checkpoint: 0 };
+    for (const record of cacheRecords)
+        layers[record.cacheType]++;
+    const states = {};
+    for (const lesson of lessons)
+        states[lesson.state] = (states[lesson.state] ?? 0) + 1;
+    const graphNodes = Array.isArray(graph?.nodes) ? graph.nodes.length : 0;
+    const graphEdges = Array.isArray(graph?.edges) ? graph.edges.length : 0;
+    return {
+        schemaVersion: 1,
+        generatedAt: new Date().toISOString(),
+        index: {
+            status: index ? automatic.structural : 'missing',
+            patterns: index?.stats?.totalPatterns ?? index?.patterns?.length ?? 0,
+            files: index?.stats?.totalFiles ?? 0,
+            updatedAt: index?.lastUpdated,
+        },
+        graph: { status: graph ? automatic.graph : 'missing', nodes: graphNodes, edges: graphEdges, updatedAt: graph?.generatedAt },
+        semantic: storage.semantic
+            ? {
+                status: storage.semantic.status,
+                provider: 'pgvector',
+                message: storage.semantic.status === 'ready'
+                    ? `pgvector · ${storage.semantic.indexedLessons ?? 0} lessons indexed${storage.semantic.missingLessons ? ` · ${storage.semantic.missingLessons} pending` : ''}`
+                    : storage.semantic.message,
+            }
+            : {
+                status: automatic.semantic,
+                provider: 'local',
+                message: automatic.message ?? (automatic.semantic === 'ready' ? 'Local pattern embeddings ready.' : undefined),
+            },
+        caches: { status: Object.values(layers).every(count => count > 0) ? 'ready' : 'warming', layers },
+        learning: { status: observations || lessons.length ? 'active' : 'idle', total: lessons.length, observations, states },
+        storage,
+    };
+}