@rigour-labs/core 6.5.4 → 6.6.1

package/dist/context/automatic-index-cache.test.d.ts

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

package/dist/context/automatic-index-cache.test.js

@@ -0,0 +1,30 @@
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+const writes = vi.hoisted(() => ({ count: 0 }));
+vi.mock('../storage/context-telemetry.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    setContextCacheRecord: async () => { writes.count++; },
+}));
+const { ensureAutomaticIndex, updateAutomaticIndexForFiles } = await import('./automatic-index.js');
+let cwd;
+beforeEach(() => {
+    writes.count = 0;
+    cwd = fs.mkdtempSync(path.join(os.tmpdir(), 'auto-index-'));
+    fs.mkdirSync(path.join(cwd, 'src'));
+    fs.writeFileSync(path.join(cwd, 'src/a.ts'), 'export function alpha() { return 1; }\n');
+    fs.writeFileSync(path.join(cwd, 'src/b.ts'), 'export function beta() { return 2; }\n');
+});
+afterEach(() => fs.rmSync(cwd, { recursive: true, force: true }));
+describe('automatic indexing', () => {
+    it('writes nothing to the context cache, however many edits it sees', async () => {
+        await ensureAutomaticIndex(cwd, { backgroundSemantic: false });
+        for (let edit = 0; edit < 5; edit++) {
+            fs.writeFileSync(path.join(cwd, 'src/a.ts'), `export function alpha() { return ${edit}; }\n`);
+            await updateAutomaticIndexForFiles(cwd, ['src/a.ts']);
+        }
+        expect(writes.count).toBe(0);
+        expect(fs.existsSync(path.join(cwd, '.rigour', 'patterns.json'))).toBe(true);
+    });
+});

package/dist/context/automatic-index.js

@@ -3,7 +3,6 @@ import path from 'path';
 import { PatternIndexer, getDefaultIndexPath, loadPatternIndex, savePatternIndex } from '../pattern-index/indexer.js';
 import { EMBEDDING_TEXT_VERSION } from '../pattern-index/embeddings.js';
 import { affectedDependents, buildDependencyGraph, updateDependencyGraph } from './dependency-graph.js';
-import { syncIndexToContextCache } from './index-bridge.js';
 const enrichmentJobs = new Map();
 function projectRelativeFiles(cwd, files) {
     const root = path.resolve(cwd);
@@ -78,7 +77,6 @@ async function enrichSemantic(cwd, index) {
         const merged = mergeSemanticEmbeddings(latest, enriched);
         const embedded = merged.patterns.filter((pattern) => (pattern.embedding?.length ?? 0) > 0).length;
         await savePatternIndex(merged, indexPath);
-        await syncIndexToContextCache(cwd, merged);
         await writeStatus(cwd, {
             structural: 'ready',
             graph: 'ready',
@@ -114,7 +112,6 @@ export async function ensureAutomaticIndex(cwd, options = {}) {
     const index = existing ?? await indexer.buildIndex();
     if (!existing)
         await savePatternIndex(index, indexPath);
-    await syncIndexToContextCache(cwd, index);
     if (!(await fs.pathExists(path.join(cwd, '.rigour', 'dependency-graph.json')))) {
         await buildDependencyGraph(cwd, index);
     }
@@ -144,7 +141,6 @@ export async function updateAutomaticIndexForFiles(cwd, changedFiles) {
     const indexer = new PatternIndexer(cwd, { useEmbeddings: false });
     const index = await indexer.updateFiles(existing, affectedFiles);
     await savePatternIndex(index, getDefaultIndexPath(cwd));
-    await syncIndexToContextCache(cwd, index);
     if (graph)
         await updateDependencyGraph(cwd, index, graph, affectedFiles);
     else

package/dist/context/cache-engine.d.ts

@@ -1,32 +1,11 @@
 /**
- * 4-Layer Context Caching Engine for Rigour
+ * Context caching for Rigour: the two layers something reads.
+ * - Semantic-query cache: the edit and validation scope resolved for a task query.
+ * - Task checkpoint cache: compact handoff packets between agents.
  *
- * Implements:
- * 1. Content-addressed static cache (AST, exports, imports, dependencies, patterns by content SHA)
- * 2. Component context cache (Compact dossiers per component scope)
- * 3. Semantic-query cache (Intent embeddings & edit/validation scopes)
- * 4. Task checkpoint cache (Subagent handoff packets)
+ * The static (per-file) and component layers were removed: nothing read them, and the index sync
+ * that wrote them added a fresh row per component on every edit (millions of rows in real use).
  */
-export interface StaticCacheEntry {
-    astSummary?: any;
-    exports?: string[];
-    imports?: string[];
-    dependencies?: string[];
-    ownership?: string;
-    schemas?: any[];
-    endpoints?: string[];
-    eventRelationships?: any[];
-    styleFingerprint?: string;
-    rigourPatterns?: string[];
-}
-export interface ComponentDossier {
-    component: string;
-    responsibility: string;
-    canonicalFiles: string[];
-    contracts: string[];
-    directConsumers: string[];
-    validationCommands: string[];
-}
 export interface SemanticQueryEntry {
     query: string;
     intentEmbedding?: number[];
@@ -78,17 +57,7 @@ export interface TaskCheckpointPacket {
  */
 export declare function hashContent(content: string): string;
 /**
- * Layer 1: Content-Addressed Static Cache
- */
-export declare function getStaticCache(repo: string, branch: string, filePath: string, fileContent: string, cwd?: string): Promise<StaticCacheEntry | null>;
-export declare function setStaticCache(repo: string, branch: string, filePath: string, fileContent: string, entry: StaticCacheEntry, cwd?: string): Promise<void>;
-/**
- * Layer 2: Component Context Cache
- */
-export declare function getComponentCache(componentName: string, commitSha: string, profileVersion?: string, cwd?: string): Promise<ComponentDossier | null>;
-export declare function setComponentCache(componentName: string, commitSha: string, dossier: ComponentDossier, dependencyFingerprint: string, profileVersion?: string, cwd?: string): Promise<void>;
-/**
- * Layer 3: Semantic-Query Cache
+ * Semantic-Query Cache
  */
 export declare function normalizeQuery(query: string): string;
 export declare function getSemanticQueryCache(query: string, commitSha: string, cwd?: string): Promise<SemanticQueryEntry | null>;
@@ -119,7 +88,7 @@ export declare function filterExistingEditScope(editScope: string[], cwd: string
     missing: string[];
 }>;
 /**
- * Layer 4: Task Checkpoint Cache
+ * Task Checkpoint Cache
  */
 export declare function setTaskCheckpointCache(packet: TaskCheckpointPacket, rawStateTokens: number, cwd?: string): Promise<void>;
 export declare function getTaskCheckpointCache(taskId: string, agentId: string, phase: string, cwd?: string): Promise<TaskCheckpointPacket | null>;

package/dist/context/cache-engine.js

@@ -1,11 +1,10 @@
 /**
- * 4-Layer Context Caching Engine for Rigour
+ * Context caching for Rigour: the two layers something reads.
+ * - Semantic-query cache: the edit and validation scope resolved for a task query.
+ * - Task checkpoint cache: compact handoff packets between agents.
  *
- * Implements:
- * 1. Content-addressed static cache (AST, exports, imports, dependencies, patterns by content SHA)
- * 2. Component context cache (Compact dossiers per component scope)
- * 3. Semantic-query cache (Intent embeddings & edit/validation scopes)
- * 4. Task checkpoint cache (Subagent handoff packets)
+ * The static (per-file) and component layers were removed: nothing read them, and the index sync
+ * that wrote them added a fresh row per component on every edit (millions of rows in real use).
  */
 import { createHash } from 'crypto';
 import fs from 'fs-extra';
@@ -18,69 +17,7 @@ export function hashContent(content) {
     return createHash('sha256').update(content).digest('hex').slice(0, 16);
 }
 /**
- * Layer 1: Content-Addressed Static Cache
- */
-export async function getStaticCache(repo, branch, filePath, fileContent, cwd) {
-    const contentSha = hashContent(fileContent);
-    const cacheKey = `static:${repo}:${branch}:${filePath}:${contentSha}:v1`;
-    const record = await getContextCacheRecord(cacheKey, cwd);
-    if (!record)
-        return null;
-    try {
-        return JSON.parse(record.payloadJson);
-    }
-    catch {
-        return null;
-    }
-}
-export async function setStaticCache(repo, branch, filePath, fileContent, entry, cwd) {
-    const contentSha = hashContent(fileContent);
-    const cacheKey = `static:${repo}:${branch}:${filePath}:${contentSha}:v1`;
-    const payloadJson = JSON.stringify(entry);
-    const payloadTokens = Math.ceil(payloadJson.length / 4);
-    await setContextCacheRecord({
-        cacheKey,
-        cacheType: 'static',
-        repo,
-        branch,
-        commitSha: contentSha,
-        dependencyFingerprint: `sha-${contentSha}`,
-        payloadJson,
-        payloadTokens,
-    }, cwd);
-}
-/**
- * Layer 2: Component Context Cache
- */
-export async function getComponentCache(componentName, commitSha, profileVersion = '3', cwd) {
-    const cacheKey = `component:${componentName}:${commitSha}:v${profileVersion}`;
-    const record = await getContextCacheRecord(cacheKey, cwd);
-    if (!record)
-        return null;
-    try {
-        return JSON.parse(record.payloadJson);
-    }
-    catch {
-        return null;
-    }
-}
-export async function setComponentCache(componentName, commitSha, dossier, dependencyFingerprint, profileVersion = '3', cwd) {
-    const cacheKey = `component:${componentName}:${commitSha}:v${profileVersion}`;
-    const payloadJson = JSON.stringify(dossier);
-    const payloadTokens = Math.ceil(payloadJson.length / 4);
-    await setContextCacheRecord({
-        cacheKey,
-        cacheType: 'component',
-        repo: dossier.component,
-        branch: 'main',
-        commitSha,
-        dependencyFingerprint,
-        payloadJson,
-        payloadTokens,
-    }, cwd);
-}
-/**
- * Layer 3: Semantic-Query Cache
+ * Semantic-Query Cache
  */
 export function normalizeQuery(query) {
     return query.toLowerCase().trim().replace(/[^a-z0-9\s]/g, '').replace(/\s+/g, ' ');
@@ -193,7 +130,7 @@ export async function filterExistingEditScope(editScope, cwd) {
     return { valid, missing };
 }
 /**
- * Layer 4: Task Checkpoint Cache
+ * Task Checkpoint Cache
  */
 export async function setTaskCheckpointCache(packet, rawStateTokens, cwd) {
     const cacheKey = `checkpoint:${packet.taskId}:${packet.agentId}:${packet.phase}`;

package/dist/context/cache-engine.test.js

@@ -8,8 +8,8 @@ vi.mock('./db.js', () => ({
     DB_PATH: '/tmp/rigour-test.db',
     RIGOUR_DIR: '/tmp/.rigour',
 }));
-import { getStaticCache, setStaticCache, getComponentCache, setComponentCache, getSemanticQueryCache, setSemanticQueryCache, findRelatedSemanticQueryCache, queryTokenOverlap, distinctiveTokenAgreement, filterExistingEditScope, getTaskCheckpointCache, setTaskCheckpointCache, hashContent, normalizeQuery } from './cache-engine.js';
-describe('4-Layer Context Cache Engine', () => {
+import { getSemanticQueryCache, setSemanticQueryCache, findRelatedSemanticQueryCache, queryTokenOverlap, distinctiveTokenAgreement, filterExistingEditScope, getTaskCheckpointCache, setTaskCheckpointCache, hashContent, normalizeQuery } from './cache-engine.js';
+describe('Context cache engine', () => {
     const testCwd = path.join(os.tmpdir(), `rigour-cache-test-${Date.now()}`);
     beforeEach(async () => {
         await fs.ensureDir(testCwd);
@@ -26,35 +26,6 @@ describe('4-Layer Context Cache Engine', () => {
         expect(normalizeQuery('  Add priority to task!! ')).toBe('add priority to task');
         expect(normalizeQuery('Task SHOULD Support Priority.')).toBe('task should support priority');
     });
-    it('Layer 1: should store and retrieve content-addressed static cache', async () => {
-        const fileContent = 'export function processTask() { return true; }';
-        const entry = {
-            exports: ['processTask'],
-            imports: [],
-            ownership: 'platform-team',
-            endpoints: ['/api/task']
-        };
-        await setStaticCache('rigour-repo', 'main', 'services/task.ts', fileContent, entry, testCwd);
-        const cached = await getStaticCache('rigour-repo', 'main', 'services/task.ts', fileContent, testCwd);
-        expect(cached).not.toBeNull();
-        expect(cached?.exports).toEqual(['processTask']);
-        expect(cached?.ownership).toBe('platform-team');
-    });
-    it('Layer 2: should store and retrieve component context dossier', async () => {
-        const dossier = {
-            component: 'services/task',
-            responsibility: 'Task lifecycle and persistence',
-            canonicalFiles: ['services/task.ts'],
-            contracts: ['TaskContract'],
-            directConsumers: ['controllers/task'],
-            validationCommands: ['npm test']
-        };
-        await setComponentCache('services/task', 'abc123commit', dossier, 'dep-fingerprint-v1', '3', testCwd);
-        const retrieved = await getComponentCache('services/task', 'abc123commit', '3', testCwd);
-        expect(retrieved).not.toBeNull();
-        expect(retrieved?.responsibility).toBe('Task lifecycle and persistence');
-        expect(retrieved?.canonicalFiles).toContain('services/task.ts');
-    });
     it('Layer 3: should store and retrieve semantic query scope', async () => {
         const entry = {
             query: 'task priority persistence',
@@ -125,19 +96,4 @@ describe('4-Layer Context Cache Engine', () => {
         expect(result.valid).toEqual(['alive.ts']);
         expect(result.missing).toEqual(['gone.ts']);
     });
-    it('Layer 1: invalidates static cache when file content changes', async () => {
-        const originalContent = 'export function processTask() { return true; }';
-        const entry = {
-            exports: ['processTask'],
-            imports: [],
-            ownership: 'platform-team',
-            endpoints: ['/api/task'],
-        };
-        await setStaticCache('rigour-repo', 'main', 'services/task.ts', originalContent, entry, testCwd);
-        const cached = await getStaticCache('rigour-repo', 'main', 'services/task.ts', originalContent, testCwd);
-        expect(cached?.exports).toEqual(['processTask']);
-        const changedContent = 'export function processTask() { return false; }';
-        const stale = await getStaticCache('rigour-repo', 'main', 'services/task.ts', changedContent, testCwd);
-        expect(stale).toBeNull();
-    });
 });

package/dist/context/index-bridge.d.ts

@@ -1,8 +1,6 @@
 /**
- * Bridge between Pattern Index and 4-Layer Context Cache.
- * Syncs indexed patterns into static cache entries and component dossiers.
+ * Health of the pattern index (.rigour/patterns.json): present, readable, fresh.
  */
-import type { PatternIndex } from '../pattern-index/types.js';
 export interface IndexHealthReport {
     indexPath: string;
     exists: boolean;
@@ -14,10 +12,6 @@ export interface IndexHealthReport {
     totalFiles?: number;
     message: string;
 }
-/**
- * Sync pattern index entries into static cache and component dossier layers.
- */
-export declare function syncIndexToContextCache(cwd: string, index: PatternIndex): Promise<number>;
 /**
  * Check patterns.json freshness relative to the project directory.
  */

package/dist/context/index-bridge.js

@@ -1,90 +1,12 @@
 /**
- * Bridge between Pattern Index and 4-Layer Context Cache.
- * Syncs indexed patterns into static cache entries and component dossiers.
+ * Health of the pattern index (.rigour/patterns.json): present, readable, fresh.
  */
 import fs from 'fs-extra';
 import path from 'path';
-import { setStaticCache, setComponentCache, hashContent } from './cache-engine.js';
-import { getRepositoryId } from '../storage/lessons.js';
 function getIndexPath(cwd) {
     return path.join(cwd, '.rigour', 'patterns.json');
 }
 const DEFAULT_STALE_MS = 24 * 60 * 60 * 1000;
-async function resolveGitBranch(cwd) {
-    try {
-        let gitDir = path.join(cwd, '.git');
-        const gitStat = await fs.stat(gitDir);
-        if (gitStat.isFile()) {
-            const pointer = await fs.readFile(gitDir, 'utf8');
-            const match = pointer.match(/^gitdir:\s*(.+)$/m);
-            if (!match)
-                return 'workspace';
-            gitDir = path.resolve(cwd, match[1].trim());
-        }
-        const head = (await fs.readFile(path.join(gitDir, 'HEAD'), 'utf8')).trim();
-        return head.startsWith('ref: refs/heads/') ? head.slice('ref: refs/heads/'.length) : head.slice(0, 12);
-    }
-    catch {
-        return 'workspace';
-    }
-}
-function groupByComponent(patterns) {
-    const groups = new Map();
-    for (const p of patterns) {
-        const key = p.type === 'component' ? p.name : p.category || 'uncategorized';
-        const list = groups.get(key) ?? [];
-        list.push(p);
-        groups.set(key, list);
-    }
-    return groups;
-}
-function buildDossier(component, patterns) {
-    const canonicalFiles = [...new Set(patterns.map(p => p.file))];
-    const contracts = patterns
-        .filter(p => p.signature)
-        .map(p => p.signature)
-        .slice(0, 20);
-    const descriptions = patterns.map(p => p.description).filter(Boolean);
-    const responsibility = descriptions[0] || `Indexed ${patterns.length} patterns for ${component}`;
-    return {
-        component,
-        responsibility,
-        canonicalFiles,
-        contracts,
-        directConsumers: [],
-        validationCommands: [],
-    };
-}
-/**
- * Sync pattern index entries into static cache and component dossier layers.
- */
-export async function syncIndexToContextCache(cwd, index) {
-    const resolved = path.resolve(cwd);
-    const repo = await getRepositoryId(resolved);
-    const branch = await resolveGitBranch(resolved);
-    const commitSha = hashContent(index.lastUpdated);
-    let synced = 0;
-    for (const file of index.files) {
-        const filePatterns = index.patterns.filter(p => p.file === file.path);
-        if (filePatterns.length === 0)
-            continue;
-        const payload = {
-            rigourPatterns: filePatterns.map(p => `${p.type}:${p.name}`),
-            exports: filePatterns.filter(p => p.exported).map(p => p.name),
-        };
-        const fileContent = JSON.stringify(payload);
-        await setStaticCache(repo, branch, file.path, fileContent, payload, resolved);
-        synced++;
-    }
-    const componentGroups = groupByComponent(index.patterns);
-    for (const [component, patterns] of componentGroups) {
-        const dossier = buildDossier(component, patterns);
-        const fingerprint = hashContent(JSON.stringify(patterns.map(p => p.id)));
-        await setComponentCache(component, commitSha, dossier, fingerprint, '3', resolved);
-        synced++;
-    }
-    return synced;
-}
 /**
  * Check patterns.json freshness relative to the project directory.
  */

package/dist/deep/risk.d.ts

@@ -1,4 +1,5 @@
 import type { RemovedBlock } from '../utils/diff.js';
+import { type ReviewLesson } from '../review-learning/lessons.js';
 /** Kinds of operation where a wrong line costs the most; matched on the function's text. */
 export declare const SENSITIVE: ReadonlyArray<{
     kind: string;
@@ -14,6 +15,8 @@ export interface RiskSignals {
     removedGuard: boolean;
     /** SENSITIVE kinds this function touches. */
     sensitive: string[];
+    /** A verified team lesson about this file that names code this function uses. */
+    lesson?: string;
 }
 export interface FunctionRisk {
     file: string;
@@ -22,7 +25,7 @@ export interface FunctionRisk {
     end: number;
     signals: RiskSignals;
     score: number;
-    /** sha256 of the function's text with whitespace collapsed: any edit to it changes this. */
+    /** sha256 of the function's exact text (line endings normalised): any edit to it changes this. */
     hash: string;
 }
 /**
@@ -30,8 +33,8 @@ export interface FunctionRisk {
  * "rules only". The router reviews functions at or above `min_score`.
  */
 export declare function scoreRisk(signals: RiskSignals): number;
-/** Changed functions across the change, riskiest first. */
-export declare function rankChangedFunctions(cwd: string, focusLines: Record<string, number[]>, removed?: Record<string, RemovedBlock[]>): FunctionRisk[];
+/** Changed functions outside tests, riskiest first; `lessons` are the team's verified review lessons in play. */
+export declare function rankChangedFunctions(cwd: string, focusLines: Record<string, number[]>, removed?: Record<string, RemovedBlock[]>, lessons?: ReviewLesson[]): FunctionRisk[];
 /** The current text hash and span of a named function in a file, if the file parses and has it. */
 export declare function findFunction(cwd: string, file: string, name: string): {
     hash: string;

package/dist/deep/risk.js

@@ -12,7 +12,10 @@ import fs from 'fs';
 import path from 'path';
 import ts from 'typescript';
 import { changedFunctions, isExported } from './changed-functions.js';
+import { isSpecific } from '../review-learning/lessons.js';
 const PARSEABLE = /\.(?:[cm]?[jt]sx?)$/i;
+/** Tests are reviewed with the change, not routed: their fixtures read as data writes and money, and their callbacks have no callers. */
+const TEST_FILE = /\.(?:test|spec)\.[cm]?[jt]sx?$|(?:^|\/)__tests__\//i;
 /** Kinds of operation where a wrong line costs the most; matched on the function's text. */
 export const SENSITIVE = [
     { kind: 'data-write', pattern: /\.(?:insert|update|upsert|delete|rpc)\s*\(|\b(?:INSERT|UPDATE|DELETE)\s+(?:INTO\s+)?\w|\bON CONFLICT\b/ },
@@ -28,7 +31,9 @@ export const SENSITIVE = [
  */
 export function scoreRisk(signals) {
     // Strong signals clear the default bar (1) on their own; shape alone (size, nesting) never does.
+    // A mistake this team already fixed once is as strong a signal as a removed guard.
     let score = signals.removedGuard ? 2 : 0;
+    score += signals.lesson ? 2 : 0;
     score += signals.sensitive.includes('data-write') ? 2 : 0;
     // Other sensitive kinds add, capped so a function that mentions everything does not drown the rest.
     score += Math.min(2, signals.sensitive.filter(kind => kind !== 'data-write').length);
@@ -37,11 +42,11 @@ export function scoreRisk(signals) {
     score += signals.exported && signals.async ? 0.5 : 0;
     return score;
 }
-/** Changed functions across the change, riskiest first. */
-export function rankChangedFunctions(cwd, focusLines, removed = {}) {
+/** Changed functions outside tests, riskiest first; `lessons` are the team's verified review lessons in play. */
+export function rankChangedFunctions(cwd, focusLines, removed = {}, lessons = []) {
     const ranked = [];
     for (const [file, lines] of Object.entries(focusLines)) {
-        if (!PARSEABLE.test(file) || lines.length === 0)
+        if (!PARSEABLE.test(file) || TEST_FILE.test(file) || lines.length === 0)
             continue;
         let text;
         try {
@@ -57,6 +62,9 @@ export function rankChangedFunctions(cwd, focusLines, removed = {}) {
             const end = sourceFile.getLineAndCharacterOfPosition(fn.getEnd()).line + 1;
             const added = lines.filter(l => l >= start && l <= end).map(l => textLines[l - 1] ?? '');
             const signals = signalsOf(fn, sourceFile, start, end, removed[file] ?? [], added);
+            const lesson = lessonFor(file, fn.getText(sourceFile), lessons);
+            if (lesson)
+                signals.lesson = lesson;
             ranked.push({ file, name: nameOf(fn, sourceFile), start, end, signals, score: scoreRisk(signals), hash: functionHash(fn.getText(sourceFile)) });
         }
     }
@@ -101,6 +109,14 @@ export function findFunction(cwd, file, name) {
 export function functionHash(text) {
     return crypto.createHash('sha256').update(text.replace(/\r\n/g, '\n')).digest('hex');
 }
+/** The first lesson about this file that names an identifier the function uses (only specific names link code). */
+function lessonFor(file, body, lessons) {
+    const forFile = lessons.filter(l => l.file === file);
+    if (forFile.length === 0)
+        return undefined;
+    const used = new Set(body.match(/[A-Za-z_$][\w$]*/g) ?? []);
+    return forFile.find(l => l.symbols.some(s => isSpecific(s) && used.has(s)))?.text;
+}
 const GUARD = /\b(?:if|else|return|throw|break|continue|catch)\b|\?\?|\?\./g;
 function guards(lines) {
     return lines.reduce((count, line) => count + (line.match(GUARD)?.length ?? 0), 0);

package/dist/deep/risk.test.js

@@ -3,7 +3,7 @@ import os from 'os';
 import path from 'path';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { functionHash, rankChangedFunctions, scoreRisk } from './risk.js';
-import { routeFiles } from './router.js';
+import { DEFAULT_MIN_SCORE, routeFiles } from './router.js';
 let dir;
 beforeEach(() => { dir = fs.mkdtempSync(path.join(os.tmpdir(), 'risk-')); });
 afterEach(() => { fs.rmSync(dir, { recursive: true, force: true }); });
@@ -32,6 +32,33 @@ describe('rankChangedFunctions', () => {
         expect([byName.label.start, byName.label.end]).toEqual([8, 10]);
     });
 });
+describe('test files', () => {
+    it('are never routed, however their fixtures read', () => {
+        fs.mkdirSync(path.join(dir, '__tests__'));
+        for (const file of ['sync.test.ts', 'sync.spec.js', '__tests__/sync.ts'])
+            fs.writeFileSync(path.join(dir, file), SYNC);
+        expect(rankChangedFunctions(dir, { 'sync.test.ts': [4], 'sync.spec.js': [4], '__tests__/sync.ts': [4] })).toEqual([]);
+    });
+});
+describe('team lessons as a risk signal', () => {
+    const lesson = (over) => ({
+        id: 'l1', text: 'Trim before comparing names.', file: 'sync.ts', symbols: ['trimStart'], state: 'verified',
+        evidence: [{ pr: 1, comment: 'c', author: 'r' }], createdAt: '', updatedAt: '', ...over,
+    });
+    const LABEL = 'function label(name) {\n  return name.trimStart();\n}\n';
+    it('makes a plain function risky when a lesson for its file names a symbol it uses', () => {
+        fs.writeFileSync(path.join(dir, 'sync.ts'), LABEL);
+        const [f] = rankChangedFunctions(dir, { 'sync.ts': [2] }, {}, [lesson({})]);
+        expect(f.signals.lesson).toBe('Trim before comparing names.');
+        expect(f.score).toBeGreaterThanOrEqual(DEFAULT_MIN_SCORE);
+    });
+    it('ignores lessons for other files and lessons naming only common words', () => {
+        fs.writeFileSync(path.join(dir, 'sync.ts'), LABEL);
+        const other = rankChangedFunctions(dir, { 'sync.ts': [2] }, {}, [lesson({ file: 'other.ts' }), lesson({ symbols: ['name'] })]);
+        expect(other[0].signals.lesson).toBeUndefined();
+        expect(other[0].score).toBe(0);
+    });
+});
 describe('scoreRisk', () => {
     it('ranks a data write behind a removed guard above a plain helper', () => {
         const risky = { exported: true, async: true, nesting: 2, lines: 30, removedGuard: true, sensitive: ['data-write', 'paging'] };

package/dist/deep/router.d.ts

@@ -7,6 +7,7 @@
  */
 import type { RemovedBlock } from '../utils/diff.js';
 import { type ReviewedKey } from '../review/ledger.js';
+import type { ReviewLesson } from '../review-learning/lessons.js';
 export interface RouterPolicy {
     enabled?: boolean;
     min_score?: number;
@@ -21,7 +22,7 @@ export interface RouterStats {
 }
 export declare const DEFAULT_MIN_SCORE = 1;
 export declare const DEFAULT_MAX_FUNCTIONS = 12;
-export declare function routeFiles(cwd: string, files: string[], focusLines: Record<string, number[]>, removed?: Record<string, RemovedBlock[]>, policy?: RouterPolicy, reviewed?: ReviewedKey[]): {
+export declare function routeFiles(cwd: string, files: string[], focusLines: Record<string, number[]>, removed?: Record<string, RemovedBlock[]>, policy?: RouterPolicy, reviewed?: ReviewedKey[], lessons?: ReviewLesson[]): {
     files: Set<string>;
     stats: RouterStats;
 };

package/dist/deep/router.js

@@ -2,9 +2,9 @@ import { rankChangedFunctions } from './risk.js';
 import { isReviewed } from '../review/ledger.js';
 export const DEFAULT_MIN_SCORE = 1;
 export const DEFAULT_MAX_FUNCTIONS = 12;
-export function routeFiles(cwd, files, focusLines, removed = {}, policy = {}, reviewed = []) {
+export function routeFiles(cwd, files, focusLines, removed = {}, policy = {}, reviewed = [], lessons = []) {
     const inScope = Object.fromEntries(files.filter(f => focusLines[f]?.length).map(f => [f, focusLines[f]]));
-    const ranked = rankChangedFunctions(cwd, inScope, removed);
+    const ranked = rankChangedFunctions(cwd, inScope, removed, lessons);
     const minScore = policy.min_score ?? DEFAULT_MIN_SCORE;
     const risky = ranked.filter(f => f.score >= minScore);
     const unreviewed = risky.filter(f => !isReviewed(reviewed, { file: f.file, function: f.name, hash: f.hash }));

package/dist/firewall/execution-receipt.d.ts

@@ -1,4 +1,9 @@
 import type { ExecutionReceipt } from './types.js';
+/**
+ * Another append holds the lock. On Windows, creating a file another process is still deleting
+ * fails with EPERM (or EACCES/EBUSY) rather than EEXIST; elsewhere those are real permission errors.
+ */
+export declare function isLockContention(code: unknown, platform?: NodeJS.Platform): boolean;
 export declare function appendExecutionReceipt(cwd: string, input: Omit<ExecutionReceipt, 'version' | 'id' | 'repositoryId' | 'createdAt' | 'previousReceipt' | 'digest' | 'signature'>, controlRoot?: string): Promise<ExecutionReceipt>;
 export declare function listExecutionReceipts(cwd: string, limit?: number, controlRoot?: string): Promise<ExecutionReceipt[]>;
 export declare function verifyExecutionReceiptChain(cwd: string, controlRoot?: string): Promise<{

package/dist/firewall/execution-receipt.js

@@ -17,6 +17,15 @@ async function receiptKey(cwd, controlRoot) {
     await fs.writeFile(keyPath, key, { mode: 0o600 });
     return key;
 }
+/**
+ * Another append holds the lock. On Windows, creating a file another process is still deleting
+ * fails with EPERM (or EACCES/EBUSY) rather than EEXIST; elsewhere those are real permission errors.
+ */
+export function isLockContention(code, platform = process.platform) {
+    if (code === 'EEXIST')
+        return true;
+    return platform === 'win32' && (code === 'EPERM' || code === 'EACCES' || code === 'EBUSY');
+}
 async function acquireReceiptLock(logPath) {
     const lockPath = `${logPath}.append-lock`;
     for (let attempt = 0; attempt < 100; attempt += 1) {
@@ -24,7 +33,7 @@ async function acquireReceiptLock(logPath) {
             return await fs.promises.open(lockPath, 'wx', 0o600);
         }
         catch (error) {
-            if (error?.code !== 'EEXIST')
+            if (!isLockContention(error?.code))
                 throw error;
             await delay(10);
         }

package/dist/firewall/trusted-control.test.js

@@ -176,3 +176,13 @@ describe('action normalization and receipts', () => {
         expect(await verifyExecutionReceiptChain(cwd, root)).toMatchObject({ valid: true, count: 1 });
     });
 });
+describe('receipt lock contention', () => {
+    it('retries while another append releases the lock, including Windows delete-pending errors', async () => {
+        const { isLockContention } = await import('./execution-receipt.js');
+        expect(isLockContention('EEXIST', 'linux')).toBe(true);
+        expect(isLockContention('EPERM', 'win32')).toBe(true);
+        expect(isLockContention('EBUSY', 'win32')).toBe(true);
+        expect(isLockContention('EPERM', 'linux')).toBe(false); // a real permission error elsewhere
+        expect(isLockContention('ENOENT', 'win32')).toBe(false);
+    });
+});