@rigour-labs/mcp 6.5.1 → 6.5.3

package/dist/tools/index-handlers.js

@@ -5,7 +5,7 @@
  */
 import path from 'path';
 import { PatternIndexer, savePatternIndex, loadPatternIndex, getDefaultIndexPath, } from '@rigour-labs/core/pattern-index';
-import { setStaticCache, setComponentCache, } from '@rigour-labs/core';
+import { setStaticCache, setComponentCache, recordIndexChoice, } from '@rigour-labs/core';
 import { notifyProgress } from '../utils/notifications.js';
 import { buildTelemetryMeta, getWorkspaceCommitSha } from '../utils/context-telemetry.js';
 import { appendContextFooter } from '../utils/context-footer.js';
@@ -52,7 +52,8 @@ export async function handleIndex(cwd, options = {}) {
     const candidateEstimate = 'Full codebase AST scan for pattern extraction';
     try {
         notifyProgress('info', 'Building pattern index...');
-        const indexer = new PatternIndexer(cwd, { useEmbeddings: options.semantic ?? true });
+        const semantic = options.semantic ?? true;
+        const indexer = new PatternIndexer(cwd, { useEmbeddings: semantic });
         const existingIndex = await loadPatternIndex(indexPath);
         let index;
         if (existingIndex && !options.force) {
@@ -63,17 +64,17 @@ export async function handleIndex(cwd, options = {}) {
         }
         await savePatternIndex(index, indexPath);
         await syncIndexToCache(cwd, index);
+        await recordIndexChoice(cwd, index, semantic);
         notifyProgress('info', 'Pattern index complete');
         const byType = Object.entries(index.stats.byType)
             .map(([type, count]) => `${type}: ${count}`)
             .join(', ');
-        let text = `✅ PATTERN INDEX ${options.force ? 'REBUILT' : 'UPDATED'}\n\n`;
+        let text = `✅ PATTERN INDEX ${existingIndex && !options.force ? 'UPDATED' : 'BUILT'}\n\n`;
         text += `- Total Patterns: ${index.stats.totalPatterns}\n`;
         text += `- Total Files: ${index.stats.totalFiles}\n`;
         text += `- Index Path: ${indexPath}\n`;
         text += `- Duration: ${index.stats.indexDurationMs}ms\n`;
-        if (options.semantic)
-            text += `- Semantic Search: Enabled\n`;
+        text += `- Search by meaning: ${semantic ? (index.patterns.some(p => p.embedding?.length) ? 'on' : 'unavailable (local model did not load; name matching still works)') : 'off'}\n`;
         text += `- Types: ${byType}\n\n`;
         text += `Index synced to context cache layers. Use rigour_context_scope before reading files.`;
         const telemetry = buildTelemetryMeta({

package/dist/tools/memory-handlers.d.ts

@@ -1,4 +1,27 @@
-import { type ToolResult } from '../utils/context-telemetry.js';
-export declare function handleRemember(cwd: string, key: string, value: string): Promise<ToolResult>;
-export declare function handleRecall(cwd: string, key?: string): Promise<ToolResult>;
-export declare function handleForget(cwd: string, key: string): Promise<ToolResult>;
+/**
+ * Memory Persistence Tool Handlers
+ *
+ * Handlers for: rigour_remember, rigour_forget (rigour_recall is in memory-recall.ts)
+ *
+ * Three scopes: `repo` (.rigour/memory.json in this checkout), `user`
+ * (~/.rigour/memory.json, every repository) and `team` (stored for the repo and
+ * shared as a team lesson candidate; teammates' agents receive it once a
+ * person promotes it).
+ *
+ * DLP enforcement: rigour_remember scans BOTH key and value for
+ * credentials before persisting. Blocked if secrets detected.
+ *
+ * @since v2.17.0 — extracted from monolithic index.ts
+ * @since v4.2.0  — DLP gate on memory persistence
+ */
+import { type LocalMemoryScope } from '../utils/config.js';
+import { type GuidanceMeta, type ToolResult } from '../utils/context-telemetry.js';
+/**
+ * Append a DLP audit event to .rigour/events.jsonl
+ */
+export declare function appendDLPAudit(cwd: string, entry: Record<string, unknown>): Promise<void>;
+export declare function getIndexHealthBlock(cwd: string): Promise<string>;
+export declare function wrapRecallResult(text: string, candidateText: string, cacheStatus: 'exact-hit' | 'semantic-hit' | 'miss', deduplicatedTokens?: number, guidance?: GuidanceMeta): ToolResult;
+export type MemoryScope = LocalMemoryScope | 'team';
+export declare function handleRemember(cwd: string, key: string, value: string, scope?: MemoryScope): Promise<ToolResult>;
+export declare function handleForget(cwd: string, key: string, scope?: LocalMemoryScope): Promise<ToolResult>;

package/dist/tools/memory-handlers.js

@@ -1,7 +1,12 @@
 /**
  * Memory Persistence Tool Handlers
  *
- * Handlers for: rigour_remember, rigour_recall, rigour_forget
+ * Handlers for: rigour_remember, rigour_forget (rigour_recall is in memory-recall.ts)
+ *
+ * Three scopes: `repo` (.rigour/memory.json in this checkout), `user`
+ * (~/.rigour/memory.json, every repository) and `team` (stored for the repo and
+ * shared as a team lesson candidate; teammates' agents receive it once a
+ * person promotes it).
  *
  * DLP enforcement: rigour_remember scans BOTH key and value for
  * credentials before persisting. Blocked if secrets detected.
@@ -10,16 +15,16 @@
  * @since v4.2.0  — DLP gate on memory persistence
  */
 import { loadMemory, saveMemory } from '../utils/config.js';
-import { scanInputForCredentials, formatDLPAlert, createDLPAuditEntry, getSemanticQueryCache, setSemanticQueryCache, estimateTokenCount, } from '@rigour-labs/core';
+import { scanInputForCredentials, formatDLPAlert, createDLPAuditEntry, loadTeamConfiguration, shareMemoryLesson, } from '@rigour-labs/core';
 import { loadPatternIndex, getDefaultIndexPath, } from '@rigour-labs/core/pattern-index';
-import { buildTelemetryMeta, getWorkspaceCommitSha } from '../utils/context-telemetry.js';
+import { buildTelemetryMeta } from '../utils/context-telemetry.js';
 import { appendContextFooter } from '../utils/context-footer.js';
 import fs from 'fs-extra';
 import path from 'path';
 /**
  * Append a DLP audit event to .rigour/events.jsonl
  */
-async function appendDLPAudit(cwd, entry) {
+export async function appendDLPAudit(cwd, entry) {
     try {
         const eventsPath = path.join(cwd, '.rigour', 'events.jsonl');
         await fs.ensureDir(path.dirname(eventsPath));
@@ -52,7 +57,7 @@ function extractStrings(obj, out) {
             extractStrings(v, out);
     }
 }
-async function getIndexHealthBlock(cwd) {
+export async function getIndexHealthBlock(cwd) {
     const indexPath = getDefaultIndexPath(cwd);
     const index = await loadPatternIndex(indexPath);
     if (!index) {
@@ -60,7 +65,7 @@ async function getIndexHealthBlock(cwd) {
     }
     return `\n\n📊 Pattern Index: ${index.stats.totalPatterns} patterns across ${index.stats.totalFiles} files (updated ${index.lastUpdated}).`;
 }
-function wrapRecallResult(text, candidateText, cacheStatus, deduplicatedTokens = 0, guidance) {
+export function wrapRecallResult(text, candidateText, cacheStatus, deduplicatedTokens = 0, guidance) {
     const telemetry = buildTelemetryMeta({
         candidateText,
         returnedText: text,
@@ -76,7 +81,7 @@ function wrapRecallResult(text, candidateText, cacheStatus, deduplicatedTokens =
         _guidance: guidance,
     };
 }
-export async function handleRemember(cwd, key, value) {
+export async function handleRemember(cwd, key, value, scope = 'repo') {
     // Fallback: if key is missing but value exists, auto-generate a key
     if (!key && value) {
         key = value.slice(0, 40).toLowerCase().replace(/[^a-z0-9]+/g, '_').replace(/^_|_$/g, '') || 'convention';
@@ -108,142 +113,46 @@ export async function handleRemember(cwd, key, value) {
                 }],
         };
     }
-    // Clean — proceed with storage
-    const store = await loadMemory(cwd);
+    // Clean — proceed with storage. A team memory is kept for this repository too.
+    const local = scope === 'user' ? 'user' : 'repo';
+    const store = await loadMemory(cwd, local);
     store.memories[key] = { value, timestamp: new Date().toISOString() };
-    await saveMemory(cwd, store);
+    await saveMemory(cwd, store, local);
+    await appendDLPAudit(cwd, { type: 'memory_stored', key, scope, timestamp: new Date().toISOString() });
+    const sharing = scope === 'team' ? await shareWithTeam(cwd, key, value) : '';
     // If there were warnings (non-blocking), include them
     if (dlpResult.status === 'warning') {
         const alert = formatDLPAlert(dlpResult);
         return {
             content: [{
                     type: "text",
-                    text: `MEMORY STORED: "${key}" has been saved (with warnings).\n\n${alert}\n\nStored value: ${value}`,
+                    text: `MEMORY STORED: "${key}" has been saved (with warnings).${sharing}\n\n${alert}\n\nStored value: ${value}`,
                 }],
         };
     }
     return {
         content: [{
                 type: "text",
-                text: `MEMORY STORED: "${key}" has been saved. This instruction will persist across sessions.\n\nStored value: ${value}`,
+                text: `MEMORY STORED: "${key}" has been saved ${scope === 'user' ? 'for all your repositories' : 'for this repository'}.${sharing}\n\nStored value: ${value}`,
             }],
     };
 }
-export async function handleRecall(cwd, key) {
-    const commitSha = await getWorkspaceCommitSha(cwd);
-    const cacheQuery = key ? `recall:${key}` : 'recall:all';
-    const store = await loadMemory(cwd);
-    const candidateText = JSON.stringify(store);
-    const cached = await getSemanticQueryCache(cacheQuery, commitSha, cwd);
-    if (cached?.evidence?.length) {
-        const cachedBody = cached.evidence.join('\n');
-        const indexHealth = await getIndexHealthBlock(cwd);
-        return wrapRecallResult(`${cachedBody}${indexHealth}`, candidateText, 'semantic-hit', Math.max(0, estimateTokenCount(candidateText) - estimateTokenCount(cachedBody)), cached.guidance ?? {
-            kind: 'memory',
-            query: key ?? 'all memories',
-            recommendation: key ? `Apply recalled memory "${key}" where relevant.` : 'Apply the recalled project memories where relevant.',
-            memoryRefs: key ? [{ id: key, label: key }] : [],
-        });
-    }
-    if (key) {
-        const memory = store.memories[key];
-        if (!memory) {
-            const text = `NO MEMORY FOUND for key "${key}". Use rigour_remember to store instructions.${await getIndexHealthBlock(cwd)}`;
-            return wrapRecallResult(text, candidateText, 'miss');
-        }
-        // ── DLP Gate on recall: catch credentials stored before DLP existed ──
-        const dlpResult = scanInputForCredentials(memory.value);
-        if (dlpResult.status === 'blocked') {
-            const alert = formatDLPAlert(dlpResult);
-            await appendDLPAudit(cwd, {
-                ...createDLPAuditEntry(dlpResult, { agent: 'rigour_recall' }),
-                memory_key: key,
-                action: 'recall_blocked',
-            });
-            return {
-                content: [{
-                        type: "text",
-                        text: `🛑 RECALL BLOCKED — memory "${key}" contains ${dlpResult.detections.length} credential(s).\n\n${alert}\n\nThis memory was stored before DLP was active. Remove it with rigour_forget("${key}") and use environment variables instead.`,
-                    }],
-            };
-        }
-        const body = `RECALLED MEMORY [${key}]:\n${memory.value}\n\n(Stored: ${memory.timestamp})`;
-        const indexHealth = await getIndexHealthBlock(cwd);
-        const fullText = `${body}${indexHealth}`;
-        const guidance = {
-            kind: 'memory',
-            query: key,
-            recommendation: `Apply recalled memory "${key}" where relevant.`,
-            memoryRefs: [{ id: key, label: key }],
-        };
-        await setSemanticQueryCache(cacheQuery, commitSha, {
-            query: cacheQuery,
-            resolvedOwner: 'memory',
-            editScope: [],
-            validationScope: [],
-            evidence: [body],
-            commitSha,
-            confidence: 1,
-            guidance,
-        }, cwd);
-        return wrapRecallResult(fullText, candidateText, 'miss', 0, guidance);
-    }
-    const keys = Object.keys(store.memories);
-    if (keys.length === 0) {
-        const text = `NO MEMORIES STORED. Use rigour_remember to persist important instructions.${await getIndexHealthBlock(cwd)}`;
-        return wrapRecallResult(text, candidateText, 'miss');
-    }
-    // ── DLP scan all memories on bulk recall ──
-    const cleanMemories = [];
-    const taintedKeys = [];
-    for (const k of keys) {
-        const mem = store.memories[k];
-        const dlpResult = scanInputForCredentials(mem.value);
-        if (dlpResult.status === 'blocked') {
-            taintedKeys.push(k);
-        }
-        else {
-            cleanMemories.push(`## ${k}\n${mem.value}\n(Stored: ${mem.timestamp})`);
-        }
-    }
-    let text = '';
-    if (taintedKeys.length > 0) {
-        text += `🛑 ${taintedKeys.length} memory(ies) BLOCKED — contain credentials: ${taintedKeys.join(', ')}\nUse rigour_forget to remove them.\n\n---\n\n`;
-    }
-    if (cleanMemories.length > 0) {
-        text += `RECALLED ${cleanMemories.length} CLEAN MEMORIES:\n\n${cleanMemories.join('\n\n---\n\n')}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`;
-    }
-    else if (taintedKeys.length > 0) {
-        text += `No clean memories to recall. All stored memories contain credentials.`;
-    }
-    else {
-        text = "NO MEMORIES STORED. Use rigour_remember to persist important instructions.";
-    }
-    text += await getIndexHealthBlock(cwd);
-    const guidance = {
-        kind: 'memory',
-        query: 'all memories',
-        recommendation: `Apply ${cleanMemories.length} recalled project memory item(s) where relevant.`,
-        memoryRefs: keys.filter(k => !taintedKeys.includes(k)).map(k => ({ id: k, label: k })),
-    };
-    await setSemanticQueryCache(cacheQuery, commitSha, {
-        query: cacheQuery,
-        resolvedOwner: 'memory',
-        editScope: [],
-        validationScope: [],
-        evidence: [text],
-        commitSha,
-        confidence: 1,
-        guidance,
-    }, cwd);
-    return wrapRecallResult(text, candidateText, 'miss', Math.max(0, estimateTokenCount(candidateText) - estimateTokenCount(text)), guidance);
+/** Share as a team lesson candidate and say what happens next. */
+async function shareWithTeam(cwd, key, value) {
+    const lessonId = await shareMemoryLesson(cwd, key, value);
+    if (!lessonId)
+        return '\nNot shared: the local knowledge store is unavailable.';
+    if (!(await loadTeamConfiguration())) {
+        return '\nKept as a team candidate on this machine; it is shared once team mode is configured (rigour team configure).';
+    }
+    return '\nShared with your team as a candidate. Teammates\' agents receive it once someone promotes it in Studio (Knowledge › Lessons).';
 }
-export async function handleForget(cwd, key) {
-    const store = await loadMemory(cwd);
+export async function handleForget(cwd, key, scope = 'repo') {
+    const store = await loadMemory(cwd, scope);
     if (!store.memories[key]) {
-        return { content: [{ type: "text", text: `NO MEMORY FOUND for key "${key}". Nothing to forget.` }] };
+        return { content: [{ type: "text", text: `NO MEMORY FOUND for key "${key}" in ${scope} memory. Nothing to forget.` }] };
     }
     delete store.memories[key];
-    await saveMemory(cwd, store);
-    return { content: [{ type: "text", text: `MEMORY DELETED: "${key}" has been removed.` }] };
+    await saveMemory(cwd, store, scope);
+    return { content: [{ type: "text", text: `MEMORY DELETED: "${key}" has been removed from ${scope} memory.` }] };
 }

package/dist/tools/memory-recall.d.ts

@@ -0,0 +1,6 @@
+import type { ToolResult } from '../utils/context-telemetry.js';
+export interface RecallArgs {
+    key?: string;
+    query?: string;
+}
+export declare function handleRecall(cwd: string, args?: RecallArgs): Promise<ToolResult>;

package/dist/tools/memory-recall.js

@@ -0,0 +1,105 @@
+/**
+ * rigour_recall: memories back to the agent.
+ *
+ * - `key`: that memory, from this repository, else from the user's own memory.
+ * - `query`: the few memories that match by meaning (local, see core
+ *   memory/recall.ts); lessons this machine has validated or a person promoted,
+ *   such as a kind of defect agents keep fixing; and team knowledge from
+ *   pgvector when team mode is on, never a teammate's unreviewed candidate.
+ * - neither: every repository and user memory, as an agent loads at the start.
+ *
+ * Every returned memory passes the credential scan first; nothing is cached.
+ */
+import { formatDLPAlert, createDLPAuditEntry, listKnowledgeLessons, rankByMeaning, rankMemories, scanInputForCredentials, searchTeamKnowledge } from '@rigour-labs/core';
+import { loadMemory } from '../utils/config.js';
+import { appendDLPAudit, getIndexHealthBlock, wrapRecallResult } from './memory-handlers.js';
+export async function handleRecall(cwd, args = {}) {
+    const entries = await localEntries(cwd);
+    const candidateText = JSON.stringify(entries);
+    if (args.key)
+        return recallKey(cwd, args.key, entries, candidateText);
+    if (args.query?.trim())
+        return recallQuery(cwd, args.query.trim(), entries, candidateText);
+    return recallAll(cwd, entries, candidateText);
+}
+/** Repository memories first, then the user's own; a repository memory wins a shared key. */
+async function localEntries(cwd) {
+    const repo = await loadMemory(cwd, 'repo');
+    const user = await loadMemory(cwd, 'user');
+    const toEntries = (scope, store) => Object.entries(store.memories).map(([key, m]) => ({ scope, key, value: m.value, timestamp: m.timestamp }));
+    const repoEntries = toEntries('repo', repo);
+    const repoKeys = new Set(repoEntries.map(e => e.key));
+    return [...repoEntries, ...toEntries('user', user).filter(e => !repoKeys.has(e.key))];
+}
+async function recallKey(cwd, key, entries, candidateText) {
+    const memory = entries.find(e => e.key === key);
+    if (!memory) {
+        const text = `NO MEMORY FOUND for key "${key}". Pass \`query\` to search by meaning, or use rigour_remember to store it.${await getIndexHealthBlock(cwd)}`;
+        return wrapRecallResult(text, candidateText, 'miss');
+    }
+    const blocked = await blockedReason(cwd, memory);
+    if (blocked)
+        return { content: [{ type: 'text', text: blocked }] };
+    const text = `RECALLED MEMORY [${key}] (${memory.scope}):\n${memory.value}\n\n(Stored: ${memory.timestamp})${await getIndexHealthBlock(cwd)}`;
+    return wrapRecallResult(text, candidateText, 'miss', 0, guidance(key, `Apply recalled memory "${key}" where relevant.`, [key]));
+}
+async function recallQuery(cwd, query, entries, candidateText) {
+    const clean = await cleanEntries(cwd, entries);
+    const [ranked, lessons, team] = await Promise.all([
+        rankMemories(query, clean),
+        rankByMeaning(query, await trustedLessons(cwd), lesson => lesson.subject),
+        searchTeamKnowledge(query, 3),
+    ]);
+    const teamOnly = team.status === 'ready' ? team.candidates.filter(c => !lessons.some(l => l.id === c.lessonId)) : [];
+    const sections = [];
+    if (ranked.length) {
+        sections.push(`MEMORIES MATCHING "${query}":\n\n` + ranked.map(m => `## ${m.key} (${m.scope}, ${m.match} ${m.score.toFixed(2)})\n${m.value}`).join('\n\n'));
+    }
+    if (lessons.length) {
+        sections.push('LESSONS (validated by repeated fixes, or promoted):\n\n' + lessons.map(l => `- ${l.subject} (${l.state}, ${l.match} ${l.score.toFixed(2)})`).join('\n'));
+    }
+    if (teamOnly.length) {
+        sections.push('TEAM KNOWLEDGE (promoted lessons):\n\n' + teamOnly.map(c => `- ${c.subject} (similarity ${c.similarity.toFixed(2)}, ${c.state})`).join('\n'));
+    }
+    const text = sections.length
+        ? `${sections.join('\n\n---\n\n')}\n\nApply these where they fit the task.`
+        : `NO MEMORY MATCHES "${query}". Recall with no arguments lists every memory.`;
+    const keys = ranked.map(m => m.key);
+    return wrapRecallResult(text, candidateText, 'miss', 0, guidance(query, `Apply ${keys.length + lessons.length + teamOnly.length} matching item(s).`, keys));
+}
+async function recallAll(cwd, entries, candidateText) {
+    if (entries.length === 0) {
+        return wrapRecallResult(`NO MEMORIES STORED. Use rigour_remember to persist important instructions.${await getIndexHealthBlock(cwd)}`, candidateText, 'miss');
+    }
+    const clean = await cleanEntries(cwd, entries);
+    const blocked = entries.filter(e => !clean.includes(e)).map(e => e.key);
+    let text = blocked.length ? `🛑 ${blocked.length} memory(ies) BLOCKED — contain credentials: ${blocked.join(', ')}\nUse rigour_forget to remove them.\n\n---\n\n` : '';
+    text += clean.length
+        ? `RECALLED ${clean.length} CLEAN MEMORIES:\n\n${clean.map(m => `## ${m.key} (${m.scope})\n${m.value}\n(Stored: ${m.timestamp})`).join('\n\n---\n\n')}\n\n---\nIMPORTANT: Follow these stored instructions throughout this session.`
+        : 'No clean memories to recall. All stored memories contain credentials.';
+    text += await getIndexHealthBlock(cwd);
+    return wrapRecallResult(text, candidateText, 'miss', 0, guidance('all memories', `Apply ${clean.length} recalled memory item(s) where relevant.`, clean.map(m => m.key)));
+}
+/** Lessons an agent may act on: validated by evidence, or promoted by a person. */
+async function trustedLessons(cwd) {
+    return (await listKnowledgeLessons(cwd)).filter(lesson => lesson.state === 'validated' || lesson.state === 'promoted');
+}
+/** Memories with no credential in them; a blocked one is audited, and never returned. */
+async function cleanEntries(cwd, entries) {
+    const clean = [];
+    for (const entry of entries) {
+        if (!(await blockedReason(cwd, entry)))
+            clean.push(entry);
+    }
+    return clean;
+}
+async function blockedReason(cwd, memory) {
+    const dlp = scanInputForCredentials(memory.value);
+    if (dlp.status !== 'blocked')
+        return undefined;
+    await appendDLPAudit(cwd, { ...createDLPAuditEntry(dlp, { agent: 'rigour_recall' }), memory_key: memory.key, action: 'recall_blocked' });
+    return `🛑 RECALL BLOCKED — memory "${memory.key}" contains ${dlp.detections.length} credential(s).\n\n${formatDLPAlert(dlp)}\n\nRemove it with rigour_forget("${memory.key}") and use environment variables instead.`;
+}
+function guidance(query, recommendation, keys) {
+    return { kind: 'memory', query, recommendation, memoryRefs: keys.map(id => ({ id, label: id })) };
+}

package/dist/tools/pattern-handlers.d.ts

@@ -1,3 +1,3 @@
 import { type ToolResult } from '../utils/context-telemetry.js';
-export declare function handleCheckPattern(cwd: string, patternName: string, type?: string, intent?: string, file?: string): Promise<ToolResult>;
+export declare function handleCheckPattern(cwd: string, patternName: string, type?: string, intent?: string, file?: string, signature?: string, keywords?: string[]): Promise<ToolResult>;
 export declare function handleSecurityAudit(cwd: string): Promise<ToolResult>;

package/dist/tools/pattern-handlers.js

@@ -8,10 +8,10 @@
 import path from "path";
 import yaml from "yaml";
 import fs from "fs-extra";
-import { PatternMatcher, loadPatternIndex, getDefaultIndexPath, StalenessDetector, SecurityDetector, } from "@rigour-labs/core/pattern-index";
-import { ConfigSchema, getSemanticQueryCache, setSemanticQueryCache, estimateTokenCount } from "@rigour-labs/core";
+import { assessPattern, loadPatternIndex, getDefaultIndexPath, SecurityDetector, } from "@rigour-labs/core/pattern-index";
+import { ConfigSchema, estimateTokenCount } from "@rigour-labs/core";
 import { notifyProgress } from '../utils/notifications.js';
-import { buildTelemetryMeta, getWorkspaceCommitSha } from '../utils/context-telemetry.js';
+import { buildTelemetryMeta } from '../utils/context-telemetry.js';
 import { appendContextFooter } from '../utils/context-footer.js';
 /**
  * Check if a file path is protected by safety.protected_paths in rigour.yml.
@@ -43,38 +43,14 @@ async function checkFileGuard(cwd, filePath) {
         return normalized.startsWith(clean + '/');
     }) ?? null;
 }
-function buildCacheQuery(patternName, type, intent, file) {
-    return `check_pattern:${patternName}:${type ?? ''}:${intent ?? ''}:${file ?? ''}`;
-}
-export async function handleCheckPattern(cwd, patternName, type, intent, file) {
-    const commitSha = await getWorkspaceCommitSha(cwd);
-    const cacheQuery = buildCacheQuery(patternName, type, intent, file);
+export async function handleCheckPattern(cwd, patternName, type, intent, file, signature, keywords) {
+    // No answer cache: a cache keyed on the commit kept naming functions renamed since, and the
+    // index lookup it saved is milliseconds.
     const indexPath = getDefaultIndexPath(cwd);
     const index = await loadPatternIndex(indexPath);
     const indexScanEstimate = index
         ? `Pattern index scan (${index.stats.totalPatterns} patterns) for ${patternName}`
         : `Full pattern discovery for ${patternName}`;
-    const cached = await getSemanticQueryCache(cacheQuery, commitSha, cwd);
-    if (cached?.evidence?.length) {
-        const cachedText = cached.evidence.join('\n');
-        const telemetry = buildTelemetryMeta({
-            candidateText: indexScanEstimate,
-            returnedText: cachedText,
-            cacheStatus: 'exact-hit',
-        });
-        return {
-            content: [{
-                    type: 'text',
-                    text: appendContextFooter(cachedText, telemetry, 'proceed with implementation or rigour_check when done'),
-                }],
-            _telemetry: telemetry,
-            _guidance: cached.guidance ?? {
-                kind: 'pattern',
-                query: patternName,
-                recommendation: `Apply the cached pattern guidance for "${patternName}".`,
-            },
-        };
-    }
     let resultText = "";
     let matchedPattern;
     // 0. File Guard — BLOCK writes to protected paths
@@ -103,30 +79,28 @@ export async function handleCheckPattern(cwd, patternName, type, intent, file) {
             };
         }
     }
-    // 1. Check for Reinvention
+    // 1. Reuse: does it exist already, and is what would be reused out of date?
+    let action = 'ALLOW';
     if (index) {
-        const matcher = new PatternMatcher(index);
-        const matchResult = await matcher.match({ name: patternName, type, intent });
-        if (matchResult.status === "FOUND_SIMILAR") {
-            matchedPattern = matchResult.matches[0].pattern;
-            resultText += `🚨 PATTERN REINVENTION DETECTED\n`;
-            resultText += `Similar pattern already exists: "${matchResult.matches[0].pattern.name}" in ${matchResult.matches[0].pattern.file}\n`;
-            resultText += `SUGGESTION: ${matchResult.suggestion}\n\n`;
+        const assessment = await assessPattern(cwd, index, { name: patternName, type, intent, signature, keywords });
+        action = assessment.action;
+        if (assessment.match) {
+            const best = assessment.match;
+            matchedPattern = best.pattern;
+            resultText += action === 'BLOCK' ? `🚨 PATTERN REINVENTION DETECTED\n` : `💡 SIMILAR PATTERN EXISTS\n`;
+            resultText += `"${best.pattern.name}" in ${best.pattern.file}:${best.pattern.line} (${best.matchType}, ${best.confidence}%)\n`;
+            resultText += `SUGGESTION: ${assessment.suggestion}\n\n`;
+        }
+        if (assessment.deprecations.length) {
+            resultText += `⚠️ THE EXISTING "${matchedPattern?.name}" USES SOMETHING DEPRECATED\n`;
+            for (const issue of assessment.deprecations)
+                resultText += `- ${issue.reason}\n  REPLACEMENT: ${issue.replacement}\n`;
+            resultText += `\n`;
         }
     }
     else {
         resultText += `⚠️ Pattern index not found. Run rigour_index to enable reinvention detection.\n\n`;
     }
-    // 2. Check for Staleness/Best Practices
-    const detector = new StalenessDetector(cwd);
-    const staleness = await detector.checkStaleness(`${type || 'function'} ${patternName} {}`);
-    if (staleness.status !== "FRESH") {
-        resultText += `⚠️ STALENESS/ANTI-PATTERN WARNING\n`;
-        for (const issue of staleness.issues) {
-            resultText += `- ${issue.reason}\n  REPLACEMENT: ${issue.replacement}\n`;
-        }
-        resultText += `\n`;
-    }
     // 3. Check Security for this library (if it's an import)
     if (intent && intent.includes('import')) {
         const security = new SecurityDetector(cwd);
@@ -147,9 +121,12 @@ export async function handleCheckPattern(cwd, patternName, type, intent, file) {
     }
     else {
         recommendation = "Proceed with caution, addressing the warnings above.";
-        if (resultText.includes("🚨 PATTERN REINVENTION")) {
+        if (action === 'BLOCK') {
             recommendation = "STOP and REUSE the existing pattern mentioned above. Do not create a duplicate.";
         }
+        else if (action === 'WARN') {
+            recommendation = "Look at the similar pattern above and reuse it if it does what you need; otherwise proceed.";
+        }
         else if (resultText.includes("🛡️ SECURITY/CVE WARNING")) {
             recommendation = "STOP and update your dependencies or find an alternative library. Do not proceed with vulnerable code.";
         }
@@ -165,16 +142,6 @@ export async function handleCheckPattern(cwd, patternName, type, intent, file) {
         patternRefs: matchedPattern ? [{ id: matchedPattern.id, label: matchedPattern.name, file: matchedPattern.file }] : [],
         selectedFiles: file ? [file] : matchedPattern?.file ? [matchedPattern.file] : [],
     };
-    await setSemanticQueryCache(cacheQuery, commitSha, {
-        query: cacheQuery,
-        resolvedOwner: file ? path.dirname(file) : 'patterns',
-        editScope: file ? [file] : [],
-        validationScope: [],
-        evidence: [resultText],
-        commitSha,
-        confidence: resultText.includes('✅') ? 0.9 : 0.7,
-        guidance,
-    }, cwd);
     const telemetry = buildTelemetryMeta({
         candidateText: indexScanEstimate,
         returnedText: resultText,

package/dist/tools/review-handler.js

@@ -5,7 +5,7 @@
  * With no diff, the change is taken from git: uncommitted work (what the
  * agent just wrote, new files included), or the branch against `base`.
  */
-import { acknowledgeReview, buildReviewTask, diffFromGit, recordReviewOutcome, reviewChange, toReviewFinding } from "@rigour-labs/core";
+import { acknowledgeReview, buildReviewTask, diffFromGit, recordFixLessons, recordReviewOutcome, reviewChange, toReviewFinding } from "@rigour-labs/core";
 import { notifyProgress } from '../utils/notifications.js';
 export async function handleReview(config, cwd, args) {
     notifyProgress("info", args.diff ? "Reviewing the provided diff..." : `Reviewing ${args.base ? `this branch against ${args.base}` : "uncommitted changes"}...`);
@@ -13,7 +13,8 @@ export async function handleReview(config, cwd, args) {
         const diff = args.diff ?? diffFromGit(cwd, args.base ? { mode: 'base', base: args.base } : { mode: 'working' });
         const result = await reviewChange({ cwd, config, diff, files: args.files });
         const task = args.mode === 'agent' ? buildReviewTask(cwd, diff, config.gates.deep?.router, config.gates.deep?.review_lessons, config.gates.deep?.repo_rules) : undefined;
-        recordReviewOutcome(cwd, result.findings, Object.keys(result.changedLines));
+        const capture = recordReviewOutcome(cwd, result.findings, Object.keys(result.changedLines));
+        await recordFixLessons(cwd, capture.fixes).catch(() => undefined); // learning never fails a review
         const stats = result.report?.stats;
         return text({
             status: result.status,
@@ -25,8 +26,10 @@ export async function handleReview(config, cwd, args) {
             file_findings: result.fileFindings.map(toReviewFinding),
             context_findings: result.contextFindings.map(toReviewFinding),
             advisory_count: result.advisory.length,
+            muted_count: result.muted,
             excluded_outside_changed_lines: result.excludedOutsideChangedLines,
             unlocated_failures: result.unlocated,
+            gate_errors: result.gateErrors,
             ...(task ? { review_task: { items: task.items, already_reviewed: task.alreadyReviewed, team_lessons: task.lessons, repo_rules: task.rules, instructions: task.instructions } } : {}),
             next_step: nextStep(result.findings.length, task?.items.length ?? 0),
         });

package/dist/utils/config.d.ts

@@ -226,6 +226,18 @@ export declare function loadConfig(cwd: string): Promise<{
             custom_patterns: string[];
             audit_log: boolean;
         };
+        unindexed_reads: {
+            enabled: boolean;
+            migrations: string[];
+        };
+        deprecated_dependencies: {
+            enabled: boolean;
+            registry?: string | undefined;
+        };
+        migration_order: {
+            enabled: boolean;
+            dirs: string[];
+        };
         semantic_bugs: {
             enabled: boolean;
             rules?: string[] | undefined;
@@ -281,9 +293,13 @@ export interface MemoryStore {
         timestamp: string;
     }>;
 }
-export declare function getMemoryPath(cwd: string): Promise<string>;
-export declare function loadMemory(cwd: string): Promise<MemoryStore>;
-export declare function saveMemory(cwd: string, store: MemoryStore): Promise<void>;
+/** The home whose .rigour/ holds user-scope memory: RIGOUR_HOME when set (tests, sandboxes), else the OS home. */
+export declare function userHome(): string;
+/** Where memories live: `repo` in this checkout's .rigour/, `user` in ~/.rigour/ for every repository. */
+export type LocalMemoryScope = 'repo' | 'user';
+export declare function getMemoryPath(cwd: string, scope?: LocalMemoryScope): Promise<string>;
+export declare function loadMemory(cwd: string, scope?: LocalMemoryScope): Promise<MemoryStore>;
+export declare function saveMemory(cwd: string, store: MemoryStore, scope?: LocalMemoryScope): Promise<void>;
 export interface McpSettings {
     deep_default_mode: 'off' | 'quick' | 'full';
 }