@rigour-labs/core 6.5.2 → 6.5.3

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

package/dist/types/index.d.ts

@@ -498,6 +498,36 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns?: string[] | undefined;
         audit_log?: boolean | undefined;
     }>>>;
+    unindexed_reads: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        migrations: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        migrations: string[];
+    }, {
+        enabled?: boolean | undefined;
+        migrations?: string[] | undefined;
+    }>>>;
+    deprecated_dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        registry: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        registry?: string | undefined;
+    }, {
+        enabled?: boolean | undefined;
+        registry?: string | undefined;
+    }>>>;
+    migration_order: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+        dirs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+    }, "strip", z.ZodTypeAny, {
+        enabled: boolean;
+        dirs: string[];
+    }, {
+        enabled?: boolean | undefined;
+        dirs?: string[] | undefined;
+    }>>>;
     semantic_bugs: z.ZodDefault<z.ZodOptional<z.ZodObject<{
         enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
         rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -917,6 +947,18 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns: string[];
         audit_log: boolean;
     };
+    unindexed_reads: {
+        enabled: boolean;
+        migrations: string[];
+    };
+    deprecated_dependencies: {
+        enabled: boolean;
+        registry?: string | undefined;
+    };
+    migration_order: {
+        enabled: boolean;
+        dirs: string[];
+    };
     semantic_bugs: {
         enabled: boolean;
         rules?: string[] | undefined;
@@ -1160,6 +1202,18 @@ export declare const GatesSchema: z.ZodObject<{
         custom_patterns?: string[] | undefined;
         audit_log?: boolean | undefined;
     } | undefined;
+    unindexed_reads?: {
+        enabled?: boolean | undefined;
+        migrations?: string[] | undefined;
+    } | undefined;
+    deprecated_dependencies?: {
+        enabled?: boolean | undefined;
+        registry?: string | undefined;
+    } | undefined;
+    migration_order?: {
+        enabled?: boolean | undefined;
+        dirs?: string[] | undefined;
+    } | undefined;
     semantic_bugs?: {
         enabled?: boolean | undefined;
         rules?: string[] | undefined;
@@ -1752,6 +1806,36 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         }>>>;
+        unindexed_reads: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            migrations: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            migrations: string[];
+        }, {
+            enabled?: boolean | undefined;
+            migrations?: string[] | undefined;
+        }>>>;
+        deprecated_dependencies: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            registry: z.ZodOptional<z.ZodString>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            registry?: string | undefined;
+        }, {
+            enabled?: boolean | undefined;
+            registry?: string | undefined;
+        }>>>;
+        migration_order: z.ZodDefault<z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
+            dirs: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
+        }, "strip", z.ZodTypeAny, {
+            enabled: boolean;
+            dirs: string[];
+        }, {
+            enabled?: boolean | undefined;
+            dirs?: string[] | undefined;
+        }>>>;
         semantic_bugs: z.ZodDefault<z.ZodOptional<z.ZodObject<{
             enabled: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
             rules: z.ZodOptional<z.ZodArray<z.ZodString, "many">>;
@@ -2171,6 +2255,18 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns: string[];
             audit_log: boolean;
         };
+        unindexed_reads: {
+            enabled: boolean;
+            migrations: string[];
+        };
+        deprecated_dependencies: {
+            enabled: boolean;
+            registry?: string | undefined;
+        };
+        migration_order: {
+            enabled: boolean;
+            dirs: string[];
+        };
         semantic_bugs: {
             enabled: boolean;
             rules?: string[] | undefined;
@@ -2414,6 +2510,18 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         } | undefined;
+        unindexed_reads?: {
+            enabled?: boolean | undefined;
+            migrations?: string[] | undefined;
+        } | undefined;
+        deprecated_dependencies?: {
+            enabled?: boolean | undefined;
+            registry?: string | undefined;
+        } | undefined;
+        migration_order?: {
+            enabled?: boolean | undefined;
+            dirs?: string[] | undefined;
+        } | undefined;
         semantic_bugs?: {
             enabled?: boolean | undefined;
             rules?: string[] | undefined;
@@ -2712,6 +2820,18 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns: string[];
             audit_log: boolean;
         };
+        unindexed_reads: {
+            enabled: boolean;
+            migrations: string[];
+        };
+        deprecated_dependencies: {
+            enabled: boolean;
+            registry?: string | undefined;
+        };
+        migration_order: {
+            enabled: boolean;
+            dirs: string[];
+        };
         semantic_bugs: {
             enabled: boolean;
             rules?: string[] | undefined;
@@ -2985,6 +3105,18 @@ export declare const ConfigSchema: z.ZodObject<{
             custom_patterns?: string[] | undefined;
             audit_log?: boolean | undefined;
         } | undefined;
+        unindexed_reads?: {
+            enabled?: boolean | undefined;
+            migrations?: string[] | undefined;
+        } | undefined;
+        deprecated_dependencies?: {
+            enabled?: boolean | undefined;
+            registry?: string | undefined;
+        } | undefined;
+        migration_order?: {
+            enabled?: boolean | undefined;
+            dirs?: string[] | undefined;
+        } | undefined;
         semantic_bugs?: {
             enabled?: boolean | undefined;
             rules?: string[] | undefined;

package/dist/types/index.js

@@ -270,6 +270,21 @@ export const GatesSchema = z.object({
     }).optional().default({}),
     // v4.3+ Side-Effect Safety Analysis
     // On by default: full scans of three real repositories reported no finding that was not a real defect.
+    // A supabase-js read no index can serve, proved from the repository's own migrations (advisory, off by default).
+    unindexed_reads: z.object({
+        enabled: z.boolean().optional().default(false),
+        migrations: z.array(z.string()).optional().default([]),
+    }).optional().default({}),
+    // A dependency whose installed version npm marks deprecated (advisory, off by default: it asks the registry).
+    deprecated_dependencies: z.object({
+        enabled: z.boolean().optional().default(false),
+        registry: z.string().optional(),
+    }).optional().default({}),
+    // A migration added on a branch that sorts before the newest one on the base (advisory, off by default).
+    migration_order: z.object({
+        enabled: z.boolean().optional().default(false),
+        dirs: z.array(z.string()).optional().default(['**/supabase/migrations']),
+    }).optional().default({}),
     semantic_bugs: z.object({
         enabled: z.boolean().optional().default(true),
         rules: z.array(z.string()).optional(),

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.5.2",
-  "description": "AI-native quality gate engine with local Bayesian learning. AST analysis, drift detection, Fix Packet generation, and agent self-healing across TypeScript, JavaScript, Python, Go, Ruby, and C#.",
+  "version": "6.5.3",
+  "description": "Rigour's review engine: deterministic gates on changed lines, rules and lessons learned from your team's fixes, and per-check precision from what you fix versus dismiss, across TypeScript, JavaScript, Python, Go, Ruby and C#.",
   "engines": {
     "node": ">=22"
   },
@@ -70,11 +70,11 @@
     "pg": "^8.16.3",
     "sqlite3": "^5.1.7",
     "openai": "^4.104.0",
-    "@rigour-labs/brain-darwin-arm64": "6.5.2",
-    "@rigour-labs/brain-linux-arm64": "6.5.2",
-    "@rigour-labs/brain-darwin-x64": "6.5.2",
-    "@rigour-labs/brain-win-x64": "6.5.2",
-    "@rigour-labs/brain-linux-x64": "6.5.2"
+    "@rigour-labs/brain-darwin-arm64": "6.5.3",
+    "@rigour-labs/brain-darwin-x64": "6.5.3",
+    "@rigour-labs/brain-linux-x64": "6.5.3",
+    "@rigour-labs/brain-linux-arm64": "6.5.3",
+    "@rigour-labs/brain-win-x64": "6.5.3"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",