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

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

@@ -0,0 +1,76 @@
+export type AgentEventOutcome = 'success' | 'error' | 'rejected' | 'unknown';
+export interface AgentGuidance {
+    kind: 'context-scope' | 'pattern' | 'memory';
+    recommendation: string;
+    patternRefs: Array<{
+        id: string;
+        label: string;
+        file?: string;
+    }>;
+    lessonRefs: Array<{
+        id: string;
+        label: string;
+        visibility?: string;
+    }>;
+    memoryRefs: Array<{
+        id: string;
+        label: string;
+    }>;
+    selectedFiles: string[];
+    excludedFileCount: number;
+    conflicts: number;
+}
+export interface AgentImpact {
+    guidanceCount: number;
+    knowledgeItems: number;
+    candidateTokens: number;
+    returnedTokens: number;
+    avoidedTokens: number;
+    candidateFiles: number;
+    returnedFiles: number;
+    excludedFiles: number;
+    cacheHits: number;
+    recommendations: string[];
+}
+export interface AgentHistoryEvent {
+    id: string;
+    timestamp: string;
+    type: string;
+    agentId: string;
+    taskId?: string;
+    sessionId?: string;
+    requestId?: string;
+    tool?: string;
+    outcome: AgentEventOutcome;
+    files: string[];
+    summary: string;
+    guidance?: AgentGuidance;
+    telemetry?: {
+        candidateTokens: number;
+        returnedTokens: number;
+        candidateFiles: number;
+        returnedFiles: number;
+        cacheStatus: string;
+        classification: 'observed' | 'measured estimate' | 'modelled estimate';
+    };
+}
+export interface AgentRun {
+    id: string;
+    agentId: string;
+    taskId?: string;
+    sessionId?: string;
+    startedAt: string;
+    endedAt: string;
+    status: AgentEventOutcome | 'active';
+    eventCount: number;
+    files: string[];
+    tools: string[];
+    impact?: AgentImpact;
+}
+export declare function normalizeAgentEvent(input: unknown, index?: number): AgentHistoryEvent;
+/**
+ * Normalizes a page as a unit so a response inherits identity and scope from its
+ * matching request. Older event logs often stored those fields only on tool_call.
+ */
+export declare function normalizeAgentEvents(inputs: unknown[]): AgentHistoryEvent[];
+export declare function buildAgentRuns(events: AgentHistoryEvent[]): AgentRun[];

package/dist/services/agent-history.js

@@ -0,0 +1,201 @@
+function text(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function validDate(value) {
+    const candidate = text(value);
+    return candidate && !Number.isNaN(Date.parse(candidate)) ? candidate : new Date(0).toISOString();
+}
+function strings(value) {
+    return Array.isArray(value) ? value.filter((item) => typeof item === 'string' && item.length > 0) : [];
+}
+function number(value) {
+    return typeof value === 'number' && Number.isFinite(value) && value > 0 ? value : 0;
+}
+function refs(value) {
+    if (!Array.isArray(value))
+        return [];
+    return value.flatMap(item => {
+        if (!item || typeof item !== 'object')
+            return [];
+        const record = item;
+        const id = text(record.id);
+        const label = text(record.label);
+        return id && label ? [{ id, label, file: text(record.file), visibility: text(record.visibility) }] : [];
+    });
+}
+function eventGuidance(event) {
+    const value = event.guidance ?? event._guidance;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const recommendation = text(record.recommendation);
+    const kind = text(record.kind);
+    if (!recommendation || !['context-scope', 'pattern', 'memory'].includes(kind ?? ''))
+        return undefined;
+    return {
+        kind: kind,
+        recommendation,
+        patternRefs: refs(record.patternRefs),
+        lessonRefs: refs(record.lessonRefs),
+        memoryRefs: refs(record.memoryRefs),
+        selectedFiles: strings(record.selectedFiles),
+        excludedFileCount: number(record.excludedFileCount),
+        conflicts: number(record.conflicts),
+    };
+}
+function eventTelemetry(event) {
+    const value = event.telemetry ?? event._telemetry;
+    if (!value || typeof value !== 'object')
+        return undefined;
+    const record = value;
+    const classification = text(record.classification);
+    return {
+        candidateTokens: number(record.candidateTokens),
+        returnedTokens: number(record.returnedTokens),
+        candidateFiles: number(record.candidateFiles),
+        returnedFiles: number(record.returnedFiles),
+        cacheStatus: text(record.cacheStatus) ?? 'none',
+        classification: classification === 'observed' || classification === 'modelled estimate'
+            ? classification
+            : 'measured estimate',
+    };
+}
+function emptyImpact() {
+    return {
+        guidanceCount: 0,
+        knowledgeItems: 0,
+        candidateTokens: 0,
+        returnedTokens: 0,
+        avoidedTokens: 0,
+        candidateFiles: 0,
+        returnedFiles: 0,
+        excludedFiles: 0,
+        cacheHits: 0,
+        recommendations: [],
+    };
+}
+function eventFiles(event) {
+    const args = event.arguments && typeof event.arguments === 'object' ? event.arguments : {};
+    const report = event._rigour_report && typeof event._rigour_report === 'object'
+        ? event._rigour_report
+        : {};
+    const failures = Array.isArray(report.failures) ? report.failures : [];
+    const reported = failures.flatMap((failure) => failure && typeof failure === 'object'
+        ? strings(failure.files)
+        : []);
+    return [...new Set([
+            ...strings(event.files),
+            ...strings(args.files),
+            ...reported,
+            text(event.file),
+            text(event.path),
+        ].filter((file) => Boolean(file)))];
+}
+function eventOutcome(event) {
+    const value = String(event.outcome ?? event.status ?? '').toLowerCase();
+    const type = String(event.type ?? '').toLowerCase();
+    if (value.includes('reject') || type.includes('reject') || type.includes('deny'))
+        return 'rejected';
+    if (value.includes('error') || value.includes('fail') || type.includes('error') || type.includes('fail'))
+        return 'error';
+    if (value.includes('success') || value === 'pass' || type.includes('success') || type.includes('completed'))
+        return 'success';
+    return 'unknown';
+}
+export function normalizeAgentEvent(input, index = 0) {
+    const event = input && typeof input === 'object' ? input : {};
+    const type = text(event.type) ?? 'unknown';
+    const tool = text(event.tool ?? event.toolName);
+    const outcome = eventOutcome(event);
+    const summary = text(event.summary ?? event.message ?? event.description)
+        ?? `${tool ?? type}${outcome === 'unknown' ? '' : ` · ${outcome}`}`;
+    return {
+        id: text(event.id) ?? text(event.requestId) ?? `legacy-event-${index + 1}`,
+        timestamp: validDate(event.timestamp ?? event.createdAt),
+        type,
+        agentId: text(event.agentId ?? event.agent_id) ?? 'unknown-agent',
+        taskId: text(event.taskId ?? event.task_id),
+        sessionId: text(event.sessionId ?? event.session_id),
+        requestId: text(event.requestId ?? event.request_id),
+        tool,
+        outcome,
+        files: eventFiles(event),
+        summary,
+        guidance: eventGuidance(event),
+        telemetry: eventTelemetry(event),
+    };
+}
+/**
+ * Normalizes a page as a unit so a response inherits identity and scope from its
+ * matching request. Older event logs often stored those fields only on tool_call.
+ */
+export function normalizeAgentEvents(inputs) {
+    const requestContext = new Map();
+    for (const input of inputs) {
+        const event = input && typeof input === 'object' ? input : {};
+        const requestId = text(event.requestId ?? event.request_id);
+        if (!requestId || String(event.type) !== 'tool_call')
+            continue;
+        const args = event.arguments && typeof event.arguments === 'object'
+            ? event.arguments
+            : {};
+        requestContext.set(requestId, {
+            agentId: event.agentId ?? event.agent_id ?? args.agentId ?? args.agent_id ?? args.agent
+                ?? args.fromAgentId ?? args.toAgentId,
+            taskId: event.taskId ?? event.task_id ?? args.taskId ?? args.task_id,
+            sessionId: event.sessionId ?? event.session_id ?? args.sessionId ?? args.session_id,
+            files: event.files ?? args.files ?? args.filesChanged ?? args.filesInScope,
+        });
+    }
+    return inputs.map((input, index) => {
+        const event = input && typeof input === 'object' ? input : {};
+        const requestId = text(event.requestId ?? event.request_id);
+        return normalizeAgentEvent(requestId ? { ...requestContext.get(requestId), ...event } : event, index);
+    });
+}
+export function buildAgentRuns(events) {
+    const runs = new Map();
+    for (const event of [...events].sort((a, b) => Date.parse(a.timestamp) - Date.parse(b.timestamp))) {
+        const day = event.timestamp.slice(0, 10);
+        const id = event.sessionId ?? event.taskId ?? event.requestId ?? `${event.agentId}:${day}`;
+        const current = runs.get(id) ?? {
+            id,
+            agentId: event.agentId,
+            taskId: event.taskId,
+            sessionId: event.sessionId,
+            startedAt: event.timestamp,
+            endedAt: event.timestamp,
+            status: 'active',
+            eventCount: 0,
+            files: [],
+            tools: [],
+            impact: emptyImpact(),
+        };
+        current.endedAt = event.timestamp;
+        current.eventCount++;
+        current.files = [...new Set([...current.files, ...event.files])];
+        if (event.tool)
+            current.tools = [...new Set([...current.tools, event.tool])];
+        if (event.guidance) {
+            current.impact ??= emptyImpact();
+            const telemetry = event.telemetry;
+            current.impact.guidanceCount++;
+            current.impact.knowledgeItems += event.guidance.patternRefs.length
+                + event.guidance.lessonRefs.length
+                + event.guidance.memoryRefs.length;
+            current.impact.candidateTokens += telemetry?.candidateTokens ?? 0;
+            current.impact.returnedTokens += telemetry?.returnedTokens ?? 0;
+            current.impact.avoidedTokens += Math.max(0, (telemetry?.candidateTokens ?? 0) - (telemetry?.returnedTokens ?? 0));
+            current.impact.candidateFiles += telemetry?.candidateFiles ?? 0;
+            current.impact.returnedFiles += telemetry?.returnedFiles ?? 0;
+            current.impact.excludedFiles += event.guidance.excludedFileCount;
+            if (telemetry?.cacheStatus && !['none', 'miss'].includes(telemetry.cacheStatus))
+                current.impact.cacheHits++;
+            current.impact.recommendations = [...new Set([...current.impact.recommendations, event.guidance.recommendation])];
+        }
+        if (event.outcome !== 'unknown')
+            current.status = event.outcome;
+        runs.set(id, current);
+    }
+    return [...runs.values()].sort((a, b) => Date.parse(b.endedAt) - Date.parse(a.endedAt));
+}

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

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

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

@@ -0,0 +1,69 @@
+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-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 {};