@rigour-labs/core 6.5.1 → 6.5.3

package/dist/memory/recall.test.js

@@ -0,0 +1,36 @@
+import { describe, expect, it } from 'vitest';
+import { RECALL_LIMIT, rankMemories } from './recall.js';
+const memories = [
+    { scope: 'repo', key: 'retry_policy', value: 'Wrap network calls in withRetry from lib/net; never hand-roll backoff.' },
+    { scope: 'repo', key: 'db_access', value: 'Reports read from the replica, never the primary.' },
+    { scope: 'user', key: 'pr_size', value: 'Keep pull requests under 400 lines.' },
+];
+/** A stand-in embedding: one dimension per topic word, so similarity is predictable. */
+const TOPICS = ['retry', 'backoff', 'network', 'replica', 'report', 'pull', 'request'];
+const embed = async (text) => TOPICS.map(topic => (text.toLowerCase().includes(topic) ? 1 : 0));
+describe('rankMemories', () => {
+    it('returns the memories that match by meaning, best first, above the floor', async () => {
+        const ranked = await rankMemories('add exponential backoff to a flaky network call', memories, embed);
+        expect(ranked.map(m => [m.key, m.match])).toEqual([['retry_policy', 'semantic']]);
+    });
+    it('returns nothing rather than the closest weak match', async () => {
+        expect(await rankMemories('rename a css class', memories, embed)).toEqual([]);
+    });
+    it('falls back to keyword overlap when the model is unavailable, and says so', async () => {
+        const ranked = await rankMemories('replica reports', memories, async () => []);
+        expect(ranked.map(m => [m.key, m.match])).toEqual([['db_access', 'keyword']]);
+    });
+    it(`returns at most ${RECALL_LIMIT}`, async () => {
+        const many = Array.from({ length: 10 }, (_, i) => ({ scope: 'repo', key: `retry_${i}`, value: 'network retry backoff' }));
+        expect(await rankMemories('network retry backoff', many, embed)).toHaveLength(RECALL_LIMIT);
+    });
+    it('embeds each text once, not on every recall', async () => {
+        let calls = 0;
+        const counting = async (text) => { calls++; return embed(text); };
+        const fresh = memories.map(m => ({ ...m, value: `${m.value} (cache test)` }));
+        await rankMemories('network retry', fresh, counting);
+        const first = calls;
+        await rankMemories('replica reports', fresh, counting);
+        expect(calls - first).toBe(1); // only the new query
+    });
+});

package/dist/pattern-index/assess.d.ts

@@ -0,0 +1,16 @@
+import type { PatternIndex, PatternMatch, StalenessIssue } from './types.js';
+export interface PatternQuery {
+    name: string;
+    type?: string;
+    intent?: string;
+    signature?: string;
+    keywords?: string[];
+}
+export interface PatternAssessment {
+    action: 'BLOCK' | 'WARN' | 'ALLOW';
+    match?: PatternMatch;
+    suggestion: string;
+    /** Deprecated usage inside the matched function, if any. */
+    deprecations: StalenessIssue[];
+}
+export declare function assessPattern(cwd: string, index: PatternIndex, query: PatternQuery): Promise<PatternAssessment>;

package/dist/pattern-index/assess.js

@@ -0,0 +1,37 @@
+/**
+ * Before writing a function: does the codebase already have it, and is what
+ * would be reused itself out of date? Shared by the MCP rigour_check_pattern
+ * tool and the CLI `rigour check-pattern`.
+ *
+ * BLOCK means an exact or near-certain match (reuse it); WARN means a similar
+ * function exists (look before writing). Deprecations come from the matched
+ * function's own source, never from its name.
+ */
+import fs from 'fs-extra';
+import path from 'path';
+import { PatternMatcher } from './matcher.js';
+import { StalenessDetector } from './staleness.js';
+export async function assessPattern(cwd, index, query) {
+    const result = await new PatternMatcher(index).match(query);
+    if (result.status !== 'FOUND_SIMILAR')
+        return { action: 'ALLOW', suggestion: '', deprecations: [] };
+    const match = result.matches[0];
+    const source = await readPatternSource(cwd, match.pattern);
+    const staleness = source ? await new StalenessDetector(cwd).checkStaleness(source, match.pattern.file) : undefined;
+    return {
+        action: result.action,
+        match,
+        suggestion: result.suggestion,
+        deprecations: staleness && staleness.status !== 'FRESH' ? staleness.issues : [],
+    };
+}
+/** The lines a pattern spans, or undefined when its file cannot be read. */
+async function readPatternSource(cwd, pattern) {
+    try {
+        const lines = (await fs.readFile(path.join(cwd, pattern.file), 'utf8')).split('\n');
+        return lines.slice(Math.max(0, pattern.line - 1), pattern.endLine).join('\n');
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/pattern-index/embeddings.d.ts

@@ -7,6 +7,25 @@
  * Generate an embedding for a piece of text.
  */
 export declare function generateEmbedding(text: string): Promise<number[]>;
+/**
+ * Version of the text patterns are embedded by. An index embedded with an older text is
+ * re-embedded on its next enrichment.
+ *   2: the name split into words (`retryWithBackoff` → "retry with backoff"). Measured by
+ *      scripts/eval/pattern-intent.mjs: recall by intent 87% at 0.30 with no false matches,
+ *      against 13% for the raw name at the old 0.60 bar.
+ */
+export declare const EMBEDDING_TEXT_VERSION = 2;
+export declare function patternEmbeddingText(pattern: {
+    name: string;
+    type: string;
+    description?: string;
+}): string;
+/** A pattern's embedding, rounded to 4 decimals: a third of the size on disk, no change to ranking. */
+export declare function embedPattern(pattern: {
+    name: string;
+    type: string;
+    description?: string;
+}): Promise<number[]>;
 /**
  * Calculate cosine similarity between two vectors.
  */

package/dist/pattern-index/embeddings.js

@@ -56,6 +56,22 @@ export async function generateEmbedding(text) {
         return [];
     }
 }
+/**
+ * Version of the text patterns are embedded by. An index embedded with an older text is
+ * re-embedded on its next enrichment.
+ *   2: the name split into words (`retryWithBackoff` → "retry with backoff"). Measured by
+ *      scripts/eval/pattern-intent.mjs: recall by intent 87% at 0.30 with no false matches,
+ *      against 13% for the raw name at the old 0.60 bar.
+ */
+export const EMBEDDING_TEXT_VERSION = 2;
+export function patternEmbeddingText(pattern) {
+    const words = pattern.name.replace(/([a-z0-9])([A-Z])/g, '$1 $2').replace(/[_-]+/g, ' ').toLowerCase();
+    return `${words} ${pattern.type} ${pattern.description ?? ''}`.trim();
+}
+/** A pattern's embedding, rounded to 4 decimals: a third of the size on disk, no change to ranking. */
+export async function embedPattern(pattern) {
+    return (await generateEmbedding(patternEmbeddingText(pattern))).map(x => Math.round(x * 1e4) / 1e4);
+}
 /**
  * Calculate cosine similarity between two vectors.
  */

package/dist/pattern-index/index.d.ts

@@ -5,8 +5,9 @@
  */
 export type { PatternType, PatternEntry, PatternIndex, PatternIndexConfig, PatternIndexStats, IndexedFile, PatternMatchResult, PatternMatch, PatternOverride, StalenessResult, StalenessIssue, DeprecationEntry } from './types.js';
 export { PatternIndexer, savePatternIndex, loadPatternIndex, getDefaultIndexPath } from './indexer.js';
-export { PatternMatcher, checkPatternDuplicate, type MatcherConfig } from './matcher.js';
+export { PatternMatcher, checkPatternDuplicate, SEMANTIC_MATCH_FLOOR, type MatcherConfig } from './matcher.js';
+export { assessPattern, type PatternQuery, type PatternAssessment } from './assess.js';
 export { StalenessDetector, checkCodeStaleness } from './staleness.js';
 export { SecurityDetector } from './security.js';
 export { OverrideManager, loadConfigOverrides } from './overrides.js';
-export { generateEmbedding, semanticSearch, cosineSimilarity } from './embeddings.js';
+export { generateEmbedding, semanticSearch, cosineSimilarity, embedPattern, patternEmbeddingText, EMBEDDING_TEXT_VERSION } from './embeddings.js';

package/dist/pattern-index/index.js

@@ -6,7 +6,9 @@
 // Indexer
 export { PatternIndexer, savePatternIndex, loadPatternIndex, getDefaultIndexPath } from './indexer.js';
 // Matcher
-export { PatternMatcher, checkPatternDuplicate } from './matcher.js';
+export { PatternMatcher, checkPatternDuplicate, SEMANTIC_MATCH_FLOOR } from './matcher.js';
+// Reuse check before writing
+export { assessPattern } from './assess.js';
 // Staleness Detection
 export { StalenessDetector, checkCodeStaleness } from './staleness.js';
 // Security Detection
@@ -14,4 +16,4 @@ export { SecurityDetector } from './security.js';
 // Override Management
 export { OverrideManager, loadConfigOverrides } from './overrides.js';
 // Embeddings
-export { generateEmbedding, semanticSearch, cosineSimilarity } from './embeddings.js';
+export { generateEmbedding, semanticSearch, cosineSimilarity, embedPattern, patternEmbeddingText, EMBEDDING_TEXT_VERSION } from './embeddings.js';

package/dist/pattern-index/indexer.js

@@ -13,10 +13,11 @@ import * as path from 'path';
 import { globby } from 'globby';
 import ts from 'typescript';
 import micromatch from 'micromatch';
-import { generateEmbedding } from './embeddings.js';
+import { EMBEDDING_TEXT_VERSION, embedPattern } from './embeddings.js';
 import { hashContent } from './indexer-helpers.js';
 import { extractGoPatterns, extractRustPatterns, extractJVMStylePatterns, extractPythonPatterns, extractGenericCPatterns, } from './indexer-lang.js';
 import { nodeToPattern } from './indexer-ts.js';
+import { directoriesAsGlobs, withDirectoryForms } from '../utils/glob-paths.js';
 // ---------------------------------------------------------------------------
 // Configuration
 // ---------------------------------------------------------------------------
@@ -87,7 +88,7 @@ export class PatternIndexer {
             for (let i = 0; i < patterns.length; i += BATCH_SIZE) {
                 const batch = patterns.slice(i, i + BATCH_SIZE);
                 await Promise.all(batch.map(async (pattern) => {
-                    pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+                    pattern.embedding = await embedPattern(pattern);
                 }));
             }
         }
@@ -95,6 +96,8 @@ export class PatternIndexer {
         const stats = this.calculateStats(patterns, indexedFiles, endTime - startTime);
         return {
             version: INDEX_VERSION,
+            // Set only when this build embedded the patterns.
+            ...(this.config.useEmbeddings ? { embeddingTextVersion: EMBEDDING_TEXT_VERSION } : {}),
             lastUpdated: new Date().toISOString(),
             rootDir: this.rootDir,
             patterns,
@@ -141,7 +144,7 @@ export class PatternIndexer {
                 const batch = updatedPatterns.slice(i, i + BATCH_SIZE);
                 await Promise.all(batch.map(async (pattern) => {
                     if (!pattern.embedding) {
-                        pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+                        pattern.embedding = await embedPattern(pattern);
                     }
                 }));
             }
@@ -150,6 +153,8 @@ export class PatternIndexer {
         const stats = this.calculateStats(updatedPatterns, updatedFiles, endTime - startTime);
         return {
             version: INDEX_VERSION,
+            // Kept from the index being updated, so an incremental update never looks stale.
+            embeddingTextVersion: this.config.useEmbeddings ? EMBEDDING_TEXT_VERSION : existingIndex.embeddingTextVersion,
             lastUpdated: new Date().toISOString(),
             rootDir: this.rootDir,
             patterns: updatedPatterns,
@@ -181,7 +186,7 @@ export class PatternIndexer {
                 const filePatterns = await this.extractPatterns(absolutePath, content);
                 if (this.config.useEmbeddings) {
                     await Promise.all(filePatterns.map(async (pattern) => {
-                        pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+                        pattern.embedding = await embedPattern(pattern);
                     }));
                 }
                 patterns.push(...filePatterns);
@@ -199,6 +204,7 @@ export class PatternIndexer {
         }
         return {
             version: INDEX_VERSION,
+            embeddingTextVersion: this.config.useEmbeddings ? EMBEDDING_TEXT_VERSION : existingIndex.embeddingTextVersion,
             lastUpdated: new Date().toISOString(),
             rootDir: this.rootDir,
             patterns,
@@ -209,20 +215,23 @@ export class PatternIndexer {
     async enrichIndex(existingIndex) {
         const startTime = Date.now();
         const patterns = existingIndex.patterns.map(pattern => ({ ...pattern }));
-        const pending = patterns.filter(pattern => !pattern.embedding?.length);
+        // An index embedded from an older text is re-embedded whole: mixed vectors would not compare.
+        const stale = existingIndex.embeddingTextVersion !== EMBEDDING_TEXT_VERSION;
+        const pending = patterns.filter(pattern => stale || !pattern.embedding?.length);
         if (pending.length > 0) {
-            pending[0].embedding = await generateEmbedding(`${pending[0].name} ${pending[0].type} ${pending[0].description}`);
+            pending[0].embedding = await embedPattern(pending[0]);
             if (!pending[0].embedding.length)
                 return existingIndex;
         }
         const batchSize = 10;
         for (let i = 1; i < pending.length; i += batchSize) {
             await Promise.all(pending.slice(i, i + batchSize).map(async (pattern) => {
-                pattern.embedding = await generateEmbedding(`${pattern.name} ${pattern.type} ${pattern.description}`);
+                pattern.embedding = await embedPattern(pattern);
             }));
         }
         return {
             ...existingIndex,
+            embeddingTextVersion: EMBEDDING_TEXT_VERSION,
             lastUpdated: new Date().toISOString(),
             patterns,
             stats: this.calculateStats(patterns, existingIndex.files, Date.now() - startTime),
@@ -239,10 +248,11 @@ export class PatternIndexer {
         if (!this.config.indexTests) {
             exclude.push('**/*.test.*', '**/*.spec.*', '**/__tests__/**');
         }
-        return globby(patterns, {
+        return globby(directoriesAsGlobs(this.rootDir, patterns), {
             cwd: this.rootDir,
             absolute: true,
-            ignore: exclude,
+            ignore: withDirectoryForms(exclude),
+            expandDirectories: false,
             gitignore: true,
         });
     }

package/dist/pattern-index/matcher.d.ts

@@ -8,6 +8,12 @@
  * 4. Keyword/semantic match
  */
 import type { PatternIndex, PatternMatchResult, PatternOverride } from './types.js';
+/**
+ * The similarity a match by meaning needs. Measured by scripts/eval/pattern-intent.mjs: at 0.30,
+ * 87% of intents found the existing function with no false matches; name-based strategies keep
+ * minConfidence, which this cosine scale does not share.
+ */
+export declare const SEMANTIC_MATCH_FLOOR = 0.3;
 /**
  * Configuration for pattern matching.
  */

package/dist/pattern-index/matcher.js

@@ -7,7 +7,13 @@
  * 3. Signature match
  * 4. Keyword/semantic match
  */
-import { generateEmbedding, cosineSimilarity } from './embeddings.js';
+import { generateEmbedding, cosineSimilarity, patternEmbeddingText } from './embeddings.js';
+/**
+ * The similarity a match by meaning needs. Measured by scripts/eval/pattern-intent.mjs: at 0.30,
+ * 87% of intents found the existing function with no false matches; name-based strategies keep
+ * minConfidence, which this cosine scale does not share.
+ */
+export const SEMANTIC_MATCH_FLOOR = 0.3;
 /** Default matcher configuration */
 const DEFAULT_MATCHER_CONFIG = {
     minConfidence: 60,
@@ -48,7 +54,8 @@ export class PatternMatcher {
         // Pre-calculate query embedding if semantic search is enabled
         let queryEmbedding = null;
         if (this.config.useEmbeddings && (query.intent || query.name)) {
-            queryEmbedding = await generateEmbedding(`${query.name || ''} ${query.intent || ''}`);
+            // The same text shape patterns are embedded by: the name split into words, then the intent.
+            queryEmbedding = await generateEmbedding(`${patternEmbeddingText({ name: query.name || '', type: '' })} ${query.intent || ''}`.trim());
         }
         // Check for override first
         if (query.name && this.hasOverride(query.name)) {
@@ -118,7 +125,10 @@ export class PatternMatcher {
                     maxConfidence = confidence;
                 }
             }
-            if (currentBest && maxConfidence >= this.config.minConfidence) {
+            const accepted = currentBest?.matchType === 'semantic'
+                ? maxConfidence >= SEMANTIC_MATCH_FLOOR * 100
+                : maxConfidence >= this.config.minConfidence;
+            if (currentBest && accepted) {
                 matches.push(currentBest);
             }
         }

package/dist/pattern-index/pattern-reuse.test.d.ts

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

package/dist/pattern-index/pattern-reuse.test.js

@@ -0,0 +1,76 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+/** Topic vectors: one dimension per word, so similarity between texts is predictable. */
+const TOPICS = ['retry', 'backoff', 'request', 'date', 'format', 'chart'];
+const topicVector = (text) => TOPICS.map(t => (text.toLowerCase().includes(t) ? 1 : 0));
+vi.mock('./embeddings.js', async (importOriginal) => {
+    const real = await importOriginal();
+    return {
+        ...real,
+        generateEmbedding: async (text) => topicVector(text),
+        embedPattern: async (p) => topicVector(real.patternEmbeddingText(p)),
+    };
+});
+const { patternEmbeddingText, EMBEDDING_TEXT_VERSION } = await import('./embeddings.js');
+const { PatternMatcher, SEMANTIC_MATCH_FLOOR } = await import('./matcher.js');
+const { PatternIndexer } = await import('./indexer.js');
+const { assessPattern } = await import('./assess.js');
+const pattern = (name, extra = {}) => ({
+    id: name, type: 'function', name, file: 'src/util.ts', line: 1, endLine: 3, signature: '', description: '',
+    keywords: [], hash: name, exported: true, usageCount: 0, indexedAt: '2026-10-02T00:00:00Z', ...extra,
+});
+const index = (patterns, version) => ({
+    version: '1.0.0', lastUpdated: '', rootDir: '/x', patterns, files: [],
+    stats: { totalPatterns: patterns.length, totalFiles: 1, byType: {}, indexDurationMs: 0 },
+    ...(version ? { embeddingTextVersion: version } : {}),
+});
+describe('pattern embedding text', () => {
+    it('reads a name as words, which is what lets an intent find it', () => {
+        expect(patternEmbeddingText({ name: 'retryWithBackoff', type: 'function' })).toBe('retry with backoff function');
+        expect(patternEmbeddingText({ name: 'parse_csv-rows', type: 'function', description: 'Rows from a file' })).toBe('parse csv rows function Rows from a file');
+    });
+});
+describe('matching by meaning', () => {
+    it(`accepts a match by meaning at ${SEMANTIC_MATCH_FLOOR}, below the bar name matching keeps`, async () => {
+        // The query shares 1 of 3 topics with the pattern: cosine 0.58, under the old 0.60.
+        const retry = pattern('retryWithBackoff', { embedding: topicVector('retry backoff request') });
+        const result = await new PatternMatcher(index([retry]), { useFuzzy: false }).match({ name: 'callAgain', intent: 'make the request work on a flaky network' });
+        expect(result.matches.map(m => [m.pattern.name, m.matchType])).toEqual([['retryWithBackoff', 'semantic']]);
+        expect(result.action).toBe('WARN');
+    });
+    it('returns nothing for an unrelated intent', async () => {
+        const retry = pattern('retryWithBackoff', { embedding: topicVector('retry backoff request') });
+        const result = await new PatternMatcher(index([retry]), { useFuzzy: false }).match({ name: 'drawPie', intent: 'render a pie chart' });
+        expect(result.status).toBe('NO_MATCH');
+    });
+});
+describe('enrichIndex', () => {
+    it('re-embeds an index built from an older embedding text, and marks the version', async () => {
+        const stale = index([pattern('formatDate', { embedding: [9, 9, 9, 9, 9, 9] })], 1);
+        const enriched = await new PatternIndexer('/x', { useEmbeddings: true }).enrichIndex(stale);
+        expect(enriched.embeddingTextVersion).toBe(EMBEDDING_TEXT_VERSION);
+        expect(enriched.patterns[0].embedding).toEqual(topicVector('format date function'));
+    });
+});
+describe('assessPattern', () => {
+    let cwd;
+    beforeEach(() => {
+        cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'assess-'));
+        fs.mkdirSync(path.join(cwd, 'src'));
+        fs.writeFileSync(path.join(cwd, 'package.json'), JSON.stringify({ dependencies: { 'react-dom': '18.2.0' } }));
+        fs.writeFileSync(path.join(cwd, 'src/mount.ts'), 'export function mountApp(el) {\n  ReactDOM.render(<App />, el);\n}\n');
+    });
+    afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
+    it('blocks an exact duplicate and reports what is deprecated inside the function it would reuse', async () => {
+        const mount = pattern('mountApp', { file: 'src/mount.ts', line: 1, endLine: 3 });
+        const result = await assessPattern(cwd, index([mount]), { name: 'mountApp' });
+        expect(result.action).toBe('BLOCK');
+        expect(result.deprecations.map(d => d.replacement)).toEqual(['createRoot(container).render(<App />)']);
+    });
+    it('allows a name nothing resembles', async () => {
+        const result = await assessPattern(cwd, index([pattern('mountApp', { file: 'src/mount.ts' })]), { name: 'exportPdfReport' });
+        expect(result).toEqual({ action: 'ALLOW', suggestion: '', deprecations: [] });
+    });
+});

package/dist/pattern-index/staleness.d.ts

@@ -4,7 +4,7 @@
  * Detects when AI is suggesting deprecated or outdated patterns.
  * Uses package.json analysis and a deprecation database.
  */
-import type { StalenessResult, StalenessIssue, DeprecationEntry } from './types.js';
+import type { StalenessResult, DeprecationEntry } from './types.js';
 /**
  * Project context extracted from package.json and other config files.
  */
@@ -21,18 +21,7 @@ export declare class StalenessDetector {
     private deprecations;
     private projectContext;
     private rootDir;
-    private remoteRulesUrl;
     constructor(rootDir: string, customDeprecations?: DeprecationEntry[]);
-    /**
-     * Fetch latest deprecation rules from Rigour's remote registry.
-     * This ensures the tool stays up-to-date even without a package update.
-     */
-    syncRemoteRules(): Promise<number>;
-    /**
-     * Check NPM registry for live deprecation status of project dependencies.
-     * This is the ultimate "up-to-date" check.
-     */
-    checkLiveRegistry(context: ProjectContext): Promise<StalenessIssue[]>;
     /**
      * Load project context from package.json.
      */
@@ -40,9 +29,7 @@ export declare class StalenessDetector {
     /**
      * Check code for staleness issues.
      */
-    checkStaleness(code: string, filePath?: string, options?: {
-        live?: boolean;
-    }): Promise<StalenessResult>;
+    checkStaleness(code: string, filePath?: string): Promise<StalenessResult>;
     /**
      * Check if project has a library.
      */

package/dist/pattern-index/staleness.js

@@ -19,82 +19,10 @@ export class StalenessDetector {
     deprecations;
     projectContext = null;
     rootDir;
-    remoteRulesUrl = 'https://raw.githubusercontent.com/rigour-labs/rules/main/deprecations.json';
     constructor(rootDir, customDeprecations = []) {
         this.rootDir = rootDir;
         this.deprecations = [...BUILT_IN_DEPRECATIONS, ...customDeprecations];
     }
-    /**
-     * Fetch latest deprecation rules from Rigour's remote registry.
-     * This ensures the tool stays up-to-date even without a package update.
-     */
-    async syncRemoteRules() {
-        try {
-            // Using dynamic import for fetch to avoid Node < 18 issues
-            const response = await fetch(this.remoteRulesUrl);
-            if (!response.ok)
-                throw new Error(`HTTP error! status: ${response.status}`);
-            const data = await response.json();
-            if (data.deprecations && Array.isArray(data.deprecations)) {
-                // Merge remote rules, avoiding duplicates
-                const existingPatterns = new Set(this.deprecations.map(d => d.pattern));
-                const newRules = data.deprecations.filter((d) => !existingPatterns.has(d.pattern));
-                this.deprecations.push(...newRules);
-                return newRules.length;
-            }
-            return 0;
-        }
-        catch (error) {
-            console.warn('Failed to sync remote rules, using built-in database:', error);
-            return 0;
-        }
-    }
-    /**
-     * Check NPM registry for live deprecation status of project dependencies.
-     * This is the ultimate "up-to-date" check.
-     */
-    async checkLiveRegistry(context) {
-        const issues = [];
-        const { execa } = await import('execa');
-        // We only check top-level dependencies to avoid noise/performance hits
-        const deps = Object.keys(context.dependencies);
-        for (const dep of deps) {
-            try {
-                // Run 'npm info <package> --json' to get metadata
-                const { stdout } = await execa('npm', ['info', dep, '--json']);
-                const info = JSON.parse(stdout);
-                // 1. Check if package is deprecated
-                if (info.deprecated) {
-                    issues.push({
-                        line: 0, // Package-level
-                        pattern: dep,
-                        severity: 'error',
-                        reason: `Package "${dep}" is marked as DEPRECATED in NPM registry: ${info.deprecated}`,
-                        replacement: 'Check package README for suggested alternatives',
-                        docs: `https://www.npmjs.com/package/${dep}`
-                    });
-                }
-                // 2. Check for latest version staleness
-                const current = context.dependencies[dep].replace(/^[\^~>=<]+/, '');
-                const latest = info['dist-tags']?.latest;
-                if (latest && semver.major(latest) > semver.major(current)) {
-                    issues.push({
-                        line: 0,
-                        pattern: dep,
-                        severity: 'info',
-                        reason: `Package "${dep}" has a new major version available (${latest}). Your version: ${current}`,
-                        replacement: `npm install ${dep}@latest`,
-                        docs: `https://www.npmjs.com/package/${dep}`
-                    });
-                }
-            }
-            catch (error) {
-                // Silently skip if npm check fails
-                continue;
-            }
-        }
-        return issues;
-    }
     /**
      * Load project context from package.json.
      */
@@ -125,7 +53,7 @@ export class StalenessDetector {
     /**
      * Check code for staleness issues.
      */
-    async checkStaleness(code, filePath, options = {}) {
+    async checkStaleness(code, filePath) {
         const context = await this.loadProjectContext();
         const issues = [];
         // 1. Check built-in/remote rules
@@ -161,11 +89,6 @@ export class StalenessDetector {
                 regex.lastIndex = 0;
             }
         }
-        // 2. Perform live registry check if requested (only once per run/file usually)
-        if (options.live) {
-            const liveIssues = await this.checkLiveRegistry(context);
-            issues.push(...liveIssues);
-        }
         // Determine overall status
         let status = 'FRESH';
         if (issues.some(i => i.severity === 'error')) {

package/dist/pattern-index/types.d.ts

@@ -49,6 +49,8 @@ export interface PatternEntry {
 export interface PatternIndex {
     /** Index format version */
     version: string;
+    /** Version of the text its embeddings were built from (embeddings.ts EMBEDDING_TEXT_VERSION). */
+    embeddingTextVersion?: number;
     /** When the index was last updated */
     lastUpdated: string;
     /** Root directory that was indexed */

package/dist/review/agent-fixes.d.ts

@@ -3,6 +3,8 @@ export interface ResolvedFix {
     id: string;
     file: string;
     rule: string;
+    title?: string;
+    details?: string;
     before: string;
     after: string;
     resolvedAt: string;
@@ -10,6 +12,8 @@ export interface ResolvedFix {
 export interface FixCapture {
     opened: number;
     resolved: number;
+    /** The fixes this review resolved, for turning into lessons (storage/fix-lessons.ts). */
+    fixes: ResolvedFix[];
 }
 /** Record a review's findings: open new ones, resolve open ones the review no longer reports. */
 export declare function recordReviewOutcome(cwd: string, findings: Failure[], reviewedFiles: string[]): FixCapture;

package/dist/review/agent-fixes.js

@@ -13,6 +13,7 @@
 import crypto from 'crypto';
 import fs from 'fs';
 import path from 'path';
+import { checkId, recordOutcome } from './check-outcomes.js';
 const DIR = path.join('.rigour', 'agent-fixes');
 const MAX_FILE_BYTES = 200_000;
 const OPEN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
@@ -20,13 +21,14 @@ const OPEN_TTL_MS = 7 * 24 * 60 * 60 * 1000;
 export function recordReviewOutcome(cwd, findings, reviewedFiles) {
     const open = readOpen(cwd);
     const current = new Map(findings.flatMap(f => (f.files?.[0] ? [[`${f.id}:${f.files[0]}`, f]] : [])));
-    const capture = { resolved: resolveGone(cwd, open, current, new Set(reviewedFiles)), opened: openNew(cwd, open, current) };
+    const fixes = resolveGone(cwd, open, current, new Set(reviewedFiles));
+    const opened = openNew(cwd, open, current);
     writeOpen(cwd, open);
-    return capture;
+    return { opened, resolved: fixes.length, fixes };
 }
 /** Open findings this review no longer reports: resolved when their file was reviewed and changed. */
 function resolveGone(cwd, open, current, reviewed) {
-    let resolved = 0;
+    const resolved = [];
     for (const [key, entry] of Object.entries(open)) {
         if (current.has(key))
             continue;
@@ -37,8 +39,8 @@ function resolveGone(cwd, open, current, reviewed) {
         }
         const after = readSmall(cwd, entry.file);
         if (after !== null && after !== entry.before) {
-            writeResolved(cwd, entry, after);
-            resolved++;
+            resolved.push(writeResolved(cwd, entry, after));
+            recordOutcome(cwd, checkId({ rule: entry.rule, title: entry.title }), 'fixed');
         }
         delete open[key];
     }
@@ -53,7 +55,7 @@ function openNew(cwd, open, current) {
         const before = readSmall(cwd, file);
         if (before === null)
             continue;
-        open[key] = { file, rule: finding.id, before, openedAt: new Date().toISOString() };
+        open[key] = { file, rule: finding.id, title: finding.title, details: finding.details, before, openedAt: new Date().toISOString() };
         opened++;
     }
     return opened;
@@ -96,7 +98,7 @@ function writeOpen(cwd, open) {
 }
 function writeResolved(cwd, entry, after) {
     const id = crypto.createHash('sha256').update(`${entry.rule}\0${entry.file}\0${entry.before}\0${after}`).digest('hex').slice(0, 16);
-    const fix = { id, file: entry.file, rule: entry.rule, before: entry.before, after, resolvedAt: new Date().toISOString() };
+    const fix = { id, file: entry.file, rule: entry.rule, title: entry.title, details: entry.details, before: entry.before, after, resolvedAt: new Date().toISOString() };
     try {
         fs.mkdirSync(path.join(cwd, DIR, 'resolved'), { recursive: true });
         fs.writeFileSync(path.join(cwd, DIR, 'resolved', `${id}.json`), JSON.stringify(fix));
@@ -104,6 +106,7 @@ function writeResolved(cwd, entry, after) {
     catch {
         // Best-effort, as above.
     }
+    return fix;
 }
 function readSmall(cwd, file) {
     try {