@rigour-labs/core 6.5.2 → 6.5.3

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,7 +13,7 @@ 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';
@@ -88,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);
                 }));
             }
         }
@@ -96,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,
@@ -142,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);
                     }
                 }));
             }
@@ -151,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,
@@ -182,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);
@@ -200,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,
@@ -210,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),

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 {

package/dist/review/agent-fixes.test.js

@@ -12,21 +12,21 @@ describe('recordReviewOutcome', () => {
     });
     afterEach(() => { fs.rmSync(cwd, { recursive: true, force: true }); });
     it('stores the before and after once a reviewed file no longer has the finding', () => {
-        expect(recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts'])).toEqual({ opened: 1, resolved: 0 });
+        expect(recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts'])).toMatchObject({ opened: 1, resolved: 0 });
         fs.writeFileSync(path.join(cwd, 'a.ts'), 'after\n');
-        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toEqual({ opened: 0, resolved: 1 });
+        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toMatchObject({ opened: 0, resolved: 1 });
         const [fix] = listResolvedFixes(cwd);
         expect(fix).toMatchObject({ file: 'a.ts', rule: 'semantic-bugs', before: 'before\n', after: 'after\n' });
         expect(openFindingCount(cwd)).toBe(0);
     });
     it('keeps a finding open when its file was not part of the review (committed, not fixed)', () => {
         recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts']);
-        expect(recordReviewOutcome(cwd, [], ['other.ts'])).toEqual({ opened: 0, resolved: 0 });
+        expect(recordReviewOutcome(cwd, [], ['other.ts'])).toMatchObject({ opened: 0, resolved: 0 });
         expect(openFindingCount(cwd)).toBe(1);
     });
     it('does not count a finding that vanished without an edit as a fix', () => {
         recordReviewOutcome(cwd, [finding('a.ts')], ['a.ts']);
-        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toEqual({ opened: 0, resolved: 0 });
+        expect(recordReviewOutcome(cwd, [], ['a.ts'])).toMatchObject({ opened: 0, resolved: 0 });
         expect(listResolvedFixes(cwd)).toEqual([]);
     });
 });

package/dist/review/changed-lines.d.ts

@@ -14,6 +14,7 @@
  * change gets the same verdict everywhere.
  */
 import type { Failure } from '../types/index.js';
+import type { RemovedBlock } from '../utils/diff.js';
 import { type LineSpan } from './changed-function-spans.js';
 export interface ChangedLineSplit {
     findings: Failure[];
@@ -22,4 +23,4 @@ export interface ChangedLineSplit {
     unlocated: number;
     outside: number;
 }
-export declare function splitByChangedLines(failures: Failure[], changedLines: Record<string, Set<number>>, spans?: Record<string, LineSpan[]>): ChangedLineSplit;
+export declare function splitByChangedLines(failures: Failure[], changedLines: Record<string, Set<number>>, spans?: Record<string, LineSpan[]>, removed?: Record<string, RemovedBlock[]>): ChangedLineSplit;

package/dist/review/changed-lines.js

@@ -1,5 +1,5 @@
 import { anchorInChangedFunction } from './changed-function-spans.js';
-export function splitByChangedLines(failures, changedLines, spans = {}) {
+export function splitByChangedLines(failures, changedLines, spans = {}, removed = {}) {
     const split = { findings: [], fileFindings: [], contextFindings: [], unlocated: 0, outside: 0 };
     for (const failure of failures) {
         const files = failure.files ?? [];
@@ -12,7 +12,7 @@ export function splitByChangedLines(failures, changedLines, spans = {}) {
             else
                 split.outside++;
         }
-        else if (files.some(file => changedLines[file]?.has(failure.line))) {
+        else if (files.some(file => changedLines[file]?.has(failure.line) || removedInside(failure, removed[file]))) {
             split.findings.push(failure);
         }
         else if (failure.provenance === 'deep-analysis') {
@@ -37,3 +37,13 @@ function placeDeepFinding(failure, files, changedLines, spans, split) {
     else
         split.outside++;
 }
+/**
+ * Whether the change deleted lines inside a multi-line finding (its line to endLine), such as an
+ * option removed from a call whose first line did not change: that call is part of the change.
+ */
+function removedInside(failure, blocks) {
+    const end = failure.endLine;
+    if (!blocks?.length || end === undefined || failure.line === undefined || end <= failure.line)
+        return false;
+    return blocks.some(block => block.line > failure.line && block.line <= end);
+}

package/dist/review/check-outcomes.d.ts

@@ -0,0 +1,31 @@
+/** Outcomes a check needs before it can be muted, and the posterior mean below which it is. */
+export declare const MUTE_MIN_OUTCOMES = 5;
+export declare const MUTE_BELOW = 0.25;
+export interface CheckOutcome {
+    fixed: number;
+    dismissed: number;
+}
+export interface CheckPrecision extends CheckOutcome {
+    check: string;
+    /** Posterior mean of Beta(fixed + 1, dismissed + 1). */
+    precision: number;
+    muted: boolean;
+}
+/** A check is a gate and the rule within it: `ast` alone would mute complexity and parameter count together. */
+export declare function checkId(finding: {
+    id?: string;
+    rule?: string;
+    title?: string;
+}): string;
+export declare function precisionOf(outcome: CheckOutcome): number;
+export declare function isMuted(outcome: CheckOutcome | undefined): boolean;
+export declare function readOutcomes(cwd: string): Record<string, CheckOutcome>;
+export declare function recordOutcome(cwd: string, check: string, kind: keyof CheckOutcome): void;
+/** Every check with an outcome, most dismissed first. */
+export declare function checkPrecisions(cwd: string): CheckPrecision[];
+/** Remember which check each reported finding key came from (most recent kept). */
+export declare function rememberReported(cwd: string, entries: Array<{
+    key: string;
+    check: string;
+}>): void;
+export declare function reportedCheck(cwd: string, key: string): string | undefined;