@rigour-labs/core 6.5.4 → 6.6.1

package/dist/review/stories.js

@@ -0,0 +1,75 @@
+/**
+ * What Rigour stopped, as people read it: one entry per problem an agent fixed after Rigour
+ * reported it, with the stage that caught it and the code change that fixed it.
+ *
+ * agent-fixes.ts keeps the before and after only until `rigour learn` turns them into rules;
+ * this log keeps a small, permanent summary for Studio. It never holds whole files: only the
+ * changed lines with a little context, capped.
+ */
+import crypto from 'crypto';
+import fs from 'fs';
+import path from 'path';
+export const STORIES_FILE = path.join('.rigour', 'stories.jsonl');
+/** Kept on disk; older entries are dropped when the log is rewritten. */
+const MAX_STORIES = 500;
+const CONTEXT_LINES = 2;
+const MAX_DIFF_LINES = 40;
+const MAX_LINE_CHARS = 200;
+export function appendStory(cwd, story) {
+    const entry = { id: crypto.createHash('sha256').update(`${story.at}\0${story.file}\0${story.rule}`).digest('hex').slice(0, 16), ...story };
+    const file = path.join(cwd, STORIES_FILE);
+    try {
+        fs.mkdirSync(path.dirname(file), { recursive: true });
+        fs.appendFileSync(file, JSON.stringify(entry) + '\n');
+        trim(file);
+    }
+    catch {
+        // Stories are a view; failing to keep one must never break a review or a hook.
+    }
+}
+/** Every story, oldest first; `since` keeps those at or after it. */
+export function readStories(cwd, since) {
+    let lines;
+    try {
+        lines = fs.readFileSync(path.join(cwd, STORIES_FILE), 'utf8').split('\n');
+    }
+    catch {
+        return [];
+    }
+    const stories = lines.flatMap(line => {
+        try {
+            return line.trim() ? [JSON.parse(line)] : [];
+        }
+        catch {
+            return [];
+        }
+    });
+    return since ? stories.filter(s => Date.parse(s.at) >= since.getTime()) : stories;
+}
+/**
+ * The lines that changed between two versions of a file, with context: the common head and
+ * tail are trimmed and what is left between them is shown as removed then added.
+ */
+export function compactDiff(before, after) {
+    const a = before.split('\n');
+    const b = after.split('\n');
+    let head = 0;
+    while (head < a.length && head < b.length && a[head] === b[head])
+        head++;
+    let tail = 0;
+    while (tail < a.length - head && tail < b.length - head && a[a.length - 1 - tail] === b[b.length - 1 - tail])
+        tail++;
+    const clip = (line) => (line.length > MAX_LINE_CHARS ? line.slice(0, MAX_LINE_CHARS) + '…' : line);
+    const lines = [
+        ...a.slice(Math.max(0, head - CONTEXT_LINES), head).map(l => ' ' + clip(l)),
+        ...a.slice(head, a.length - tail).map(l => '-' + clip(l)),
+        ...b.slice(head, b.length - tail).map(l => '+' + clip(l)),
+        ...a.slice(a.length - tail, Math.min(a.length, a.length - tail + CONTEXT_LINES)).map(l => ' ' + clip(l)),
+    ];
+    return lines.length > MAX_DIFF_LINES ? [...lines.slice(0, MAX_DIFF_LINES), ' …'] : lines;
+}
+function trim(file) {
+    const lines = fs.readFileSync(file, 'utf8').split('\n').filter(Boolean);
+    if (lines.length > MAX_STORIES * 1.2)
+        fs.writeFileSync(file, lines.slice(-MAX_STORIES).join('\n') + '\n');
+}

package/dist/review/stories.test.d.ts

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

package/dist/review/stories.test.js

@@ -0,0 +1,58 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { recordReviewOutcome } from './agent-fixes.js';
+import { readAgentEvents } from './effectiveness.js';
+import { recordLessonsServed, recordPrCatches } from './learning-events.js';
+import { compactDiff, readStories } from './stories.js';
+let cwd;
+beforeEach(() => { cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'stories-')); fs.mkdirSync(path.join(cwd, 'src')); });
+afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
+const finding = (id, title) => ({ id, title, details: `${title}.`, severity: 'high', files: ['src/a.ts'], line: 2 });
+describe('compactDiff', () => {
+    it('keeps only the changed lines and two lines of context', () => {
+        const before = ['a', 'b', 'c', 'old', 'd', 'e', 'f'].join('\n');
+        const after = ['a', 'b', 'c', 'new', 'd', 'e', 'f'].join('\n');
+        expect(compactDiff(before, after)).toEqual([' b', ' c', '-old', '+new', ' d', ' e']);
+    });
+});
+describe('stories from fixes', () => {
+    it('credits a fix to the stage that first reported it, with the code change', () => {
+        fs.writeFileSync(path.join(cwd, 'src/a.ts'), "fetch(url, { headers });\n");
+        recordReviewOutcome(cwd, [finding('semantic-bugs', 'Credential header follows redirects')], ['src/a.ts'], 'edit');
+        fs.writeFileSync(path.join(cwd, 'src/a.ts'), "fetch(url, { headers, redirect: 'error' });\n");
+        recordReviewOutcome(cwd, [], ['src/a.ts'], 'stop');
+        const [story] = readStories(cwd);
+        expect(story).toMatchObject({ stage: 'edit', file: 'src/a.ts', rule: 'semantic-bugs', title: 'Credential header follows redirects' });
+        expect(story.diff).toEqual(['-fetch(url, { headers });', "+fetch(url, { headers, redirect: 'error' });", ' ']);
+    });
+    it('writes no story for a finding someone dismissed, even after its file changed', async () => {
+        const { dismissFinding, findingKey } = await import('./quiet.js');
+        const f = finding('semantic-bugs', 'Looks risky');
+        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'x\n');
+        recordReviewOutcome(cwd, [f], ['src/a.ts'], 'review');
+        dismissFinding(cwd, findingKey(f), 'intended');
+        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'y\n');
+        recordReviewOutcome(cwd, [], ['src/a.ts'], 'review');
+        expect(readStories(cwd)).toEqual([]);
+    });
+    it('writes no story while the finding is still open', () => {
+        fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'x\n');
+        recordReviewOutcome(cwd, [finding('semantic-bugs', 'X')], ['src/a.ts'], 'review');
+        expect(readStories(cwd)).toEqual([]);
+    });
+});
+describe('learning events', () => {
+    it('records lessons served and PR catches, and nothing when there are none', () => {
+        recordLessonsServed(cwd, 'recall', []);
+        recordPrCatches(cwd, []);
+        expect(readAgentEvents(cwd)).toEqual([]);
+        recordLessonsServed(cwd, 'review', ['Never follow redirects with credentials', 'Never follow redirects with credentials']);
+        recordPrCatches(cwd, [finding('semantic-bugs', 'Unbounded query')]);
+        expect(readAgentEvents(cwd)).toEqual([
+            expect.objectContaining({ type: 'lessons_served', via: 'review', lessons: ['Never follow redirects with credentials'] }),
+            expect.objectContaining({ type: 'pr_catches', findings: [{ rule: 'semantic-bugs', title: 'Unbounded query', file: 'src/a.ts' }] }),
+        ]);
+    });
+});

package/dist/review-learning/team-lessons.d.ts

@@ -1,4 +1,8 @@
 import { type ReviewLesson } from './lessons.js';
 export type LessonMode = 'verified' | 'all' | 'off';
+/** Lessons a person or repeated evidence verified reach the reviewer unless a team turns them off. */
+export declare const DEFAULT_LESSON_MODE: LessonMode;
+/** The team's review lessons in play for this mode: none when off, verified ones by default. */
+export declare function activeLessons(cwd: string, mode?: LessonMode): ReviewLesson[];
 export declare function lessonsForDiff(cwd: string, diff: string, mode?: LessonMode): ReviewLesson[];
 export declare function lessonsSection(lessons: ReviewLesson[]): string;

package/dist/review-learning/team-lessons.js

@@ -5,7 +5,15 @@
  */
 import { parseDiff } from '../utils/diff.js';
 import { matchLessons, readLessons } from './lessons.js';
-export function lessonsForDiff(cwd, diff, mode = 'off') {
+/** Lessons a person or repeated evidence verified reach the reviewer unless a team turns them off. */
+export const DEFAULT_LESSON_MODE = 'verified';
+/** The team's review lessons in play for this mode: none when off, verified ones by default. */
+export function activeLessons(cwd, mode = DEFAULT_LESSON_MODE) {
+    if (mode === 'off')
+        return [];
+    return readLessons(cwd).filter(l => mode === 'all' || l.state === 'verified');
+}
+export function lessonsForDiff(cwd, diff, mode = DEFAULT_LESSON_MODE) {
     if (mode === 'off')
         return [];
     const lessons = readLessons(cwd);

package/dist/storage/cache-cleanup.d.ts

@@ -0,0 +1,19 @@
+/** Layers no reader uses (context/cache-engine.ts keeps only semantic and checkpoint). */
+export declare const DEAD_CACHE_TYPES: readonly ["static", "component"];
+export interface CacheCleanupReport {
+    removed: number;
+    kept: number;
+    sizeBefore: number;
+    sizeAfter: number;
+    vacuumed: boolean;
+    /** Why the file was not shrunk, when it was not. */
+    vacuumSkipped?: string;
+}
+/** How many dead rows the database holds, and its size on disk; null when there is no database. */
+export declare function deadCacheRows(dbPath?: string): Promise<{
+    rows: number;
+    bytes: number;
+} | null>;
+export declare function cleanContextCache(dbPath?: string, freeBytes?: typeof freeSpace): Promise<CacheCleanupReport>;
+declare function freeSpace(dir: string): number;
+export {};

package/dist/storage/cache-cleanup.js

@@ -0,0 +1,90 @@
+/**
+ * Removing context-cache rows nothing reads: the static and component layers that index sync wrote
+ * on every edit until it was removed (millions of rows, gigabytes, in real use).
+ *
+ * Built for a database that is large and a disk that is nearly full. Deleting the rows one by one
+ * would copy every changed page into the write-ahead log (as much again on disk); instead the rows
+ * worth keeping are set aside, the table is dropped (its pages are freed, not rewritten) and
+ * recreated. VACUUM, which hands the freed space back to the disk, needs room for a copy of what
+ * remains, so it runs only when that room exists.
+ */
+import fs from 'fs';
+import path from 'path';
+import { DB_PATH, openDatabase } from './db.js';
+/** Layers no reader uses (context/cache-engine.ts keeps only semantic and checkpoint). */
+export const DEAD_CACHE_TYPES = ['static', 'component'];
+const DEAD_LIST = DEAD_CACHE_TYPES.map(t => `'${t}'`).join(', ');
+/** VACUUM writes a copy of the live data; ask for that much free space, with headroom. */
+const VACUUM_HEADROOM = 1.2;
+/** How many dead rows the database holds, and its size on disk; null when there is no database. */
+export async function deadCacheRows(dbPath = DB_PATH) {
+    if (!fs.existsSync(dbPath))
+        return null;
+    const db = await openDatabase(dbPath);
+    if (!db)
+        return null;
+    try {
+        const row = await db.get(`SELECT COUNT(*) AS n FROM context_cache WHERE cache_type IN (${DEAD_LIST})`);
+        return { rows: Number(row?.n ?? 0), bytes: fileBytes(dbPath) };
+    }
+    finally {
+        await db.close();
+    }
+}
+export async function cleanContextCache(dbPath = DB_PATH, freeBytes = freeSpace) {
+    const sizeBefore = fileBytes(dbPath);
+    const db = await openDatabase(dbPath);
+    if (!db)
+        return { removed: 0, kept: 0, sizeBefore, sizeAfter: sizeBefore, vacuumed: false, vacuumSkipped: 'SQLite is not available' };
+    try {
+        const { removed, kept } = await dropDeadRows(db);
+        if (removed === 0)
+            return { removed, kept, sizeBefore, sizeAfter: sizeBefore, vacuumed: false, vacuumSkipped: 'nothing to remove' };
+        const live = await liveBytes(db);
+        const available = freeBytes(path.dirname(dbPath));
+        if (available < live * VACUUM_HEADROOM) {
+            return { removed, kept, sizeBefore, sizeAfter: fileBytes(dbPath), vacuumed: false,
+                vacuumSkipped: `needs about ${mb(live * VACUUM_HEADROOM)} free to shrink the file, ${mb(available)} available; the space is reused by Rigour either way` };
+        }
+        await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        await db.exec('VACUUM');
+        await db.exec('PRAGMA wal_checkpoint(TRUNCATE)');
+        return { removed, kept, sizeBefore, sizeAfter: fileBytes(dbPath), vacuumed: true };
+    }
+    finally {
+        await db.close();
+    }
+}
+/** Set the readable rows aside, drop the table, recreate it with its indexes, put them back. */
+async function dropDeadRows(db) {
+    return db.transaction(async (tx) => {
+        const removed = Number((await tx.get(`SELECT COUNT(*) AS n FROM context_cache WHERE cache_type IN (${DEAD_LIST})`))?.n ?? 0);
+        if (removed === 0)
+            return { removed, kept: 0 };
+        const schema = await tx.all(`SELECT sql FROM sqlite_master WHERE tbl_name = 'context_cache' AND sql IS NOT NULL ORDER BY type DESC`);
+        await tx.exec(`CREATE TEMP TABLE context_cache_keep AS SELECT * FROM context_cache WHERE cache_type NOT IN (${DEAD_LIST})`);
+        await tx.exec('DROP TABLE context_cache');
+        for (const { sql } of schema)
+            await tx.exec(sql); // the table first (type 'table' sorts after 'index' descending), then its indexes
+        await tx.exec('INSERT INTO context_cache SELECT * FROM context_cache_keep');
+        const kept = Number((await tx.get('SELECT COUNT(*) AS n FROM context_cache'))?.n ?? 0);
+        await tx.exec('DROP TABLE context_cache_keep');
+        return { removed, kept };
+    });
+}
+async function liveBytes(db) {
+    const pages = Number((await db.get('PRAGMA page_count'))?.page_count ?? 0);
+    const free = Number((await db.get('PRAGMA freelist_count'))?.freelist_count ?? 0);
+    const size = Number((await db.get('PRAGMA page_size'))?.page_size ?? 4096);
+    return (pages - free) * size;
+}
+function fileBytes(dbPath) {
+    return [dbPath, `${dbPath}-wal`].reduce((n, f) => n + (fs.existsSync(f) ? fs.statSync(f).size : 0), 0);
+}
+function freeSpace(dir) {
+    const stats = fs.statfsSync(dir);
+    return Number(stats.bavail) * Number(stats.bsize);
+}
+function mb(bytes) {
+    return bytes >= 1024 ** 3 ? `${(bytes / 1024 ** 3).toFixed(1)} GB` : `${Math.round(bytes / 1024 ** 2)} MB`;
+}

package/dist/storage/cache-cleanup.test.d.ts

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

package/dist/storage/cache-cleanup.test.js

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it } from 'vitest';
+import { cleanContextCache, deadCacheRows } from './cache-cleanup.js';
+import { openDatabase } from './db.js';
+let dir;
+let dbPath;
+async function seed(rows) {
+    const db = (await openDatabase(dbPath));
+    // One transaction: row-at-a-time commits are slow enough on Windows to time the test out.
+    await db.exec('BEGIN');
+    for (const [key, type] of rows) {
+        await db.run(`INSERT INTO context_cache (cache_key, cache_type, repo, branch, dependency_fingerprint, payload_json, payload_tokens, created_at)
+             VALUES (?, ?, 'r', 'main', 'f', ?, 1, 0)`, key, type, JSON.stringify({ padding: 'x'.repeat(2000) }));
+    }
+    await db.exec('COMMIT');
+    await db.close();
+}
+beforeEach(() => {
+    dir = fs.mkdtempSync(path.join(os.tmpdir(), 'cache-cleanup-')); // a temporary database: never ~/.rigour
+    dbPath = path.join(dir, 'rigour.db');
+});
+// Windows keeps a just-closed SQLite file locked for a moment: retry the removal instead of failing.
+afterEach(() => fs.rmSync(dir, { recursive: true, force: true, maxRetries: 10, retryDelay: 100 }));
+// Real SQLite files on disk: slower on Windows runners than the 5 s default allows.
+describe('cleanContextCache', { timeout: 30_000 }, () => {
+    it('removes the unread layers, keeps the readable rows and the indexes, and shrinks the file', async () => {
+        await seed([
+            ...Array.from({ length: 200 }, (_, i) => [`static:${i}`, 'static']),
+            ...Array.from({ length: 200 }, (_, i) => [`component:${i}`, 'component']),
+            ['semantic:a', 'semantic'], ['checkpoint:b', 'checkpoint'],
+        ]);
+        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 400 });
+        const report = await cleanContextCache(dbPath, () => Number.MAX_SAFE_INTEGER);
+        expect(report).toMatchObject({ removed: 400, kept: 2, vacuumed: true });
+        expect(report.sizeAfter).toBeLessThan(report.sizeBefore);
+        const db = (await openDatabase(dbPath));
+        expect((await db.all('SELECT cache_key FROM context_cache ORDER BY cache_key')).map(r => r.cache_key)).toEqual(['checkpoint:b', 'semantic:a']);
+        expect((await db.all("SELECT name FROM sqlite_master WHERE tbl_name = 'context_cache' AND type = 'index'")).map(r => r.name)).toContain('idx_context_cache_type');
+        await db.close();
+        expect(await deadCacheRows(dbPath)).toMatchObject({ rows: 0 });
+    });
+    it('still removes the rows but leaves the file size alone when the disk lacks room to shrink it', async () => {
+        await seed([['static:1', 'static'], ['semantic:a', 'semantic']]);
+        const report = await cleanContextCache(dbPath, () => 0);
+        expect(report).toMatchObject({ removed: 1, kept: 1, vacuumed: false });
+        expect(report.vacuumSkipped).toContain('free to shrink the file');
+    });
+    it('does nothing when there is nothing to remove', async () => {
+        await seed([['semantic:a', 'semantic']]);
+        expect(await cleanContextCache(dbPath, () => 0)).toMatchObject({ removed: 0, vacuumed: false, vacuumSkipped: 'nothing to remove' });
+    });
+});

package/dist/storage/db.js

@@ -10,6 +10,7 @@ import path from 'path';
 import os from 'os';
 import fs from 'fs-extra';
 import { createRequire } from 'module';
+import { rigourUserDir } from '../utils/user-state.js';
 // ---------------------------------------------------------------------------
 // Optional dynamic import of sqlite3
 // ---------------------------------------------------------------------------
@@ -42,7 +43,8 @@ function loadSqlite3() {
     sqlite3Module = null;
     return sqlite3Module;
 }
-const RIGOUR_DIR = path.join(os.homedir(), '.rigour');
+// RIGOUR_HOME when set (tests, sandboxes) so nothing but a real run touches ~/.rigour.
+const RIGOUR_DIR = rigourUserDir();
 const DB_PATH = path.join(RIGOUR_DIR, 'rigour.db');
 /** Current schema version — bump when adding migrations. */
 const SCHEMA_VERSION = 7;

package/dist/storage/index.d.ts

@@ -3,6 +3,7 @@
  * Everything in one file: ~/.rigour/rigour.db
  */
 export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, resetDatabase, RIGOUR_DIR, DB_PATH } from './db.js';
+export { cleanContextCache, deadCacheRows, DEAD_CACHE_TYPES, type CacheCleanupReport } from './cache-cleanup.js';
 export type { RigourDB, CompactResult } from './db.js';
 export { insertScan, getRecentScans, getScoreTrendFromDB, getTopIssues } from './scans.js';
 export { insertFindings, getFindingsForScan, getDeepFindings } from './findings.js';

package/dist/storage/index.js

@@ -3,6 +3,7 @@
  * Everything in one file: ~/.rigour/rigour.db
  */
 export { openDatabase, isSQLiteAvailable, compactDatabase, getDatabaseSize, resetDatabase, RIGOUR_DIR, DB_PATH } from './db.js';
+export { cleanContextCache, deadCacheRows, DEAD_CACHE_TYPES } from './cache-cleanup.js';
 export { insertScan, getRecentScans, getScoreTrendFromDB, getTopIssues } from './scans.js';
 export { insertFindings, getFindingsForScan, getDeepFindings } from './findings.js';
 export { reinforcePattern, decayPatterns, getStrongPatterns, getPatterns, getHardRules } from './patterns.js';

package/dist/storage/local-encryption.js

@@ -1,9 +1,9 @@
 import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
 import { chmod, link, readFile, unlink, writeFile } from 'node:fs/promises';
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
-const KEY_PATH = path.join(os.homedir(), '.rigour', 'team-cache.key');
+import { rigourUserDir } from '../utils/user-state.js';
+const KEY_PATH = path.join(rigourUserDir(), 'team-cache.key');
 let fileKeyPromise;
 function decodeKey(value, source) {
     const normalized = value.trim();

package/dist/storage/team-store.js

@@ -1,17 +1,17 @@
 import fs from 'fs-extra';
-import os from 'os';
 import path from 'path';
 import { openDatabase } from './db.js';
 import { decryptLocalPayload, encryptLocalPayload } from './local-encryption.js';
 import { TEAM_SCHEMA } from './team-schema.js';
 import { diagnoseMissingMembership, explainTeamConnectionError } from './team-diagnostics.js';
+import { rigourUserDir } from '../utils/user-state.js';
 import { TEAM_VECTOR_SCHEMA, backfillConfiguredTeamEmbeddings, getTeamSemanticHealth, searchConfiguredTeamKnowledge, upsertTeamLessonEmbedding, } from './team-vector-store.js';
 const DEFAULT_SEMANTIC = {
     provider: 'pgvector',
     model: 'Xenova/all-MiniLM-L6-v2',
     dimensions: 384,
 };
-export const TEAM_CONFIG_PATH = path.join(os.homedir(), '.rigour', 'team.json');
+export const TEAM_CONFIG_PATH = path.join(rigourUserDir(), 'team.json');
 function nonEmpty(value) {
     return typeof value === 'string' && value.trim() ? value.trim() : undefined;
 }

package/dist/types/index.js

@@ -333,7 +333,7 @@ export const GatesSchema = z.object({
         budget_ms: z.number().optional(), // whole deep run; files not started in time are reported as skipped
         agentic: z.boolean().optional(), // cloud tier: the model may read the repository while it reviews (default true)
         repo_rules: z.boolean().optional(), // show the reviewer the rules in AGENTS.md / CLAUDE.md / Cursor rules that name what the change touches (default false)
-        review_lessons: z.enum(['verified', 'all', 'off']).optional(), // the team's past review lessons shown to the reviewer: off (default), verified, or all
+        review_lessons: z.enum(['verified', 'all', 'off']).optional(), // the team's past review lessons: they raise a function's risk and are shown to the reviewer. verified (default), all, or off
         router: z.object({
             enabled: z.boolean().optional(), // default true
             min_score: z.number().optional(), // functions below this get the deterministic gates only

package/dist/utils/user-state.js

@@ -13,7 +13,7 @@ export function rigourUserDir() {
 export function repoStateDir(cwd) {
     let root = path.resolve(cwd);
     try {
-        root = fs.realpathSync(root);
+        root = fs.realpathSync.native(root);
     }
     catch { /* not created yet: the resolved path is the key */ }
     const key = crypto.createHash('sha256').update(root).digest('hex').slice(0, 16);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@rigour-labs/core",
-  "version": "6.5.4",
+  "version": "6.6.1",
   "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.4",
-    "@rigour-labs/brain-darwin-x64": "6.5.4",
-    "@rigour-labs/brain-linux-arm64": "6.5.4",
-    "@rigour-labs/brain-linux-x64": "6.5.4",
-    "@rigour-labs/brain-win-x64": "6.5.4"
+    "@rigour-labs/brain-darwin-x64": "6.6.1",
+    "@rigour-labs/brain-linux-arm64": "6.6.1",
+    "@rigour-labs/brain-darwin-arm64": "6.6.1",
+    "@rigour-labs/brain-linux-x64": "6.6.1",
+    "@rigour-labs/brain-win-x64": "6.6.1"
   },
   "devDependencies": {
     "@types/fs-extra": "^11.0.4",