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

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,
+    };
+}

package/dist/storage/db.js

@@ -45,7 +45,7 @@ function loadSqlite3() {
 const RIGOUR_DIR = path.join(os.homedir(), '.rigour');
 const DB_PATH = path.join(RIGOUR_DIR, 'rigour.db');
 /** Current schema version — bump when adding migrations. */
-const SCHEMA_VERSION = 4;
+const SCHEMA_VERSION = 7;
 const SCHEMA_SQL = `
 -- Schema version tracking
 CREATE TABLE IF NOT EXISTS meta (
@@ -177,6 +177,61 @@ CREATE TABLE IF NOT EXISTS checkpoint_metrics (
     created_at INTEGER NOT NULL
 );
 
+-- Evidence-gated learning produced during normal agent interaction.
+CREATE TABLE IF NOT EXISTS lessons (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    actor_id TEXT,
+    team_id TEXT,
+    visibility TEXT NOT NULL DEFAULT 'personal',
+    state TEXT NOT NULL DEFAULT 'candidate',
+    kind TEXT NOT NULL,
+    subject TEXT NOT NULL,
+    evidence_json TEXT NOT NULL,
+    confidence REAL NOT NULL DEFAULT 0.3,
+    source TEXT NOT NULL,
+    supersedes_id TEXT,
+    created_at INTEGER NOT NULL,
+    updated_at INTEGER NOT NULL
+);
+
+CREATE TABLE IF NOT EXISTS sync_outbox (
+    id TEXT PRIMARY KEY,
+    operation TEXT NOT NULL,
+    entity_type TEXT NOT NULL,
+    entity_id TEXT NOT NULL,
+    payload_json TEXT NOT NULL,
+    attempts INTEGER NOT NULL DEFAULT 0,
+    last_error TEXT,
+    created_at INTEGER NOT NULL,
+    synced_at INTEGER
+);
+
+-- Stable repository registry used by cross-project learning and graph views.
+CREATE TABLE IF NOT EXISTS repositories (
+    id TEXT PRIMARY KEY,
+    canonical_uri TEXT NOT NULL,
+    display_name TEXT NOT NULL,
+    last_seen INTEGER NOT NULL
+);
+
+-- Append-only observations from normal governed agent work. These are evidence,
+-- not reusable rules; lesson promotion remains a separate gated decision.
+CREATE TABLE IF NOT EXISTS interaction_events (
+    id TEXT PRIMARY KEY,
+    repository_id TEXT NOT NULL,
+    actor_id TEXT,
+    task_id TEXT,
+    session_id TEXT,
+    request_id TEXT NOT NULL,
+    tool_name TEXT NOT NULL,
+    phase TEXT NOT NULL,
+    outcome TEXT NOT NULL,
+    deterministic INTEGER NOT NULL DEFAULT 0,
+    evidence_json TEXT NOT NULL,
+    created_at INTEGER NOT NULL
+);
+
 -- Indexes for performance
 CREATE INDEX IF NOT EXISTS idx_scans_repo ON scans(repo);
 CREATE INDEX IF NOT EXISTS idx_scans_timestamp ON scans(timestamp);
@@ -192,6 +247,11 @@ CREATE INDEX IF NOT EXISTS idx_model_usage_task ON model_usage(task_id);
 CREATE INDEX IF NOT EXISTS idx_model_usage_created ON model_usage(created_at);
 CREATE INDEX IF NOT EXISTS idx_context_cache_type ON context_cache(cache_type);
 CREATE INDEX IF NOT EXISTS idx_checkpoint_metrics_task ON checkpoint_metrics(task_id);
+CREATE INDEX IF NOT EXISTS idx_lessons_lookup ON lessons(repository_id, actor_id, team_id, state);
+CREATE INDEX IF NOT EXISTS idx_sync_outbox_pending ON sync_outbox(synced_at, created_at);
+CREATE INDEX IF NOT EXISTS idx_repositories_last_seen ON repositories(last_seen);
+CREATE INDEX IF NOT EXISTS idx_interaction_events_repo_created ON interaction_events(repository_id, created_at);
+CREATE INDEX IF NOT EXISTS idx_interaction_events_request ON interaction_events(request_id);
 `;
 function wrapDatabase(raw) {
     const db = {
@@ -369,6 +429,75 @@ async function runMigrations(db) {
         `);
         await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '4')");
     }
+    if (current < 5) {
+        await db.exec(`
+            CREATE TABLE IF NOT EXISTS lessons (
+                id TEXT PRIMARY KEY,
+                repository_id TEXT NOT NULL,
+                actor_id TEXT,
+                team_id TEXT,
+                visibility TEXT NOT NULL DEFAULT 'personal',
+                state TEXT NOT NULL DEFAULT 'candidate',
+                kind TEXT NOT NULL,
+                subject TEXT NOT NULL,
+                evidence_json TEXT NOT NULL,
+                confidence REAL NOT NULL DEFAULT 0.3,
+                source TEXT NOT NULL,
+                supersedes_id TEXT,
+                created_at INTEGER NOT NULL,
+                updated_at INTEGER NOT NULL
+            );
+            CREATE TABLE IF NOT EXISTS sync_outbox (
+                id TEXT PRIMARY KEY,
+                operation TEXT NOT NULL,
+                entity_type TEXT NOT NULL,
+                entity_id TEXT NOT NULL,
+                payload_json TEXT NOT NULL,
+                attempts INTEGER NOT NULL DEFAULT 0,
+                last_error TEXT,
+                created_at INTEGER NOT NULL,
+                synced_at INTEGER
+            );
+            CREATE INDEX IF NOT EXISTS idx_lessons_lookup ON lessons(repository_id, actor_id, team_id, state);
+            CREATE INDEX IF NOT EXISTS idx_sync_outbox_pending ON sync_outbox(synced_at, created_at);
+        `);
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '5')");
+    }
+    if (current < 6) {
+        await db.exec(`
+            CREATE TABLE IF NOT EXISTS repositories (
+                id TEXT PRIMARY KEY,
+                canonical_uri TEXT NOT NULL,
+                display_name TEXT NOT NULL,
+                last_seen INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_repositories_last_seen ON repositories(last_seen);
+        `);
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '6')");
+    }
+    if (current < 7) {
+        await db.exec(`
+            CREATE TABLE IF NOT EXISTS interaction_events (
+                id TEXT PRIMARY KEY,
+                repository_id TEXT NOT NULL,
+                actor_id TEXT,
+                task_id TEXT,
+                session_id TEXT,
+                request_id TEXT NOT NULL,
+                tool_name TEXT NOT NULL,
+                phase TEXT NOT NULL,
+                outcome TEXT NOT NULL,
+                deterministic INTEGER NOT NULL DEFAULT 0,
+                evidence_json TEXT NOT NULL,
+                created_at INTEGER NOT NULL
+            );
+            CREATE INDEX IF NOT EXISTS idx_interaction_events_repo_created
+                ON interaction_events(repository_id, created_at);
+            CREATE INDEX IF NOT EXISTS idx_interaction_events_request
+                ON interaction_events(request_id);
+        `);
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '7')");
+    }
 }
 /**
  * Compact the database — prune old data, reclaim disk space.

package/dist/storage/index.d.ts

@@ -11,3 +11,7 @@ export { checkLocalPatterns, persistAndReinforce, getProjectStats } from './loca
 export type { ProjectStats } from './local-memory.js';
 export { recordContextEvent, recordModelUsage, setContextCacheRecord, getContextCacheRecord, listContextCacheRecords, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics } from './context-telemetry.js';
 export type { ContextEvent, ModelUsage, ContextCacheRecord, CheckpointMetric } from './context-telemetry.js';
+export { recordInteractionEvidence, countInteractionEvidence, recordInteractionLesson, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId } from './lessons.js';
+export type { ApplicableLessons, InteractionEvidence, LessonRecord, LessonState, LessonVisibility } from './lessons.js';
+export { loadTeamConfiguration, saveTeamConfiguration, initializeTeamSchema, getTeamModeStatus, doctorTeamConnection, syncTeamOutbox, searchTeamKnowledge, backfillTeamEmbeddings, TEAM_CONFIG_PATH, validateTeamDatabaseUrl, } from './team-store.js';
+export type { TeamConfiguration, TeamSemanticConfiguration, TeamModeStatus, TeamDoctorResult, SemanticKnowledgeCandidate, SemanticKnowledgeResult, } from './team-store.js';

package/dist/storage/index.js

@@ -8,3 +8,5 @@ export { insertFindings, getFindingsForScan, getDeepFindings } from './findings.
 export { reinforcePattern, decayPatterns, getStrongPatterns, getPatterns, getHardRules } from './patterns.js';
 export { checkLocalPatterns, persistAndReinforce, getProjectStats } from './local-memory.js';
 export { recordContextEvent, recordModelUsage, setContextCacheRecord, getContextCacheRecord, listContextCacheRecords, recordCheckpointMetric, getContextEvents, getModelUsages, getCheckpointMetrics } from './context-telemetry.js';
+export { recordInteractionEvidence, countInteractionEvidence, recordInteractionLesson, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId } from './lessons.js';
+export { loadTeamConfiguration, saveTeamConfiguration, initializeTeamSchema, getTeamModeStatus, doctorTeamConnection, syncTeamOutbox, searchTeamKnowledge, backfillTeamEmbeddings, TEAM_CONFIG_PATH, validateTeamDatabaseUrl, } from './team-store.js';

package/dist/storage/lessons.d.ts

@@ -0,0 +1,60 @@
+export type LessonState = 'candidate' | 'validated' | 'promoted' | 'rejected' | 'superseded';
+export type LessonVisibility = 'personal' | 'team';
+export interface LessonRecord {
+    id: string;
+    repositoryId: string;
+    actorId?: string;
+    teamId?: string;
+    visibility: LessonVisibility;
+    state: LessonState;
+    kind: string;
+    subject: string;
+    evidence: Record<string, unknown>;
+    confidence: number;
+    source: string;
+    supersedesId?: string;
+    createdAt: number;
+    updatedAt: number;
+    repositoryName?: string;
+}
+export interface InteractionEvidence {
+    tool: string;
+    outcome: 'success' | 'error' | 'rejected';
+    requestId: string;
+    taskId?: string;
+    agentId?: string;
+    deterministic?: boolean;
+    verifiedOutcome?: boolean;
+    phase?: 'request' | 'response';
+    sessionId?: string;
+    files?: string[];
+    summary?: string;
+    /** A concise, evidence-backed proposition that could be reused beyond this call. */
+    reusableClaim?: string;
+}
+export declare function shouldValidateInteractionLesson(evidence: InteractionEvidence, verifiedSuccessfulOutcomes?: number): boolean;
+export declare function recordInteractionEvidence(cwd: string, evidence: InteractionEvidence): Promise<string | null>;
+export declare function countInteractionEvidence(cwd: string): Promise<number>;
+export declare function getRepositoryId(cwd: string): Promise<string>;
+export declare function recordInteractionLesson(cwd: string, evidence: InteractionEvidence): Promise<string | null>;
+export declare function listLessons(cwd: string, limit?: number): Promise<LessonRecord[]>;
+/**
+ * Returns the evidence visible to the current workspace for exploration. Cross-repository
+ * records are candidates only; getApplicableLessons remains the enforcement boundary.
+ */
+export declare function listKnowledgeLessons(cwd: string, limit?: number): Promise<LessonRecord[]>;
+export interface ApplicableLessons {
+    lessons: Array<LessonRecord & {
+        priority: number;
+        provenance: string;
+    }>;
+    conflicts: Array<{
+        subject: string;
+        lessonIds: string[];
+    }>;
+}
+export declare function getApplicableLessons(cwd: string, actorId?: string, teamId?: string): Promise<ApplicableLessons>;
+export declare function transitionLesson(id: string, state: LessonState, options?: {
+    visibility?: LessonVisibility;
+    queueSync?: boolean;
+}): Promise<boolean>;