@codragraph/cli 2.1.4 → 2.1.5

package/dist/cli/tool.js

@@ -17,6 +17,7 @@
 import { writeSync } from 'node:fs';
 import { LocalBackend } from '../mcp/local/local-backend.js';
 import { emitTokenStats } from './compress-stats.js';
+import { findRepo } from '../storage/repo-manager.js';
 let _backend = null;
 async function getBackend() {
     if (_backend)
@@ -29,6 +30,21 @@ async function getBackend() {
     }
     return _backend;
 }
+async function callToolOnce(toolName, params) {
+    const backend = await getBackend();
+    return backend.callTool(toolName, params);
+}
+async function resolveCliRepoParam(repoParam) {
+    if (repoParam)
+        return repoParam;
+    const currentRepo = await findRepo(process.cwd());
+    if (currentRepo)
+        return currentRepo.repoPath;
+    output(`Error: Current repository is not indexed: ${process.cwd()}\n` +
+        'Run: npx @codragraph/cli analyze');
+    process.exitCode = 1;
+    return null;
+}
 /**
  * Write tool output to stdout using low-level fd write.
  *
@@ -59,14 +75,16 @@ export async function queryCommand(queryText, options) {
         console.error('Usage: codragraph query <search_query>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('query', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('query', {
         query: queryText,
         task_context: options?.context,
         goal: options?.goal,
         limit: options?.limit ? parseInt(options.limit) : undefined,
         include_content: options?.content ?? false,
-        repo: options?.repo,
+        repo,
     });
     output(result);
     emitTokenStats(result);
@@ -76,13 +94,15 @@ export async function contextCommand(name, options) {
         console.error('Usage: codragraph context <symbol_name> [--uid <uid>] [--file <path>]');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('context', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('context', {
         name: name || undefined,
         uid: options?.uid,
         file_path: options?.file,
         include_content: options?.content ?? false,
-        repo: options?.repo,
+        repo,
     });
     output(result);
     emitTokenStats(result);
@@ -93,13 +113,15 @@ export async function impactCommand(target, options) {
         process.exit(1);
     }
     try {
-        const backend = await getBackend();
-        const result = await backend.callTool('impact', {
+        const repo = await resolveCliRepoParam(options?.repo);
+        if (!repo)
+            return;
+        const result = await callToolOnce('impact', {
             target,
             direction: options?.direction || 'upstream',
             maxDepth: options?.depth ? parseInt(options.depth, 10) : undefined,
             includeTests: options?.includeTests ?? false,
-            repo: options?.repo,
+            repo,
         });
         output(result);
         emitTokenStats(result);
@@ -121,26 +143,32 @@ export async function cypherCommand(query, options) {
         console.error('Usage: codragraph cypher <cypher_query>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cypher', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cypher', {
         query,
-        repo: options?.repo,
+        repo,
     });
     output(result);
 }
 export async function featureClustersCommand(options) {
-    const backend = await getBackend();
-    const result = await backend.callTool('feature_clusters', {
-        repo: options?.repo,
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('feature_clusters', {
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
 }
 export async function clusterQueryCommand(query, options) {
-    const backend = await getBackend();
-    const result = await backend.callTool('cluster_query', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_query', {
         query,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -150,10 +178,12 @@ export async function featureContextCommand(name, options) {
         console.error('Usage: codragraph feature-context <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('feature_context', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('feature_context', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -164,10 +194,12 @@ export async function clusterContextCommand(name, options) {
         console.error('Usage: codragraph cluster-context <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cluster_context', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_context', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -178,10 +210,12 @@ export async function contextPackCommand(name, options) {
         console.error('Usage: codragraph context-pack <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('context_pack', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('context_pack', {
         name,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -192,11 +226,13 @@ export async function clusterImpactCommand(name, options) {
         console.error('Usage: codragraph cluster-impact <name>');
         process.exit(1);
     }
-    const backend = await getBackend();
-    const result = await backend.callTool('cluster_impact', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('cluster_impact', {
         name,
         direction: options?.direction,
-        repo: options?.repo,
+        repo,
         limit: options?.limit ? parseInt(options.limit, 10) : undefined,
     });
     output(result);
@@ -236,11 +272,15 @@ function formatDetectChangesResult(result) {
     return lines.join('\n').trim();
 }
 export async function detectChangesCommand(options) {
-    const backend = await getBackend();
-    const result = await backend.callTool('detect_changes', {
+    const repo = await resolveCliRepoParam(options?.repo);
+    if (!repo)
+        return;
+    const result = await callToolOnce('detect_changes', {
         scope: options?.scope || 'unstaged',
         base_ref: options?.baseRef,
-        repo: options?.repo,
+        repo,
     });
     output(formatDetectChangesResult(result));
+    if (result?.error)
+        process.exitCode = 1;
 }

package/dist/config/ignore-service.js

@@ -4,6 +4,7 @@ import nodePath from 'path';
 const DEFAULT_IGNORE_LIST = new Set([
     // Version Control
     '.git',
+    '.codragraph',
     '.svn',
     '.hg',
     '.bzr',

package/dist/core/cgdb/pool-adapter.js

@@ -16,7 +16,49 @@
  */
 import fs from 'fs/promises';
 import cgdb from '@ladybugdb/core';
+import { NODE_TABLES } from './schema.js';
 const pool = new Map();
+const SIMPLE_LABELLESS_MATCH_RE = /^MATCH\s*\(\s*([A-Za-z_][A-Za-z0-9_]*)\s*\)/i;
+const CYPHER_LIMIT_RE = /\bLIMIT\s+(\d+)\s*;?\s*$/i;
+const CYPHER_RELATION_RE = /--|-\[|\]-|->|<-/;
+const NATIVE_UNSAFE_NODE_LABELS = new Set(['Union']);
+function quoteKnownNodeLabels(query) {
+    return query;
+}
+function getNativeUnsafeNodeLabel(query) {
+    const labelRe = /\(\s*[A-Za-z_][A-Za-z0-9_]*\s*:\s*`?([A-Za-z_][A-Za-z0-9_]*)`?(?=[\s){])/g;
+    for (const match of query.matchAll(labelRe)) {
+        const label = match[1];
+        if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+            return label;
+    }
+    return null;
+}
+function getSimpleLabellessNodeAlias(query) {
+    const trimmed = query.trim();
+    const match = SIMPLE_LABELLESS_MATCH_RE.exec(trimmed);
+    if (!match)
+        return null;
+    if (CYPHER_RELATION_RE.test(trimmed))
+        return null;
+    if (/\bMATCH\b/i.test(trimmed.slice(match[0].length)))
+        return null;
+    return match[1];
+}
+function getCypherLimit(query) {
+    const match = CYPHER_LIMIT_RE.exec(query);
+    if (!match)
+        return null;
+    const limit = Number.parseInt(match[1], 10);
+    return Number.isFinite(limit) && limit > 0 ? limit : null;
+}
+function withCypherLimit(query, limit) {
+    const safeLimit = Math.max(1, Math.trunc(limit));
+    if (CYPHER_LIMIT_RE.test(query)) {
+        return query.replace(CYPHER_LIMIT_RE, `LIMIT ${safeLimit}`);
+    }
+    return `${query.replace(/;\s*$/, '')} LIMIT ${safeLimit}`;
+}
 const poolCloseListeners = new Set();
 /**
  * Subscribe to pool-close events. Returns a disposer that removes the
@@ -463,15 +505,7 @@ function withTimeout(promise, ms, label) {
     });
     return Promise.race([promise, timeout]).finally(() => clearTimeout(timer));
 }
-export const executeQuery = async (repoId, cypher) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
-    }
-    if (isWriteQuery(cypher)) {
-        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
-    }
-    entry.lastUsed = Date.now();
+async function runQueryOnEntry(entry, cypher) {
     const conn = await checkout(entry);
     silenceStdout();
     activeQueryCount++;
@@ -486,17 +520,8 @@ export const executeQuery = async (repoId, cypher) => {
         restoreStdout();
         checkin(entry, conn);
     }
-};
-/**
- * Execute a parameterized query on a specific repo's connection pool.
- * Uses prepare/execute pattern to prevent Cypher injection.
- */
-export const executeParameterized = async (repoId, cypher, params) => {
-    const entry = pool.get(repoId);
-    if (!entry) {
-        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
-    }
-    entry.lastUsed = Date.now();
+}
+async function runParameterizedOnEntry(entry, cypher, params) {
     const conn = await checkout(entry);
     silenceStdout();
     activeQueryCount++;
@@ -516,6 +541,91 @@ export const executeParameterized = async (repoId, cypher, params) => {
         restoreStdout();
         checkin(entry, conn);
     }
+}
+async function runLabellessNodeScan(query, alias, runner) {
+    const limit = getCypherLimit(query) ?? 100;
+    const rows = [];
+    let lastError = null;
+    for (const label of NODE_TABLES) {
+        if (NATIVE_UNSAFE_NODE_LABELS.has(label))
+            continue;
+        if (rows.length >= limit)
+            break;
+        const labelQuery = withCypherLimit(query.replace(SIMPLE_LABELLESS_MATCH_RE, `MATCH (${alias}:\`${label}\`)`), limit - rows.length);
+        try {
+            const labelRows = await runner(labelQuery);
+            rows.push(...decorateLabellessRows(labelRows, label));
+        }
+        catch (err) {
+            const error = err instanceof Error ? err : new Error(String(err));
+            if (!isBenignLabelScanError(error)) {
+                lastError = error;
+            }
+        }
+    }
+    if (rows.length === 0 && lastError) {
+        throw lastError;
+    }
+    return rows.slice(0, limit);
+}
+function decorateLabellessRows(rows, label) {
+    return rows.map((row) => {
+        if (!row || typeof row !== 'object' || Array.isArray(row))
+            return row;
+        const decorated = { ...row, __cgLabel: label };
+        for (const key of ['type', 'kind', 'label']) {
+            const value = decorated[key];
+            if (value === '' || value === null || value === undefined) {
+                decorated[key] = label;
+            }
+        }
+        return decorated;
+    });
+}
+function isBenignLabelScanError(error) {
+    const message = error.message.toLowerCase();
+    return (message.includes('cannot find property') ||
+        message.includes('does not have property') ||
+        message.includes('property') && message.includes('not found'));
+}
+export const executeQuery = async (repoId, cypher) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
+    }
+    const safeCypher = quoteKnownNodeLabels(cypher);
+    if (isWriteQuery(safeCypher)) {
+        throw new Error('Write operations are not allowed. The pool adapter is read-only.');
+    }
+    if (getNativeUnsafeNodeLabel(safeCypher)) {
+        return [];
+    }
+    entry.lastUsed = Date.now();
+    const labellessAlias = getSimpleLabellessNodeAlias(safeCypher);
+    if (labellessAlias) {
+        return runLabellessNodeScan(safeCypher, labellessAlias, (labelQuery) => runQueryOnEntry(entry, labelQuery));
+    }
+    return runQueryOnEntry(entry, safeCypher);
+};
+/**
+ * Execute a parameterized query on a specific repo's connection pool.
+ * Uses prepare/execute pattern to prevent Cypher injection.
+ */
+export const executeParameterized = async (repoId, cypher, params) => {
+    const entry = pool.get(repoId);
+    if (!entry) {
+        throw new Error(`LadybugDB not initialized for repo "${repoId}". Call initCgdb first.`);
+    }
+    entry.lastUsed = Date.now();
+    const safeCypher = quoteKnownNodeLabels(cypher);
+    if (getNativeUnsafeNodeLabel(safeCypher)) {
+        return [];
+    }
+    const labellessAlias = getSimpleLabellessNodeAlias(safeCypher);
+    if (labellessAlias) {
+        return runLabellessNodeScan(safeCypher, labellessAlias, (labelQuery) => runParameterizedOnEntry(entry, labelQuery, params));
+    }
+    return runParameterizedOnEntry(entry, safeCypher, params);
 };
 /**
  * Close one or all repo pools.

package/dist/core/ingestion/parsing-processor.js

@@ -567,7 +567,13 @@ scopeTreeCache, onFileProgress, workerPool) => {
             return await processParsingWithWorkers(graph, files, symbolTable, astCache, workerPool, onFileProgress);
         }
         catch (err) {
-            console.warn('Worker pool parsing failed, falling back to sequential:', err instanceof Error ? err.message : err);
+            console.warn('Worker pool parsing failed for this chunk, falling back to sequential:', err instanceof Error ? err.message : err);
+            try {
+                await workerPool.terminate();
+            }
+            catch (terminateErr) {
+                console.warn('Worker pool termination after parsing failure failed:', terminateErr instanceof Error ? terminateErr.message : terminateErr);
+            }
         }
     }
     // Fallback: sequential parsing (no pre-extracted data)

package/dist/core/ingestion/pipeline-phases/parse-impl.js

@@ -170,6 +170,7 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
             const chunkFiles = chunkPaths
                 .filter((p) => chunkContents.has(p))
                 .map((p) => ({ path: p, content: chunkContents.get(p) }));
+            const usedWorkerPoolForChunk = workerPool !== undefined;
             const chunkWorkerData = await processParsing(graph, chunkFiles, symbolTable, astCache, scopeTreeCache, (current, _total, filePath) => {
                 const globalCurrent = filesParsedSoFar + current;
                 const parsingProgress = 20 + (globalCurrent / totalParseable) * 62;
@@ -185,6 +186,9 @@ export async function runChunkedParseAndResolve(graph, scannedFiles, allPaths, t
                     },
                 });
             }, workerPool);
+            if (usedWorkerPoolForChunk && !chunkWorkerData) {
+                workerPool = undefined;
+            }
             const chunkBasePercent = 20 + (filesParsedSoFar / totalParseable) * 62;
             if (chunkWorkerData) {
                 await processImportsFromExtracted(graph, allPathObjects, chunkWorkerData.imports, ctx, (current, total) => {

package/dist/core/ingestion/workers/parse-worker.js

@@ -452,7 +452,7 @@ const processBatch = (files, onProgress) => {
     }
     let totalProcessed = 0;
     let lastReported = 0;
-    const PROGRESS_INTERVAL = 100; // report every 100 files
+    const PROGRESS_INTERVAL = 25; // report often enough to keep worker idle timers fresh
     const onFileProcessed = onProgress
         ? () => {
             totalProcessed++;

package/dist/core/ingestion/workers/worker-pool.d.ts

@@ -10,7 +10,20 @@ export interface WorkerPool {
     /** Number of workers in the pool */
     readonly size: number;
 }
+export interface WorkerPoolOptions {
+    /**
+     * Max files to send to a worker in one postMessage. Lower values reduce
+     * structured-clone memory spikes and give the main thread more chances to
+     * observe progress on large repos.
+     */
+    subBatchSize?: number;
+    /**
+     * Idle timeout while waiting for a worker response. Reset by worker progress
+     * so slow-but-moving chunks do not get retried sequentially.
+     */
+    subBatchIdleTimeoutMs?: number;
+}
 /**
  * Create a pool of worker threads.
  */
-export declare const createWorkerPool: (workerUrl: URL, poolSize?: number) => WorkerPool;
+export declare const createWorkerPool: (workerUrl: URL, poolSize?: number, options?: WorkerPoolOptions) => WorkerPool;

package/dist/core/ingestion/workers/worker-pool.js

@@ -6,14 +6,24 @@ import { fileURLToPath } from 'node:url';
  * Max files to send to a worker in a single postMessage.
  * Keeps structured-clone memory bounded per sub-batch.
  */
-const SUB_BATCH_SIZE = 1500;
-/** Per sub-batch timeout. If a single sub-batch takes longer than this,
- *  likely a pathological file (e.g. minified 50MB JS). Fail fast. */
-const SUB_BATCH_TIMEOUT_MS = 30_000;
+const DEFAULT_SUB_BATCH_SIZE = 250;
+/**
+ * Idle timeout while waiting for a worker response. This is not a wall-clock
+ * limit: worker progress resets it. Large repos can legitimately need more
+ * than 30s for a chunk, but a wedged parser should still fall back.
+ */
+const DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS = 120_000;
+const positiveIntFromEnv = (name, fallback) => {
+    const raw = process.env[name];
+    if (!raw)
+        return fallback;
+    const parsed = Number.parseInt(raw, 10);
+    return Number.isFinite(parsed) && parsed > 0 ? parsed : fallback;
+};
 /**
  * Create a pool of worker threads.
  */
-export const createWorkerPool = (workerUrl, poolSize) => {
+export const createWorkerPool = (workerUrl, poolSize, options = {}) => {
     // Validate worker script exists before spawning to prevent uncaught
     // MODULE_NOT_FOUND crashes in worker threads (e.g. when running from src/ via vitest)
     const workerPath = fileURLToPath(workerUrl);
@@ -21,6 +31,10 @@ export const createWorkerPool = (workerUrl, poolSize) => {
         throw new Error(`Worker script not found: ${workerPath}`);
     }
     const size = poolSize ?? Math.min(8, Math.max(1, os.cpus().length - 1));
+    const subBatchSize = options.subBatchSize ??
+        positiveIntFromEnv('CODRAGRAPH_WORKER_SUB_BATCH_SIZE', DEFAULT_SUB_BATCH_SIZE);
+    const subBatchIdleTimeoutMs = options.subBatchIdleTimeoutMs ??
+        positiveIntFromEnv('CODRAGRAPH_WORKER_IDLE_TIMEOUT_MS', DEFAULT_SUB_BATCH_IDLE_TIMEOUT_MS);
     const workers = [];
     for (let i = 0; i < size; i++) {
         workers.push(new Worker(workerUrl));
@@ -38,41 +52,43 @@ export const createWorkerPool = (workerUrl, poolSize) => {
             const worker = workers[i];
             return new Promise((resolve, reject) => {
                 let settled = false;
-                let subBatchTimer = null;
+                let workerIdleTimer = null;
                 const cleanup = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
+                    if (workerIdleTimer)
+                        clearTimeout(workerIdleTimer);
                     worker.removeListener('message', handler);
                     worker.removeListener('error', errorHandler);
                     worker.removeListener('exit', exitHandler);
                 };
-                const resetSubBatchTimer = () => {
-                    if (subBatchTimer)
-                        clearTimeout(subBatchTimer);
-                    subBatchTimer = setTimeout(() => {
+                const resetWorkerIdleTimer = () => {
+                    if (workerIdleTimer)
+                        clearTimeout(workerIdleTimer);
+                    workerIdleTimer = setTimeout(() => {
                         if (!settled) {
                             settled = true;
                             cleanup();
-                            reject(new Error(`Worker ${i} sub-batch timed out after ${SUB_BATCH_TIMEOUT_MS / 1000}s (chunk: ${chunk.length} items).`));
+                            reject(new Error(`Worker ${i} was idle for ${subBatchIdleTimeoutMs / 1000}s while waiting for a response (chunk: ${chunk.length} items).`));
                         }
-                    }, SUB_BATCH_TIMEOUT_MS);
+                    }, subBatchIdleTimeoutMs);
                 };
                 let subBatchIdx = 0;
                 const sendNextSubBatch = () => {
-                    const start = subBatchIdx * SUB_BATCH_SIZE;
+                    const start = subBatchIdx * subBatchSize;
                     if (start >= chunk.length) {
+                        resetWorkerIdleTimer();
                         worker.postMessage({ type: 'flush' });
                         return;
                     }
-                    const subBatch = chunk.slice(start, start + SUB_BATCH_SIZE);
+                    const subBatch = chunk.slice(start, start + subBatchSize);
                     subBatchIdx++;
-                    resetSubBatchTimer();
+                    resetWorkerIdleTimer();
                     worker.postMessage({ type: 'sub-batch', files: subBatch });
                 };
                 const handler = (msg) => {
                     if (settled)
                         return;
                     if (msg.type === 'progress') {
+                        resetWorkerIdleTimer();
                         workerProgress[i] = msg.filesProcessed;
                         if (onProgress) {
                             const total = workerProgress.reduce((a, b) => a + b, 0);

package/dist/core/run-analyze.js

@@ -144,8 +144,10 @@ export const changedPathAffectsGraph = (change) => {
     const paths = [change.path, change.previousPath].filter((p) => Boolean(p));
     if (paths.some(isGraphContentPath))
         return true;
-    // Add/delete/rename/copy can change File/Folder structure even when content
-    // is not parsed. Ignored or generated-agent paths are outside the index.
+    // Add/delete/rename/copy affect the graph's File/Folder topology even when
+    // the path is not source code. Ignore only generated agent context and
+    // configured ignored paths; staying conservative here prevents stale file
+    // and documentation surfaces after path-only commits.
     if (statusCode === 'A' || statusCode === 'D' || statusCode === 'R' || statusCode === 'C') {
         return paths.some((p) => !isGeneratedAgentContextPath(p) && !shouldIgnorePath(p));
     }
@@ -176,6 +178,14 @@ const buildReusedMeta = (existingMeta, repoPath, currentCommit) => ({
     schemaVersion: INDEX_SCHEMA_VERSION,
     remoteUrl: hasGitDir(repoPath) ? getRemoteUrl(repoPath) : existingMeta.remoteUrl,
 });
+const metaStatsForAIContext = (stats = {}) => ({
+    files: stats.files,
+    nodes: stats.nodes,
+    edges: stats.edges,
+    communities: stats.communities,
+    clusters: stats.featureClusters,
+    processes: stats.processes,
+});
 const pathExists = async (targetPath) => {
     try {
         await fs.stat(targetPath);
@@ -297,8 +307,15 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
         existingMeta.lastCommit === currentCommit) {
         // Non-git folders have currentCommit = '' — always rebuild since we can't detect changes
         if (currentCommit !== '') {
+            const repoName = options.registryName ?? getInferredRepoName(repoPath) ?? path.basename(repoPath);
+            try {
+                await generateAIContextFiles(repoPath, storagePath, repoName, metaStatsForAIContext(existingMeta.stats), undefined, { skipAgentsMd: options.skipAgentsMd, noStats: options.noStats });
+            }
+            catch {
+                // Best-effort only.
+            }
             return {
-                repoName: options.registryName ?? getInferredRepoName(repoPath) ?? path.basename(repoPath),
+                repoName,
                 repoPath,
                 stats: existingMeta.stats ?? {},
                 alreadyUpToDate: true,
@@ -327,8 +344,14 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
                 if (hasGitDir(repoPath)) {
                     await addToGitignore(repoPath);
                 }
+                try {
+                    await generateAIContextFiles(repoPath, storagePath, projectName, metaStatsForAIContext(reusedMeta.stats), undefined, { skipAgentsMd: options.skipAgentsMd, noStats: options.noStats });
+                }
+                catch {
+                    // Best-effort only.
+                }
                 const reuseReason = `Smart analyze reused the existing graph; ${changedPaths.length} changed ` +
-                    `file(s) did not affect indexed code, docs, config, or file structure.`;
+                    `file(s) did not affect indexed graph inputs.`;
                 log(reuseReason);
                 progress('done', 100, 'Existing graph reused');
                 return {
@@ -342,7 +365,7 @@ export async function runFullAnalysis(repoPath, options, callbacks) {
             }
             const preview = graphRelevantChanges.slice(0, 5).map(formatChangeForLog).join(', ');
             const suffix = graphRelevantChanges.length > 5 ? ', ...' : '';
-            log(`Smart analyze: ${graphRelevantChanges.length} indexed change(s) require rebuild` +
+            log(`Smart analyze: ${graphRelevantChanges.length} indexed graph input change(s) require rebuild` +
                 (preview ? ` (${preview}${suffix})` : '') +
                 '.');
         }

package/dist/core/search/bm25-index.d.ts

@@ -16,17 +16,6 @@ export interface BM25SearchResult {
     rank: number;
     nodeIds?: string[];
 }
-/**
- * Drop all ensured-FTS cache entries for a given repoId.
- *
- * Called from the pool-close listener so that a pool teardown / recreation
- * forces the next `searchFTSFromCgdb` call to re-issue `CREATE_FTS_INDEX`
- * against the fresh connection rather than trust stale ensure-state from a
- * previous pool lifetime.
- *
- * Exported for tests; the listener wiring is internal.
- */
-export declare function invalidateEnsuredFTSForRepo(repoId: string): void;
 /**
  * Search using LadybugDB's built-in FTS (always fresh, reads from disk)
  *