codebase-context 1.4.1 → 1.5.1

package/dist/index.js

@@ -16,9 +16,16 @@ import { analyzerRegistry } from './core/analyzer-registry.js';
 import { AngularAnalyzer } from './analyzers/angular/index.js';
 import { GenericAnalyzer } from './analyzers/generic/index.js';
 import { InternalFileGraph } from './utils/usage-tracker.js';
+import { getFileCommitDates } from './utils/git-dates.js';
 import { IndexCorruptedError } from './errors/index.js';
 import { CODEBASE_CONTEXT_DIRNAME, MEMORY_FILENAME, INTELLIGENCE_FILENAME, KEYWORD_INDEX_FILENAME, VECTOR_DB_DIRNAME } from './constants/codebase-context.js';
-import { appendMemoryFile, readMemoriesFile, filterMemories, applyUnfilteredLimit } from './memory/store.js';
+import { appendMemoryFile, readMemoriesFile, filterMemories, applyUnfilteredLimit, withConfidence } from './memory/store.js';
+import { parseGitLogLineToMemory } from './memory/git-memory.js';
+import { buildEvidenceLock } from './preflight/evidence-lock.js';
+import { shouldIncludePatternConflictCategory } from './preflight/query-scope.js';
+import { isComplementaryPatternCategory, isComplementaryPatternConflict, shouldSkipLegacyTestingFrameworkCategory } from './patterns/semantics.js';
+import { CONTEXT_RESOURCE_URI, isContextResourceUri } from './resources/uri.js';
+import { assessSearchQuality } from './core/search-quality.js';
 analyzerRegistry.register(new AngularAnalyzer());
 analyzerRegistry.register(new GenericAnalyzer());
 // Resolve root path with validation
@@ -110,12 +117,14 @@ async function migrateToNewStructure() {
         return false;
     }
 }
+// Read version from package.json so it never drifts
+const PKG_VERSION = JSON.parse(await fs.readFile(new URL('../package.json', import.meta.url), 'utf-8')).version;
 const indexState = {
     status: 'idle'
 };
 const server = new Server({
     name: 'codebase-context',
-    version: '1.4.0'
+    version: PKG_VERSION
 }, {
     capabilities: {
         tools: {},
@@ -127,6 +136,8 @@ const TOOLS = [
         name: 'search_codebase',
         description: 'Search the indexed codebase using natural language queries. Returns code summaries with file locations. ' +
             'Supports framework-specific queries and architectural layer filtering. ' +
+            'When intent is "edit", "refactor", or "migrate", returns a preflight card with risk level, ' +
+            'patterns to use/avoid, impact candidates, related memories, and an evidence lock score — all in one call. ' +
             'Use the returned filePath with other tools to read complete file contents.',
         inputSchema: {
             type: 'object',
@@ -135,6 +146,13 @@ const TOOLS = [
                     type: 'string',
                     description: 'Natural language search query'
                 },
+                intent: {
+                    type: 'string',
+                    enum: ['explore', 'edit', 'refactor', 'migrate'],
+                    description: 'Search intent. Use "explore" (default) for read-only browsing. ' +
+                        'Use "edit", "refactor", or "migrate" to get a preflight card with risk assessment, ' +
+                        'patterns to prefer/avoid, affected files, relevant team memories, and ready-to-edit evidence checks.'
+                },
                 limit: {
                     type: 'number',
                     description: 'Maximum number of results to return (default: 5)',
@@ -289,8 +307,9 @@ const TOOLS = [
             properties: {
                 type: {
                     type: 'string',
-                    enum: ['convention', 'decision', 'gotcha'],
-                    description: 'Type of memory being recorded'
+                    enum: ['convention', 'decision', 'gotcha', 'failure'],
+                    description: 'Type of memory being recorded. Use "failure" for things that were tried and failed — ' +
+                        'prevents repeating the same mistakes.'
                 },
                 category: {
                     type: 'string',
@@ -325,7 +344,7 @@ const TOOLS = [
                 type: {
                     type: 'string',
                     description: 'Filter by memory type',
-                    enum: ['convention', 'decision', 'gotcha']
+                    enum: ['convention', 'decision', 'gotcha', 'failure']
                 },
                 query: {
                     type: 'string',
@@ -341,7 +360,7 @@ server.setRequestHandler(ListToolsRequestSchema, async () => {
 // MCP Resources - Proactive context injection
 const RESOURCES = [
     {
-        uri: 'codebase://context',
+        uri: CONTEXT_RESOURCE_URI,
         name: 'Codebase Intelligence',
         description: 'Automatic codebase context: libraries used, team patterns, and conventions. ' +
             'Read this BEFORE generating code to follow team standards.',
@@ -389,16 +408,35 @@ async function generateCodebaseContext() {
         }
         // Pattern consensus
         if (intelligence.patterns && Object.keys(intelligence.patterns).length > 0) {
+            const patterns = intelligence.patterns;
             lines.push("## YOUR Codebase's Actual Patterns (Not Generic Best Practices)");
             lines.push('');
             lines.push('These patterns were detected by analyzing your actual code.');
             lines.push('This is what YOUR team does in practice, not what tutorials recommend.');
             lines.push('');
-            for (const [category, data] of Object.entries(intelligence.patterns)) {
+            for (const [category, data] of Object.entries(patterns)) {
+                if (shouldSkipLegacyTestingFrameworkCategory(category, patterns)) {
+                    continue;
+                }
                 const patternData = data;
                 const primary = patternData.primary;
+                const alternatives = patternData.alsoDetected ?? [];
                 if (!primary)
                     continue;
+                if (isComplementaryPatternCategory(category, [primary.name, ...alternatives.map((alt) => alt.name)].filter(Boolean))) {
+                    const secondary = alternatives[0];
+                    if (secondary) {
+                        const categoryName = category
+                            .replace(/([A-Z])/g, ' $1')
+                            .trim()
+                            .replace(/^./, (str) => str.toUpperCase());
+                        lines.push(`### ${categoryName}: **${primary.name}** (${primary.frequency}) + **${secondary.name}** (${secondary.frequency})`);
+                        lines.push('   → Computed and effect are complementary Signals primitives and are commonly used together.');
+                        lines.push('   → Treat this as balanced usage, not a hard split decision.');
+                        lines.push('');
+                        continue;
+                    }
+                }
                 const percentage = parseInt(primary.frequency);
                 const categoryName = category
                     .replace(/([A-Z])/g, ' $1')
@@ -411,16 +449,16 @@ async function generateCodebaseContext() {
                 else if (percentage >= 80) {
                     lines.push(`### ${categoryName}: **${primary.name}** (${primary.frequency} - strong consensus)`);
                     lines.push(`   → Your team strongly prefers ${primary.name}`);
-                    if (patternData.alsoDetected?.length) {
-                        const alt = patternData.alsoDetected[0];
+                    if (alternatives.length) {
+                        const alt = alternatives[0];
                         lines.push(`   → Minority pattern: ${alt.name} (${alt.frequency}) - avoid for new code`);
                     }
                 }
                 else if (percentage >= 60) {
                     lines.push(`### ${categoryName}: **${primary.name}** (${primary.frequency} - majority)`);
                     lines.push(`   → Most code uses ${primary.name}, but not unanimous`);
-                    if (patternData.alsoDetected?.length) {
-                        lines.push(`   → Also detected: ${patternData.alsoDetected[0].name} (${patternData.alsoDetected[0].frequency})`);
+                    if (alternatives.length) {
+                        lines.push(`   → Also detected: ${alternatives[0].name} (${alternatives[0].frequency})`);
                     }
                 }
                 else {
@@ -428,8 +466,8 @@ async function generateCodebaseContext() {
                     lines.push(`### ${categoryName}: ⚠️ NO TEAM CONSENSUS`);
                     lines.push(`   Your codebase is split between multiple approaches:`);
                     lines.push(`   - ${primary.name} (${primary.frequency})`);
-                    if (patternData.alsoDetected?.length) {
-                        for (const alt of patternData.alsoDetected.slice(0, 2)) {
+                    if (alternatives.length) {
+                        for (const alt of alternatives.slice(0, 2)) {
                             lines.push(`   - ${alt.name} (${alt.frequency})`);
                         }
                     }
@@ -450,12 +488,12 @@ async function generateCodebaseContext() {
 }
 server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     const uri = request.params.uri;
-    if (uri === 'codebase://context') {
+    if (isContextResourceUri(uri)) {
         const content = await generateCodebaseContext();
         return {
             contents: [
                 {
-                    uri,
+                    uri: CONTEXT_RESOURCE_URI,
                     mimeType: 'text/plain',
                     text: content
                 }
@@ -464,13 +502,51 @@ server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
     }
     throw new Error(`Unknown resource: ${uri}`);
 });
-async function performIndexing() {
+/**
+ * Extract memories from conventional git commits (refactor:, migrate:, fix:, revert:).
+ * Scans last 90 days. Deduplicates via content hash. Zero friction alternative to manual memory.
+ */
+async function extractGitMemories() {
+    // Quick check: skip if not a git repo
+    if (!(await fileExists(path.join(ROOT_PATH, '.git'))))
+        return 0;
+    const { execSync } = await import('child_process');
+    let log;
+    try {
+        // Format: ISO-date<TAB>hash subject  (e.g. "2026-01-15T10:00:00+00:00\tabc1234 fix: race condition")
+        log = execSync('git log --format="%aI\t%h %s" --since="90 days ago" --no-merges', {
+            cwd: ROOT_PATH,
+            encoding: 'utf-8',
+            timeout: 5000
+        }).trim();
+    }
+    catch {
+        // Git not available or command failed — silently skip
+        return 0;
+    }
+    if (!log)
+        return 0;
+    const lines = log.split('\n').filter(Boolean);
+    let added = 0;
+    for (const line of lines) {
+        const parsedMemory = parseGitLogLineToMemory(line);
+        if (!parsedMemory)
+            continue;
+        const result = await appendMemoryFile(PATHS.memory, parsedMemory);
+        if (result.status === 'added')
+            added++;
+    }
+    return added;
+}
+async function performIndexing(incrementalOnly) {
     indexState.status = 'indexing';
-    console.error(`Indexing: ${ROOT_PATH}`);
+    const mode = incrementalOnly ? 'incremental' : 'full';
+    console.error(`Indexing (${mode}): ${ROOT_PATH}`);
     try {
         let lastLoggedProgress = { phase: '', percentage: -1 };
         const indexer = new CodebaseIndexer({
             rootPath: ROOT_PATH,
+            incrementalOnly,
             onProgress: (progress) => {
                 // Only log when phase or percentage actually changes (prevents duplicate logs)
                 const shouldLog = progress.phase !== lastLoggedProgress.phase ||
@@ -487,6 +563,16 @@ async function performIndexing() {
         indexState.lastIndexed = new Date();
         indexState.stats = stats;
         console.error(`Complete: ${stats.indexedFiles} files, ${stats.totalChunks} chunks in ${(stats.duration / 1000).toFixed(2)}s`);
+        // Auto-extract memories from git history (non-blocking, best-effort)
+        try {
+            const gitMemories = await extractGitMemories();
+            if (gitMemories > 0) {
+                console.error(`[git-memory] Extracted ${gitMemories} new memor${gitMemories === 1 ? 'y' : 'ies'} from git history`);
+            }
+        }
+        catch {
+            // Git memory extraction is optional — never fail indexing over it
+        }
     }
     catch (error) {
         indexState.status = 'error';
@@ -509,7 +595,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
     try {
         switch (name) {
             case 'search_codebase': {
-                const { query, limit, filters } = args;
+                const { query, limit, filters, intent } = args;
                 if (indexState.status === 'indexing') {
                     return {
                         content: [
@@ -539,8 +625,13 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 }
                 const searcher = new CodebaseSearcher(ROOT_PATH);
                 let results;
+                const searchProfile = intent && ['explore', 'edit', 'refactor', 'migrate'].includes(intent)
+                    ? intent
+                    : 'explore';
                 try {
-                    results = await searcher.search(query, limit || 5, filters);
+                    results = await searcher.search(query, limit || 5, filters, {
+                        profile: searchProfile
+                    });
                 }
                 catch (error) {
                     if (error instanceof IndexCorruptedError) {
@@ -550,7 +641,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                             console.error('[Auto-Heal] Success. Retrying search...');
                             const freshSearcher = new CodebaseSearcher(ROOT_PATH);
                             try {
-                                results = await freshSearcher.search(query, limit || 5, filters);
+                                results = await freshSearcher.search(query, limit || 5, filters, {
+                                    profile: searchProfile
+                                });
                             }
                             catch (retryError) {
                                 return {
@@ -585,36 +678,305 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         throw error; // Propagate unexpected errors
                     }
                 }
-                // Load memories for keyword matching
+                // Load memories for keyword matching, enriched with confidence
                 const allMemories = await readMemoriesFile(PATHS.memory);
-                const findRelatedMemories = (queryTerms) => {
-                    return allMemories.filter((m) => {
-                        const searchText = `${m.memory} ${m.reason}`.toLowerCase();
-                        return queryTerms.some((term) => searchText.includes(term));
-                    });
-                };
+                const allMemoriesWithConf = withConfidence(allMemories);
                 const queryTerms = query.toLowerCase().split(/\s+/);
-                const relatedMemories = findRelatedMemories(queryTerms);
+                const relatedMemories = allMemoriesWithConf
+                    .filter((m) => {
+                    const searchText = `${m.memory} ${m.reason}`.toLowerCase();
+                    return queryTerms.some((term) => searchText.includes(term));
+                })
+                    .sort((a, b) => b.effectiveConfidence - a.effectiveConfidence);
+                // Load intelligence data for enrichment (all intents, not just preflight)
+                let intelligence = null;
+                try {
+                    const intelligenceContent = await fs.readFile(PATHS.intelligence, 'utf-8');
+                    intelligence = JSON.parse(intelligenceContent);
+                }
+                catch {
+                    /* graceful degradation — intelligence file may not exist yet */
+                }
+                // Build reverse import map from intelligence graph
+                const reverseImports = new Map();
+                if (intelligence?.internalFileGraph?.imports) {
+                    for (const [file, deps] of Object.entries(intelligence.internalFileGraph.imports)) {
+                        for (const dep of deps) {
+                            if (!reverseImports.has(dep))
+                                reverseImports.set(dep, []);
+                            reverseImports.get(dep).push(file);
+                        }
+                    }
+                }
+                // Load git dates for lastModified enrichment
+                let gitDates = null;
+                try {
+                    gitDates = await getFileCommitDates(ROOT_PATH);
+                }
+                catch {
+                    /* not a git repo */
+                }
+                // Enrich a search result with relationship data
+                function enrichResult(r) {
+                    const rPath = r.filePath;
+                    // importedBy: files that import this result (reverse lookup)
+                    const importedBy = [];
+                    for (const [dep, importers] of reverseImports) {
+                        if (dep.endsWith(rPath) || rPath.endsWith(dep)) {
+                            importedBy.push(...importers);
+                        }
+                    }
+                    // imports: files this result depends on (forward lookup)
+                    const imports = [];
+                    if (intelligence?.internalFileGraph?.imports) {
+                        for (const [file, deps] of Object.entries(intelligence.internalFileGraph.imports)) {
+                            if (file.endsWith(rPath) || rPath.endsWith(file)) {
+                                imports.push(...deps);
+                            }
+                        }
+                    }
+                    // testedIn: heuristic — same basename with .spec/.test extension
+                    const testedIn = [];
+                    const baseName = path.basename(rPath).replace(/\.[^.]+$/, '');
+                    if (intelligence?.internalFileGraph?.imports) {
+                        for (const file of Object.keys(intelligence.internalFileGraph.imports)) {
+                            const fileBase = path.basename(file);
+                            if ((fileBase.includes('.spec.') || fileBase.includes('.test.')) &&
+                                fileBase.startsWith(baseName)) {
+                                testedIn.push(file);
+                            }
+                        }
+                    }
+                    // lastModified: from git dates
+                    let lastModified;
+                    if (gitDates) {
+                        // Try matching by relative path (git dates use repo-relative forward-slash paths)
+                        const relPath = path.relative(ROOT_PATH, rPath).replace(/\\/g, '/');
+                        const date = gitDates.get(relPath);
+                        if (date) {
+                            lastModified = date.toISOString();
+                        }
+                    }
+                    // Only return if we have at least one piece of data
+                    if (importedBy.length === 0 &&
+                        imports.length === 0 &&
+                        testedIn.length === 0 &&
+                        !lastModified) {
+                        return undefined;
+                    }
+                    return {
+                        ...(importedBy.length > 0 && { importedBy }),
+                        ...(imports.length > 0 && { imports }),
+                        ...(testedIn.length > 0 && { testedIn }),
+                        ...(lastModified && { lastModified })
+                    };
+                }
+                const searchQuality = assessSearchQuality(query, results);
+                // Compose preflight card for edit/refactor/migrate intents
+                let preflight = undefined;
+                const preflightIntents = ['edit', 'refactor', 'migrate'];
+                if (intent && preflightIntents.includes(intent) && intelligence) {
+                    try {
+                        // --- Avoid / Prefer patterns ---
+                        const avoidPatterns = [];
+                        const preferredPatterns = [];
+                        const patterns = intelligence.patterns || {};
+                        for (const [category, data] of Object.entries(patterns)) {
+                            // Primary pattern = preferred if Rising or Stable
+                            if (data.primary) {
+                                const p = data.primary;
+                                if (p.trend === 'Rising' || p.trend === 'Stable') {
+                                    preferredPatterns.push({
+                                        pattern: p.name,
+                                        category,
+                                        adoption: p.frequency,
+                                        trend: p.trend,
+                                        guidance: p.guidance,
+                                        ...(p.canonicalExample && { example: p.canonicalExample.file })
+                                    });
+                                }
+                            }
+                            // Also-detected patterns that are Declining = avoid
+                            if (data.alsoDetected) {
+                                for (const alt of data.alsoDetected) {
+                                    if (alt.trend === 'Declining') {
+                                        avoidPatterns.push({
+                                            pattern: alt.name,
+                                            category,
+                                            adoption: alt.frequency,
+                                            trend: 'Declining',
+                                            guidance: alt.guidance
+                                        });
+                                    }
+                                }
+                            }
+                        }
+                        // --- Impact candidates (files importing the result files) ---
+                        const impactCandidates = [];
+                        const resultPaths = results.map((r) => r.filePath);
+                        if (intelligence.internalFileGraph?.imports) {
+                            const allImports = intelligence.internalFileGraph.imports;
+                            for (const [file, deps] of Object.entries(allImports)) {
+                                if (deps.some((dep) => resultPaths.some((rp) => dep.endsWith(rp) || rp.endsWith(dep)))) {
+                                    if (!resultPaths.some((rp) => file.endsWith(rp) || rp.endsWith(file))) {
+                                        impactCandidates.push(file);
+                                    }
+                                }
+                            }
+                        }
+                        // --- Risk level (based on circular deps + impact breadth) ---
+                        let riskLevel = 'low';
+                        let cycleCount = 0;
+                        if (intelligence.internalFileGraph) {
+                            try {
+                                const graph = InternalFileGraph.fromJSON(intelligence.internalFileGraph, ROOT_PATH);
+                                // Use directory prefixes as scope (not full file paths)
+                                // findCycles(scope) filters files by startsWith, so a full path would only match itself
+                                const scopes = new Set(resultPaths.map((rp) => {
+                                    const lastSlash = rp.lastIndexOf('/');
+                                    return lastSlash > 0 ? rp.substring(0, lastSlash + 1) : rp;
+                                }));
+                                for (const scope of scopes) {
+                                    const cycles = graph.findCycles(scope);
+                                    cycleCount += cycles.length;
+                                }
+                            }
+                            catch {
+                                // Graph reconstruction failed — skip cycle check
+                            }
+                        }
+                        if (cycleCount > 0 || impactCandidates.length > 10) {
+                            riskLevel = 'high';
+                        }
+                        else if (impactCandidates.length > 3) {
+                            riskLevel = 'medium';
+                        }
+                        // --- Golden files (exemplar code) ---
+                        const goldenFiles = (intelligence.goldenFiles || []).slice(0, 3).map((g) => ({
+                            file: g.file,
+                            score: g.score
+                        }));
+                        // --- Confidence (index freshness) ---
+                        let confidence = 'stale';
+                        if (intelligence.generatedAt) {
+                            const indexAge = Date.now() - new Date(intelligence.generatedAt).getTime();
+                            const hoursOld = indexAge / (1000 * 60 * 60);
+                            if (hoursOld < 24) {
+                                confidence = 'fresh';
+                            }
+                            else if (hoursOld < 168) {
+                                confidence = 'aging';
+                            }
+                        }
+                        // --- Failure memories (1.5x relevance boost) ---
+                        const failureWarnings = relatedMemories
+                            .filter((m) => m.type === 'failure' && !m.stale)
+                            .map((m) => ({
+                            memory: m.memory,
+                            reason: m.reason,
+                            confidence: m.effectiveConfidence
+                        }))
+                            .slice(0, 3);
+                        const preferredPatternsForOutput = preferredPatterns.slice(0, 5);
+                        const avoidPatternsForOutput = avoidPatterns.slice(0, 5);
+                        // --- Pattern conflicts (split decisions within categories) ---
+                        const patternConflicts = [];
+                        const hasUnitTestFramework = Boolean(patterns.unitTestFramework?.primary);
+                        for (const [cat, data] of Object.entries(patterns)) {
+                            if (shouldSkipLegacyTestingFrameworkCategory(cat, patterns))
+                                continue;
+                            if (!shouldIncludePatternConflictCategory(cat, query))
+                                continue;
+                            if (!data.primary || !data.alsoDetected?.length)
+                                continue;
+                            const primaryFreq = parseFloat(data.primary.frequency) || 100;
+                            if (primaryFreq >= 80)
+                                continue;
+                            for (const alt of data.alsoDetected) {
+                                const altFreq = parseFloat(alt.frequency) || 0;
+                                if (altFreq >= 20) {
+                                    if (isComplementaryPatternConflict(cat, data.primary.name, alt.name))
+                                        continue;
+                                    if (hasUnitTestFramework && cat === 'testingFramework')
+                                        continue;
+                                    patternConflicts.push({
+                                        category: cat,
+                                        primary: { name: data.primary.name, adoption: data.primary.frequency },
+                                        alternative: { name: alt.name, adoption: alt.frequency }
+                                    });
+                                }
+                            }
+                        }
+                        const evidenceLock = buildEvidenceLock({
+                            results,
+                            preferredPatterns: preferredPatternsForOutput,
+                            relatedMemories,
+                            failureWarnings,
+                            patternConflicts
+                        });
+                        // Bump risk if there are active failure memories for this area
+                        if (failureWarnings.length > 0 && riskLevel === 'low') {
+                            riskLevel = 'medium';
+                        }
+                        // If evidence triangulation is weak, avoid claiming low risk
+                        if (evidenceLock.status === 'block' && riskLevel === 'low') {
+                            riskLevel = 'medium';
+                        }
+                        // If epistemic stress says abstain, bump risk
+                        if (evidenceLock.epistemicStress?.abstain && riskLevel === 'low') {
+                            riskLevel = 'medium';
+                        }
+                        preflight = {
+                            intent,
+                            riskLevel,
+                            confidence,
+                            evidenceLock,
+                            ...(preferredPatternsForOutput.length > 0 && {
+                                preferredPatterns: preferredPatternsForOutput
+                            }),
+                            ...(avoidPatternsForOutput.length > 0 && {
+                                avoidPatterns: avoidPatternsForOutput
+                            }),
+                            ...(goldenFiles.length > 0 && { goldenFiles }),
+                            ...(impactCandidates.length > 0 && {
+                                impactCandidates: impactCandidates.slice(0, 10)
+                            }),
+                            ...(cycleCount > 0 && { circularDependencies: cycleCount }),
+                            ...(failureWarnings.length > 0 && { failureWarnings })
+                        };
+                    }
+                    catch {
+                        // Preflight construction failed — skip preflight, don't fail the search
+                    }
+                }
                 return {
                     content: [
                         {
                             type: 'text',
                             text: JSON.stringify({
                                 status: 'success',
-                                results: results.map((r) => ({
-                                    summary: r.summary,
-                                    snippet: r.snippet,
-                                    filePath: `${r.filePath}:${r.startLine}-${r.endLine}`,
-                                    score: r.score,
-                                    relevanceReason: r.relevanceReason,
-                                    componentType: r.componentType,
-                                    layer: r.layer,
-                                    framework: r.framework,
-                                    trend: r.trend,
-                                    patternWarning: r.patternWarning
-                                })),
+                                ...(preflight && { preflight }),
+                                searchQuality,
+                                results: results.map((r) => {
+                                    const relationships = enrichResult(r);
+                                    return {
+                                        summary: r.summary,
+                                        snippet: r.snippet,
+                                        filePath: `${r.filePath}:${r.startLine}-${r.endLine}`,
+                                        score: r.score,
+                                        relevanceReason: r.relevanceReason,
+                                        componentType: r.componentType,
+                                        layer: r.layer,
+                                        framework: r.framework,
+                                        trend: r.trend,
+                                        patternWarning: r.patternWarning,
+                                        ...(relationships && { relationships })
+                                    };
+                                }),
                                 totalResults: results.length,
-                                ...(relatedMemories.length > 0 && { relatedMemories })
+                                ...(relatedMemories.length > 0 && {
+                                    relatedMemories: relatedMemories.slice(0, 5)
+                                })
                             }, null, 2)
                         }
                     ]
@@ -635,7 +997,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                         totalFiles: indexState.stats.totalFiles,
                                         indexedFiles: indexState.stats.indexedFiles,
                                         totalChunks: indexState.stats.totalChunks,
-                                        duration: `${(indexState.stats.duration / 1000).toFixed(2)}s`
+                                        duration: `${(indexState.stats.duration / 1000).toFixed(2)}s`,
+                                        incremental: indexState.stats.incremental
                                     }
                                     : undefined,
                                 progress: progress
@@ -657,10 +1020,7 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                 const { reason, incrementalOnly } = args;
                 const mode = incrementalOnly ? 'incremental' : 'full';
                 console.error(`Refresh requested (${mode}): ${reason || 'Manual trigger'}`);
-                // TODO: When incremental indexing is implemented (Phase 2),
-                // use `incrementalOnly` to only re-index changed files.
-                // For now, always do full re-index but acknowledge the intention.
-                performIndexing();
+                performIndexing(incrementalOnly);
                 return {
                     content: [
                         {
@@ -669,12 +1029,9 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                                 status: 'started',
                                 mode,
                                 message: incrementalOnly
-                                    ? 'Incremental re-indexing requested. Check status with get_indexing_status.'
+                                    ? 'Incremental re-indexing started. Only changed files will be re-embedded.'
                                     : 'Full re-indexing started. Check status with get_indexing_status.',
-                                reason,
-                                note: incrementalOnly
-                                    ? 'Incremental mode requested. Full re-index for now; true incremental indexing coming in Phase 2.'
-                                    : undefined
+                                reason
                             }, null, 2)
                         }
                     ]
@@ -828,6 +1185,8 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                         result.stateManagement = intelligence.patterns?.stateManagement;
                     }
                     else if (category === 'testing') {
+                        result.unitTestFramework = intelligence.patterns?.unitTestFramework;
+                        result.e2eFramework = intelligence.patterns?.e2eFramework;
                         result.testingFramework = intelligence.patterns?.testingFramework;
                         result.testMocking = intelligence.patterns?.testMocking;
                     }
@@ -857,6 +1216,47 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     catch (_error) {
                         // No memory file yet, that's fine - don't fail the whole request
                     }
+                    // Detect pattern conflicts: primary < 80% and any alternative > 20%
+                    const conflicts = [];
+                    const patternsData = intelligence.patterns || {};
+                    const hasUnitTestFramework = Boolean(patternsData.unitTestFramework?.primary);
+                    for (const [cat, data] of Object.entries(patternsData)) {
+                        if (shouldSkipLegacyTestingFrameworkCategory(cat, patternsData))
+                            continue;
+                        if (category && category !== 'all' && cat !== category)
+                            continue;
+                        if (!data.primary || !data.alsoDetected?.length)
+                            continue;
+                        const primaryFreq = parseFloat(data.primary.frequency) || 100;
+                        if (primaryFreq >= 80)
+                            continue;
+                        for (const alt of data.alsoDetected) {
+                            const altFreq = parseFloat(alt.frequency) || 0;
+                            if (altFreq < 20)
+                                continue;
+                            if (isComplementaryPatternConflict(cat, data.primary.name, alt.name))
+                                continue;
+                            if (hasUnitTestFramework && cat === 'testingFramework')
+                                continue;
+                            conflicts.push({
+                                category: cat,
+                                primary: {
+                                    name: data.primary.name,
+                                    adoption: data.primary.frequency,
+                                    trend: data.primary.trend
+                                },
+                                alternative: {
+                                    name: alt.name,
+                                    adoption: alt.frequency,
+                                    trend: alt.trend
+                                },
+                                note: `Split decision: ${data.primary.frequency} ${data.primary.name} (${data.primary.trend || 'unknown'}) vs ${alt.frequency} ${alt.name} (${alt.trend || 'unknown'})`
+                            });
+                        }
+                    }
+                    if (conflicts.length > 0) {
+                        result.conflicts = conflicts;
+                    }
                     return {
                         content: [{ type: 'text', text: JSON.stringify(result, null, 2) }]
                     };
@@ -1099,19 +1499,26 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
                     }
                     const filtered = filterMemories(allMemories, { category, type, query });
                     const limited = applyUnfilteredLimit(filtered, { category, type, query }, 20);
+                    // Enrich with confidence decay
+                    const enriched = withConfidence(limited.memories);
+                    const staleCount = enriched.filter((m) => m.stale).length;
                     return {
                         content: [
                             {
                                 type: 'text',
                                 text: JSON.stringify({
                                     status: 'success',
-                                    count: limited.memories.length,
+                                    count: enriched.length,
                                     totalCount: limited.totalCount,
                                     truncated: limited.truncated,
+                                    ...(staleCount > 0 && {
+                                        staleCount,
+                                        staleNote: `${staleCount} memor${staleCount === 1 ? 'y' : 'ies'} below 30% confidence. Consider reviewing or removing.`
+                                    }),
                                     message: limited.truncated
                                         ? 'Showing 20 most recent. Use filters (category/type/query) for targeted results.'
                                         : undefined,
-                                    memories: limited.memories
+                                    memories: enriched
                                 }, null, 2)
                             }
                         ]