@rigour-labs/core 6.5.1 → 6.5.3

package/dist/semantic/learn/learn.js

@@ -16,6 +16,8 @@ import { analyzeFiles } from '../engine.js';
 import { programBatches, loadProjectConfig } from '../program.js';
 import { compileLearnedRule, LEARNED_PREFIX } from './compile.js';
 import { extractEdits } from './extract.js';
+import { endLineOf, forEachNode, lineOf } from '../ast.js';
+import { functionKeyOf, isInvocation } from './identity.js';
 const DEFAULT_MAX_HITS = 3;
 const SOURCE = /\.(?:[cm]?[jt]s|[jt]sx)$/i;
 const NOT_SOURCE = /\.d\.[cm]?ts$|(?:^|\/)(?:__tests__|__mocks__|tests?)\/|\.(?:test|spec)\.[cm]?[jt]sx?$/;
@@ -73,6 +75,12 @@ function openTree(cwd, file) {
         throw new Error(`Cannot parse ${file} in ${cwd}`);
     return { cwd, checker: program.getTypeChecker(), sourceFile };
 }
+/**
+ * How often each candidate fires: before the fix, after it, and elsewhere. "After" counts only
+ * the function that was fixed: an unfixed copy of the bug next to it in the same file is
+ * another place the rule should find (listed with the repository hits), not a sign the rule
+ * is wrong about the fix.
+ */
 function countFindings(input, rules, files, repoFiles) {
     const compiled = rules.map(compileLearnedRule);
     const tally = (dir, scan) => analyzeFiles(dir, scan, { rules: compiled });
@@ -80,11 +88,38 @@ function countFindings(input, rules, files, repoFiles) {
     const before = tally(input.beforeDir, files);
     const after = tally(input.afterDir, files);
     const repo = tally(input.repoDir, repoFiles);
-    return new Map(rules.map(rule => [rule.id, {
-            before: byRule(before, rule.id).length,
-            after: byRule(after, rule.id).length,
-            hits: byRule(repo, rule.id).map(f => `${f.file}:${f.line}`),
-        }]));
+    const keyAt = functionKeysAt(input.afterDir, files);
+    return new Map(rules.map(rule => {
+        const afterHits = byRule(after, rule.id);
+        const atFix = afterHits.filter(f => f.file === rule.source.file && keyAt(f.file, f.line) === rule.source.function);
+        const besideFix = afterHits.filter(f => !atFix.includes(f)).map(f => `${f.file}:${f.line}`);
+        const elsewhere = byRule(repo, rule.id).map(f => `${f.file}:${f.line}`);
+        return [rule.id, { before: byRule(before, rule.id).length, after: atFix.length, hits: [...new Set([...besideFix, ...elsewhere])] }];
+    }));
+}
+/** The key of the function enclosing a call on a given line of a fixed file (the same key rules are scoped by). */
+function functionKeysAt(dir, files) {
+    const keys = new Map();
+    return (file, line) => {
+        if (!keys.has(file)) {
+            const byLine = new Map();
+            try {
+                forEachNode(openTree(dir, file).sourceFile, node => {
+                    // Every line a call spans: a finding can point inside the call, not at its first line.
+                    if (!isInvocation(node))
+                        return;
+                    for (let line = lineOf(node); line <= endLineOf(node); line++)
+                        if (!byLine.has(line))
+                            byLine.set(line, functionKeyOf(node));
+                });
+            }
+            catch {
+                // An unparseable file attributes nothing to the fix.
+            }
+            keys.set(file, byLine);
+        }
+        return files.includes(file) ? keys.get(file).get(line) : undefined;
+    };
 }
 function failure(counts, maxHits) {
     if (counts.before === 0)

package/dist/semantic/types.d.ts

@@ -16,6 +16,8 @@ export interface SemanticFinding {
     /** cwd-relative posix path of the reported line. */
     file: string;
     line: number;
+    /** Last line of the code the finding is about (a call), when it spans several lines. */
+    endLine?: number;
     message: string;
     hint: string;
     /** Supporting locations, e.g. "http.ts:51 deps.fetch(url, init)". */

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

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

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

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

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

@@ -432,7 +432,8 @@ export async function getContextScopeSummary(cwd) {
     let alwaysOnRuleTokens = 0;
     for (const fileName of GOVERNANCE_RULE_FILES) {
         const filePath = path.join(projectRoot, fileName);
-        if (await fs.pathExists(filePath)) {
+        // .clinerules may be a directory of rule files; only count regular files.
+        if ((await fs.stat(filePath).catch(() => null))?.isFile()) {
             alwaysOnRuleTokens += estimateTokenCount(await fs.readFile(filePath, 'utf8'));
         }
     }

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>;