ultracode 5.3.0 → 5.5.0

package/dist/chunks/dev-agent-Y5G5WKQ4.js

@@ -0,0 +1,1624 @@
+import { ResourceAdjustmentMixin } from './chunk-C67F6XKY.js';
+import { IndexerAgent } from './chunk-RGP5UVQ7.js';
+import { ParserAgent } from './chunk-W6VROAWQ.js';
+import './chunk-45GHQ2BB.js';
+import './chunk-75SF43YH.js';
+import { init_file_extensions, collectFilesAsync, isCodeExtension, isDataExtension } from './chunk-4GYRHAKO.js';
+export { ALL_SUPPORTED_EXTENSIONS } from './chunk-4GYRHAKO.js';
+import { buildWorkerEmbeddingConfig } from './chunk-5B7AKUHU.js';
+import { createHeuristicEntities } from './chunk-UMSHK3G6.js';
+import { getCurrentIndexingDirectory, setCurrentIndexingDirectory } from './chunk-YRTAJKB7.js';
+import './chunk-KMXE2SJJ.js';
+import { knowledgeBus } from './chunk-JPI46FLQ.js';
+import { BaseAgent } from './chunk-IGUCJL3R.js';
+import { findSolutionFile, ensureRoslynStarted } from './chunk-VFR33VOA.js';
+import { setGlobalProjectContext, getGraphStorage } from './chunk-XFGXM4CR.js';
+import './chunk-HNDYLCWI.js';
+import './chunk-CTXFPNDA.js';
+import './chunk-TJSOOFXA.js';
+import './chunk-AIZUHUK6.js';
+import './chunk-L2X4HRXI.js';
+import { init_storage_paths, getCurrentGitBranch } from './chunk-ZD54CMKT.js';
+import { init_fast_hash, hashText } from './chunk-HEMJHRHZ.js';
+import './chunk-5WKPA33T.js';
+import './chunk-TUSYCUU6.js';
+import { tryGarbageCollect } from './chunk-IMQ6WSJV.js';
+import './chunk-GMVGCSNU.js';
+import { init_yaml_config, ConfigLoader, getConfig } from './chunk-XV6GNSLC.js';
+import './chunk-F7CKCMXI.js';
+import './chunk-BMHPPH2B.js';
+import { init_logging, log } from './chunk-VCCBEJQ5.js';
+import './chunk-UN27MREV.js';
+import './chunk-NAQKA54E.js';
+import { statSync, readFileSync, existsSync } from 'fs';
+import { cpus } from 'os';
+import { extname, basename, dirname } from 'path';
+
+init_yaml_config();
+init_logging();
+init_storage_paths();
+init_fast_hash();
+
+// src/agents/dev/incremental-indexer.ts
+init_logging();
+var SUPPORTED_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".mjs",
+  ".cjs",
+  ".py",
+  ".go",
+  ".rs",
+  ".java",
+  ".kt",
+  ".kts",
+  ".cs",
+  ".csx",
+  ".c",
+  ".cpp",
+  ".cc",
+  ".cxx",
+  ".h",
+  ".hpp",
+  ".swift",
+  ".tpl"
+];
+function separateFilesBySupport(files) {
+  const supportedFiles = [];
+  const otherFiles = [];
+  for (const file of files) {
+    const ext = extname(file).toLowerCase();
+    if (SUPPORTED_EXTENSIONS.includes(ext)) {
+      supportedFiles.push(file);
+    } else {
+      otherFiles.push(file);
+    }
+  }
+  log.i("DEVAGENT", "reindex_breakdown", {
+    supported: supportedFiles.length,
+    heuristic: otherFiles.length,
+    supportedSample: supportedFiles.slice(0, 3).map((f) => {
+      const parts = f.split(/[\\/]/);
+      return parts[parts.length - 1];
+    })
+  });
+  return {
+    supportedFiles,
+    otherFiles
+  };
+}
+
+// src/agents/dev/index.ts
+init_file_extensions();
+
+// src/agents/dev-agent.ts
+var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+function getDevAgentConfig() {
+  const config = getConfig();
+  return {
+    maxConcurrency: config.devAgent?.maxConcurrency ?? 3,
+    memoryLimit: config.devAgent?.memoryLimit ?? 256,
+    priority: config.devAgent?.priority ?? 7
+  };
+}
+var DevAgent = class extends BaseAgent {
+  parserAgent = null;
+  indexerAgent = null;
+  indexBatchSize;
+  defaultBatchSize;
+  defaultMaxConcurrency;
+  defaultMemoryLimit;
+  resourceMixin = new ResourceAdjustmentMixin();
+  // Mutex: serialize indexing tasks to prevent concurrent setProjectContext corruption
+  indexingLock = Promise.resolve();
+  constructor(_agentId) {
+    const agentConfig = getDevAgentConfig();
+    super("dev" /* DEV */, {
+      maxConcurrency: agentConfig.maxConcurrency,
+      memoryLimit: agentConfig.memoryLimit,
+      priority: agentConfig.priority
+    });
+    this.defaultMaxConcurrency = this.capabilities.maxConcurrency;
+    this.defaultMemoryLimit = this.capabilities.memoryLimit;
+    this.defaultBatchSize = 100;
+    this.indexBatchSize = this.defaultBatchSize;
+  }
+  /**
+   * Get the IndexerAgent instance.
+   * Used by metrics handlers to access watcher status.
+   */
+  getIndexerAgent() {
+    return this.indexerAgent;
+  }
+  async onInitialize() {
+    try {
+      const configLoader = ConfigLoader.getInstance();
+      this.defaultBatchSize = configLoader.getDevIndexBatchSize();
+      this.indexBatchSize = this.defaultBatchSize;
+      const useParser = configLoader.shouldUseParser();
+      if (useParser) {
+        try {
+          this.parserAgent = new ParserAgent();
+          await this.parserAgent.initialize();
+          log.i("DEVAGENT", "parser_init_ok");
+        } catch (e) {
+          log.w("DEVAGENT", "parser_unavail", { err: String(e) });
+          this.parserAgent = null;
+        }
+      }
+      const currentDir = getCurrentIndexingDirectory() || process.cwd();
+      log.i("DEVAGENT", "indexer_ctx", { dir: currentDir });
+      this.indexerAgent = new IndexerAgent();
+      await this.indexerAgent.initialize();
+      const branch = getCurrentGitBranch(currentDir);
+      setGlobalProjectContext(currentDir, branch);
+      log.i("DEVAGENT", "global_ctx_set", { dir: currentDir, branch });
+      log.i("DEVAGENT", "indexer_init_ok");
+      this.tryEagerRoslynStart(currentDir);
+    } catch (error) {
+      log.e("DEVAGENT", "subagent_init_fail", { err: String(error) });
+      throw error;
+    }
+    knowledgeBus.subscribe(this.id, "task:implementation", async (entry) => {
+      const data = entry.data;
+      if (data.targetAgent === "dev-agent") {
+        const task = {
+          id: data.taskId,
+          type: "implementation",
+          priority: data.priority || 5,
+          payload: data,
+          createdAt: Date.now()
+        };
+        await this.process(task);
+      }
+    });
+    knowledgeBus.subscribe(this.id, "resources:adjusted", (entry) => this.handleResourceAdjustment(entry));
+    knowledgeBus.subscribe(this.id, "indexer:files:changed", async (entry) => {
+      const data = entry.data;
+      if (data.files && data.files.length > 0 && data.source?.startsWith("git-watcher")) {
+        log.d("DEVAGENT", "file_change_evt", { cnt: data.files.length, src: data.source });
+        await this.handleIncrementalReindex(data.files, data.repositoryPath);
+      }
+    });
+    log.i("DEVAGENT", "init_ready");
+  }
+  canProcessTask(task) {
+    return task.type === "index" || task.type === "implementation" || task.type === "refactor" || task.type === "dev" || task.type === "parse";
+  }
+  async handleMessage(message) {
+    log.d("DEVAGENT", "recv_msg", { from: message.from, type: message.type });
+  }
+  async processTask(task) {
+    log.d("DEVAGENT", "proc_task", { id: task.id, type: task.type });
+    try {
+      switch (task.type) {
+        case "index":
+          return await this.handleIndexTask(task);
+        case "implementation":
+          return await this.handleImplementationTask(task);
+        case "refactor":
+          return await this.handleRefactorTask(task);
+        case "parse":
+          return await this.handleParseTask(task);
+        default:
+          return await this.delegateTask(task);
+      }
+    } catch (error) {
+      log.e("DEVAGENT", "task_error", { err: String(error) });
+      throw error;
+    }
+  }
+  async handleIndexTask(task) {
+    const prevLock = this.indexingLock;
+    let releaseLock;
+    this.indexingLock = new Promise((resolve) => {
+      releaseLock = resolve;
+    });
+    await prevLock;
+    const payload = task.payload;
+    log.i("DEVAGENT", "index_start", { dir: payload.directory });
+    try {
+      if (!this.indexerAgent) {
+        throw new Error("Indexer agent not initialized");
+      }
+      const indexBranch = getCurrentGitBranch(payload.directory);
+      setGlobalProjectContext(payload.directory, indexBranch);
+      this.indexerAgent.setProjectContext(payload.directory);
+      setCurrentIndexingDirectory(payload.directory);
+      log.d("DEVAGENT", "set_ctx", { dir: payload.directory, branch: indexBranch });
+      const result = {
+        status: "started",
+        directory: payload.directory,
+        incremental: payload.incremental || false,
+        excludePatterns: payload.excludePatterns || [],
+        batchMode: payload.batchMode || false,
+        timestamp: Date.now(),
+        filesProcessed: 0,
+        entitiesExtracted: 0,
+        relationshipsCreated: 0
+      };
+      knowledgeBus.publish("indexing:started", result, this.id);
+      const indexingResult = await this.performRealIndexing(payload);
+      return {
+        ...result,
+        ...indexingResult,
+        status: "completed",
+        message: `Real indexing completed for ${payload.directory}`
+      };
+    } finally {
+      releaseLock();
+    }
+  }
+  async handleImplementationTask(task) {
+    const payload = task.payload;
+    log.i("DEVAGENT", "impl_start", { desc: payload.description || "task" });
+    return {
+      status: "completed",
+      taskId: task.id,
+      implementation: {
+        description: payload.description,
+        targetAgent: "dev-agent",
+        completed: true,
+        timestamp: Date.now()
+      }
+    };
+  }
+  async handleRefactorTask(task) {
+    const payload = task.payload;
+    log.i("DEVAGENT", "refactor_start", { target: payload.target || "code" });
+    return {
+      status: "completed",
+      taskId: task.id,
+      refactoring: {
+        target: payload.target,
+        suggestions: [],
+        completed: true,
+        timestamp: Date.now()
+      }
+    };
+  }
+  /**
+   * Handle parse task - parse a single file and return entities
+   */
+  async handleParseTask(task) {
+    const payload = task.payload;
+    const filePath = payload.filePath;
+    if (!filePath) {
+      throw new Error("Parse task requires filePath in payload");
+    }
+    log.d("DEVAGENT", "parse_file", { file: filePath });
+    if (!this.parserAgent) {
+      log.w("DEVAGENT", "parser_unavail_empty");
+      return {
+        filePath,
+        entities: [],
+        relationships: [],
+        error: "Parser not initialized",
+        timestamp: Date.now()
+      };
+    }
+    try {
+      const result = await this.parserAgent.parseFile(filePath, {});
+      log.d("DEVAGENT", "parsed_ok", { file: filePath, cnt: result.entities?.length || 0 });
+      return {
+        filePath,
+        entities: result.entities || [],
+        relationships: result.relationships || [],
+        timestamp: Date.now()
+      };
+    } catch (error) {
+      log.e("DEVAGENT", "parse_err", { file: filePath, err: String(error) });
+      return {
+        filePath,
+        entities: [],
+        relationships: [],
+        error: String(error),
+        timestamp: Date.now()
+      };
+    }
+  }
+  async delegateTask(task) {
+    log.d("DEVAGENT", "delegate_task", { id: task.id });
+    return {
+      status: "delegated",
+      taskId: task.id,
+      message: `Task ${task.id} delegated for processing`,
+      timestamp: Date.now()
+    };
+  }
+  /**
+   * Compare mtime of files against stored index to compute changed/new/deleted sets.
+   * Deletes entities and file info for changed/deleted files in preparation for re-indexing.
+   */
+  async prepareIncrementalDiff(allFiles, totalCollected) {
+    const storage = await getGraphStorage();
+    const indexedFiles = await storage.getAllIndexedFiles();
+    const deletedEntityIds = [];
+    if (indexedFiles.size === 0) {
+      return { filesToProcess: allFiles, deletedEntityIds, earlyReturn: null };
+    }
+    const changedFiles = [];
+    const newFiles = [];
+    const deletedFiles = [];
+    for (const file of allFiles) {
+      const normalizedPath = file.replace(/\\/g, "/");
+      const lastIndexed = indexedFiles.get(normalizedPath);
+      if (lastIndexed === void 0) {
+        newFiles.push(file);
+      } else {
+        try {
+          const stats = statSync(file);
+          const mtime = stats.mtimeMs;
+          if (mtime > lastIndexed) {
+            changedFiles.push(file);
+          }
+        } catch {
+        }
+      }
+    }
+    const currentFilesSet = new Set(allFiles.map((f) => f.replace(/\\/g, "/")));
+    for (const [indexedPath] of indexedFiles) {
+      if (!currentFilesSet.has(indexedPath)) {
+        deletedFiles.push(indexedPath);
+      }
+    }
+    if (deletedFiles.length > 0) {
+      log.i("DEVAGENT", "Invalidating deleted files", { deleted: deletedFiles.length });
+      for (const file of deletedFiles) {
+        try {
+          const ids = await storage.deleteEntitiesByFilePath(file);
+          deletedEntityIds.push(...ids);
+          await storage.deleteFileInfo(file);
+        } catch (error) {
+          log.w("DEVAGENT", "Failed to invalidate file", {
+            file,
+            error: error.message
+          });
+        }
+      }
+    }
+    for (const file of changedFiles) {
+      try {
+        await storage.deleteFileInfo(file);
+      } catch {
+      }
+    }
+    const filesToProcess = [...changedFiles, ...newFiles];
+    log.i("DEVAGENT", "Smart incremental", {
+      total: totalCollected,
+      changed: changedFiles.length,
+      new: newFiles.length,
+      deleted: deletedFiles.length,
+      toProcess: filesToProcess.length,
+      entitiesDeleted: deletedEntityIds.length
+    });
+    if (filesToProcess.length === 0) {
+      return {
+        filesToProcess: [],
+        deletedEntityIds,
+        earlyReturn: {
+          filesProcessed: 0,
+          entitiesExtracted: 0,
+          relationshipsCreated: 0,
+          incrementalStats: {
+            changedFiles: 0,
+            newFiles: 0,
+            deletedFiles: deletedFiles.length,
+            skippedFiles: totalCollected,
+            deletedEntities: deletedEntityIds.length
+          }
+        }
+      };
+    }
+    return { filesToProcess, deletedEntityIds, earlyReturn: null };
+  }
+  /**
+   * Initialize the embedding pipeline: select provider (TEI/OVMS/llamacpp/vLLM),
+   * start llama-server if needed, create centralized EmbeddingGenerator.
+   */
+  async initEmbeddingPipeline(embeddingConfig, _payload) {
+    if (embeddingConfig.provider === "llamacpp") {
+      const { llamacppEmbeddingManager } = await import('./llamacpp-server-manager-HTLX6C5P.js');
+      const { loadSemanticConfig, getDataDir } = await import('./config-paths-Y2IHHJQF.js');
+      const { existsSync: existsSync2, readdirSync } = await import('fs');
+      const { join } = await import('path');
+      const semanticConfig = loadSemanticConfig();
+      const llamacppConfig = semanticConfig?.embedding?.llamacpp;
+      if (llamacppConfig && !llamacppEmbeddingManager.getState().isRunning) {
+        const dataDir = getDataDir();
+        const searchPaths = [
+          join(dataDir, "hf-cache", "multilingual-e5-base-Q8_0.gguf"),
+          join(dataDir, "llamacpp", "models", "multilingual-e5-base-Q8_0.gguf"),
+          join(dataDir, "models", "multilingual-e5-base-Q8_0.gguf")
+        ];
+        let modelPath = null;
+        for (const p of searchPaths) {
+          if (existsSync2(p)) {
+            modelPath = p;
+            break;
+          }
+        }
+        if (!modelPath) {
+          const hfCache = join(dataDir, "hf-cache");
+          if (existsSync2(hfCache)) {
+            try {
+              const files = readdirSync(hfCache);
+              const gguf = files.find((f) => f.endsWith(".gguf"));
+              if (gguf) modelPath = join(hfCache, gguf);
+            } catch {
+            }
+          }
+        }
+        if (modelPath) {
+          log.i("DEVAGENT", "Starting llama-server for workers...", { port: 8085, model: modelPath });
+          const started = await llamacppEmbeddingManager.ensureRunning({
+            modelPath,
+            mode: "embedding",
+            port: 8085,
+            contextSize: llamacppConfig.context_size || 512,
+            nGpuLayers: llamacppConfig.n_gpu_layers ?? 99
+          });
+          if (started) {
+            log.i("DEVAGENT", "llama-server ready for workers");
+          } else {
+            log.w("DEVAGENT", "llama-server start failed - embeddings may not work");
+          }
+        }
+      }
+    }
+    if (embeddingConfig.centralizedEmbeddings && this.parserAgent) {
+      try {
+        const { EmbeddingGenerator } = await import('./embedding-generator-XR6FDO4J.js');
+        const { buildEmbeddingGeneratorOptions } = await import('./provider-config-67EQAZ5Z.js');
+        const { loadSemanticConfig } = await import('./config-paths-Y2IHHJQF.js');
+        const { getConfig: getConfig2 } = await import('./yaml-config-OVNUY25R.js');
+        const semanticConfig = loadSemanticConfig();
+        const yamlConfig = getConfig2();
+        const generatorOptions = buildEmbeddingGeneratorOptions(
+          embeddingConfig.provider,
+          embeddingConfig.modelName,
+          embeddingConfig.batchSize,
+          semanticConfig,
+          yamlConfig
+        );
+        const embeddingGenerator = new EmbeddingGenerator(generatorOptions);
+        const initTimeoutMs = 9e4;
+        try {
+          await Promise.race([
+            embeddingGenerator.initialize(),
+            new Promise(
+              (_, reject) => setTimeout(() => reject(new Error(`TEI init timeout after ${initTimeoutMs}ms`)), initTimeoutMs)
+            )
+          ]);
+        } catch (initErr) {
+          log.w(
+            "DEVAGENT",
+            "Centralized EmbeddingGenerator init timeout/fail, indexing will proceed without embeddings",
+            {
+              err: initErr.message
+            }
+          );
+        }
+        await this.parserAgent.setEmbeddingGenerator(embeddingGenerator);
+        log.i("DEVAGENT", "Centralized EmbeddingGenerator configured", {
+          provider: embeddingConfig.provider,
+          model: embeddingConfig.modelName
+        });
+      } catch (error) {
+        log.e("DEVAGENT", "Failed to initialize centralized EmbeddingGenerator", {
+          error: error.message
+        });
+      }
+    }
+  }
+  /**
+   * Initialize the vector provider (LayeredFaiss or Faiss) and configure it
+   * on the parser agent. Removes old embeddings for deleted entities in incremental mode.
+   */
+  async initVectorProvider(payload, deletedEntityIds) {
+    if (!this.parserAgent) return;
+    const { getProjectHash, getCurrentGitBranchOrDefault } = await import('./storage-paths-NGF6GAFZ.js');
+    const configLoader = ConfigLoader.getInstance();
+    const embConfig = configLoader.getEmbeddingConfig();
+    const useLayeredIndex = embConfig.useLayeredIndex;
+    const projectHash = getProjectHash(payload.directory);
+    const currentBranch = getCurrentGitBranchOrDefault(payload.directory);
+    let vectorProvider = null;
+    try {
+      if (useLayeredIndex) {
+        const { getLayeredFaissProvider } = await import('./layered-faiss-provider-M3MDI2AG.js');
+        const provider = getLayeredFaissProvider();
+        if ("initialize" in provider && typeof provider.initialize === "function") {
+          log.d("DEVAGENT", "Initializing LayeredFaissProvider", {
+            dir: payload.directory,
+            projectHash,
+            branch: currentBranch
+          });
+          await provider.initialize(payload.directory, projectHash, currentBranch);
+        }
+        vectorProvider = provider;
+      } else {
+        const { initializeFaissProvider } = await import('./faiss-provider-VAYK2VBT.js');
+        const provider = await initializeFaissProvider();
+        if (provider) {
+          await provider.setProjectContext(projectHash, currentBranch);
+          vectorProvider = provider;
+        }
+      }
+    } catch (e) {
+      log.w("DEVAGENT", "Failed to get vector provider", { error: String(e) });
+    }
+    if (vectorProvider) {
+      log.d("DEVAGENT", "vector_provider_branch", {
+        branch: currentBranch,
+        layered: useLayeredIndex
+      });
+      this.parserAgent.setVectorProvider(vectorProvider);
+      log.i("DEVAGENT", "Vector provider configured", {
+        projectHash,
+        dir: payload.directory,
+        layered: useLayeredIndex
+      });
+      if (deletedEntityIds.length > 0) {
+        try {
+          const embeddingIds = deletedEntityIds.map((id) => id.startsWith("ent:") ? id : `ent:${id}`);
+          await vectorProvider.remove(embeddingIds);
+          log.i("DEVAGENT", "Removed embeddings for changed/deleted files", {
+            count: embeddingIds.length
+          });
+        } catch (error) {
+          log.w("DEVAGENT", "Failed to remove embeddings", {
+            error: error.message
+          });
+        }
+      }
+    } else {
+      log.w("DEVAGENT", "Vector provider not available - embeddings will not be saved");
+    }
+  }
+  /**
+   * Flush pending embeddings to FAISS, create Prolly Tree commit,
+   * switch to keepalive mode, run GC.
+   */
+  async postIndexingCleanup(_codeFiles, filesProcessed, totalEntities, perfStart, perfTimings, _effectiveBatchSize, _dataFiles) {
+    perfTimings["embFlush_start"] = Date.now() - perfStart;
+    perfTimings["commit_start"] = Date.now() - perfStart;
+    const faissFlushPromise = (async () => {
+      if (!this.parserAgent) return;
+      const accumulator = this.parserAgent.getAccumulator();
+      if (!accumulator) return;
+      const pendingCount = accumulator.getPendingCount();
+      if (pendingCount > 0) {
+        log.i("DEVAGENT", "Flushing pending embeddings to FAISS", { pending: pendingCount });
+        try {
+          const flushed = await accumulator.flush();
+          log.i("DEVAGENT", "Embeddings flushed to FAISS", { flushed });
+        } catch (err) {
+          log.e("DEVAGENT", "Failed to flush embeddings", { error: err.message });
+        }
+      }
+      const stats = accumulator.getStats();
+      log.i("DEVAGENT", "Embedding accumulator stats", {
+        accumulated: stats.accumulated,
+        flushed: stats.flushed,
+        flushCount: stats.flushCount,
+        totalBytes: stats.totalBytes
+      });
+    })();
+    const graphCommitPromise = (async () => {
+      try {
+        const storage = await getGraphStorage();
+        const adapter = storage.getLibSQLAdapter?.();
+        if (adapter?.createGraphCommit) {
+          const commitHash = await adapter.createGraphCommit(`Index: ${filesProcessed} files`);
+          if (commitHash) {
+            log.i("DEVAGENT", "graph_commit_created", {
+              commit: commitHash.slice(0, 8),
+              files: filesProcessed,
+              entities: totalEntities
+            });
+          }
+          adapter.pruneAndGC?.(20)?.catch?.((err) => log.w("DEVAGENT", "prune_gc_fail", { err: String(err) }));
+        }
+      } catch (err) {
+        log.w("DEVAGENT", "graph_commit_failed", { error: err.message });
+      }
+    })();
+    await Promise.all([faissFlushPromise, graphCommitPromise]);
+    perfTimings["embFlush_end"] = Date.now() - perfStart;
+    perfTimings["commit_end"] = Date.now() - perfStart;
+    perfTimings["keepalive_start"] = Date.now() - perfStart;
+    if (this.parserAgent) {
+      try {
+        const memoryBeforeMB = this.parserAgent.getTotalMemoryMB();
+        log.i("DEVAGENT", "Switching to keepalive mode (spawning ONE worker for incremental updates)", {
+          memoryMB: memoryBeforeMB
+        });
+        await this.parserAgent.enableKeepaliveMode();
+        const memoryAfterMB = this.parserAgent.getTotalMemoryMB();
+        log.i("DEVAGENT", "Keepalive mode enabled, ready for incremental updates", {
+          memoryBeforeMB,
+          memoryAfterMB
+        });
+        log.flush();
+      } catch (err) {
+        log.w("DEVAGENT", "Failed to enable keepalive mode, falling back to shutdown", {
+          error: err.message
+        });
+        try {
+          await this.parserAgent.shutdown();
+          this.parserAgent = null;
+        } catch {
+        }
+      }
+    }
+    perfTimings["keepalive_end"] = Date.now() - perfStart;
+    if (tryGarbageCollect(true)) {
+      log.i("DEVAGENT", "gc_after_index");
+    }
+  }
+  /**
+   * Format 15+ timing measurements into a structured performance summary log.
+   */
+  buildPerfSummary(perfTimings, _codeFiles, _dataFiles, _filesProcessed, _totalEntities, _totalRelationships, _effectiveBatchSize, perfStart) {
+    perfTimings["total"] = Date.now() - perfStart;
+    log.i("DEVAGENT", "PERF_SUMMARY", {
+      collectFiles: (perfTimings["collectFiles_end"] ?? 0) - (perfTimings["collectFiles_start"] ?? 0),
+      destroyPools: (perfTimings["destroyPools_end"] ?? 0) - (perfTimings["destroyPools_start"] ?? 0),
+      preSpawn: (perfTimings["preSpawn_end"] ?? 0) - (perfTimings["preSpawn_start"] ?? 0),
+      parsing: (perfTimings["parsing_end"] ?? 0) - (perfTimings["parsing_start"] ?? 0),
+      flush: (perfTimings["flush_end"] ?? 0) - (perfTimings["flush_start"] ?? 0),
+      dataFiles: (perfTimings["dataFiles_end"] ?? 0) - (perfTimings["dataFiles_start"] ?? 0),
+      swaggerLink: (perfTimings["swaggerLink_end"] ?? 0) - (perfTimings["swaggerLink_start"] ?? 0),
+      embFlush: (perfTimings["embFlush_end"] ?? 0) - (perfTimings["embFlush_start"] ?? 0),
+      keepalive: (perfTimings["keepalive_end"] ?? 0) - (perfTimings["keepalive_start"] ?? 0),
+      total: perfTimings["total"]
+    });
+  }
+  async performRealIndexing(payload) {
+    const directory = payload.directory;
+    const excludePatterns = payload.excludePatterns || [];
+    const perfStart = Date.now();
+    const perfTimings = {};
+    log.i("DEVAGENT", "Starting indexing", {
+      directory,
+      excludePatternsCount: excludePatterns.length,
+      samplePatterns: excludePatterns.slice(0, 5)
+    });
+    const isIncremental = payload.incremental === true;
+    perfTimings["collectFiles_start"] = Date.now() - perfStart;
+    const collectPromise = collectFilesAsync(directory, { excludePatterns, agentId: this.id });
+    let preSpawnPreparePromise = null;
+    if (!isIncremental && this.parserAgent) {
+      perfTimings["preSpawnPrepare_start"] = Date.now() - perfStart;
+      preSpawnPreparePromise = (async () => {
+        log.i("DEVAGENT", "Destroying existing worker pools for full reindex (parallel with collectFiles)");
+        await this.parserAgent.destroyWorkerPools();
+        await this.parserAgent.setPoolMode("per-language");
+        const embeddingConfig2 = buildWorkerEmbeddingConfig();
+        if (embeddingConfig2) {
+          this.parserAgent.setEmbeddingConfig(embeddingConfig2);
+          log.i("DEVAGENT", "Embedding config passed to parser", {
+            provider: embeddingConfig2.provider,
+            model: embeddingConfig2.modelName
+          });
+        }
+        return { embeddingConfig: embeddingConfig2 };
+      })();
+    }
+    const collectResult = await collectPromise;
+    let allFiles = collectResult.files;
+    perfTimings["collectFiles_end"] = Date.now() - perfStart;
+    log.i("DEVAGENT", "Files collected", {
+      count: allFiles.length,
+      ms: perfTimings["collectFiles_end"] - perfTimings["collectFiles_start"]
+    });
+    let preSpawnPrepareResult = null;
+    if (preSpawnPreparePromise) {
+      preSpawnPrepareResult = await preSpawnPreparePromise;
+      perfTimings["preSpawnPrepare_end"] = Date.now() - perfStart;
+      log.i("DEVAGENT", "PreSpawn preparation done (parallel)", {
+        ms: perfTimings["preSpawnPrepare_end"] - perfTimings["preSpawnPrepare_start"]
+      });
+    }
+    let deletedEntityIds = [];
+    if (isIncremental && allFiles.length > 0) {
+      const diff = await this.prepareIncrementalDiff(allFiles, collectResult.files.length);
+      deletedEntityIds = diff.deletedEntityIds;
+      if (diff.earlyReturn) {
+        log.i("DEVAGENT", "No files changed, skipping indexing");
+        return diff.earlyReturn;
+      }
+      allFiles = diff.filesToProcess;
+    }
+    const codeFiles = [];
+    const dataFiles = [];
+    for (const file of allFiles) {
+      const ext = extname(file).toLowerCase();
+      if (isCodeExtension(ext)) {
+        codeFiles.push(file);
+      } else {
+        dataFiles.push(file);
+      }
+    }
+    log.i("DEVAGENT", "Files separated", {
+      codeFiles: codeFiles.length,
+      dataFiles: dataFiles.length
+    });
+    const isDebugMode = process.env["MCP_DEBUG_MODE"] === "1";
+    const effectiveBatchSize = Infinity;
+    log.i("DEVAGENT", "parser_batch", { files: codeFiles.length });
+    const parseOptions = isDebugMode ? {
+      batchSize: Math.max(1, Math.min(3, effectiveBatchSize)),
+      useCache: false
+    } : {};
+    let totalEntities = 0;
+    let totalRelationships = 0;
+    let filesProcessed = 0;
+    const initialIndexerStats = this.indexerAgent?.getIndexingStats() ?? {
+      entitiesIndexed: 0,
+      relationshipsCreated: 0};
+    let preSpawnPromise = null;
+    if (this.parserAgent) {
+      if (isIncremental) {
+        await this.parserAgent.setPoolMode("universal");
+        log.i("DEVAGENT", "Pool mode configured", { mode: "universal", isIncremental });
+      } else {
+        log.i("DEVAGENT", "Pool mode configured", { mode: "per-language", isIncremental });
+      }
+    }
+    const embeddingConfig = preSpawnPrepareResult?.embeddingConfig ?? buildWorkerEmbeddingConfig();
+    if (this.parserAgent && embeddingConfig) {
+      if (isIncremental) {
+        this.parserAgent.setEmbeddingConfig(embeddingConfig);
+        log.i("DEVAGENT", "Embedding config passed to parser", {
+          provider: embeddingConfig.provider,
+          model: embeddingConfig.modelName
+        });
+      }
+      const pipelinePromise = this.initEmbeddingPipeline(embeddingConfig, payload);
+      if (this.parserAgent) {
+        this.parserAgent.setStreamingMode(true);
+      }
+      if (!isIncremental && codeFiles.length > 0) {
+        perfTimings["preSpawn_start"] = Date.now() - perfStart;
+        preSpawnPromise = this.parserAgent.preSpawnPools(codeFiles);
+      }
+      await pipelinePromise;
+      await this.initVectorProvider(payload, deletedEntityIds);
+    }
+    const streamingIndexedFiles = /* @__PURE__ */ new Set();
+    let totalStreamingQueueMs = 0;
+    let streamingCallbackCount = 0;
+    if (this.parserAgent && this.indexerAgent) {
+      this.parserAgent.setStreamingMode(true, (result, _taskId, _fileIndex, _totalFiles) => {
+        if (!result.filePath || !result.entities || result.entities.length === 0) {
+          return;
+        }
+        streamingIndexedFiles.add(result.filePath);
+        const queueStart = Date.now();
+        this.indexerAgent.queueForIndexing(result.entities, result.filePath, result.relationships || []);
+        totalStreamingQueueMs += Date.now() - queueStart;
+        streamingCallbackCount++;
+      });
+      log.i("DEVAGENT", "Streaming mode enabled (batch accumulator)");
+    }
+    if (preSpawnPromise) {
+      await preSpawnPromise;
+      perfTimings["preSpawn_end"] = Date.now() - perfStart;
+    }
+    perfTimings["parsing_start"] = Date.now() - perfStart;
+    let totalWorkerParseMs = 0;
+    let totalMainProcessMs = 0;
+    let totalMainIndexMs = 0;
+    const files = codeFiles;
+    for (let i = 0; i < files.length; i += effectiveBatchSize) {
+      const batch = files.slice(i, Math.min(i + effectiveBatchSize, files.length));
+      try {
+        if (this.parserAgent) {
+          const batchExtStats = {};
+          for (const f of batch) {
+            const ext = extname(f).toLowerCase() || "(no ext)";
+            batchExtStats[ext] = (batchExtStats[ext] || 0) + 1;
+          }
+          log.i("DEVAGENT", "Sending batch to parser", {
+            batchSize: batch.length,
+            batchIndex: i,
+            extensions: batchExtStats
+          });
+          const parseTask = {
+            id: `parse-${Date.now()}-${i}`,
+            type: "parse:batch",
+            priority: 8,
+            payload: { files: batch, options: parseOptions },
+            createdAt: Date.now()
+          };
+          const parseStart = Date.now();
+          const results = await this.parserAgent.process(parseTask);
+          const parseMs = Date.now() - parseStart;
+          totalWorkerParseMs += parseMs;
+          const processStart = Date.now();
+          log.i("DEVAGENT", "Parser batch completed", {
+            batchSent: batch.length,
+            resultsReceived: results?.length || 0,
+            batchIndex: i,
+            parseMs,
+            filesPerSec: Math.round(batch.length / parseMs * 1e3)
+          });
+          log.flush();
+          let resultsWithFilePath = 0;
+          let resultsWithEntities = 0;
+          let resultsWithEmptyEntities = 0;
+          let totalEntityCount = 0;
+          for (const res of results || []) {
+            if (res?.filePath) resultsWithFilePath++;
+            if (Array.isArray(res?.entities)) {
+              if (res.entities.length > 0) {
+                resultsWithEntities++;
+                totalEntityCount += res.entities.length;
+              } else {
+                resultsWithEmptyEntities++;
+              }
+            }
+          }
+          log.d("DEVAGENT", "batch_parse_analysis", {
+            batch: i,
+            results: results?.length || 0,
+            withPath: resultsWithFilePath,
+            withEnts: resultsWithEntities,
+            empty: resultsWithEmptyEntities,
+            total: totalEntityCount
+          });
+          const byFile = /* @__PURE__ */ new Map();
+          for (const res of results || []) {
+            const fp = res?.filePath;
+            if (!fp) continue;
+            const slot = byFile.get(fp) ?? { entities: [], relationships: [] };
+            if (Array.isArray(res.entities)) {
+              slot.entities.push(...res.entities);
+            }
+            if (Array.isArray(res.relationships)) {
+              for (const r of res.relationships) {
+                if (r?.from && r.to && r.type) {
+                  slot.relationships.push({
+                    from: r.from,
+                    to: r.to,
+                    type: r.type,
+                    targetFile: fp
+                  });
+                }
+              }
+            }
+            byFile.set(fp, slot);
+          }
+          let totalRelationshipsExtracted = 0;
+          let resultsWithRelationships = 0;
+          for (const res of results || []) {
+            if (Array.isArray(res?.relationships) && res.relationships.length > 0) {
+              resultsWithRelationships++;
+              totalRelationshipsExtracted += res.relationships.length;
+            }
+          }
+          log.d("DEVAGENT", "batch_rels", {
+            batch: i,
+            withRels: resultsWithRelationships,
+            total: totalRelationshipsExtracted
+          });
+          log.i("DEVAGENT", "Files ready for indexing", {
+            uniqueFiles: byFile.size,
+            batchIndex: i,
+            totalEntities: totalEntityCount,
+            totalRelationships: totalRelationshipsExtracted
+          });
+          log.d("DEVAGENT", "batch_summary", {
+            batch: i,
+            sent: batch.length,
+            results: results?.length || 0,
+            unique: byFile.size
+          });
+          totalMainProcessMs += Date.now() - processStart;
+          const indexStart = Date.now();
+          const INDEXING_CONCURRENCY = 8;
+          const fileEntries = Array.from(byFile.entries()).filter(([file]) => !streamingIndexedFiles.has(file));
+          if (fileEntries.length > 0) {
+            log.i("DEVAGENT", "Post-batch indexing (non-streamed files)", {
+              total: byFile.size,
+              alreadyStreamed: streamingIndexedFiles.size,
+              remaining: fileEntries.length
+            });
+          }
+          let pendingPromises = [];
+          let pendingCount = 0;
+          for (const [file, group] of fileEntries) {
+            const indexTask = {
+              id: `index-entities-${Date.now()}-${i}-${file}`,
+              type: "index:entities",
+              priority: 7,
+              payload: {
+                entities: group.entities,
+                relationships: group.relationships,
+                filePath: file
+              },
+              createdAt: Date.now()
+            };
+            const promise = (async () => {
+              try {
+                const indexResult = await this.indexerAgent?.enqueue(indexTask);
+                return { result: indexResult, error: null };
+              } catch (err) {
+                log.w("DEVAGENT", "index_file_fail", { file, err: err.message });
+                return { result: null, error: err };
+              }
+            })();
+            pendingPromises.push(promise);
+            pendingCount++;
+            if (pendingCount >= INDEXING_CONCURRENCY) {
+              const results2 = await Promise.all(pendingPromises);
+              for (const { result } of results2) {
+                if (result) {
+                  totalEntities += result.entitiesIndexed || 0;
+                  totalRelationships += result.relationshipsCreated || 0;
+                  filesProcessed += 1;
+                }
+              }
+              pendingPromises = [];
+              pendingCount = 0;
+              await yieldToEventLoop();
+            }
+          }
+          if (pendingPromises.length > 0) {
+            const results2 = await Promise.all(pendingPromises);
+            for (const { result } of results2) {
+              if (result) {
+                totalEntities += result.entitiesIndexed || 0;
+                totalRelationships += result.relationshipsCreated || 0;
+                filesProcessed += 1;
+              }
+            }
+          }
+          totalMainIndexMs += Date.now() - indexStart;
+        } else {
+          const entities = [];
+          const relationships = [];
+          for (const file of batch) {
+            const extWithDot = extname(file).toLowerCase();
+            const fileName = basename(file);
+            const fileNameNoExt = fileName.replace(/\.[^/.]+$/, "");
+            const ext = extWithDot.slice(1) || fileName;
+            const isCode = isCodeExtension(extWithDot);
+            const isData = isDataExtension(extWithDot) || isDataExtension("." + fileName.toLowerCase());
+            if (!isCode && !isData) {
+              continue;
+            }
+            let contentHash;
+            let fileContent;
+            if (isData) {
+              try {
+                fileContent = readFileSync(file, "utf-8");
+                contentHash = hashText(fileContent);
+              } catch {
+              }
+            }
+            entities.push({
+              name: fileName,
+              type: "file",
+              filePath: file,
+              language: ext,
+              // Top-level language for TechnologyDetector
+              location: { start: { line: 1, column: 0, index: 0 }, end: { line: 1, column: 0, index: 0 } },
+              metadata: {
+                language: ext,
+                path: file,
+                isDataFile: isData,
+                contentHash
+                // For semantic merge
+              }
+            });
+            if (isData) {
+              continue;
+            }
+            entities.push({
+              name: fileNameNoExt,
+              type: "module",
+              filePath: file,
+              language: ext,
+              // Top-level language for TechnologyDetector
+              location: { start: { line: 1, column: 0, index: 0 }, end: { line: 100, column: 0, index: 0 } },
+              metadata: { language: ext, moduleType: "file" }
+            });
+            if (ext === "py" && /^[A-Z]/.test(fileNameNoExt)) {
+              entities.push({
+                name: fileNameNoExt,
+                type: "class",
+                filePath: file,
+                language: "python",
+                location: { start: { line: 5, column: 0, index: 0 }, end: { line: 50, column: 0, index: 0 } },
+                metadata: { language: "python", visibility: "public" }
+              });
+            }
+            if ((ext === "kt" || ext === "kts" || ext === "java") && /^[A-Z]/.test(fileNameNoExt)) {
+              entities.push({
+                name: fileNameNoExt,
+                type: "class",
+                filePath: file,
+                language: ext === "java" ? "java" : "kotlin",
+                location: { start: { line: 5, column: 0, index: 0 }, end: { line: 50, column: 0, index: 0 } },
+                metadata: { language: ext, visibility: "public" }
+              });
+            }
+            if ((ext === "js" || ext === "ts") && !file.includes(".test.") && !file.includes(".spec.")) {
+              entities.push({
+                name: `export_default`,
+                type: "function",
+                filePath: file,
+                language: ext === "ts" ? "typescript" : "javascript",
+                location: { start: { line: 10, column: 0, index: 0 }, end: { line: 30, column: 0, index: 0 } },
+                metadata: { language: ext, exported: true }
+              });
+            }
+          }
+          for (const entity of entities) {
+            if (entity.type === "file") {
+              const moduleEntity = entities.find((e) => e.type === "module" && e.filePath === entity.filePath);
+              if (moduleEntity) {
+                relationships.push({
+                  from: entity.name,
+                  to: moduleEntity.name,
+                  type: "contains"
+                });
+              }
+            }
+          }
+          for (const entity of entities) {
+            if (entity.type === "module") {
+              const related = entities.filter(
+                (e) => (e.type === "class" || e.type === "function") && e.filePath === entity.filePath
+              );
+              for (const rel of related) {
+                relationships.push({
+                  from: entity.name,
+                  to: rel.name,
+                  type: rel.type === "class" ? "defines_class" : "defines_function",
+                  sourceFile: entity.filePath
+                });
+              }
+            }
+          }
+          for (const entity of entities) {
+            if (entity.type === "class") {
+              const funcs = entities.filter((e) => e.type === "function" && e.filePath === entity.filePath);
+              for (const f of funcs) {
+                relationships.push({ from: entity.name, to: f.name, type: "has_method", sourceFile: entity.filePath });
+              }
+            }
+          }
+          const byFile = /* @__PURE__ */ new Map();
+          for (const e of entities) {
+            if (!e.filePath) continue;
+            const slot = byFile.get(e.filePath) ?? { entities: [], relationships: [] };
+            slot.entities.push(e);
+            byFile.set(e.filePath, slot);
+          }
+          for (const r of relationships) {
+            const fp = r.sourceFile || null;
+            if (!fp) continue;
+            const slot = byFile.get(fp) ?? { entities: [], relationships: [] };
+            slot.relationships.push({ from: r.from, to: r.to, type: r.type, targetFile: r.targetFile });
+            byFile.set(fp, slot);
+          }
+          for (const [file, group] of byFile.entries()) {
+            if (!group.entities.length) continue;
+            const indexTask = {
+              id: `index-entities-${Date.now()}-${i}-${file}`,
+              type: "index:entities",
+              priority: 7,
+              payload: { entities: group.entities, relationships: group.relationships, filePath: file },
+              createdAt: Date.now()
+            };
+            try {
+              const indexResult = await this.indexerAgent?.process(indexTask);
+              const indexed = indexResult;
+              if (indexed) {
+                totalEntities += indexed.entitiesIndexed || 0;
+                totalRelationships += indexed.relationshipsCreated || 0;
+                filesProcessed += 1;
+              }
+            } catch (err) {
+              log.w("DEVAGENT", "idx_fail", { file, err: String(err) });
+            }
+          }
+        }
+      } catch (error) {
+        log.e("DEVAGENT", "batch_err", {
+          batch: i,
+          cnt: batch.length,
+          err: error instanceof Error ? error.message : String(error)
+        });
+      }
+      if ((i + effectiveBatchSize) % 500 === 0 || i + effectiveBatchSize >= files.length) {
+        log.i("DEVAGENT", "progress", { done: filesProcessed, total: files.length });
+      }
+    }
+    perfTimings["parsing_end"] = Date.now() - perfStart;
+    const totalParsingPhase = (perfTimings["parsing_end"] ?? 0) - (perfTimings["parsing_start"] ?? 0);
+    const estimatedPureWorkerMs = Math.max(0, totalWorkerParseMs - totalStreamingQueueMs);
+    log.i("DEVAGENT", "PARSING_PHASE_BREAKDOWN", {
+      totalMs: totalParsingPhase,
+      workerParseMs: totalWorkerParseMs,
+      streamingQueueMs: totalStreamingQueueMs,
+      streamingCallbacks: streamingCallbackCount,
+      estimatedPureWorkerMs,
+      mainProcessMs: totalMainProcessMs,
+      mainIndexMs: totalMainIndexMs,
+      overheadMs: totalParsingPhase - totalWorkerParseMs - totalMainProcessMs - totalMainIndexMs,
+      pureWorkerPct: totalParsingPhase > 0 ? `${Math.round(estimatedPureWorkerMs / totalParsingPhase * 100)}%` : "0%",
+      streamingPct: totalParsingPhase > 0 ? `${Math.round(totalStreamingQueueMs / totalParsingPhase * 100)}%` : "0%",
+      mainProcessPct: totalParsingPhase > 0 ? `${Math.round(totalMainProcessMs / totalParsingPhase * 100)}%` : "0%",
+      mainIndexPct: totalParsingPhase > 0 ? `${Math.round(totalMainIndexMs / totalParsingPhase * 100)}%` : "0%"
+    });
+    if (this.parserAgent) {
+      this.parserAgent.setStreamingMode(false);
+    }
+    perfTimings["flush_start"] = Date.now() - perfStart;
+    let streamingEntities = 0;
+    let streamingRelationships = 0;
+    if (this.indexerAgent) {
+      const pendingStats = this.indexerAgent.getPendingBatchStats();
+      if (pendingStats.files > 0) {
+        log.i("DEVAGENT", "Flushing remaining batch accumulator", pendingStats);
+      }
+      await this.indexerAgent.flushPendingBatch();
+      const finalStats = this.indexerAgent.getIndexingStats();
+      streamingEntities = finalStats.entitiesIndexed - initialIndexerStats.entitiesIndexed;
+      streamingRelationships = finalStats.relationshipsCreated - initialIndexerStats.relationshipsCreated;
+      log.i("DEVAGENT", "Streaming mode disabled, code parsing complete", {
+        streamedFiles: streamingIndexedFiles.size,
+        deltaEntities: streamingEntities,
+        deltaRelationships: streamingRelationships
+      });
+    }
+    totalEntities = streamingEntities;
+    totalRelationships = streamingRelationships;
+    filesProcessed += streamingIndexedFiles.size;
+    perfTimings["flush_end"] = Date.now() - perfStart;
+    if (dataFiles.length > 0) {
+      perfTimings["dataFiles_start"] = Date.now() - perfStart;
+      const dataResult = await this.processDataFilesParallel(dataFiles);
+      totalEntities += dataResult.entities;
+      filesProcessed += dataResult.files;
+      perfTimings["dataFiles_end"] = Date.now() - perfStart;
+    }
+    perfTimings["swaggerLink_start"] = Date.now() - perfStart;
+    try {
+      const { resolveSwaggerLinks } = await import('./indexing-pipeline-WCXIDMAP.js');
+      const swaggerRels = await resolveSwaggerLinks();
+      if (swaggerRels > 0) {
+        totalRelationships += swaggerRels;
+        log.i("DEVAGENT", "swagger_links_created", { count: swaggerRels });
+      }
+    } catch (err) {
+      log.w("DEVAGENT", "swagger_link_skip", { error: err.message });
+    }
+    perfTimings["swaggerLink_end"] = Date.now() - perfStart;
+    perfTimings["indexing_end"] = Date.now() - perfStart;
+    log.i("DEVAGENT", "index_done", {
+      files: filesProcessed,
+      total: allFiles.length,
+      entities: totalEntities,
+      rels: totalRelationships,
+      totalMs: perfTimings["indexing_end"]
+    });
+    log.i("DEVAGENT", "=== ALL BATCH PROCESSING COMPLETE ===", {
+      totalBatches: Math.ceil(codeFiles.length / effectiveBatchSize),
+      codeFiles: codeFiles.length,
+      dataFiles: dataFiles.length,
+      filesProcessed,
+      totalEntities,
+      totalRelationships,
+      perfTimings
+    });
+    log.flush();
+    await this.postIndexingCleanup(
+      codeFiles,
+      filesProcessed,
+      totalEntities,
+      perfStart,
+      perfTimings,
+      effectiveBatchSize,
+      dataFiles
+    );
+    this.buildPerfSummary(
+      perfTimings,
+      codeFiles,
+      dataFiles,
+      filesProcessed,
+      totalEntities,
+      totalRelationships,
+      effectiveBatchSize,
+      perfStart
+    );
+    return {
+      filesProcessed,
+      entitiesExtracted: totalEntities,
+      relationshipsCreated: totalRelationships,
+      totalFiles: allFiles.length,
+      perfTimings
+      // Detailed timing breakdown
+    };
+  }
+  handleResourceAdjustment(entry) {
+    this.resourceMixin.handleResourceAdjustment.call(this, entry);
+  }
+  adjustConcurrency(newLimit) {
+    const adjusted = Math.max(1, Math.min(this.defaultMaxConcurrency * 2, Math.floor(newLimit)));
+    if (this.capabilities.maxConcurrency !== adjusted) {
+      log.d("DEVAGENT", "adj_concurrency", { from: this.capabilities.maxConcurrency, to: adjusted });
+      this.capabilities.maxConcurrency = adjusted;
+    }
+  }
+  adjustBatchSize(newMemoryLimit) {
+    const ratio = Math.max(0.5, Math.min(2, newMemoryLimit / this.defaultMemoryLimit));
+    const newBatchSize = Math.max(10, Math.round(this.defaultBatchSize * ratio));
+    if (this.indexBatchSize !== newBatchSize) {
+      log.d("DEVAGENT", "adj_batch", { from: this.indexBatchSize, to: newBatchSize });
+      this.indexBatchSize = newBatchSize;
+    }
+  }
+  /**
+   * Eager-start Roslyn addon if project directory contains .sln/.slnx.
+   * Walks up to 5 levels from projectDir looking for solution file.
+   * Non-blocking — fires and logs, does not delay init.
+   */
+  tryEagerRoslynStart(projectDir) {
+    let dir = projectDir;
+    let slnPath = null;
+    for (let i = 0; i < 5; i++) {
+      slnPath = findSolutionFile(dir);
+      if (slnPath) break;
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+    if (!slnPath) return;
+    log.i("DEVAGENT", "roslyn_eager_start", { sln: slnPath });
+    ensureRoslynStarted(slnPath).then((parser) => {
+      if (parser) {
+        log.i("DEVAGENT", "roslyn_eager_ready", { sln: slnPath });
+      } else {
+        log.w("DEVAGENT", "roslyn_eager_fail", { sln: slnPath });
+      }
+    }).catch((err) => {
+      log.w("DEVAGENT", "roslyn_eager_error", { sln: slnPath, err: String(err) });
+    });
+  }
+  /**
+   * Handle incremental reindexing for changed files
+   * Called when GitWatcher detects uncommitted file changes
+   */
+  async handleIncrementalReindex(files, repositoryPath) {
+    if (!this.parserAgent || !this.indexerAgent) {
+      log.w("DEVAGENT", "skip_reindex_no_agents");
+      return;
+    }
+    const startTime = Date.now();
+    log.i("DEVAGENT", "incr_reindex_start", { files: files.length });
+    const { supportedFiles, otherFiles } = separateFilesBySupport(files);
+    if (supportedFiles.length === 0 && otherFiles.length === 0) {
+      log.i("DEVAGENT", "no_files_to_reindex");
+      return;
+    }
+    const existingFiles = [];
+    const deletedFiles = [];
+    for (const f of files) {
+      if (existsSync(f)) {
+        existingFiles.push(f);
+      } else {
+        deletedFiles.push(f);
+      }
+    }
+    try {
+      if (deletedFiles.length > 0) {
+        const storage = await getGraphStorage();
+        for (const filePath of deletedFiles) {
+          try {
+            await storage.deleteEntitiesByFilePath(filePath);
+            await storage.deleteFileInfo(filePath);
+          } catch {
+          }
+        }
+        log.i("DEVAGENT", "incr_cleanup", {
+          deleted: deletedFiles.length,
+          existing: existingFiles.length
+        });
+      }
+    } catch (err) {
+      log.w("DEVAGENT", "incr_cleanup_fail", { error: err.message });
+    }
+    const { supportedFiles: supportedExisting, otherFiles: otherExisting } = separateFilesBySupport(existingFiles);
+    let successCount = 0;
+    let errorCount = 0;
+    const embeddingConfig = buildWorkerEmbeddingConfig();
+    if (embeddingConfig && this.parserAgent) {
+      this.parserAgent.setEmbeddingConfig(embeddingConfig);
+      log.d("DEVAGENT", "incr_embedding_config", { provider: embeddingConfig.provider });
+      const configLoader = ConfigLoader.getInstance();
+      const embConfig = configLoader.getEmbeddingConfig();
+      const useLayeredIndex = embConfig.useLayeredIndex;
+      const currentDir = repositoryPath || getCurrentIndexingDirectory() || process.cwd();
+      const { getProjectHash, getCurrentGitBranchOrDefault } = await import('./storage-paths-NGF6GAFZ.js');
+      const projectHash = getProjectHash(currentDir);
+      const currentBranch = getCurrentGitBranchOrDefault(currentDir);
+      try {
+        if (useLayeredIndex) {
+          const { getLayeredFaissProvider } = await import('./layered-faiss-provider-M3MDI2AG.js');
+          const provider = getLayeredFaissProvider();
+          if ("initialize" in provider && typeof provider.initialize === "function") {
+            await provider.initialize(currentDir, projectHash, currentBranch);
+          }
+          this.parserAgent.setVectorProvider(provider);
+          log.i("DEVAGENT", "incr_vector_provider", { branch: currentBranch, layered: true });
+        } else {
+          const { initializeFaissProvider } = await import('./faiss-provider-VAYK2VBT.js');
+          const provider = await initializeFaissProvider();
+          if (provider) {
+            await provider.setProjectContext(projectHash, currentBranch);
+            this.parserAgent.setVectorProvider(provider);
+            log.i("DEVAGENT", "incr_vector_provider", { branch: currentBranch, layered: false });
+          }
+        }
+      } catch (e) {
+        log.w("DEVAGENT", "incr_vector_provider_fail", { error: String(e) });
+      }
+      log.d("DEVAGENT", "incr_embedding_config", {
+        provider: embeddingConfig.provider,
+        centralized: embeddingConfig.centralizedEmbeddings,
+        batchSize: embeddingConfig.batchSize
+      });
+      if (embeddingConfig.centralizedEmbeddings) {
+        try {
+          const { EmbeddingGenerator } = await import('./embedding-generator-XR6FDO4J.js');
+          const { buildEmbeddingGeneratorOptions } = await import('./provider-config-67EQAZ5Z.js');
+          const { loadSemanticConfig } = await import('./config-paths-Y2IHHJQF.js');
+          const { getConfig: getConfig2 } = await import('./yaml-config-OVNUY25R.js');
+          const semanticConfig = loadSemanticConfig();
+          const yamlConfig = getConfig2();
+          const generatorOptions = buildEmbeddingGeneratorOptions(
+            embeddingConfig.provider,
+            embeddingConfig.modelName,
+            embeddingConfig.batchSize,
+            semanticConfig,
+            yamlConfig
+          );
+          const embeddingGenerator = new EmbeddingGenerator(generatorOptions);
+          await embeddingGenerator.initialize();
+          await this.parserAgent.setEmbeddingGenerator(embeddingGenerator);
+          log.i("DEVAGENT", "incr_embedding_generator", {
+            provider: embeddingConfig.provider,
+            model: embeddingConfig.modelName
+          });
+        } catch (error) {
+          log.w("DEVAGENT", "incr_embedding_generator_fail", {
+            error: error.message
+          });
+        }
+      }
+    }
+    if (supportedExisting.length > 0) {
+      try {
+        log.i("DEVAGENT", "incr_parseBatch_start", { files: supportedExisting.length });
+        const parseResults = await this.parserAgent.parseBatch(supportedExisting, {});
+        log.i("DEVAGENT", "incr_parseBatch_done", { files: supportedExisting.length, results: parseResults.length });
+        for (const parseResult of parseResults) {
+          if (parseResult.entities && parseResult.entities.length > 0) {
+            try {
+              this.indexerAgent.queueForIndexing(parseResult.entities, parseResult.filePath, parseResult.relationships);
+              successCount++;
+            } catch (queueError) {
+              log.e("DEVAGENT", "queue_fail", { file: parseResult.filePath, err: String(queueError) });
+              errorCount++;
+            }
+          }
+        }
+      } catch (error) {
+        log.e("DEVAGENT", "batch_parse_fail", { files: supportedExisting.length, err: String(error) });
+        errorCount += supportedExisting.length;
+      }
+    }
+    for (const filePath of otherExisting) {
+      try {
+        const heuristicResult = createHeuristicEntities(filePath);
+        if (heuristicResult.entities.length > 0) {
+          this.indexerAgent.queueForIndexing(heuristicResult.entities, filePath, heuristicResult.relationships);
+          successCount++;
+        }
+      } catch (error) {
+        log.e("DEVAGENT", "heuristic_fail", { file: filePath, err: String(error) });
+        errorCount++;
+      }
+    }
+    try {
+      const flushResult = await this.indexerAgent.flushPendingBatch();
+      log.i("DEVAGENT", "incr_batch_flush", {
+        entities: flushResult.entities,
+        relationships: flushResult.relationships,
+        files: flushResult.files
+      });
+    } catch (flushError) {
+      log.e("DEVAGENT", "incr_flush_fail", { err: String(flushError) });
+    }
+    const elapsed = Date.now() - startTime;
+    log.i("DEVAGENT", "incr_reindex_done", {
+      success: successCount,
+      errors: errorCount,
+      deleted: deletedFiles.length,
+      ms: elapsed
+    });
+    if (this.parserAgent) {
+      const accumulator = this.parserAgent.getAccumulator();
+      if (accumulator) {
+        const pendingCount = accumulator.getPendingCount();
+        if (pendingCount > 0) {
+          log.i("DEVAGENT", "Flushing incremental embeddings to FAISS", { pending: pendingCount });
+          try {
+            const flushed = await accumulator.flush();
+            log.i("DEVAGENT", "Incremental embeddings flushed", { flushed });
+          } catch (err) {
+            log.e("DEVAGENT", "Failed to flush incremental embeddings", { error: err.message });
+          }
+        }
+        try {
+          const configLoader = ConfigLoader.getInstance();
+          const embConfig = configLoader.getEmbeddingConfig();
+          const useLayeredIndex = embConfig.useLayeredIndex;
+          if (useLayeredIndex) {
+            const { getLayeredFaissProvider } = await import('./layered-faiss-provider-M3MDI2AG.js');
+            const provider = getLayeredFaissProvider();
+            if ("save" in provider && typeof provider.save === "function") {
+              await provider.save();
+              log.i("DEVAGENT", "Saved layered FAISS index after incremental");
+            }
+          }
+        } catch (saveErr) {
+          log.w("DEVAGENT", "Failed to save FAISS index after incremental", {
+            error: saveErr.message
+          });
+        }
+      }
+    }
+    try {
+      const storage = await getGraphStorage();
+      const adapter = storage.getLibSQLAdapter?.();
+      if (adapter?.createGraphCommit && successCount > 0) {
+        const commitHash = await adapter.createGraphCommit(`Incremental: ${successCount} files`);
+        if (commitHash) {
+          log.i("DEVAGENT", "incr_commit_created", {
+            commit: commitHash.slice(0, 8),
+            files: successCount
+          });
+        }
+        adapter.pruneAndGC?.(20)?.catch?.((err) => log.w("DEVAGENT", "incr_prune_gc_fail", { err: String(err) }));
+      }
+    } catch (err) {
+      log.w("DEVAGENT", "incr_commit_failed", { error: err.message });
+    }
+    if (this.parserAgent) {
+      try {
+        const killed = await this.parserAgent.killIfMemoryHigh(1024);
+        if (killed) {
+          this.parserAgent = null;
+          log.i("DEVAGENT", "Parser workers killed (memory > 1GB after incremental)");
+        }
+      } catch (_err) {
+      }
+    }
+    if (tryGarbageCollect(true)) {
+      log.d("DEVAGENT", "gc_after_incremental");
+    }
+    knowledgeBus.publish(
+      "indexer:incremental:complete",
+      {
+        filesProcessed: successCount,
+        errors: errorCount,
+        elapsedMs: elapsed,
+        source: "dev-agent"
+        // Different source to distinguish from git-watcher
+      },
+      this.id
+    );
+    getGraphStorage().then((storage) => storage.runGenerationGC()).then((gc) => {
+      if (gc.entities > 0 || gc.tokens > 0) {
+        log.i("DEVAGENT", "gen_gc_complete", gc);
+      }
+    }).catch((err) => log.w("DEVAGENT", "gen_gc_fail", { error: err.message }));
+  }
+  /**
+   * Process data files in parallel with batch insert
+   * OPTIMIZATION: Instead of sequential await per file, we:
+   * 1. Create heuristic entities for all files in parallel (CPU-bound, fast)
+   * 2. Group by file and batch insert via indexerAgent
+   * 3. Use Promise.all with chunking for controlled parallelism
+   */
+  async processDataFilesParallel(dataFiles) {
+    if (dataFiles.length === 0 || !this.indexerAgent) {
+      return { entities: 0, files: 0 };
+    }
+    const startTime = Date.now();
+    log.i("DEVAGENT", "Processing data files in PARALLEL", {
+      count: dataFiles.length
+    });
+    const CHUNK_SIZE = Math.max(32, cpus().length * 4);
+    const allResults = [];
+    for (let i = 0; i < dataFiles.length; i += CHUNK_SIZE) {
+      const chunk = dataFiles.slice(i, i + CHUNK_SIZE);
+      const chunkResults = await Promise.all(
+        chunk.map(async (file) => {
+          try {
+            return createHeuristicEntities(file);
+          } catch {
+            return null;
+          }
+        })
+      );
+      for (const result of chunkResults) {
+        if (result && result.entities.length > 0) {
+          allResults.push(result);
+        }
+      }
+    }
+    const INDEXING_CHUNK_SIZE = Math.max(32, cpus().length * 2);
+    let totalEntities = 0;
+    let filesProcessed = 0;
+    for (let i = 0; i < allResults.length; i += INDEXING_CHUNK_SIZE) {
+      const chunk = allResults.slice(i, i + INDEXING_CHUNK_SIZE);
+      const indexPromises = chunk.map(async (result) => {
+        try {
+          const indexResult = await this.indexerAgent.indexEntities(
+            result.entities,
+            result.filePath,
+            result.relationships
+          );
+          return { entities: indexResult.entitiesIndexed, success: true };
+        } catch {
+          return { entities: 0, success: false };
+        }
+      });
+      const results = await Promise.all(indexPromises);
+      for (const r of results) {
+        if (r.success) {
+          totalEntities += r.entities;
+          filesProcessed++;
+        }
+      }
+    }
+    const elapsed = Date.now() - startTime;
+    log.i("DEVAGENT", "Data files processed in PARALLEL", {
+      files: filesProcessed,
+      entities: totalEntities,
+      elapsedMs: elapsed,
+      filesPerSec: Math.round(filesProcessed / elapsed * 1e3)
+    });
+    return { entities: totalEntities, files: filesProcessed };
+  }
+  /**
+   * Get embedding generation statistics from parser agent
+   */
+  getEmbeddingStats() {
+    return this.parserAgent?.getEmbeddingPoolStats?.() ?? null;
+  }
+  async onShutdown() {
+    log.i("DEVAGENT", "shutdown_start");
+    if (this.parserAgent) {
+      await this.parserAgent.shutdown();
+    }
+    if (this.indexerAgent) {
+      await this.indexerAgent.shutdown();
+    }
+  }
+};
+var devAgent = new DevAgent();
+
+export { DevAgent, devAgent };
+//# sourceMappingURL=dev-agent-Y5G5WKQ4.js.map
+//# sourceMappingURL=dev-agent-Y5G5WKQ4.js.map