@rigour-labs/core 6.5.2 → 6.5.3

package/dist/storage/context-telemetry.js

@@ -6,6 +6,26 @@ import { randomUUID } from 'crypto';
 import fs from 'fs-extra';
 import path from 'path';
 import { openDatabase, isSQLiteAvailable } from './db.js';
+import { getRepositoryId } from './lessons.js';
+/** The repository a telemetry row belongs to, or null when no working directory was given. */
+async function repositoryOf(cwd) {
+    return cwd ? getRepositoryId(cwd) : null;
+}
+/** WHERE clause for a telemetry read: the task when given, and this repository when cwd is given. */
+async function scopedWhere(taskId, cwd) {
+    const clauses = [];
+    const params = [];
+    if (taskId) {
+        clauses.push('task_id = ?');
+        params.push(taskId);
+    }
+    const repositoryId = await repositoryOf(cwd);
+    if (repositoryId) {
+        clauses.push('repository_id = ?');
+        params.push(repositoryId);
+    }
+    return { where: clauses.length ? `WHERE ${clauses.join(' AND ')}` : '', params };
+}
 // Fallback JSON persistence path if SQLite is unavailable
 function getFallbackDir(cwd) {
     return path.join(cwd || process.cwd(), '.rigour');
@@ -27,8 +47,8 @@ export async function recordContextEvent(event, cwd) {
             if (db) {
                 await db.run(`INSERT INTO context_events (
                         id, task_id, session_id, agent_id, tool_name, query_hash, cache_status,
-                        candidate_tokens, returned_tokens, deduplicated_tokens, candidate_files, returned_files, created_at
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, event.taskId || null, event.sessionId || null, event.agentId || null, event.toolName, event.queryHash || null, event.cacheStatus, candidateTokens, returnedTokens, deduplicatedTokens, candidateFiles, returnedFiles, timestamp);
+                        candidate_tokens, returned_tokens, deduplicated_tokens, candidate_files, returned_files, created_at, repository_id
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, event.taskId || null, event.sessionId || null, event.agentId || null, event.toolName, event.queryHash || null, event.cacheStatus, candidateTokens, returnedTokens, deduplicatedTokens, candidateFiles, returnedFiles, timestamp, await repositoryOf(cwd));
                 await db.close();
                 return id;
             }
@@ -56,8 +76,8 @@ export async function recordModelUsage(usage, cwd) {
             if (db) {
                 await db.run(`INSERT INTO model_usage (
                         id, task_id, session_id, agent_id, provider, model,
-                        input_tokens, output_tokens, cached_input_tokens, observed_cost_usd, source, created_at
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, usage.taskId || null, usage.sessionId || null, usage.agentId || null, usage.provider || 'cursor', usage.model || 'claude-3-5-sonnet', usage.inputTokens, usage.outputTokens, usage.cachedInputTokens || 0, usage.observedCostUsd || 0, usage.source, timestamp);
+                        input_tokens, output_tokens, cached_input_tokens, observed_cost_usd, source, created_at, repository_id
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, id, usage.taskId || null, usage.sessionId || null, usage.agentId || null, usage.provider || 'cursor', usage.model || 'claude-3-5-sonnet', usage.inputTokens, usage.outputTokens, usage.cachedInputTokens || 0, usage.observedCostUsd || 0, usage.source, timestamp, await repositoryOf(cwd));
                 await db.close();
                 return id;
             }
@@ -234,12 +254,12 @@ export async function recordCheckpointMetric(metric, cwd) {
             const db = await openDatabase();
             if (db) {
                 await db.run(`INSERT INTO checkpoint_metrics (
-                        checkpoint_id, task_id, agent_id, raw_state_tokens, checkpoint_tokens, replay_tokens_avoided, created_at
-                    ) VALUES (?, ?, ?, ?, ?, ?, ?)
+                        checkpoint_id, task_id, agent_id, raw_state_tokens, checkpoint_tokens, replay_tokens_avoided, created_at, repository_id
+                    ) VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                     ON CONFLICT(checkpoint_id) DO UPDATE SET
                         raw_state_tokens=excluded.raw_state_tokens,
                         checkpoint_tokens=excluded.checkpoint_tokens,
-                        replay_tokens_avoided=excluded.replay_tokens_avoided`, metric.checkpointId, metric.taskId, metric.agentId, metric.rawStateTokens, metric.checkpointTokens, metric.replayTokensAvoided, timestamp);
+                        replay_tokens_avoided=excluded.replay_tokens_avoided`, metric.checkpointId, metric.taskId, metric.agentId, metric.rawStateTokens, metric.checkpointTokens, metric.replayTokensAvoided, timestamp, await repositoryOf(cwd));
                 await db.close();
                 return;
             }
@@ -261,10 +281,8 @@ export async function getContextEvents(taskId, cwd) {
         try {
             const db = await openDatabase();
             if (db) {
-                const query = taskId
-                    ? `SELECT * FROM context_events WHERE task_id = ? ORDER BY created_at DESC`
-                    : `SELECT * FROM context_events ORDER BY created_at DESC`;
-                const params = taskId ? [taskId] : [];
+                const { where, params } = await scopedWhere(taskId, cwd);
+                const query = `SELECT * FROM context_events ${where} ORDER BY created_at DESC`;
                 const rows = await db.all(query, ...params);
                 await db.close();
                 return rows.map((r) => ({
@@ -303,10 +321,8 @@ export async function getModelUsages(taskId, cwd) {
         try {
             const db = await openDatabase();
             if (db) {
-                const query = taskId
-                    ? `SELECT * FROM model_usage WHERE task_id = ? ORDER BY created_at DESC`
-                    : `SELECT * FROM model_usage ORDER BY created_at DESC`;
-                const params = taskId ? [taskId] : [];
+                const { where, params } = await scopedWhere(taskId, cwd);
+                const query = `SELECT * FROM model_usage ${where} ORDER BY created_at DESC`;
                 const rows = await db.all(query, ...params);
                 await db.close();
                 return rows.map((r) => ({
@@ -344,10 +360,8 @@ export async function getCheckpointMetrics(taskId, cwd) {
         try {
             const db = await openDatabase();
             if (db) {
-                const query = taskId
-                    ? `SELECT * FROM checkpoint_metrics WHERE task_id = ? ORDER BY created_at DESC`
-                    : `SELECT * FROM checkpoint_metrics ORDER BY created_at DESC`;
-                const params = taskId ? [taskId] : [];
+                const { where, params } = await scopedWhere(taskId, cwd);
+                const query = `SELECT * FROM checkpoint_metrics ${where} ORDER BY created_at DESC`;
                 const rows = await db.all(query, ...params);
                 await db.close();
                 return rows.map((r) => ({

package/dist/storage/db.js

@@ -333,8 +333,11 @@ export async function openDatabase(dbPath) {
         });
     });
     const db = wrapDatabase(raw);
+    // Wait for a lock instead of failing at once: a hook and an MCP server often open the database
+    // at the same moment, and without this the second open fails with SQLITE_BUSY.
+    await db.exec('PRAGMA busy_timeout = 5000');
     // WAL mode for better concurrent read performance
-    await db.exec('PRAGMA journal_mode = WAL');
+    await enableWal(db);
     await db.exec('PRAGMA foreign_keys = ON');
     // Run schema creation + migrations
     await db.exec(SCHEMA_SQL);
@@ -498,6 +501,54 @@ async function runMigrations(db) {
         `);
         await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '7')");
     }
+    if (current < 8) {
+        // Telemetry rows record their repository, so Studio shows this repository's numbers, not
+        // every repository's on the machine. Older rows stay NULL and are left out of per-repo views.
+        await addColumnIfMissing(db, 'context_events', 'repository_id', 'ALTER TABLE context_events ADD COLUMN repository_id TEXT');
+        await addColumnIfMissing(db, 'model_usage', 'repository_id', 'ALTER TABLE model_usage ADD COLUMN repository_id TEXT');
+        await addColumnIfMissing(db, 'checkpoint_metrics', 'repository_id', 'ALTER TABLE checkpoint_metrics ADD COLUMN repository_id TEXT');
+        await db.exec(`
+            CREATE INDEX IF NOT EXISTS idx_context_events_repo ON context_events(repository_id, created_at);
+            CREATE INDEX IF NOT EXISTS idx_model_usage_repo ON model_usage(repository_id, created_at);
+            CREATE INDEX IF NOT EXISTS idx_checkpoint_metrics_repo ON checkpoint_metrics(repository_id, created_at);
+        `);
+        await db.run("INSERT OR REPLACE INTO meta (key, value) VALUES ('schema_version', '8')");
+    }
+}
+/**
+ * Switch to WAL. On a new database, two connections switching at once make the second fail with
+ * SQLITE_BUSY at once (busy_timeout does not cover a journal-mode change), so retry briefly; the
+ * mode is persistent, so once either succeeds, every later open finds WAL already set.
+ */
+async function enableWal(db, attempts = 10) {
+    for (let attempt = 1;; attempt++) {
+        try {
+            await db.exec('PRAGMA journal_mode = WAL');
+            return;
+        }
+        catch (error) {
+            if (!/SQLITE_BUSY/.test(String(error)) || attempt >= attempts)
+                throw error;
+            await new Promise(resolve => setTimeout(resolve, 25 * attempt));
+        }
+    }
+}
+/**
+ * Add a column unless it is there: a hook and an MCP server can open the database at once, and
+ * both may run the same migration; a second plain ALTER would fail with "duplicate column".
+ */
+async function addColumnIfMissing(db, table, column, alterSql) {
+    // The table is a bound parameter and the ALTER a literal written by the caller: nothing is interpolated.
+    const columns = await db.all('SELECT name FROM pragma_table_info(?)', table);
+    if (columns.some((c) => c.name === column))
+        return;
+    try {
+        await db.exec(alterSql);
+    }
+    catch (error) {
+        if (!/duplicate column/i.test(String(error)))
+            throw error;
+    }
 }
 /**
  * Compact the database — prune old data, reclaim disk space.

package/dist/storage/findings.js

@@ -25,7 +25,7 @@ export async function getFindingsForScan(store, scanId) {
  * Used by local memory to match known patterns against new scans.
  */
 export async function getDeepFindings(store, repo, limit = 50) {
-    return store.all(`SELECT f.* FROM findings f
+    return store.all(`SELECT f.*, s.timestamp AS scan_time FROM findings f
          JOIN scans s ON f.scan_id = s.id
          WHERE s.repo = ? AND (f.source = 'llm' OR f.source = 'hybrid' OR f.confidence >= 0.7)
          ORDER BY f.confidence DESC LIMIT ?`, repo, limit);

package/dist/storage/fix-lessons.d.ts

@@ -0,0 +1,13 @@
+import type { ResolvedFix } from '../review/agent-fixes.js';
+/** Distinct files a kind of fix must reach before its lesson is validated. */
+export declare const FILES_TO_VALIDATE = 2;
+/** Groups fixes of one kind of defect: every lesson subject starts with it. */
+export declare function fixLessonPrefix(fix: Pick<ResolvedFix, 'rule' | 'title'>): string;
+/**
+ * What a lesson says, and what it is embedded and matched by: the kind of defect, then what was
+ * wrong in the first fix. The detail is what lets a task match it by meaning (a direct match
+ * scored 0.37 with it and 0.05 with the title alone).
+ */
+export declare function fixLessonSubject(fix: Pick<ResolvedFix, 'rule' | 'title' | 'details'>): string;
+/** Record resolved fixes as lesson evidence. Returns the ids of lessons created or updated. */
+export declare function recordFixLessons(cwd: string, fixes: ResolvedFix[]): Promise<string[]>;

package/dist/storage/fix-lessons.js

@@ -0,0 +1,84 @@
+/**
+ * Lessons from fixes: when an agent fixes a finding Rigour reported, that fix
+ * becomes evidence for a lesson of kind `fix`, one per kind of defect.
+ *
+ * A lesson starts as a personal candidate and is validated by evidence alone:
+ * fixes of the same kind landing in two different files make it a pattern
+ * rather than a one-off (a repeat fix in one file may be the same bug
+ * reintroduced). Validated lessons are what team knowledge search serves and
+ * what pgvector embeds; a person can still promote one to the whole team.
+ */
+import { randomUUID } from 'crypto';
+import { openDatabase } from './db.js';
+import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
+import { getRepositoryId, queueLessonSync, registerRepository, txSafeLesson } from './lessons.js';
+import { loadTeamConfiguration } from './team-store.js';
+/** Distinct files a kind of fix must reach before its lesson is validated. */
+export const FILES_TO_VALIDATE = 2;
+/** Example fixes kept per lesson; older ones still count through `files`. */
+const MAX_EXAMPLES = 5;
+/** Groups fixes of one kind of defect: every lesson subject starts with it. */
+export function fixLessonPrefix(fix) {
+    return `Fixed before: ${fix.title?.trim() || fix.rule} (${fix.rule}).`;
+}
+/**
+ * What a lesson says, and what it is embedded and matched by: the kind of defect, then what was
+ * wrong in the first fix. The detail is what lets a task match it by meaning (a direct match
+ * scored 0.37 with it and 0.05 with the title alone).
+ */
+export function fixLessonSubject(fix) {
+    const detail = fix.details?.trim().split(/(?<=[.!?])\s/)[0]?.slice(0, 240);
+    return detail ? `${fixLessonPrefix(fix)} ${detail}` : fixLessonPrefix(fix);
+}
+/** Record resolved fixes as lesson evidence. Returns the ids of lessons created or updated. */
+export async function recordFixLessons(cwd, fixes) {
+    if (fixes.length === 0)
+        return [];
+    const db = await openDatabase();
+    if (!db)
+        return [];
+    try {
+        const repositoryId = await getRepositoryId(cwd);
+        await registerRepository(db, cwd, repositoryId);
+        const config = await loadTeamConfiguration();
+        const ids = [];
+        for (const fix of fixes)
+            ids.push(await recordOne(db, repositoryId, fix, config));
+        return [...new Set(ids)];
+    }
+    finally {
+        await db.close();
+    }
+}
+async function recordOne(db, repositoryId, fix, config) {
+    const subject = fixLessonSubject(fix);
+    const now = Date.now();
+    const row = await db.get(`SELECT id, evidence_json FROM lessons WHERE repository_id = ? AND kind = 'fix' AND substr(subject, 1, ?) = ?`, repositoryId, fixLessonPrefix(fix).length, fixLessonPrefix(fix));
+    const prior = row ? await decryptLocalPayload(row.evidence_json) : { rule: fix.rule, files: [], examples: [] };
+    if (prior.examples.some(e => e.fixId === fix.id))
+        return row.id;
+    const evidence = {
+        rule: fix.rule,
+        files: [...new Set([...prior.files, fix.file])],
+        examples: [{ fixId: fix.id, file: fix.file, details: fix.details?.slice(0, 300), resolvedAt: fix.resolvedAt }, ...prior.examples].slice(0, MAX_EXAMPLES),
+    };
+    const validated = evidence.files.length >= FILES_TO_VALIDATE;
+    const confidence = validated ? 0.8 : 0.4;
+    const id = row?.id ?? `lesson-${randomUUID()}`;
+    if (row) {
+        await db.run(`UPDATE lessons SET state = CASE WHEN state IN ('promoted', 'rejected') THEN state ELSE ? END,
+                evidence_json = ?, confidence = MAX(confidence, ?), updated_at = ? WHERE id = ?`, validated ? 'validated' : 'candidate', await encryptLocalPayload(evidence), confidence, now, id);
+    }
+    else {
+        await db.run(`INSERT INTO lessons (
+                id, repository_id, actor_id, team_id, visibility, state, kind, subject,
+                evidence_json, confidence, source, created_at, updated_at
+            ) VALUES (?, ?, ?, ?, 'personal', ?, 'fix', ?, ?, ?, 'agent-fix', ?, ?)`, id, repositoryId, config?.actorId || process.env.RIGOUR_ACTOR_ID || null, config?.teamId || process.env.RIGOUR_TEAM_ID || null, validated ? 'validated' : 'candidate', subject, await encryptLocalPayload(evidence), confidence, now, now);
+    }
+    if (config) {
+        const lesson = await txSafeLesson(db, id);
+        if (lesson)
+            await queueLessonSync(db, lesson, now);
+    }
+    return id;
+}

package/dist/storage/fix-lessons.test.d.ts

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

package/dist/storage/fix-lessons.test.js

@@ -0,0 +1,61 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+/** An in-memory lessons table, enough for the reads and writes fix lessons make. */
+const db = vi.hoisted(() => ({ rows: new Map(), reset() { this.rows = new Map(); } }));
+vi.mock('./db.js', () => {
+    const store = {
+        run: async (sql, ...p) => {
+            if (sql.includes('INSERT INTO lessons'))
+                db.rows.set(p[0], { id: p[0], state: p[4], subject: p[5], evidence_json: p[6], confidence: p[7] });
+            if (sql.includes('UPDATE lessons')) {
+                const row = db.rows.get(p[4]);
+                if (!['promoted', 'rejected'].includes(row.state))
+                    row.state = p[0];
+                Object.assign(row, { evidence_json: p[1], confidence: Math.max(row.confidence, p[2]) });
+            }
+            return { changes: 1, lastID: 0 };
+        },
+        get: async (sql, ...p) => (sql.includes("kind = 'fix'") ? [...db.rows.values()].find(r => r.subject.slice(0, p[1]) === p[2]) : undefined),
+        all: async () => [],
+        exec: async () => undefined,
+        close: async () => undefined,
+    };
+    return { openDatabase: async () => store };
+});
+vi.mock('./local-encryption.js', () => ({ encryptLocalPayload: async (v) => JSON.stringify(v), decryptLocalPayload: async (v) => JSON.parse(v) }));
+vi.mock('./team-store.js', () => ({ loadTeamConfiguration: async () => null }));
+const { recordFixLessons, fixLessonSubject } = await import('./fix-lessons.js');
+const fix = (id, file) => ({
+    id, file, rule: 'semantic-bugs', title: 'Unbounded read without paging', details: 'Rows read without a limit.', before: 'a', after: 'b', resolvedAt: '2026-10-02T00:00:00Z',
+});
+const lessons = () => [...db.rows.values()];
+beforeEach(() => db.reset());
+describe('recordFixLessons', () => {
+    it('turns a fix into a candidate lesson named after the defect it removed', async () => {
+        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
+        expect(lessons().map(l => [l.subject, l.state])).toEqual([['Fixed before: Unbounded read without paging (semantic-bugs). Rows read without a limit.', 'candidate']]);
+    });
+    it('validates the lesson once fixes of that kind reach a second file, and counts the same fix once', async () => {
+        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
+        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts'), fix('f2', 'src/orders.ts')]);
+        expect(lessons()[0].state).toBe('candidate');
+        await recordFixLessons(process.cwd(), [fix('f3', 'src/invoices.ts')]);
+        expect(lessons()).toHaveLength(1);
+        expect(lessons()[0].state).toBe('validated');
+        expect(JSON.parse(lessons()[0].evidence_json).files).toEqual(['src/orders.ts', 'src/invoices.ts']);
+    });
+    it("never overrides a person's decision to promote or reject", async () => {
+        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
+        lessons()[0].state = 'rejected';
+        await recordFixLessons(process.cwd(), [fix('f2', 'src/invoices.ts')]);
+        expect(lessons()[0].state).toBe('rejected');
+    });
+    it('names a fix whose finding had no title after its rule', () => {
+        expect(fixLessonSubject({ rule: 'hallucinated-imports' })).toBe('Fixed before: hallucinated-imports (hallucinated-imports).');
+    });
+    it('groups fixes of one kind even when their details differ', async () => {
+        await recordFixLessons(process.cwd(), [fix('f1', 'src/orders.ts')]);
+        await recordFixLessons(process.cwd(), [{ ...fix('f2', 'src/invoices.ts'), details: 'Invoices read in full to count them.' }]);
+        expect(lessons()).toHaveLength(1);
+        expect(lessons()[0].state).toBe('validated');
+    });
+});

package/dist/storage/index.d.ts

@@ -11,7 +11,8 @@ 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 { recordFixLessons, fixLessonSubject, fixLessonPrefix, FILES_TO_VALIDATE } from './fix-lessons.js';
+export { recordInteractionEvidence, countInteractionEvidence, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId, shareMemoryLesson } from './lessons.js';
 export type { ApplicableLessons, InteractionEvidence, LessonRecord, LessonState, LessonVisibility } from './lessons.js';
 export { queueLocalLessonsForTeam } from './team-import.js';
 export type { LocalLessonImportOptions, LocalLessonImportResult } from './team-import.js';

package/dist/storage/index.js

@@ -8,7 +8,8 @@ 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 { recordFixLessons, fixLessonSubject, fixLessonPrefix, FILES_TO_VALIDATE } from './fix-lessons.js';
+export { recordInteractionEvidence, countInteractionEvidence, listLessons, listKnowledgeLessons, getApplicableLessons, transitionLesson, getRepositoryId, shareMemoryLesson } from './lessons.js';
 export { queueLocalLessonsForTeam } from './team-import.js';
 export { loadTeamConfiguration, saveTeamConfiguration, initializeTeamSchema, getTeamModeStatus, doctorTeamConnection, syncTeamOutbox, searchTeamKnowledge, backfillTeamEmbeddings, TEAM_CONFIG_PATH, validateTeamDatabaseUrl, } from './team-store.js';
 export { explainTeamConnectionError } from './team-diagnostics.js';

package/dist/storage/lessons.d.ts

@@ -32,11 +32,22 @@ export interface InteractionEvidence {
     /** 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 registerRepository(db: {
+    run(sql: string, ...params: unknown[]): Promise<unknown>;
+}, cwd: string, repositoryId: string): Promise<void>;
+/**
+ * Share a memory with the team: a lesson of kind `memory` whose subject is the memory itself.
+ * It starts as a team candidate, so teammates' agents only receive it once a person promotes it
+ * (team knowledge search serves team lessons in the `promoted` state). Returns the lesson id, or
+ * null when the local store is unavailable.
+ */
+export declare function shareMemoryLesson(cwd: string, key: string, value: string): Promise<string | null>;
+export declare function queueLessonSync(db: {
+    run(sql: string, ...params: unknown[]): Promise<unknown>;
+}, lesson: LessonRecord, now: number): Promise<void>;
 export declare function listLessons(cwd: string, limit?: number): Promise<LessonRecord[]>;
 /**
  * Returns the evidence visible to the current workspace for exploration. Cross-repository
@@ -58,3 +69,6 @@ export declare function transitionLesson(id: string, state: LessonState, options
     visibility?: LessonVisibility;
     queueSync?: boolean;
 }): Promise<boolean>;
+export declare function txSafeLesson(db: {
+    get(sql: string, ...params: unknown[]): Promise<any>;
+}, id: string): Promise<LessonRecord | null>;

package/dist/storage/lessons.js

@@ -5,11 +5,6 @@ import { openDatabase } from './db.js';
 import { encryptLocalPayload } from './local-encryption.js';
 import { lessonRowToRecord as rowToLesson } from './lesson-record.js';
 import { loadTeamConfiguration } from './team-store.js';
-export function shouldValidateInteractionLesson(evidence, verifiedSuccessfulOutcomes = 0) {
-    return evidence.outcome === 'success'
-        && Boolean(evidence.reusableClaim?.trim())
-        && (evidence.deterministic === true || verifiedSuccessfulOutcomes >= 3);
-}
 export async function recordInteractionEvidence(cwd, evidence) {
     const db = await openDatabase();
     if (!db)
@@ -77,7 +72,7 @@ export async function getRepositoryId(cwd) {
     }
     return createHash('sha256').update(identity).digest('hex');
 }
-async function registerRepository(db, cwd, repositoryId) {
+export async function registerRepository(db, cwd, repositoryId) {
     let canonicalUri = path.resolve(cwd);
     try {
         const config = await readGitConfig(cwd);
@@ -93,65 +88,34 @@ async function registerRepository(db, cwd, repositoryId) {
          ON CONFLICT(id) DO UPDATE SET canonical_uri=excluded.canonical_uri,
              display_name=excluded.display_name, last_seen=excluded.last_seen`, repositoryId, canonicalUri, remoteName || path.basename(cwd), Date.now());
 }
-export async function recordInteractionLesson(cwd, evidence) {
+/**
+ * Share a memory with the team: a lesson of kind `memory` whose subject is the memory itself.
+ * It starts as a team candidate, so teammates' agents only receive it once a person promotes it
+ * (team knowledge search serves team lessons in the `promoted` state). Returns the lesson id, or
+ * null when the local store is unavailable.
+ */
+export async function shareMemoryLesson(cwd, key, value) {
     const db = await openDatabase();
     if (!db)
         return null;
     try {
         const repositoryId = await getRepositoryId(cwd);
         await registerRepository(db, cwd, repositoryId);
-        const id = `lesson-${randomUUID()}`;
-        const now = Date.now();
-        const verifiedSuccess = shouldValidateInteractionLesson(evidence, evidence.verifiedOutcome ? 3 : 0);
-        const confidence = verifiedSuccess ? 0.8 : 0.3;
-        const state = confidence >= 0.8 ? 'validated' : 'candidate';
         const config = await loadTeamConfiguration();
-        const actorId = config?.actorId || process.env.RIGOUR_ACTOR_ID || null;
-        const priorRow = await db.get(`SELECT * FROM lessons
-             WHERE repository_id = ? AND actor_id IS ? AND visibility = 'personal'
-               AND state = 'candidate' AND kind = 'interaction' AND subject = ?
-             ORDER BY updated_at DESC LIMIT 1`, repositoryId, actorId, evidence.reusableClaim?.trim() || `interaction:${evidence.tool}`);
-        if (priorRow) {
-            const prior = await rowToLesson(priorRow);
-            const previousSuccesses = Number(prior.evidence.successfulOutcomes ?? 0);
-            const successfulOutcomes = previousSuccesses + (evidence.outcome === 'success' ? 1 : 0);
-            const previousVerified = Number(prior.evidence.verifiedSuccessfulOutcomes ?? 0);
-            const verifiedSuccessfulOutcomes = previousVerified + (evidence.verifiedOutcome && evidence.outcome === 'success' ? 1 : 0);
-            const repeatedValidation = shouldValidateInteractionLesson(evidence, verifiedSuccessfulOutcomes);
-            const mergedEvidence = {
-                ...evidence,
-                observationCount: Number(prior.evidence.observationCount ?? 1) + 1,
-                successfulOutcomes,
-                verifiedSuccessfulOutcomes,
-                previousRequestId: prior.evidence.requestId,
-            };
-            const updated = {
-                ...prior,
-                state: repeatedValidation ? 'validated' : 'candidate',
-                evidence: mergedEvidence,
-                confidence: repeatedValidation ? 0.8 : Math.min(0.7, prior.confidence + 0.15),
-                updatedAt: now,
-            };
-            await db.run('UPDATE lessons SET state = ?, evidence_json = ?, confidence = ?, updated_at = ? WHERE id = ?', updated.state, await encryptLocalPayload(updated.evidence), updated.confidence, updated.updatedAt, updated.id);
-            if (config)
-                await queueLessonSync(db, updated, now);
-            return prior.id;
-        }
-        const storedEvidence = {
-            ...evidence,
-            observationCount: 1,
-            successfulOutcomes: evidence.outcome === 'success' ? 1 : 0,
-            verifiedSuccessfulOutcomes: evidence.verifiedOutcome && evidence.outcome === 'success' ? 1 : 0,
-        };
-        const encryptedEvidence = await encryptLocalPayload(storedEvidence);
+        const now = Date.now();
+        const subject = `${key}: ${value}`;
+        const existing = await db.get(`SELECT id FROM lessons WHERE repository_id = ? AND kind = 'memory' AND visibility = 'team' AND subject = ?`, repositoryId, subject);
+        if (existing)
+            return String(existing.id);
+        const id = `lesson-${randomUUID()}`;
         await db.run(`INSERT INTO lessons (
                 id, repository_id, actor_id, team_id, visibility, state, kind, subject,
                 evidence_json, confidence, source, created_at, updated_at
-            ) VALUES (?, ?, ?, ?, 'personal', ?, 'interaction', ?, ?, ?, 'mcp', ?, ?)`, id, repositoryId, actorId, config?.teamId || process.env.RIGOUR_TEAM_ID || null, state, evidence.reusableClaim?.trim() || `interaction:${evidence.tool}`, encryptedEvidence, confidence, now, now);
+            ) VALUES (?, ?, ?, ?, 'team', 'candidate', 'memory', ?, ?, 0.5, 'rigour_remember', ?, ?)`, id, repositoryId, config?.actorId || process.env.RIGOUR_ACTOR_ID || null, config?.teamId || process.env.RIGOUR_TEAM_ID || null, subject, await encryptLocalPayload({ key, value, sharedAt: now }), now, now);
         if (config) {
-            const personal = await txSafeLesson(db, id);
-            if (personal)
-                await queueLessonSync(db, personal, now);
+            const lesson = await txSafeLesson(db, id);
+            if (lesson)
+                await queueLessonSync(db, lesson, now);
         }
         return id;
     }
@@ -159,7 +123,7 @@ export async function recordInteractionLesson(cwd, evidence) {
         await db.close();
     }
 }
-async function queueLessonSync(db, lesson, now) {
+export async function queueLessonSync(db, lesson, now) {
     await db.run(`INSERT INTO sync_outbox (id, operation, entity_type, entity_id, payload_json, created_at)
          VALUES (?, 'upsert', 'lesson', ?, ?, ?)`, `outbox-${randomUUID()}`, lesson.id, await encryptLocalPayload(lesson), now);
 }
@@ -178,7 +142,7 @@ export async function listLessons(cwd, limit = 100) {
         await registerRepository(db, cwd, repositoryId);
         const rows = await db.all(`SELECT lessons.*, repositories.display_name AS repository_name
              FROM lessons LEFT JOIN repositories ON repositories.id = lessons.repository_id
-             WHERE repository_id = ?
+             WHERE repository_id = ? AND kind != 'interaction'
              ORDER BY updated_at DESC LIMIT ?`, repositoryId, limit);
         return await Promise.all(rows.map(rowToLesson));
     }
@@ -207,14 +171,16 @@ export async function listKnowledgeLessons(cwd, limit = 500) {
         const rows = config
             ? await db.all(`SELECT lessons.*, repositories.display_name AS repository_name
                  FROM lessons LEFT JOIN repositories ON repositories.id = lessons.repository_id
-                 WHERE lessons.repository_id = ?
+                 WHERE lessons.kind != 'interaction'
+                   AND (lessons.repository_id = ?
                     OR (lessons.visibility = 'personal' AND lessons.actor_id = ?)
-                    OR (lessons.visibility = 'team' AND lessons.team_id = ? AND lessons.state = 'promoted')
+                    OR (lessons.visibility = 'team' AND lessons.team_id = ? AND lessons.state = 'promoted'))
                  ORDER BY lessons.updated_at DESC LIMIT ?`, repositoryId, config.actorId, config.teamId, limit)
             : await db.all(`SELECT lessons.*, repositories.display_name AS repository_name
                  FROM lessons LEFT JOIN repositories ON repositories.id = lessons.repository_id
-                 WHERE lessons.repository_id = ?
-                    OR (lessons.visibility = 'personal' AND lessons.actor_id IS NULL)
+                 WHERE lessons.kind != 'interaction'
+                   AND (lessons.repository_id = ?
+                    OR (lessons.visibility = 'personal' AND lessons.actor_id IS NULL))
                  ORDER BY lessons.updated_at DESC LIMIT ?`, repositoryId, limit);
         return await Promise.all(rows.map(rowToLesson));
     }
@@ -298,7 +264,7 @@ export async function transitionLesson(id, state, options = {}) {
         await db.close();
     }
 }
-async function txSafeLesson(db, id) {
+export async function txSafeLesson(db, id) {
     const row = await db.get('SELECT * FROM lessons WHERE id = ?', id);
     return row ? rowToLesson(row) : null;
 }

package/dist/storage/lessons.test.js

@@ -4,7 +4,7 @@ import path from 'path';
 import { afterEach, describe, expect, it, vi } from 'vitest';
 import { openDatabase } from './db.js';
 import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
-import { getRepositoryId, shouldValidateInteractionLesson } from './lessons.js';
+import { getRepositoryId } from './lessons.js';
 import { queueLocalLessonsForTeam } from './team-import.js';
 const roots = [];
 afterEach(async () => {
@@ -40,20 +40,6 @@ describe('getRepositoryId', () => {
         expect(await getRepositoryId(worktree)).toHaveLength(64);
     });
 });
-describe('interaction lesson validation', () => {
-    const evidence = { tool: 'rigour_context_scope', outcome: 'success', requestId: 'req-1' };
-    it('keeps repeated unverified interaction as evidence only', () => {
-        expect(shouldValidateInteractionLesson(evidence, 0)).toBe(false);
-        expect(shouldValidateInteractionLesson(evidence, 2)).toBe(false);
-    });
-    it('validates deterministic or repeatedly verified outcomes', () => {
-        expect(shouldValidateInteractionLesson({ ...evidence, deterministic: true, reusableClaim: 'Use scoped retrieval before edits.' }, 0)).toBe(true);
-        expect(shouldValidateInteractionLesson({ ...evidence, verifiedOutcome: true, reusableClaim: 'Run the focused test suite.' }, 3)).toBe(true);
-    });
-    it('does not turn a successful tool call into reusable knowledge', () => {
-        expect(shouldValidateInteractionLesson({ ...evidence, deterministic: true }, 3)).toBe(false);
-    });
-});
 describe('local lesson team import', () => {
     it('dry-runs, assigns legacy ownership, and queues each lesson version once', async () => {
         const root = await fs.mkdtemp(path.join(os.tmpdir(), 'rigour-team-import-'));