@rigour-labs/core 6.5.1 → 6.5.3

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

package/dist/storage/local-memory.js

@@ -3,7 +3,8 @@
  *
  * Before deep scan: checks local SQLite for known patterns in this project.
  * After any scan: stores verified findings and reinforces patterns.
- * Result: Rigour gets smarter every time you use it, code never leaves the machine.
+ * Counts are per repository and stay on the machine; replayed findings are limited to files
+ * unchanged since the scan that found them.
  */
 import path from 'path';
 import { openDatabase } from './db.js';
@@ -11,6 +12,8 @@ import { insertScan, getRecentScans } from './scans.js';
 import { insertFindings, getDeepFindings } from './findings.js';
 import { reinforcePattern, getStrongPatterns, getHardRules, decayPatterns } from './patterns.js';
 import { Logger } from '../utils/logger.js';
+import { getRepositoryId } from './lessons.js';
+import fs from 'fs-extra';
 /** Minimum pattern strength to produce instant findings (skip LLM). */
 const INSTANT_MATCH_THRESHOLD = 0.7;
 /** Max local findings to inject per scan (avoid flooding). */
@@ -20,6 +23,14 @@ const MIN_REUSE_CONFIDENCE = 0.7;
 /**
  * Build a map of relative file path → known issues from past findings.
  */
+async function fileModifiedAt(cwd, relPath) {
+    try {
+        return (await fs.stat(path.join(cwd, relPath))).mtimeMs;
+    }
+    catch {
+        return undefined;
+    }
+}
 function buildFileIssueMap(recentFindings) {
     const map = new Map();
     for (const f of recentFindings) {
@@ -40,7 +51,9 @@ export async function checkLocalPatterns(cwd, fileList) {
     const db = await openDatabase();
     if (!db)
         return [];
-    const repoName = path.basename(cwd);
+    // The repository's identity (its remote, else its path), never the folder name: two
+    // checkouts called `api` are different projects.
+    const repoName = await getRepositoryId(cwd);
     const findings = [];
     try {
         const patterns = await getStrongPatterns(db, repoName, INSTANT_MATCH_THRESHOLD);
@@ -52,13 +65,23 @@ export async function checkLocalPatterns(cwd, fileList) {
             return [];
         const fileIssueMap = buildFileIssueMap(recentFindings);
         // fileList contains relative paths — match directly against DB (also relative)
+        const seen = new Set();
         for (const relPath of fileList) {
             const known = fileIssueMap.get(relPath);
             if (!known)
                 continue;
+            const modifiedAt = await fileModifiedAt(cwd, relPath);
             for (const issue of known) {
                 if ((issue.confidence ?? 0) < MIN_REUSE_CONFIDENCE)
                     continue;
+                // A finding still holds only while its file is the one it was found in: an edit
+                // since that scan may be the fix, and replaying it would report fixed code.
+                if (modifiedAt === undefined || modifiedAt > Number(issue.scan_time))
+                    continue;
+                const key = `${issue.line}:${issue.category}:${issue.description}`;
+                if (seen.has(`${relPath}:${key}`))
+                    continue;
+                seen.add(`${relPath}:${key}`);
                 const matchingPattern = patterns.find((p) => p.pattern === issue.category && p.strength >= INSTANT_MATCH_THRESHOLD);
                 if (!matchingPattern)
                     continue;
@@ -95,20 +118,29 @@ export async function persistAndReinforce(cwd, report, meta) {
     const db = await openDatabase();
     if (!db)
         return;
-    const repoName = path.basename(cwd);
+    // The repository's identity (its remote, else its path), never the folder name: two
+    // checkouts called `api` are different projects.
+    const repoName = await getRepositoryId(cwd);
     try {
         const scanId = await insertScan(db, repoName, report, meta);
         if (report.failures.length > 0) {
             await insertFindings(db, scanId, report.failures);
         }
+        // One reinforcement per category per scan: five findings of one kind in one scan are
+        // one observation of that kind, not five.
+        const byCategory = new Map();
         for (const f of report.failures) {
             const category = f.category || f.id;
+            if (!byCategory.has(category))
+                byCategory.set(category, f);
+        }
+        for (const [category, f] of byCategory) {
             const source = f.source === 'llm' ? 'llm' : 'ast';
             await reinforcePattern(db, repoName, category, `${f.title}: ${f.details?.substring(0, 120)}`, source);
         }
         await decayPatterns(db, 30);
         Logger.info(`Local memory: stored ${report.failures.length} findings, ` +
-            `reinforced ${report.failures.length} patterns for ${repoName}`);
+            `reinforced ${byCategory.size} patterns`);
     }
     catch (error) {
         Logger.warn(`Local memory persist failed: ${error}`);
@@ -124,7 +156,9 @@ export async function getProjectStats(cwd) {
     const db = await openDatabase();
     if (!db)
         return null;
-    const repoName = path.basename(cwd);
+    // The repository's identity (its remote, else its path), never the folder name: two
+    // checkouts called `api` are different projects.
+    const repoName = await getRepositoryId(cwd);
     try {
         const scans = await getRecentScans(db, repoName, 100);
         const patterns = await getStrongPatterns(db, repoName, 0.3);

package/dist/storage/local-memory.test.d.ts

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

package/dist/storage/local-memory.test.js

@@ -0,0 +1,55 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+/** An in-memory stand-in for the local SQLite store: records writes, answers the two reads under test. */
+const db = vi.hoisted(() => ({
+    writes: [],
+    patterns: [],
+    findings: [],
+    reset() { this.writes = []; this.patterns = []; this.findings = []; },
+}));
+vi.mock('./db.js', () => {
+    const store = {
+        run: async (sql) => { db.writes.push(sql.trim().split(/\s+/).slice(0, 3).join(' ')); return { changes: 1, lastID: 0 }; },
+        get: async () => undefined,
+        all: async (sql) => (sql.includes('FROM patterns') ? db.patterns : sql.includes('FROM findings') ? db.findings : []),
+        exec: async () => undefined,
+        transaction: async (work) => work(store),
+        close: async () => undefined,
+    };
+    return { openDatabase: async () => store };
+});
+const { checkLocalPatterns, persistAndReinforce } = await import('./local-memory.js');
+let repo;
+beforeEach(() => {
+    db.reset();
+    repo = fs.mkdtempSync(path.join(os.tmpdir(), 'local-memory-'));
+    fs.mkdirSync(path.join(repo, 'src'));
+});
+afterEach(() => fs.rmSync(repo, { recursive: true, force: true }));
+const failure = (id, line) => ({ id, title: id, details: 'x', severity: 'medium', provenance: 'traditional', files: ['src/a.ts'], line });
+describe('persistAndReinforce', () => {
+    it('reinforces each category once per scan, however many findings it has', async () => {
+        await persistAndReinforce(repo, { status: 'FAIL', failures: [failure('content-check', 1), failure('content-check', 2), failure('content-check', 3), failure('ast', 4)], stats: {} });
+        expect(db.writes.filter(w => w.startsWith('INSERT INTO patterns'))).toHaveLength(2);
+    });
+});
+describe('checkLocalPatterns', () => {
+    const remembered = (scanTime) => ({ file: 'src/a.ts', line: 3, category: 'security', description: 'token logged', confidence: 0.9, scan_time: scanTime });
+    it('replays a remembered finding while its file is unchanged since that scan, once', async () => {
+        fs.writeFileSync(path.join(repo, 'src/a.ts'), 'log(token)\n');
+        const after = fs.statSync(path.join(repo, 'src/a.ts')).mtimeMs + 1000;
+        db.patterns = [{ pattern: 'security', strength: 0.9 }];
+        db.findings = [remembered(after), remembered(after)];
+        const findings = await checkLocalPatterns(repo, ['src/a.ts']);
+        expect(findings.map(f => f.description)).toEqual(['[Local Memory] token logged']);
+    });
+    it('never replays a finding for a file edited since, which may be the fix', async () => {
+        fs.writeFileSync(path.join(repo, 'src/a.ts'), 'log(redact(token))\n');
+        const before = fs.statSync(path.join(repo, 'src/a.ts')).mtimeMs - 1000;
+        db.patterns = [{ pattern: 'security', strength: 0.9 }];
+        db.findings = [remembered(before)];
+        expect(await checkLocalPatterns(repo, ['src/a.ts'])).toEqual([]);
+    });
+});

package/dist/storage/patterns.d.ts

@@ -30,6 +30,6 @@ export declare function getStrongPatterns(store: RigourDB, repo: string, thresho
 export declare function getPatterns(store: RigourDB, repo: string): Promise<PatternRecord[]>;
 /**
  * Get patterns promoted to hard rules (strength > 0.9).
- * These can be used as AST-level checks without LLM inference.
+ * Categories seen this often; shown by `rigour brain`. They are counts, not checks.
  */
 export declare function getHardRules(store: RigourDB, repo: string): Promise<PatternRecord[]>;

package/dist/storage/patterns.js

@@ -49,7 +49,7 @@ export async function getPatterns(store, repo) {
 }
 /**
  * Get patterns promoted to hard rules (strength > 0.9).
- * These can be used as AST-level checks without LLM inference.
+ * Categories seen this often; shown by `rigour brain`. They are counts, not checks.
  */
 export async function getHardRules(store, repo) {
     return store.all('SELECT * FROM patterns WHERE repo = ? AND strength >= 0.9 ORDER BY times_seen DESC', repo);

package/dist/storage/share-memory.test.d.ts

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

package/dist/storage/share-memory.test.js

@@ -0,0 +1,34 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+const db = vi.hoisted(() => ({ rows: [], outbox: 0, reset() { this.rows = []; this.outbox = 0; } }));
+vi.mock('./db.js', () => {
+    const store = {
+        run: async (sql, ...params) => {
+            if (sql.includes('INSERT INTO lessons'))
+                db.rows.push({ id: params[0], visibility: 'team', state: 'candidate', kind: 'memory', subject: params[4] });
+            if (sql.includes('INSERT INTO sync_outbox'))
+                db.outbox++;
+            return { changes: 1, lastID: 0 };
+        },
+        get: async (sql, ...params) => (sql.includes("kind = 'memory'") ? db.rows.find(r => r.subject === params[1]) : 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 { shareMemoryLesson } = await import('./lessons.js');
+beforeEach(() => db.reset());
+describe('shareMemoryLesson', () => {
+    it('stores a team candidate of kind memory, once per memory', async () => {
+        const first = await shareMemoryLesson(process.cwd(), 'retries', 'Use withRetry from lib/net.');
+        const again = await shareMemoryLesson(process.cwd(), 'retries', 'Use withRetry from lib/net.');
+        expect(first).toBe(again);
+        expect(db.rows).toEqual([{ id: first, visibility: 'team', state: 'candidate', kind: 'memory', subject: 'retries: Use withRetry from lib/net.' }]);
+    });
+    it('queues nothing for sync until team mode is configured', async () => {
+        await shareMemoryLesson(process.cwd(), 'naming', 'Hooks are named useX.');
+        expect(db.outbox).toBe(0);
+    });
+});

package/dist/storage/team-vector-store.js

@@ -1,4 +1,5 @@
 import { createHash } from 'node:crypto';
+import { SEMANTIC_FLOOR } from '../memory/recall.js';
 export const TEAM_VECTOR_SCHEMA = `
 CREATE EXTENSION IF NOT EXISTS vector;
 CREATE TABLE IF NOT EXISTS rigour.lesson_embeddings (
@@ -176,7 +177,7 @@ export async function searchConfiguredTeamKnowledge(config, query, limit) {
                          OR (lesson.visibility = 'team' AND lesson.state = 'promoted'))
                     AND 1 - (embedding.embedding <=> $1::vector) >= $6
                   ORDER BY embedding.embedding <=> $1::vector LIMIT $5`, [vectorLiteral(embedding), config.organizationId, config.teamId, config.semantic.model,
-                Math.max(1, Math.min(25, limit)), 0.45, config.actorId]);
+                Math.max(1, Math.min(25, limit)), SEMANTIC_FLOOR, config.actorId]);
             return {
                 status: 'ready', provider: 'pgvector', model: config.semantic.model,
                 candidates: result.rows.map((row) => ({

package/dist/storage/telemetry-scope.test.d.ts

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

package/dist/storage/telemetry-scope.test.js

@@ -0,0 +1,38 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterAll, describe, expect, it, vi } from 'vitest';
+/** Every open goes to a scratch database, never ~/.rigour/rigour.db. */
+const dbFile = vi.hoisted(() => require('path').join(require('os').tmpdir(), `rigour-telemetry-${process.pid}.db`));
+vi.mock('./db.js', async (importOriginal) => {
+    const real = await importOriginal();
+    return { ...real, openDatabase: (p) => real.openDatabase(p ?? dbFile) };
+});
+const { openDatabase, isSQLiteAvailable } = await import('./db.js');
+const { getCheckpointMetrics, getContextEvents, recordCheckpointMetric, recordContextEvent } = await import('./context-telemetry.js');
+const repoA = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-a-'));
+const repoB = fs.mkdtempSync(path.join(os.tmpdir(), 'telemetry-b-'));
+afterAll(() => {
+    for (const p of [dbFile, `${dbFile}-wal`, `${dbFile}-shm`])
+        fs.rmSync(p, { force: true });
+    for (const dir of [repoA, repoB])
+        fs.rmSync(dir, { recursive: true, force: true });
+});
+describe.runIf(isSQLiteAvailable())('telemetry scoped to its repository', () => {
+    it('migrates idempotently when two processes open the database at once', async () => {
+        const [a, b] = await Promise.all([openDatabase(), openDatabase()]);
+        const columns = (await a.all('PRAGMA table_info(checkpoint_metrics)')).map((c) => c.name);
+        expect(columns).toContain('repository_id');
+        await a.close();
+        await b.close();
+    });
+    it("shows a repository its own checkpoints and context events, never another's", async () => {
+        await recordCheckpointMetric({ checkpointId: 'cp-a', taskId: 't', agentId: 'agent', checkpointTokens: 10, rawStateTokens: 0, replayTokensAvoided: 0 }, repoA);
+        await recordCheckpointMetric({ checkpointId: 'cp-b', taskId: 't', agentId: 'agent', checkpointTokens: 10, rawStateTokens: 0, replayTokensAvoided: 0 }, repoB);
+        await recordContextEvent({ toolName: 'rigour_recall', cacheStatus: 'miss', candidateTokens: 0, returnedTokens: 0 }, repoA);
+        expect((await getCheckpointMetrics(undefined, repoA)).map(m => m.checkpointId)).toEqual(['cp-a']);
+        expect((await getCheckpointMetrics(undefined, repoB)).map(m => m.checkpointId)).toEqual(['cp-b']);
+        expect(await getContextEvents(undefined, repoB)).toEqual([]);
+        expect((await getContextEvents(undefined, repoA)).map(e => e.toolName)).toEqual(['rigour_recall']);
+    });
+});

package/dist/templates/universal-config.js

@@ -234,6 +234,17 @@ export const UNIVERSAL_CONFIG = {
             track_branches: false,
             track_returns: false,
         },
+        unindexed_reads: {
+            enabled: false,
+            migrations: [],
+        },
+        deprecated_dependencies: {
+            enabled: false,
+        },
+        migration_order: {
+            enabled: false,
+            dirs: ['**/supabase/migrations'],
+        },
         semantic_bugs: {
             enabled: true,
         },