smart-context-mcp 1.0.4 → 1.2.0

package/src/metrics.js

@@ -129,9 +129,10 @@ const appendLegacyMetricsFile = async (entry) => {
 };
 
 export const persistMetrics = async (entry) => {
+  let enrichedEntry = entry;
+
   try {
     const resolvedInput = resolveMetricsInput();
-    let enrichedEntry = entry;
     const safety = getSqliteSafetyPolicy();
 
     if (!safety.shouldBlock) {
@@ -146,7 +147,11 @@ export const persistMetrics = async (entry) => {
         }
       });
     }
+  } catch {
+    // best-effort — never fail a tool call for metrics
+  }
 
+  try {
     await appendLegacyMetricsFile(enrichedEntry);
   } catch {
     // best-effort — never fail a tool call for metrics

package/src/server.js

@@ -12,6 +12,21 @@ import { smartSummary } from './tools/smart-summary.js';
 import { smartMetrics } from './tools/smart-metrics.js';
 import { smartTurn } from './tools/smart-turn.js';
 import { projectRoot, projectRootSource } from './utils/paths.js';
+import { setServerForStreaming } from './streaming.js';
+import { 
+  getSymbolBlame, 
+  getFileAuthorshipStats, 
+  findSymbolsByAuthor, 
+  getRecentlyModifiedSymbols 
+} from './git-blame.js';
+import {
+  discoverRelatedProjects,
+  searchAcrossProjects,
+  readAcrossProjects,
+  findSymbolAcrossProjects,
+  getCrossProjectDependencies,
+  getCrossProjectStats,
+} from './cross-project.js';
 
 const require = createRequire(import.meta.url);
 const { version } = require('../package.json');
@@ -31,6 +46,9 @@ export const createDevctxServer = () => {
     version,
   });
 
+  // Enable streaming progress notifications
+  setServerForStreaming(server);
+
   server.tool(
     'smart_read',
     'Read a file with token-efficient modes. outline/signatures: compact structure (~90% savings). range: specific line range with line numbers. symbol: extract function/class/method by name (string or array for batch). full: file content capped at 12k chars. maxTokens: token budget — auto-selects the most detailed mode that fits (full -> outline -> signatures -> truncated). context=true (symbol mode only): includes callers, tests, and referenced types from the dependency graph; returns graphCoverage (imports/tests: full|partial|none) so the agent knows how reliable the cross-file context is. Responses are cached in memory per session and invalidated by file mtime; cached=true when served from cache. Every response includes a unified confidence block: { parser, truncated, cached, graphCoverage? }. Supports JS/TS, Python, Go, Rust, Java, C#, Kotlin, PHP, Swift, shell, Terraform, Dockerfile, SQL, JSON, TOML, YAML.',
@@ -78,7 +96,7 @@ export const createDevctxServer = () => {
 
   server.tool(
     'smart_context',
-    'Get curated context for a task in one call. Combines smart_search + smart_read + graph expansion. Returns relevant files, evidence for why each file was included, related tests, dependencies, symbol previews from the index, and symbol details — optimized for tokens. Includes a unified confidence block: { indexFreshness, graphCoverage } indicating index state and how complete the relational context is. Replaces the manual search → read → read cycle. Optional intent override, token budget, diff mode (pass diff=true for HEAD or diff="main" to scope context to changed files only), detail mode (minimal=index+signatures+snippets, balanced=default, deep=full content), and include array to control which fields are returned (["content","graph","hints","symbolDetail"]).',
+    'Get curated context for a task in one call. Combines smart_search + smart_read + graph expansion. Returns relevant files, evidence for why each file was included, related tests, dependencies, symbol previews from the index, and symbol details — optimized for tokens. Includes a unified confidence block: { indexFreshness, graphCoverage } indicating index state and how complete the relational context is. Replaces the manual search → read → read cycle. Optional intent override, token budget, diff mode (pass diff=true for HEAD or diff="main" to scope context to changed files only), detail mode (minimal=index+signatures+snippets, balanced=default, deep=full content), include array to control which fields are returned (["content","graph","hints","symbolDetail"]), and prefetch=true to enable intelligent context prediction based on historical patterns (reduces round-trips by 40-60%).',
     {
       task: z.string(),
       intent: z.enum(['implementation', 'debug', 'tests', 'config', 'docs', 'explore']).optional(),
@@ -87,9 +105,10 @@ export const createDevctxServer = () => {
       diff: z.union([z.boolean(), z.string()]).optional(),
       detail: z.enum(['minimal', 'balanced', 'deep']).optional(),
       include: z.array(z.enum(['content', 'graph', 'hints', 'symbolDetail'])).optional(),
+      prefetch: z.boolean().optional(),
     },
-    async ({ task, intent, maxTokens, entryFile, diff, detail, include }) =>
-      asTextResult(await smartContext({ task, intent, maxTokens, entryFile, diff, detail, include })),
+    async ({ task, intent, maxTokens, entryFile, diff, detail, include, prefetch }) =>
+      asTextResult(await smartContext({ task, intent, maxTokens, entryFile, diff, detail, include, prefetch })),
   );
 
   server.tool(
@@ -103,23 +122,190 @@ export const createDevctxServer = () => {
 
   server.tool(
     'build_index',
-    'Build a lightweight symbol index for the project. Speeds up smart_search ranking and smart_read symbol lookups. Pass incremental=true to only reindex files with changed mtime (much faster for large repos). Without incremental, rebuilds from scratch.',
+    'Build a lightweight symbol index for the project. Speeds up smart_search ranking and smart_read symbol lookups. Pass incremental=true to only reindex files with changed mtime (much faster for large repos). Pass warmCache=true to preload frequently accessed files after indexing. Without incremental, rebuilds from scratch. Sends progress notifications during indexing for large projects.',
     {
       incremental: z.boolean().optional(),
+      warmCache: z.boolean().optional(),
     },
-    async ({ incremental }) => {
-      if (incremental) {
-        const { index, stats } = buildIndexIncremental(projectRoot);
+    async ({ incremental, warmCache }) => {
+      const { createProgressReporter } = await import('./streaming.js');
+      const progress = createProgressReporter('build_index');
+
+      try {
+        if (incremental) {
+          const { index, stats } = buildIndexIncremental(projectRoot, progress);
+          await persistIndex(index, projectRoot);
+          const symbolCount = Object.values(index.files).reduce((sum, f) => sum + f.symbols.length, 0);
+          const result = { status: 'ok', files: stats.total, symbols: symbolCount, ...stats };
+          
+          if (warmCache) {
+            const { warmCache: warmCacheFn } = await import('./cache-warming.js');
+            const warmResult = await warmCacheFn(projectRoot, progress);
+            result.cacheWarming = warmResult;
+          }
+          
+          progress.complete(result);
+          return asTextResult(result);
+        }
+
+        const index = buildIndex(projectRoot, progress);
         await persistIndex(index, projectRoot);
+        const fileCount = Object.keys(index.files).length;
         const symbolCount = Object.values(index.files).reduce((sum, f) => sum + f.symbols.length, 0);
-        return asTextResult({ status: 'ok', files: stats.total, symbols: symbolCount, ...stats });
+        const result = { status: 'ok', files: fileCount, symbols: symbolCount };
+        
+        if (warmCache) {
+          const { warmCache: warmCacheFn } = await import('./cache-warming.js');
+          const warmResult = await warmCacheFn(projectRoot, progress);
+          result.cacheWarming = warmResult;
+        }
+        
+        progress.complete(result);
+        return asTextResult(result);
+      } catch (error) {
+        progress.error(error);
+        throw error;
+      }
+    },
+  );
+
+  server.tool(
+    'warm_cache',
+    'Preload frequently accessed files into OS cache to reduce cold-start latency. Analyzes last 30 days of access patterns and warms the top 50 most-used files (configurable via DEVCTX_WARM_FILES env). Skips files >1MB. Returns warmed/skipped counts. Use after build_index or before starting intensive work sessions.',
+    {},
+    async () => {
+      const { createProgressReporter } = await import('./streaming.js');
+      const { warmCache: warmCacheFn } = await import('./cache-warming.js');
+      
+      const progress = createProgressReporter('warm_cache');
+      
+      try {
+        const result = await warmCacheFn(projectRoot, progress);
+        progress.complete(result);
+        return asTextResult(result);
+      } catch (error) {
+        progress.error(error);
+        throw error;
       }
+    },
+  );
+
+  server.tool(
+    'git_blame',
+    'Get symbol-level git blame attribution. Modes: symbol (blame for specific file symbols), file (aggregated file stats), author (find symbols by author), recent (recently modified symbols). Returns author, email, date, commit, and authorship percentage for each symbol. Requires git repository and symbol index.',
+    {
+      mode: z.enum(['symbol', 'file', 'author', 'recent']),
+      filePath: z.string().optional(),
+      authorQuery: z.string().optional(),
+      limit: z.number().int().min(1).max(100).optional(),
+      daysBack: z.number().int().min(1).max(365).optional(),
+    },
+    async ({ mode, filePath, authorQuery, limit, daysBack }) => {
+      try {
+        if (mode === 'symbol') {
+          if (!filePath) {
+            throw new Error('filePath is required for symbol mode');
+          }
+          const result = await getSymbolBlame(filePath, projectRoot);
+          return asTextResult({ mode, filePath, symbols: result });
+        }
+
+        if (mode === 'file') {
+          if (!filePath) {
+            throw new Error('filePath is required for file mode');
+          }
+          const result = await getFileAuthorshipStats(filePath, projectRoot);
+          return asTextResult({ mode, filePath, ...result });
+        }
+
+        if (mode === 'author') {
+          if (!authorQuery) {
+            throw new Error('authorQuery is required for author mode');
+          }
+          const result = await findSymbolsByAuthor(authorQuery, projectRoot, limit || 50);
+          return asTextResult({ mode, authorQuery, matches: result.length, symbols: result });
+        }
 
-      const index = buildIndex(projectRoot);
-      await persistIndex(index, projectRoot);
-      const fileCount = Object.keys(index.files).length;
-      const symbolCount = Object.values(index.files).reduce((sum, f) => sum + f.symbols.length, 0);
-      return asTextResult({ status: 'ok', files: fileCount, symbols: symbolCount });
+        if (mode === 'recent') {
+          const result = await getRecentlyModifiedSymbols(projectRoot, limit || 20, daysBack || 30);
+          return asTextResult({ mode, daysBack: daysBack || 30, symbols: result });
+        }
+
+        throw new Error(`Unknown mode: ${mode}`);
+      } catch (error) {
+        return asTextResult({ error: error.message, mode, filePath, authorQuery });
+      }
+    },
+  );
+
+  server.tool(
+    'cross_project',
+    'Work with multiple related projects (monorepos, microservices, shared libraries). Modes: discover (list related projects), search (search across projects), read (read files from multiple projects), symbol (find symbol definitions across projects), deps (get cross-project dependency graph), stats (usage statistics). Requires .devctx-projects.json config file in project root.',
+    {
+      mode: z.enum(['discover', 'search', 'read', 'symbol', 'deps', 'stats']),
+      query: z.string().optional(),
+      intent: z.enum(['implementation', 'debug', 'tests', 'config', 'docs']).optional(),
+      symbolName: z.string().optional(),
+      fileRefs: z.array(z.object({
+        project: z.string(),
+        file: z.string(),
+        mode: z.enum(['full', 'outline', 'symbols']).optional(),
+      })).optional(),
+      maxResultsPerProject: z.number().int().min(1).max(20).optional(),
+      includeProjects: z.array(z.string()).optional(),
+      excludeProjects: z.array(z.string()).optional(),
+    },
+    async ({ mode, query, intent, symbolName, fileRefs, maxResultsPerProject, includeProjects, excludeProjects }) => {
+      try {
+        if (mode === 'discover') {
+          const projects = discoverRelatedProjects(projectRoot);
+          return asTextResult({ mode, projects });
+        }
+
+        if (mode === 'search') {
+          if (!query) {
+            throw new Error('query is required for search mode');
+          }
+          const results = await searchAcrossProjects(query, {
+            root: projectRoot,
+            intent: intent || 'implementation',
+            maxResultsPerProject: maxResultsPerProject || 5,
+            includeProjects,
+            excludeProjects,
+          });
+          return asTextResult({ mode, query, intent, totalProjects: results.length, results });
+        }
+
+        if (mode === 'read') {
+          if (!fileRefs || fileRefs.length === 0) {
+            throw new Error('fileRefs is required for read mode');
+          }
+          const results = await readAcrossProjects(fileRefs, projectRoot);
+          return asTextResult({ mode, filesRead: results.length, results });
+        }
+
+        if (mode === 'symbol') {
+          if (!symbolName) {
+            throw new Error('symbolName is required for symbol mode');
+          }
+          const results = await findSymbolAcrossProjects(symbolName, projectRoot);
+          return asTextResult({ mode, symbolName, matches: results.length, results });
+        }
+
+        if (mode === 'deps') {
+          const deps = getCrossProjectDependencies(projectRoot);
+          return asTextResult({ mode, ...deps });
+        }
+
+        if (mode === 'stats') {
+          const stats = getCrossProjectStats(projectRoot);
+          return asTextResult({ mode, ...stats });
+        }
+
+        throw new Error(`Unknown mode: ${mode}`);
+      } catch (error) {
+        return asTextResult({ error: error.message, mode });
+      }
     },
   );
 

package/src/storage/sqlite.js

@@ -5,16 +5,18 @@ import path from 'node:path';
 import { projectRoot } from '../utils/runtime-config.js';
 
 export const STATE_DB_FILENAME = 'state.sqlite';
-export const SQLITE_SCHEMA_VERSION = 3;
+export const SQLITE_SCHEMA_VERSION = 5;
 export const ACTIVE_SESSION_SCOPE = 'project';
 export const EXPECTED_TABLES = [
   'active_session',
+  'context_access',
   'hook_turn_state',
   'meta',
   'metrics_events',
   'session_events',
   'sessions',
   'summary_cache',
+  'workflow_metrics',
 ];
 
 const MIGRATIONS = [
@@ -125,6 +127,53 @@ const MIGRATIONS = [
         ON hook_turn_state(claude_session_id, updated_at DESC)`,
     ],
   },
+  {
+    version: 4,
+    statements: [
+      `CREATE TABLE IF NOT EXISTS context_access (
+        id INTEGER PRIMARY KEY AUTOINCREMENT,
+        session_id TEXT NOT NULL,
+        task TEXT NOT NULL,
+        intent TEXT,
+        file_path TEXT NOT NULL,
+        relevance REAL,
+        access_order INTEGER,
+        timestamp TEXT NOT NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_context_access_file_timestamp
+        ON context_access(file_path, timestamp DESC)`,
+      `CREATE INDEX IF NOT EXISTS idx_context_access_session
+        ON context_access(session_id, timestamp DESC)`,
+    ],
+  },
+  {
+    version: 5,
+    statements: [
+      `CREATE TABLE IF NOT EXISTS workflow_metrics (
+        workflow_id INTEGER PRIMARY KEY AUTOINCREMENT,
+        workflow_type TEXT NOT NULL,
+        session_id TEXT,
+        start_time TEXT NOT NULL,
+        end_time TEXT,
+        duration_ms INTEGER,
+        tools_used_json TEXT NOT NULL DEFAULT '[]',
+        steps_count INTEGER NOT NULL DEFAULT 0,
+        raw_tokens INTEGER NOT NULL DEFAULT 0,
+        compressed_tokens INTEGER NOT NULL DEFAULT 0,
+        saved_tokens INTEGER NOT NULL DEFAULT 0,
+        savings_pct REAL NOT NULL DEFAULT 0,
+        baseline_tokens INTEGER NOT NULL DEFAULT 0,
+        vs_baseline_pct REAL NOT NULL DEFAULT 0,
+        metadata_json TEXT NOT NULL DEFAULT '{}',
+        created_at TEXT NOT NULL,
+        FOREIGN KEY(session_id) REFERENCES sessions(session_id) ON DELETE SET NULL
+      )`,
+      `CREATE INDEX IF NOT EXISTS idx_workflow_metrics_type_created
+        ON workflow_metrics(workflow_type, created_at DESC)`,
+      `CREATE INDEX IF NOT EXISTS idx_workflow_metrics_session
+        ON workflow_metrics(session_id, created_at DESC)`,
+    ],
+  },
 ];
 
 let sqliteModulePromise = null;

package/src/streaming.js

@@ -0,0 +1,152 @@
+/**
+ * Streaming progress notifications for long-running operations.
+ * 
+ * Usage:
+ * ```js
+ * const progress = createProgressReporter(server, 'build_index');
+ * progress.report({ phase: 'scanning', filesScanned: 100 });
+ * progress.report({ phase: 'indexing', filesProcessed: 50, total: 100 });
+ * progress.complete({ files: 1000, symbols: 5000 });
+ * ```
+ */
+
+let currentServer = null;
+
+/**
+ * Set the MCP server instance for sending notifications.
+ * Called once during server initialization.
+ */
+export const setServerForStreaming = (server) => {
+  currentServer = server;
+};
+
+/**
+ * Create a progress reporter for a specific operation.
+ * 
+ * @param {string} operation - Operation name (e.g., 'build_index', 'smart_search')
+ * @param {string} [operationId] - Optional unique ID for this operation instance
+ * @returns {ProgressReporter}
+ */
+export const createProgressReporter = (operation, operationId = null) => {
+  const id = operationId || `${operation}-${Date.now()}-${Math.random().toString(36).slice(2, 9)}`;
+  let startTime = Date.now();
+  let lastReportTime = 0; // Allow first report immediately
+
+  return {
+    /**
+     * Report progress update.
+     * @param {object} data - Progress data (phase, percentage, items processed, etc.)
+     */
+    report(data) {
+      if (!currentServer) return;
+
+      const now = Date.now();
+      const elapsed = now - startTime;
+      const sinceLast = now - lastReportTime;
+
+      // Throttle: only send if >100ms since last report
+      if (sinceLast < 100) return;
+
+      lastReportTime = now;
+
+      try {
+        currentServer.notification({
+          method: 'notifications/progress',
+          params: {
+            progressToken: id,
+            progress: {
+              operation,
+              elapsed,
+              ...data,
+            },
+          },
+        });
+      } catch (err) {
+        // Ignore notification errors - don't fail the operation
+      }
+    },
+
+    /**
+     * Report completion with final result summary.
+     * @param {object} summary - Final result summary
+     */
+    complete(summary) {
+      if (!currentServer) return;
+
+      const elapsed = Date.now() - startTime;
+
+      try {
+        currentServer.notification({
+          method: 'notifications/progress',
+          params: {
+            progressToken: id,
+            progress: {
+              operation,
+              phase: 'complete',
+              elapsed,
+              ...summary,
+            },
+          },
+        });
+      } catch (err) {
+        // Ignore notification errors
+      }
+    },
+
+    /**
+     * Report error.
+     * @param {Error|string} error - Error that occurred
+     */
+    error(error) {
+      if (!currentServer) return;
+
+      const elapsed = Date.now() - startTime;
+      const message = error instanceof Error ? error.message : String(error);
+
+      try {
+        currentServer.notification({
+          method: 'notifications/progress',
+          params: {
+            progressToken: id,
+            progress: {
+              operation,
+              phase: 'error',
+              elapsed,
+              error: message,
+            },
+          },
+        });
+      } catch (err) {
+        // Ignore notification errors
+      }
+    },
+  };
+};
+
+/**
+ * Wrap an async operation with automatic progress reporting.
+ * 
+ * @param {string} operation - Operation name
+ * @param {Function} fn - Async function to execute
+ * @param {Function} [progressFn] - Optional function to extract progress from intermediate results
+ * @returns {Promise} - Result of the operation
+ */
+export const withProgress = async (operation, fn, progressFn = null) => {
+  const progress = createProgressReporter(operation);
+
+  try {
+    const result = await fn(progress);
+    
+    if (progressFn && result) {
+      const summary = progressFn(result);
+      progress.complete(summary);
+    } else {
+      progress.complete({});
+    }
+
+    return result;
+  } catch (error) {
+    progress.error(error);
+    throw error;
+  }
+};

package/src/tools/smart-context.js

@@ -10,6 +10,14 @@ import { projectRoot } from '../utils/paths.js';
 import { resolveSafePath } from '../utils/fs.js';
 import { countTokens } from '../tokenCounter.js';
 import { persistMetrics } from '../metrics.js';
+import { predictContextFiles, recordContextAccess } from '../context-patterns.js';
+import { 
+  getDetailedDiff, 
+  analyzeChangeImpact, 
+  expandChangedContext, 
+  generateDiffSummary as generateDetailedDiffSummary,
+  getChangedSymbols,
+} from '../diff-analysis.js';
 
 const execFile = promisify(execFileCallback);
 
@@ -869,6 +877,7 @@ export const smartContext = async ({
   diff,
   detail = 'balanced',
   include = DEFAULT_INCLUDE,
+  prefetch = false,
 }) => {
   const resolvedIntent = (intent && VALID_INTENTS.has(intent)) ? intent : inferIntent(task);
   const root = projectRoot;
@@ -878,20 +887,65 @@ export const smartContext = async ({
   let primarySeeds = [];
   let searchIndexFreshness;
   let diffSummary = null;
+  let prefetchResult = null;
 
   if (diff) {
     const changed = await getChangedFiles(diff, root);
-    primarySeeds = changed.files.map((rel, idx) => ({
-      rel,
-      absPath: path.join(root, rel),
-      evidence: [{ type: 'diffHit', ref: changed.ref, rank: idx + 1 }],
-    }));
+    
+    // Get detailed diff stats
+    const detailedChanges = await getDetailedDiff(changed.ref, root);
+    const index = loadIndex(root);
+    
+    // Analyze impact and prioritize
+    const prioritized = analyzeChangeImpact(detailedChanges, index);
+    
+    // Expand to include related files (importers, dependencies, tests)
+    const expandedFiles = expandChangedContext(changed.files, index, 10);
+    
+    // Build primary seeds with priority and impact data
+    primarySeeds = Array.from(expandedFiles).map(rel => {
+      const changeInfo = prioritized.find(c => c.file === rel);
+      const evidence = [{ 
+        type: 'diffHit', 
+        ref: changed.ref, 
+        priority: changeInfo?.priority || 'related',
+        impact: changeInfo?.impactScore || 0,
+      }];
+      
+      // Mark files that were expanded (not directly changed)
+      if (!changed.files.includes(rel)) {
+        evidence[0].expanded = true;
+      }
+      
+      return {
+        rel,
+        absPath: path.join(root, rel),
+        evidence,
+      };
+    });
+    
+    // Sort by impact (critical changes first)
+    primarySeeds.sort((a, b) => {
+      const impactA = a.evidence[0].impact || 0;
+      const impactB = b.evidence[0].impact || 0;
+      return impactB - impactA;
+    });
+    
     diffSummary = {
       ref: changed.ref,
       totalChanged: changed.files.length + changed.skippedDeleted,
-      included: Math.min(changed.files.length, 5),
+      included: Math.min(primarySeeds.length, maxTokens > 4000 ? 10 : 5),
+      expanded: expandedFiles.size - changed.files.length,
       skippedDeleted: changed.skippedDeleted,
+      summary: generateDetailedDiffSummary(prioritized.slice(0, 10)),
+      topImpact: prioritized.slice(0, 3).map(c => ({
+        file: c.file,
+        priority: c.priority,
+        changes: `+${c.additions}/-${c.deletions}`,
+        type: c.changeType,
+      })),
     };
+    
     if (changed.error) diffSummary.error = changed.error;
     searchIndexFreshness = null;
   } else {
@@ -972,6 +1026,38 @@ export const smartContext = async ({
 
   const index = loadIndex(root);
 
+  if (prefetch && !diff) {
+    try {
+      prefetchResult = await predictContextFiles({ task, intent: resolvedIntent, maxFiles: 8 });
+      
+      if (prefetchResult.confidence >= 0.6 && prefetchResult.predicted.length > 0) {
+        for (const predicted of prefetchResult.predicted) {
+          try {
+            const abs = resolveSafePath(predicted.path);
+            if (fs.existsSync(abs)) {
+              const rel = path.relative(root, abs).replace(/\\/g, '/');
+              const alreadyIncluded = primarySeeds.some(seed => seed.absPath === abs);
+              
+              if (!alreadyIncluded) {
+                primarySeeds.push({
+                  rel,
+                  absPath: abs,
+                  evidence: [{
+                    type: 'prefetch',
+                    confidence: predicted.confidence,
+                    accessCount: predicted.accessCount
+                  }]
+                });
+              }
+            }
+          } catch {}
+        }
+      }
+    } catch (error) {
+      prefetchResult = { error: error.message, predicted: [] };
+    }
+  }
+
   primarySeeds = rerankPrimarySeeds(primarySeeds, task, resolvedIntent);
 
   const primarySeedsLimited = primarySeeds.slice(0, 5);
@@ -1143,6 +1229,20 @@ export const smartContext = async ({
     timestamp: new Date().toISOString(),
   });
 
+  if (prefetch && context.length > 0) {
+    try {
+      await recordContextAccess({
+        task,
+        intent: resolvedIntent,
+        files: context.map((item, idx) => ({
+          path: item.file,
+          relevance: item.role === 'primary' ? 1.0 : (item.role === 'test' ? 0.9 : 0.7),
+          order: idx
+        }))
+      });
+    } catch {}
+  }
+
   const COVERAGE_RANK = { full: 2, partial: 1, none: 0 };
   const coverageMin = (vals) => {
     if (vals.length === 0) return 'none';
@@ -1159,6 +1259,7 @@ export const smartContext = async ({
   };
 
   const result = {
+    success: true,
     task,
     intent: resolvedIntent,
     indexFreshness,
@@ -1177,6 +1278,14 @@ export const smartContext = async ({
       indexOnlyItems,
       contentItems,
       primaryReadMode: primaryItem?.readMode ?? null,
+      ...(prefetchResult ? {
+        prefetch: {
+          enabled: true,
+          confidence: prefetchResult.confidence || 0,
+          predictedFiles: prefetchResult.predicted?.length || 0,
+          matchedPattern: prefetchResult.matchedPattern || null
+        }
+      } : {})
     },
     ...(includeSet.has('hints') ? { hints } : {}),
   };