ultracode 5.3.0 → 5.5.0

package/dist/chunks/chunk-NZFF4DQ4.js

@@ -0,0 +1,3179 @@
+import { knowledgeBus } from './chunk-JPI46FLQ.js';
+import { BaseAgent } from './chunk-IGUCJL3R.js';
+import { getGraphStorage, getLibSQLAdapter } from './chunk-V2SCB5H5.js';
+import { flattenParsedEntities, parsedEntityToEntity } from './chunk-CTXFPNDA.js';
+import { init_storage_paths, getDataDir, getProjectHash, getCurrentGitBranchOrDefault } from './chunk-ZD54CMKT.js';
+import { init_fast_hash, hashText } from './chunk-HEMJHRHZ.js';
+import { sleep, tryGarbageCollect } from './chunk-IMQ6WSJV.js';
+import { init_yaml_config, getConfig } from './chunk-XV6GNSLC.js';
+import { init_file_ops, existsSync, readTextSync, mkdirSync, writeFileSync, readdirSync, statSync, unlinkSync } from './chunk-F7CKCMXI.js';
+import { init_logging, log, logMemory } from './chunk-VCCBEJQ5.js';
+import { nanoid } from 'nanoid';
+import { execSync } from 'child_process';
+import { join, isAbsolute, dirname } from 'path';
+import { EventEmitter } from 'events';
+import { existsSync as existsSync$1, watch } from 'fs';
+import { stat } from 'fs/promises';
+import fg from 'fast-glob';
+import xxhash from 'xxhash-wasm';
+import { LRUCache } from 'lru-cache';
+
+// src/agents/indexer-agent.ts
+init_yaml_config();
+
+// src/core/branch-manager.ts
+init_logging();
+init_storage_paths();
+init_file_ops();
+var BranchManager = class {
+  config;
+  registryPath;
+  registry;
+  currentBranch = null;
+  currentRepoPath = null;
+  constructor(config) {
+    this.config = config;
+    this.registryPath = join(config.dataDir, "branch-registry.json");
+    this.registry = this.loadRegistry();
+  }
+  /**
+   * Get projects directory (centralized storage for all repos/branches)
+   */
+  getProjectsDir() {
+    return join(this.config.dataDir, "projects");
+  }
+  /**
+   * Initialize the branch manager (no-op, kept for API compatibility)
+   */
+  async initialize() {
+  }
+  /**
+   * Get current Git branch name
+   */
+  getCurrentBranch(repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    try {
+      const gitDir = join(path, ".git");
+      if (!existsSync(gitDir)) {
+        log.d("BRANCHMGR", "no_git_dir", { path });
+        return null;
+      }
+      try {
+        const branch = execSync("git symbolic-ref --short HEAD", {
+          cwd: path,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true
+        }).trim();
+        this.currentBranch = branch;
+        this.currentRepoPath = path;
+        return branch;
+      } catch {
+        try {
+          const describe = execSync("git describe --tags --exact-match", {
+            cwd: path,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+            windowsHide: true
+          }).trim();
+          this.currentBranch = `detached-${describe}`;
+          this.currentRepoPath = path;
+          return this.currentBranch;
+        } catch {
+          const hash = execSync("git rev-parse --short HEAD", {
+            cwd: path,
+            encoding: "utf-8",
+            stdio: ["pipe", "pipe", "ignore"],
+            windowsHide: true
+          }).trim();
+          this.currentBranch = `detached-${hash}`;
+          this.currentRepoPath = path;
+          return this.currentBranch;
+        }
+      }
+    } catch (error) {
+      log.d("BRANCHMGR", "branch_get_fail", { err: String(error) });
+      return null;
+    }
+  }
+  /**
+   * Get last commit hash for current branch
+   */
+  getLastCommitHash(repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    try {
+      const hash = execSync("git rev-parse HEAD", {
+        cwd: path,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      return hash;
+    } catch (error) {
+      log.d("BRANCHMGR", "commit_hash_fail", { err: String(error) });
+      return null;
+    }
+  }
+  /**
+   * Get repository hash for path isolation
+   * Uses the same hash as storage-paths.ts for consistency
+   */
+  getRepositoryHash(repoPath) {
+    return getProjectHash(repoPath);
+  }
+  /**
+   * Sanitize branch name for filesystem
+   */
+  sanitizeBranchName(branch) {
+    return branch.replace(/\//g, "-").replace(/\\/g, "-").replace(/[^a-zA-Z0-9_-]/g, "_").replace(/^-+|-+$/g, "");
+  }
+  /**
+   * Get database path for a specific branch
+   * Returns the unified storage database path (same for all branches)
+   */
+  getBranchDbPath(_branch, _repoPath) {
+    return join(this.config.dataDir, "unified-storage.db");
+  }
+  /**
+   * Get FAISS index path for a specific branch
+   */
+  getFaissIndexPath(branch, repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    const repoHash = this.getRepositoryHash(path);
+    const sanitizedBranch = this.sanitizeBranchName(branch);
+    return join(this.getProjectsDir(), repoHash, `faiss-${sanitizedBranch}.bin`);
+  }
+  /**
+   * Get metadata for a branch
+   */
+  getBranchMetadata(branch, repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    const repoHash = this.getRepositoryHash(path);
+    const sanitizedBranch = this.sanitizeBranchName(branch);
+    const metadataPath = join(this.getProjectsDir(), repoHash, sanitizedBranch, "metadata.json");
+    if (!existsSync(metadataPath)) {
+      return null;
+    }
+    try {
+      const data = readTextSync(metadataPath);
+      return JSON.parse(data);
+    } catch (error) {
+      log.e("BRANCHMGR", "metadata_read_fail", { err: String(error) });
+      return null;
+    }
+  }
+  /**
+   * Update branch metadata
+   */
+  updateBranchMetadata(metadata) {
+    const sanitizedBranch = this.sanitizeBranchName(metadata.branch);
+    const metadataPath = join(this.getProjectsDir(), metadata.repositoryHash, sanitizedBranch, "metadata.json");
+    const dir = join(this.getProjectsDir(), metadata.repositoryHash, sanitizedBranch);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(metadataPath, JSON.stringify(metadata, null, 2), "utf-8");
+    this.updateRegistry(metadata.repositoryPath, metadata.branch, metadataPath);
+  }
+  /**
+   * Get all indexed branches for a repository
+   * Detects branches by FAISS index files (faiss-{branch}.bin)
+   */
+  getActiveBranches(repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    const repoHash = this.getRepositoryHash(path);
+    const repoDir = join(this.getProjectsDir(), repoHash);
+    if (!existsSync(repoDir)) {
+      return [];
+    }
+    const branches = [];
+    const files = readdirSync(repoDir);
+    const faissPattern = /^faiss-(.+)\.bin$/;
+    for (const file of files) {
+      const match = file.match(faissPattern);
+      if (!match || !match[1]) continue;
+      const branchName = match[1];
+      const faissPath = join(repoDir, file);
+      const stats = statSync(faissPath);
+      const metadata = this.getBranchMetadata(branchName, path);
+      branches.push({
+        name: branchName,
+        dbPath: faissPath,
+        lastAccessed: metadata?.accessedAt || stats.mtimeMs,
+        sizeBytes: stats.size,
+        metadata
+      });
+    }
+    return branches.sort((a, b) => b.lastAccessed - a.lastAccessed);
+  }
+  /**
+   * Cleanup old branches using LRU eviction
+   */
+  async cleanupOldBranches(keep) {
+    const keepCount = keep || this.config.maxBranchesPerRepo;
+    const branches = this.getActiveBranches();
+    if (branches.length <= keepCount) {
+      return 0;
+    }
+    const toDelete = branches.slice(keepCount);
+    let deletedCount = 0;
+    for (const branch of toDelete) {
+      try {
+        const branchDir = join(this.getProjectsDir(), branch.metadata?.repositoryHash || "", branch.name);
+        const files = readdirSync(branchDir);
+        for (const file of files) {
+          unlinkSync(join(branchDir, file));
+        }
+        if (branch.metadata) {
+          this.removeFromRegistry(branch.metadata.repositoryPath, branch.name);
+        }
+        deletedCount++;
+        log.i("BRANCHMGR", "branch_cleaned", { branch: branch.name });
+      } catch (error) {
+        log.e("BRANCHMGR", "cleanup_fail", { branch: branch.name, err: String(error) });
+      }
+    }
+    return deletedCount;
+  }
+  /**
+   * Switch to a different branch
+   */
+  async switchBranch(newBranch, repoPath) {
+    const path = repoPath || this.currentRepoPath || process.cwd();
+    const oldBranch = this.currentBranch;
+    this.currentBranch = newBranch;
+    this.currentRepoPath = path;
+    log.i("BRANCHMGR", "branch_switched", { from: oldBranch, to: newBranch });
+    const metadata = this.getBranchMetadata(newBranch, path);
+    if (metadata) {
+      metadata.accessedAt = Date.now();
+      this.updateBranchMetadata(metadata);
+    }
+  }
+  /**
+   * Check if branch has been indexed (FAISS index exists)
+   */
+  hasBranchDatabase(branch, repoPath) {
+    const faissPath = this.getFaissIndexPath(branch, repoPath);
+    return existsSync(faissPath);
+  }
+  // =============================================================================
+  // PRIVATE METHODS - Registry Management
+  // =============================================================================
+  loadRegistry() {
+    if (!existsSync(this.registryPath)) {
+      return {
+        repositories: {},
+        config: {
+          maxBranchesPerRepo: this.config.maxBranchesPerRepo,
+          maxTotalBranches: this.config.maxTotalBranches,
+          evictionStrategy: this.config.evictionStrategy
+        }
+      };
+    }
+    try {
+      const data = readTextSync(this.registryPath);
+      return JSON.parse(data);
+    } catch (error) {
+      log.e("BRANCHMGR", "registry_load_fail", { err: String(error) });
+      return {
+        repositories: {},
+        config: {
+          maxBranchesPerRepo: this.config.maxBranchesPerRepo,
+          maxTotalBranches: this.config.maxTotalBranches,
+          evictionStrategy: this.config.evictionStrategy
+        }
+      };
+    }
+  }
+  saveRegistry() {
+    const dir = join(this.config.dataDir);
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
+    }
+    writeFileSync(this.registryPath, JSON.stringify(this.registry, null, 2), "utf-8");
+  }
+  updateRegistry(repoPath, branch, dbPath) {
+    const repoHash = this.getRepositoryHash(repoPath);
+    if (!this.registry.repositories[repoHash]) {
+      this.registry.repositories[repoHash] = {
+        path: repoPath,
+        branches: {}
+      };
+    }
+    const sanitizedBranch = this.sanitizeBranchName(branch);
+    const stats = existsSync(dbPath) ? statSync(dbPath) : { size: 0};
+    this.registry.repositories[repoHash].branches[sanitizedBranch] = {
+      dbPath,
+      lastAccessed: Date.now(),
+      sizeBytes: stats.size
+    };
+    this.saveRegistry();
+  }
+  removeFromRegistry(repoPath, branch) {
+    const repoHash = this.getRepositoryHash(repoPath);
+    const sanitizedBranch = this.sanitizeBranchName(branch);
+    if (this.registry.repositories[repoHash]?.branches[sanitizedBranch]) {
+      delete this.registry.repositories[repoHash].branches[sanitizedBranch];
+      this.saveRegistry();
+    }
+  }
+};
+
+// src/core/file-watcher.ts
+init_logging();
+var isBunRuntime = typeof globalThis.Bun !== "undefined";
+var hasBunWatch = isBunRuntime && typeof globalThis.Bun !== "undefined" && typeof globalThis.Bun["watch"] === "function";
+var FileWatcher = class extends EventEmitter {
+  config;
+  watchers = /* @__PURE__ */ new Map();
+  watchedFiles = /* @__PURE__ */ new Set();
+  isRunning = false;
+  // Debouncing
+  pendingChanges = /* @__PURE__ */ new Map();
+  debounceAbort = null;
+  // Bun watcher (when available)
+  bunWatcher = null;
+  constructor(config) {
+    super();
+    this.config = {
+      rootDir: config.rootDir.replace(/\\/g, "/"),
+      include: config.include ?? ["**/*"],
+      exclude: config.exclude ?? ["**/node_modules/**", "**/.git/**", "**/dist/**", "**/build/**", "**/.ultracode/**"],
+      debounceMs: config.debounceMs ?? 100,
+      bulkThreshold: config.bulkThreshold ?? 1e3
+    };
+  }
+  /**
+   * Start watching
+   */
+  async start() {
+    if (this.isRunning) return;
+    this.isRunning = true;
+    const runtime = hasBunWatch ? "Bun.watch" : "fs.watch";
+    log.i("FILEWATCHER", "Starting", { runtime, rootDir: this.config.rootDir, isBun: isBunRuntime, hasBunWatch });
+    try {
+      const files = await this.scanFiles();
+      log.d("FILEWATCHER", "Initial scan complete", { files: files.length });
+      if (hasBunWatch) {
+        await this.startBunWatcher(files);
+      } else {
+        await this.startNodeWatcher(files);
+      }
+      this.emit("ready");
+    } catch (error) {
+      this.isRunning = false;
+      log.e("FILEWATCHER", "Failed to start", { error: error.message });
+      throw error;
+    }
+  }
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (!this.isRunning) return;
+    this.isRunning = false;
+    if (this.debounceAbort) {
+      this.debounceAbort.abort();
+      this.debounceAbort = null;
+    }
+    if (this.bunWatcher) {
+      this.bunWatcher.stop();
+      this.bunWatcher = null;
+    }
+    for (const watcher of this.watchers.values()) {
+      watcher.close();
+    }
+    this.watchers.clear();
+    this.watchedFiles.clear();
+    this.pendingChanges.clear();
+    log.d("FILEWATCHER", "Stopped");
+  }
+  /**
+   * Scan files matching patterns
+   * Uses Bun.Glob when available (faster), otherwise fast-glob
+   */
+  async scanFiles() {
+    const patterns = this.config.include.map(
+      (p) => p.startsWith("/") || p.includes(":") ? p : `${this.config.rootDir}/${p}`
+    );
+    if (isBunRuntime && globalThis.Bun?.Glob) {
+      const files2 = [];
+      for (const pattern of patterns) {
+        const glob = new globalThis.Bun.Glob(pattern);
+        for await (const file of glob.scan({ onlyFiles: true, ignore: this.config.exclude })) {
+          files2.push(file);
+        }
+      }
+      return files2;
+    }
+    const files = await fg(patterns, {
+      ignore: this.config.exclude,
+      onlyFiles: true,
+      absolute: true
+    });
+    return files;
+  }
+  /**
+   * Start Bun.watch() - fastest option
+   */
+  async startBunWatcher(files) {
+    const dirs = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      dirs.add(dirname(file));
+      this.watchedFiles.add(file);
+    }
+    this.bunWatcher = Bun.watch(this.config.rootDir, {
+      recursive: true,
+      filter: (path) => this.matchesPatterns(path)
+    });
+    this.bunWatcher.on("change", (event, path) => {
+      if (!path) return;
+      const fullPath = join(this.config.rootDir, path).replace(/\\/g, "/");
+      if (event === "rename") {
+        stat(fullPath).then(() => this.queueChange(fullPath, this.watchedFiles.has(fullPath) ? "change" : "add")).catch(() => this.queueChange(fullPath, "unlink"));
+      } else {
+        this.queueChange(fullPath, "change");
+      }
+    });
+    log.i("FILEWATCHER", "Bun.watch started", { dirs: dirs.size, files: files.length });
+  }
+  /**
+   * Start Node.js fs.watch()
+   */
+  async startNodeWatcher(files) {
+    const dirs = /* @__PURE__ */ new Set();
+    for (const file of files) {
+      dirs.add(dirname(file));
+      this.watchedFiles.add(file);
+    }
+    for (const dir of dirs) {
+      try {
+        const watcher = watch(dir, { persistent: true }, (event, filename) => {
+          if (!filename) return;
+          const fullPath = join(dir, filename).replace(/\\/g, "/");
+          if (!this.matchesPatterns(fullPath)) return;
+          if (event === "rename") {
+            stat(fullPath).then(() => this.queueChange(fullPath, this.watchedFiles.has(fullPath) ? "change" : "add")).catch(() => this.queueChange(fullPath, "unlink"));
+          } else {
+            this.queueChange(fullPath, "change");
+          }
+        });
+        watcher.on("error", (err) => {
+          log.w("FILEWATCHER", "Watcher error", { dir, error: err.message });
+        });
+        this.watchers.set(dir, watcher);
+      } catch (err) {
+        log.w("FILEWATCHER", "Failed to watch directory", { dir, error: err.message });
+      }
+    }
+    log.i("FILEWATCHER", "fs.watch started", { dirs: this.watchers.size, files: files.length });
+  }
+  /**
+   * Check if path matches include/exclude patterns
+   */
+  matchesPatterns(path) {
+    const normalizedPath = path.replace(/\\/g, "/");
+    for (const pattern of this.config.exclude) {
+      if (this.simpleMatch(normalizedPath, pattern)) {
+        return false;
+      }
+    }
+    for (const pattern of this.config.include) {
+      if (this.simpleMatch(normalizedPath, pattern)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Simple glob matching for common patterns
+   */
+  simpleMatch(path, pattern) {
+    if (pattern.startsWith("**/")) {
+      const suffix = pattern.slice(3);
+      if (suffix.includes("*")) {
+        const ext = suffix.replace("*", "");
+        return path.endsWith(ext) || path.includes(`/${suffix.replace("*", "")}`);
+      }
+      return path.includes(`/${suffix}`) || path.endsWith(`/${suffix}`);
+    }
+    if (pattern.startsWith("*.")) {
+      return path.endsWith(pattern.slice(1));
+    }
+    if (pattern === "**/*") {
+      return true;
+    }
+    return path === pattern || path.endsWith(`/${pattern}`);
+  }
+  /**
+   * Queue a change for debounced emission
+   */
+  queueChange(path, type) {
+    if (!this.isRunning) return;
+    if (type === "add") {
+      this.watchedFiles.add(path);
+    } else if (type === "unlink") {
+      this.watchedFiles.delete(path);
+    }
+    this.pendingChanges.set(path, {
+      path,
+      type,
+      timestamp: Date.now()
+    });
+    this.scheduleFlush();
+  }
+  /**
+   * Schedule debounced flush (Bun-compatible using async sleep)
+   */
+  scheduleFlush() {
+    if (this.debounceAbort) {
+      this.debounceAbort.abort();
+    }
+    const abortController = new AbortController();
+    this.debounceAbort = abortController;
+    (async () => {
+      await sleep(this.config.debounceMs);
+      if (!abortController.signal.aborted) {
+        this.flush();
+      }
+    })();
+  }
+  /**
+   * Flush pending changes
+   */
+  flush() {
+    if (this.debounceAbort) {
+      this.debounceAbort.abort();
+      this.debounceAbort = null;
+    }
+    if (this.pendingChanges.size === 0) return;
+    const events = Array.from(this.pendingChanges.values());
+    this.pendingChanges.clear();
+    const isBulk = events.length >= this.config.bulkThreshold;
+    log.d("FILEWATCHER", "Emitting changes", { count: events.length, bulkMode: isBulk });
+    this.emit("change", events, isBulk);
+  }
+  /**
+   * Get status
+   */
+  getStatus() {
+    return {
+      running: this.isRunning,
+      runtime: hasBunWatch ? "bun" : "node",
+      isBunRuntime,
+      hasBunWatch,
+      watchedFiles: this.watchedFiles.size,
+      watchedDirs: this.watchers.size,
+      pendingChanges: this.pendingChanges.size
+    };
+  }
+};
+async function createFileWatcher(config) {
+  const watcher = new FileWatcher(config);
+  await watcher.start();
+  return watcher;
+}
+
+// src/core/git-watcher.ts
+init_logging();
+function isBunRuntime2() {
+  return typeof globalThis.Bun !== "undefined";
+}
+async function sleep2(ms) {
+  if (typeof globalThis.Bun !== "undefined" && typeof globalThis.Bun.sleep === "function") {
+    await globalThis.Bun.sleep(ms);
+  } else {
+    await new Promise((resolve) => setTimeout(resolve, ms));
+  }
+}
+var GitWatcher = class {
+  config;
+  repoPath = null;
+  watcher = null;
+  commitPollRunning = false;
+  uncommittedPollRunning = false;
+  stopped = false;
+  // Flag to stop async loops
+  currentBranch = null;
+  currentCommit = null;
+  /** Tracks last known uncommitted files to detect changes */
+  lastUncommittedFiles = /* @__PURE__ */ new Set();
+  /** Debounce: accumulated pending changes */
+  pendingChanges = /* @__PURE__ */ new Set();
+  /** Debounce: abort controller for canceling pending debounce */
+  debounceAbortController = null;
+  /** Debounce delay in ms */
+  debounceMs;
+  /** Bulk mode threshold */
+  bulkModeThreshold;
+  branchChangeCallbacks = [];
+  commitCallbacks = [];
+  fileChangeCallbacks = [];
+  /** Callbacks specifically for uncommitted file changes */
+  uncommittedChangeCallbacks = [];
+  /** Debounced callbacks with bulk mode flag */
+  debouncedChangeCallbacks = [];
+  constructor(config) {
+    this.config = {
+      ...config,
+      watchUncommitted: config.watchUncommitted ?? true,
+      uncommittedPollIntervalMs: config.uncommittedPollIntervalMs ?? 1e4,
+      includeUntracked: config.includeUntracked ?? true
+    };
+    this.debounceMs = config.debounceMs ?? 6e4;
+    this.bulkModeThreshold = config.bulkModeThreshold ?? 1e3;
+  }
+  /**
+   * Start watching a Git repository
+   */
+  startWatching(repoPath) {
+    if (!this.config.enabled) {
+      log.i("GITWATCHER", "disabled");
+      return;
+    }
+    this.repoPath = repoPath;
+    const gitHeadPath = join(repoPath, ".git", "HEAD");
+    if (!existsSync$1(gitHeadPath)) {
+      log.i("GITWATCHER", "no_git_dir");
+      return;
+    }
+    this.currentBranch = this.getCurrentBranch();
+    this.currentCommit = this.getCurrentCommit();
+    log.i("GITWATCHER", "started", { path: repoPath });
+    log.i("GITWATCHER", "current_branch", { branch: this.currentBranch });
+    log.i("GITWATCHER", "current_commit", { commit: this.currentCommit });
+    this.stopped = false;
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    this.watcher = watch(gitHeadPath, (eventType) => {
+      if (eventType === "change") {
+        this.checkBranchChange();
+      }
+    });
+    this.startCommitPollLoop();
+    if (this.config.watchUncommitted) {
+      log.i("GITWATCHER", "uncommitted_watch_on", { interval: this.config.uncommittedPollIntervalMs });
+      this.getUncommittedFiles().then((files) => {
+        this.lastUncommittedFiles = new Set(files.map((f) => f.path));
+        log.i("GITWATCHER", "init_uncommitted", { count: this.lastUncommittedFiles.size });
+      });
+      this.startUncommittedPollLoop();
+    }
+  }
+  /** Timer handles for Node.js setInterval */
+  commitPollTimer;
+  uncommittedPollTimer;
+  /**
+   * Start commit and branch polling
+   * Node.js: uses setInterval
+   * Bun: uses async loop with Bun.sleep
+   * Also polls for branch changes as fs.watch() is unreliable on Windows
+   */
+  startCommitPollLoop() {
+    if (this.commitPollRunning) return;
+    this.commitPollRunning = true;
+    if (isBunRuntime2()) {
+      (async () => {
+        while (!this.stopped) {
+          await sleep2(this.config.pollIntervalMs);
+          if (this.stopped) break;
+          try {
+            this.checkBranchChange();
+            this.checkCommitChange();
+          } catch (error) {
+            log.w("GITWATCHER", "poll_err", { err: String(error) });
+          }
+        }
+        this.commitPollRunning = false;
+      })();
+    } else {
+      this.commitPollTimer = setInterval(() => {
+        if (!this.stopped) {
+          try {
+            this.checkBranchChange();
+            this.checkCommitChange();
+          } catch (error) {
+            log.w("GITWATCHER", "poll_err", { err: String(error) });
+          }
+        }
+      }, this.config.pollIntervalMs);
+    }
+  }
+  /**
+   * Start uncommitted file polling
+   * Node.js: uses setInterval
+   * Bun: uses async loop with Bun.sleep
+   */
+  startUncommittedPollLoop() {
+    if (this.uncommittedPollRunning) return;
+    this.uncommittedPollRunning = true;
+    if (isBunRuntime2()) {
+      (async () => {
+        while (!this.stopped) {
+          await sleep2(this.config.uncommittedPollIntervalMs);
+          if (this.stopped) break;
+          try {
+            await this.checkUncommittedChanges();
+          } catch (error) {
+            log.w("GITWATCHER", "uncommitted_poll_err", { err: String(error) });
+          }
+        }
+        this.uncommittedPollRunning = false;
+      })();
+    } else {
+      this.uncommittedPollTimer = setInterval(() => {
+        if (!this.stopped) {
+          this.checkUncommittedChanges().catch((error) => {
+            log.w("GITWATCHER", "uncommitted_poll_err", { err: String(error) });
+          });
+        }
+      }, this.config.uncommittedPollIntervalMs);
+    }
+  }
+  /**
+   * Get the current tracked branch name
+   */
+  getBranch() {
+    return this.currentBranch;
+  }
+  /**
+   * Check if watcher is currently active
+   */
+  isWatching() {
+    return !this.stopped && (!!this.watcher || this.commitPollRunning || this.uncommittedPollRunning);
+  }
+  /**
+   * Stop watching the repository
+   */
+  stopWatching() {
+    this.stopped = true;
+    if (this.commitPollTimer) {
+      clearInterval(this.commitPollTimer);
+      this.commitPollTimer = void 0;
+    }
+    if (this.uncommittedPollTimer) {
+      clearInterval(this.uncommittedPollTimer);
+      this.uncommittedPollTimer = void 0;
+    }
+    if (this.watcher) {
+      this.watcher.close();
+      this.watcher = null;
+    }
+    if (this.debounceAbortController) {
+      this.debounceAbortController.abort();
+      this.debounceAbortController = null;
+    }
+    this.lastUncommittedFiles.clear();
+    this.pendingChanges.clear();
+    log.i("GITWATCHER", "stopped");
+  }
+  /**
+   * Register callback for branch changes
+   */
+  onBranchChange(callback) {
+    this.branchChangeCallbacks.push(callback);
+  }
+  /**
+   * Register callback for new commits
+   */
+  onCommit(callback) {
+    this.commitCallbacks.push(callback);
+  }
+  /**
+   * Register callback for file changes (after commits)
+   */
+  onFileChange(callback) {
+    this.fileChangeCallbacks.push(callback);
+  }
+  /**
+   * Register callback for uncommitted file changes (working directory)
+   * These are files that have been modified but not yet committed
+   */
+  onUncommittedChange(callback) {
+    this.uncommittedChangeCallbacks.push(callback);
+  }
+  /**
+   * Register debounced callback for file changes.
+   * Callback receives accumulated files after debounce period and bulk mode flag.
+   * - bulkMode=true: many files changed, caller should drop/rebuild index
+   * - bulkMode=false: few files changed, caller should use incremental insert
+   */
+  onDebouncedChange(callback) {
+    this.debouncedChangeCallbacks.push(callback);
+  }
+  /**
+   * Get count of pending changes waiting for debounce
+   */
+  getPendingChangesCount() {
+    return this.pendingChanges.size;
+  }
+  /**
+   * Force flush pending changes immediately (bypasses debounce)
+   */
+  forceFlush() {
+    if (this.debounceAbortController) {
+      this.debounceAbortController.abort();
+      this.debounceAbortController = null;
+    }
+    this.flushPendingChanges();
+  }
+  /**
+   * Flush accumulated pending changes and trigger debounced callbacks
+   */
+  flushPendingChanges() {
+    if (this.pendingChanges.size === 0) return;
+    const files = Array.from(this.pendingChanges);
+    const bulkMode = files.length >= this.bulkModeThreshold;
+    const swaggerFiles = files.filter((f) => {
+      const lower = f.toLowerCase();
+      return lower.includes("swagger") || lower.includes("openapi") || lower.endsWith(".json") && (lower.includes("api") || lower.includes("spec"));
+    });
+    if (swaggerFiles.length > 0) {
+      log.i("GITWATCHER", "swagger_files_changed", {
+        swaggerFiles: swaggerFiles.length,
+        files: swaggerFiles,
+        warning: "Generated code may need regeneration"
+      });
+    }
+    log.i("GITWATCHER", "flushing", {
+      count: files.length,
+      bulkMode,
+      threshold: this.bulkModeThreshold,
+      swaggerChanges: swaggerFiles.length
+    });
+    this.pendingChanges.clear();
+    for (const callback of this.debouncedChangeCallbacks) {
+      try {
+        callback(files, bulkMode);
+      } catch (error) {
+        log.w("GITWATCHER", "debounce_cb_err", { err: String(error) });
+      }
+    }
+  }
+  /**
+   * Schedule debounced flush - resets timer on each call
+   */
+  scheduleDebouncedFlush() {
+    if (this.debounceAbortController) {
+      this.debounceAbortController.abort();
+    }
+    const abortController = new AbortController();
+    this.debounceAbortController = abortController;
+    (async () => {
+      await sleep2(this.debounceMs);
+      if (!abortController.signal.aborted) {
+        this.debounceAbortController = null;
+        this.flushPendingChanges();
+      }
+    })();
+    log.i("GITWATCHER", "debounce_scheduled", {
+      pending: this.pendingChanges.size,
+      flushInSec: this.debounceMs / 1e3
+    });
+  }
+  /**
+   * Get files changed since a specific commit/branch
+   */
+  async getChangedFiles(since) {
+    if (!this.repoPath) {
+      return [];
+    }
+    try {
+      const output = execSync(`git diff --name-status ${since}..HEAD`, {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      const changes = [];
+      const lines = output.trim().split("\n");
+      for (const line of lines) {
+        if (!line) continue;
+        const [status, ...pathParts] = line.split("	");
+        if (!status) continue;
+        const path = pathParts.join("	");
+        let changeStatus;
+        switch (status[0]) {
+          case "A":
+            changeStatus = "added";
+            break;
+          case "M":
+            changeStatus = "modified";
+            break;
+          case "D":
+            changeStatus = "deleted";
+            break;
+          case "R":
+            changeStatus = "renamed";
+            break;
+          default:
+            changeStatus = "modified";
+        }
+        changes.push({ path, status: changeStatus });
+      }
+      return changes;
+    } catch (error) {
+      log.w("GITWATCHER", "get_changed_fail", { err: String(error) });
+      return [];
+    }
+  }
+  /**
+   * Get changed files between two branches
+   */
+  async getChangedFilesBetweenBranches(oldBranch, newBranch) {
+    if (!this.repoPath) {
+      return [];
+    }
+    try {
+      const output = execSync(`git diff --name-status ${oldBranch}...${newBranch}`, {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      const changes = [];
+      const lines = output.trim().split("\n");
+      for (const line of lines) {
+        if (!line) continue;
+        const [status, ...pathParts] = line.split("	");
+        if (!status) continue;
+        const path = pathParts.join("	");
+        let changeStatus;
+        switch (status[0]) {
+          case "A":
+            changeStatus = "added";
+            break;
+          case "M":
+            changeStatus = "modified";
+            break;
+          case "D":
+            changeStatus = "deleted";
+            break;
+          case "R":
+            changeStatus = "renamed";
+            break;
+          default:
+            changeStatus = "modified";
+        }
+        changes.push({ path, status: changeStatus });
+      }
+      return changes;
+    } catch (error) {
+      log.w("GITWATCHER", "get_branch_diff_fail", { err: String(error) });
+      return [];
+    }
+  }
+  // =============================================================================
+  // PRIVATE METHODS
+  // =============================================================================
+  getCurrentBranch() {
+    if (!this.repoPath) return null;
+    try {
+      const branch = execSync("git symbolic-ref --short HEAD", {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      return branch;
+    } catch {
+      try {
+        const hash = execSync("git rev-parse --short HEAD", {
+          cwd: this.repoPath,
+          encoding: "utf-8",
+          stdio: ["pipe", "pipe", "ignore"],
+          windowsHide: true
+        }).trim();
+        return `detached-${hash}`;
+      } catch {
+        return null;
+      }
+    }
+  }
+  getCurrentCommit() {
+    if (!this.repoPath) return null;
+    try {
+      const commit = execSync("git rev-parse HEAD", {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      }).trim();
+      return commit;
+    } catch {
+      return null;
+    }
+  }
+  checkBranchChange() {
+    const newBranch = this.getCurrentBranch();
+    if (newBranch && newBranch !== this.currentBranch) {
+      const oldBranch = this.currentBranch || "unknown";
+      log.i("GITWATCHER", "branch_changed", { from: oldBranch, to: newBranch });
+      this.currentBranch = newBranch;
+      this.currentCommit = this.getCurrentCommit();
+      for (const callback of this.branchChangeCallbacks) {
+        try {
+          const result = callback(newBranch, oldBranch);
+          if (result && typeof result.catch === "function") {
+            result.catch((error) => {
+              log.e("GITWATCHER", "branch_cb_async_err", { err: String(error) });
+            });
+          }
+        } catch (error) {
+          log.w("GITWATCHER", "branch_cb_err", { err: String(error) });
+        }
+      }
+    }
+  }
+  checkCommitChange() {
+    const newCommit = this.getCurrentCommit();
+    if (newCommit && newCommit !== this.currentCommit) {
+      log.i("GITWATCHER", "new_commit", { commit: newCommit.slice(0, 8) });
+      const oldCommit = this.currentCommit;
+      this.currentCommit = newCommit;
+      for (const callback of this.commitCallbacks) {
+        try {
+          callback(newCommit);
+        } catch (error) {
+          log.w("GITWATCHER", "commit_cb_err", { err: String(error) });
+        }
+      }
+      if (oldCommit) {
+        this.getChangedFiles(oldCommit).then((files) => {
+          if (files.length > 0) {
+            for (const callback of this.fileChangeCallbacks) {
+              try {
+                callback(files.map((f) => f.path));
+              } catch (error) {
+                log.w("GITWATCHER", "file_cb_err", { err: String(error) });
+              }
+            }
+          }
+        });
+      }
+      this.lastUncommittedFiles.clear();
+    }
+  }
+  /**
+   * Get uncommitted files (modified + staged + optionally untracked)
+   * Uses `git status --porcelain` for efficient parsing
+   */
+  async getUncommittedFiles() {
+    if (!this.repoPath) {
+      return [];
+    }
+    try {
+      const untrackedFlag = this.config.includeUntracked ? "-uall" : "-uno";
+      const output = execSync(`git status --porcelain ${untrackedFlag}`, {
+        cwd: this.repoPath,
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "ignore"],
+        windowsHide: true
+      });
+      const changes = [];
+      const lines = output.trim().split("\n");
+      for (const line of lines) {
+        if (!line || line.length < 3) continue;
+        const indexStatus = line[0];
+        const workTreeStatus = line[1];
+        const filePath = line.slice(3).split(" -> ").pop() || line.slice(3);
+        let changeStatus;
+        const status = workTreeStatus !== " " ? workTreeStatus : indexStatus;
+        switch (status) {
+          case "A":
+          case "?":
+            changeStatus = "added";
+            break;
+          case "M":
+            changeStatus = "modified";
+            break;
+          case "D":
+            changeStatus = "deleted";
+            break;
+          case "R":
+            changeStatus = "renamed";
+            break;
+          default:
+            changeStatus = "modified";
+        }
+        changes.push({ path: filePath, status: changeStatus });
+      }
+      return changes;
+    } catch (error) {
+      log.w("GITWATCHER", "get_uncommitted_fail", { err: String(error) });
+      return [];
+    }
+  }
+  /**
+   * Check for uncommitted file changes and trigger callbacks
+   */
+  async checkUncommittedChanges() {
+    const currentFiles = await this.getUncommittedFiles();
+    const currentSet = new Set(currentFiles.map((f) => f.path));
+    const changedFiles = [];
+    for (const file of currentFiles) {
+      if (!this.lastUncommittedFiles.has(file.path)) {
+        changedFiles.push(file.path);
+      }
+    }
+    for (const filePath of this.lastUncommittedFiles) {
+      if (!currentSet.has(filePath)) {
+        changedFiles.push(filePath);
+      }
+    }
+    this.lastUncommittedFiles = currentSet;
+    if (changedFiles.length > 0) {
+      log.i("GITWATCHER", "uncommitted_detected", { count: changedFiles.length });
+      for (const callback of this.uncommittedChangeCallbacks) {
+        try {
+          callback(changedFiles);
+        } catch (error) {
+          log.w("GITWATCHER", "uncommitted_cb_err", { err: String(error) });
+        }
+      }
+      for (const callback of this.fileChangeCallbacks) {
+        try {
+          callback(changedFiles);
+        } catch (error) {
+          log.w("GITWATCHER", "file_cb_err", { err: String(error) });
+        }
+      }
+      if (this.debouncedChangeCallbacks.length > 0) {
+        for (const file of changedFiles) {
+          this.pendingChanges.add(file);
+        }
+        this.scheduleDebouncedFlush();
+      }
+    }
+  }
+};
+
+// src/agents/indexer-agent.ts
+init_logging();
+init_storage_paths();
+
+// src/storage/batch-operations-libsql.ts
+init_logging();
+init_storage_paths();
+var DEFAULT_BATCH_SIZE = 1e3;
+var MAX_BATCH_SIZE = 2e3;
+var ID_LENGTH = 12;
+var yieldToEventLoop = () => new Promise((resolve) => setImmediate(resolve));
+var BatchOperationsLibSQL = class {
+  batchSize;
+  adapter;
+  xxhashInstance = null;
+  currentContext = {
+    projectHash: "_unset_",
+    branchName: "_unset_"
+  };
+  constructor(adapter, batchSize = DEFAULT_BATCH_SIZE) {
+    this.adapter = adapter;
+    this.batchSize = Math.min(batchSize, MAX_BATCH_SIZE);
+  }
+  setProjectContext(context) {
+    log.i("BATCHOPS", "context_set", { ctx: `${context.projectHash}/${context.branchName}` });
+    this.currentContext = context;
+    this.adapter.setProjectContext(context);
+  }
+  setProject(projectPath, branchName) {
+    const resolvedBranch = branchName ?? getCurrentGitBranchOrDefault(projectPath);
+    this.setProjectContext({
+      projectHash: getProjectHash(projectPath),
+      branchName: resolvedBranch
+    });
+  }
+  async initialize() {
+    this.xxhashInstance = await xxhash();
+  }
+  destroy() {
+  }
+  // ---------------------------------------------------------------------------
+  // Helpers: stable keys/ids
+  // ---------------------------------------------------------------------------
+  entityKey(e) {
+    const isGlobal = e.type === "package" || e.type === "import";
+    return isGlobal ? `${e.type}|${e.name}` : `${e.filePath}|${e.type}|${e.name}|${e.location?.start?.index ?? -1}-${e.location?.end?.index ?? -1}`;
+  }
+  stableEntityId(e) {
+    if (!this.xxhashInstance) {
+      throw new Error("BatchOperationsLibSQL not initialized - call initialize() first");
+    }
+    const key = this.entityKey(e);
+    return this.xxhashInstance.h64ToString(key).slice(0, ID_LENGTH);
+  }
+  relationshipKey(r) {
+    return `${r.fromId}|${r.toId}|${r.type}`;
+  }
+  stableRelationshipId(r) {
+    if (!this.xxhashInstance) {
+      throw new Error("BatchOperationsLibSQL not initialized - call initialize() first");
+    }
+    const key = this.relationshipKey(r);
+    return this.xxhashInstance.h64ToString(key).slice(0, ID_LENGTH);
+  }
+  /**
+   * Generate reverse relationships for bidirectional graph traversal.
+   * For each CALLS relationship A→B, creates a CALLED_BY relationship B→A.
+   * This enables trace_backwards to find callers efficiently.
+   */
+  generateReverseRelationships(relationships) {
+    const reverseMap = {
+      ["calls" /* CALLS */]: "called_by" /* CALLED_BY */,
+      ["imports" /* IMPORTS */]: "imported_by" /* IMPORTED_BY */,
+      ["references" /* REFERENCES */]: "referenced_by" /* REFERENCED_BY */,
+      ["extends" /* EXTENDS */]: "extended_by" /* EXTENDED_BY */,
+      ["implements" /* IMPLEMENTS */]: "implemented_by" /* IMPLEMENTED_BY */,
+      // No reverse for these (already bidirectional or self-referential)
+      ["called_by" /* CALLED_BY */]: null,
+      ["imported_by" /* IMPORTED_BY */]: null,
+      ["referenced_by" /* REFERENCED_BY */]: null,
+      ["extended_by" /* EXTENDED_BY */]: null,
+      ["implemented_by" /* IMPLEMENTED_BY */]: null,
+      ["exports" /* EXPORTS */]: null,
+      ["contains" /* CONTAINS */]: null,
+      ["depends_on" /* DEPENDS_ON */]: null,
+      ["member_of" /* MEMBER_OF */]: null,
+      ["documents" /* DOCUMENTS */]: null,
+      // NgRx relationships - no auto-reverse for now
+      ["dispatches_action" /* DISPATCHES_ACTION */]: null,
+      ["listens_to_action" /* LISTENS_TO_ACTION */]: null,
+      ["handles_action" /* HANDLES_ACTION */]: null,
+      ["selects_state" /* SELECTS_STATE */]: null,
+      ["modifies_state" /* MODIFIES_STATE */]: null,
+      ["produces_api" /* PRODUCES_API */]: null,
+      ["consumes_api" /* CONSUMES_API */]: null,
+      ["generated_from" /* GENERATED_FROM */]: null
+    };
+    const reverse = [];
+    for (const r of relationships) {
+      const reverseType = reverseMap[r.type];
+      if (reverseType) {
+        reverse.push({
+          id: "",
+          // Will be assigned stable ID later
+          fromId: r.toId,
+          toId: r.fromId,
+          type: reverseType,
+          metadata: { ...r.metadata, isReverse: true, originalType: r.type }
+        });
+      }
+    }
+    return reverse;
+  }
+  // ---------------------------------------------------------------------------
+  // Entity Operations
+  // ---------------------------------------------------------------------------
+  async insertEntities(entities, onProgress) {
+    const start = Date.now();
+    const errors = [];
+    let totalProcessed = 0;
+    const { projectHash, branchName } = this.currentContext;
+    log.i("BATCHOPS", "insert_entities", { ctx: `${projectHash}/${branchName}`, count: entities.length });
+    const seen = /* @__PURE__ */ new Set();
+    const uniq = [];
+    for (const e of entities) {
+      const key = this.entityKey(e);
+      if (!seen.has(key)) {
+        seen.add(key);
+        uniq.push(e);
+      }
+    }
+    const batchCount = Math.ceil(uniq.length / this.batchSize);
+    for (let i = 0; i < uniq.length; i += this.batchSize) {
+      const batch = uniq.slice(i, Math.min(i + this.batchSize, uniq.length));
+      const batchNum = Math.floor(i / this.batchSize);
+      try {
+        const entitiesWithIds = batch.map((entity) => {
+          const now = Date.now();
+          return {
+            ...entity,
+            id: entity.id || this.stableEntityId(entity),
+            createdAt: entity.createdAt || now,
+            updatedAt: entity.updatedAt || now
+          };
+        });
+        const result = await this.adapter.insertEntities(entitiesWithIds);
+        totalProcessed += result.processed;
+        if (result.errors.length > 0) {
+          errors.push(...result.errors);
+        }
+        if (onProgress) {
+          onProgress(totalProcessed, uniq.length);
+        }
+        if (batchNum < batchCount - 1) {
+          await yieldToEventLoop();
+        }
+      } catch (error) {
+        log.e("BATCHOPS", "batch_error", { err: String(error) });
+        for (const entity of batch) {
+          errors.push({
+            item: entity,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    return {
+      processed: totalProcessed,
+      failed: errors.length,
+      errors,
+      timeMs: Date.now() - start
+    };
+  }
+  async updateEntities(updates, onProgress) {
+    const entities = updates.map((item) => {
+      if ("changes" in item && item.id) {
+        return {
+          id: item.id,
+          ...item.changes,
+          updatedAt: Date.now()
+        };
+      }
+      return item;
+    });
+    return this.insertEntities(entities, onProgress);
+  }
+  async deleteEntities(entitiesOrIds, onProgress) {
+    const start = Date.now();
+    const errors = [];
+    let totalProcessed = 0;
+    const ids = entitiesOrIds.map((item) => {
+      if (typeof item === "string") return item;
+      return item.id || this.stableEntityId(item);
+    });
+    for (let i = 0; i < ids.length; i += this.batchSize) {
+      const batch = ids.slice(i, Math.min(i + this.batchSize, ids.length));
+      try {
+        for (const id of batch) {
+          await this.adapter.deleteEntity(id);
+          totalProcessed++;
+        }
+        if (onProgress) {
+          onProgress(totalProcessed, ids.length);
+        }
+      } catch (error) {
+        for (const id of batch) {
+          errors.push({
+            item: id,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    return {
+      processed: totalProcessed,
+      failed: errors.length,
+      errors,
+      timeMs: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Relationship Operations
+  // ---------------------------------------------------------------------------
+  async insertRelationships(relationships, onProgress) {
+    const start = Date.now();
+    const errors = [];
+    let totalProcessed = 0;
+    const { projectHash, branchName } = this.currentContext;
+    const reverseRels = this.generateReverseRelationships(relationships);
+    const allRelationships = [...relationships, ...reverseRels];
+    log.i("BATCHOPS", "insert_relationships", {
+      ctx: `${projectHash}/${branchName}`,
+      original: relationships.length,
+      reverse: reverseRels.length,
+      total: allRelationships.length
+    });
+    const seen = /* @__PURE__ */ new Set();
+    const uniq = [];
+    for (const r of allRelationships) {
+      const key = this.relationshipKey(r);
+      if (!seen.has(key)) {
+        seen.add(key);
+        uniq.push(r);
+      }
+    }
+    const batchCount = Math.ceil(uniq.length / this.batchSize);
+    for (let i = 0; i < uniq.length; i += this.batchSize) {
+      const batch = uniq.slice(i, Math.min(i + this.batchSize, uniq.length));
+      const batchNum = Math.floor(i / this.batchSize);
+      try {
+        const relsWithIds = batch.map((rel) => {
+          const now = Date.now();
+          return {
+            ...rel,
+            id: this.stableRelationshipId(rel),
+            createdAt: rel.createdAt || now
+          };
+        });
+        const result = await this.adapter.insertRelationships(relsWithIds);
+        totalProcessed += result.processed;
+        if (result.errors.length > 0) {
+          errors.push(...result.errors);
+        }
+        if (onProgress) {
+          onProgress(totalProcessed, uniq.length);
+        }
+        if (batchNum < batchCount - 1) {
+          await yieldToEventLoop();
+        }
+      } catch (error) {
+        log.e("BATCHOPS", "rel_batch_error", { err: String(error) });
+        for (const rel of batch) {
+          errors.push({
+            item: rel,
+            error: error instanceof Error ? error.message : String(error)
+          });
+        }
+      }
+    }
+    return {
+      processed: totalProcessed,
+      failed: errors.length,
+      errors,
+      timeMs: Date.now() - start
+    };
+  }
+  // ---------------------------------------------------------------------------
+  // Utility Methods
+  // ---------------------------------------------------------------------------
+  optimizeBatchSize(avgProcessingTime) {
+    if (avgProcessingTime < 50) {
+      this.batchSize = Math.min(this.batchSize * 1.2, MAX_BATCH_SIZE);
+    } else if (avgProcessingTime > 200) {
+      this.batchSize = Math.max(this.batchSize * 0.8, 100);
+    }
+    this.batchSize = Math.floor(this.batchSize);
+  }
+  getBatchSize() {
+    return this.batchSize;
+  }
+};
+
+// src/storage/cache-manager.ts
+init_logging();
+init_fast_hash();
+var DEFAULTS = {
+  maxBytes: 100 * 1024 * 1024,
+  maxEntries: 2e3,
+  ttlMs: 5 * 60 * 1e3
+};
+function byteSize(v) {
+  if (v == null) return 0;
+  switch (typeof v) {
+    case "string":
+      return v.length * 2;
+    case "number":
+      return 8;
+    case "boolean":
+      return 4;
+  }
+  if (v instanceof Date) return 8;
+  if (Array.isArray(v)) {
+    let s = 24;
+    for (let i = 0; i < v.length; i++) s += byteSize(v[i]);
+    return s;
+  }
+  if (typeof v === "object") {
+    let s = 24;
+    const rec = v;
+    for (const k of Object.keys(rec)) s += k.length * 2 + byteSize(rec[k]);
+    return s;
+  }
+  return 24;
+}
+var QueryCacheManager = class {
+  store;
+  counters = { hits: 0, misses: 0, evictions: 0, sets: 0 };
+  constructor(cfg = {}) {
+    const ttl = cfg.defaultTTL ?? DEFAULTS.ttlMs;
+    this.store = new LRUCache({
+      max: cfg.maxEntries ?? DEFAULTS.maxEntries,
+      maxSize: cfg.maxSize ?? DEFAULTS.maxBytes,
+      sizeCalculation: (entry) => entry.size || byteSize(entry.value),
+      dispose: (_v, key, reason) => {
+        if (reason === "evict" || reason === "delete") {
+          this.counters.evictions++;
+          log.d("CACHEMGR", "evicted", { key, reason });
+        }
+      },
+      ttl,
+      updateAgeOnGet: true,
+      updateAgeOnHas: false,
+      allowStale: false
+    });
+  }
+  get(key) {
+    const entry = this.store.get(key);
+    if (!entry) {
+      this.counters.misses++;
+      return null;
+    }
+    this.counters.hits++;
+    entry.hits++;
+    this.store.set(key, entry);
+    return entry.value;
+  }
+  set(key, value, ttl) {
+    const entry = {
+      key,
+      value,
+      timestamp: Date.now(),
+      ttl: ttl ?? DEFAULTS.ttlMs,
+      hits: 0,
+      size: byteSize(value)
+    };
+    this.store.set(key, entry);
+    this.counters.sets++;
+  }
+  delete(key) {
+    this.store.delete(key);
+  }
+  clear() {
+    this.store.clear();
+    log.i("CACHEMGR", "cache_cleared");
+  }
+  has(key) {
+    return this.store.has(key);
+  }
+  prune() {
+    const removed = this.store.purgeStale();
+    if (removed) log.i("CACHEMGR", "pruned_stale");
+  }
+  getStats() {
+    const total = this.counters.hits + this.counters.misses;
+    return {
+      size: this.store.size,
+      hits: this.counters.hits,
+      misses: this.counters.misses,
+      hitRate: total > 0 ? this.counters.hits / total : 0,
+      entries: this.store.size,
+      evictions: this.counters.evictions,
+      memoryUsage: this.store.calculatedSize || 0
+    };
+  }
+  getEntries() {
+    return Array.from(this.store.entries()).map(([key, value]) => ({ key, value }));
+  }
+  resetStats() {
+    this.counters = { hits: 0, misses: 0, evictions: 0, sets: 0 };
+  }
+  static createKey(params) {
+    const keys = Object.keys(params).sort();
+    const ordered = {};
+    for (const k of keys) ordered[k] = params[k];
+    return hashText(JSON.stringify(ordered)).substring(0, 16);
+  }
+};
+var instance = null;
+function getCacheManager(config) {
+  if (!instance) instance = new QueryCacheManager(config);
+  return instance;
+}
+
+// src/agents/indexer/entity-resolution.ts
+var CONTAINER_TYPES = /* @__PURE__ */ new Set(["class", "interface", "module", "namespace", "enum", "struct", "object"]);
+function buildEntityNameMap(entities) {
+  const byName = /* @__PURE__ */ new Map();
+  for (const e of entities) {
+    const arr = byName.get(e.name) || [];
+    arr.push(e);
+    byName.set(e.name, arr);
+  }
+  return byName;
+}
+function addEntitiesToNameMap(byName, bySuffix, entities) {
+  for (const e of entities) {
+    const arr = byName.get(e.name) || [];
+    arr.push(e);
+    byName.set(e.name, arr);
+    const dotIdx = e.name.lastIndexOf(".");
+    if (dotIdx >= 0) {
+      const suffix = e.name.slice(dotIdx);
+      const suffArr = bySuffix.get(suffix) || [];
+      suffArr.push(e);
+      bySuffix.set(suffix, suffArr);
+    }
+  }
+}
+function resolveByNameAndLine(byName, name, line, sourceFile, preferContainerType, bySuffix) {
+  if (name.startsWith("this.")) name = name.slice(5);
+  let candidates = byName.get(name);
+  if ((!candidates || candidates.length === 0) && !name.includes(".")) {
+    const suffix = `.${name}`;
+    if (bySuffix) {
+      candidates = bySuffix.get(suffix);
+    } else {
+      candidates = [];
+      for (const [entityName, entities] of byName) {
+        if (entityName.endsWith(suffix)) {
+          candidates.push(...entities);
+        }
+      }
+    }
+  }
+  if (!candidates || candidates.length === 0) return void 0;
+  if (sourceFile && candidates.length > 1) {
+    const sameFile = candidates.filter((c) => c.filePath === sourceFile);
+    if (sameFile.length > 0) {
+      candidates = sameFile;
+    }
+  }
+  if (preferContainerType && candidates.length > 1) {
+    const containers = candidates.filter((c) => CONTAINER_TYPES.has(c.type));
+    if (containers.length > 0) {
+      candidates = containers;
+    }
+  }
+  if (line == null) return candidates[0]?.id;
+  let best;
+  let bestDelta = Infinity;
+  for (const c of candidates) {
+    const d = Math.abs((c.location?.start?.line ?? 0) - line);
+    if (d < bestDelta) {
+      best = c;
+      bestDelta = d;
+    }
+  }
+  return best?.id;
+}
+var ID_LENGTH2 = 12;
+var xxhashInstance = null;
+async function initXXHash() {
+  if (!xxhashInstance) {
+    xxhashInstance = await xxhash();
+  }
+}
+function getXXHash() {
+  if (!xxhashInstance) {
+    throw new Error("xxHash not initialized - call initXXHash() first");
+  }
+  return xxhashInstance;
+}
+function stableEntityId(base) {
+  const isGlobal = base.type === "package" || base.type === "import";
+  const key = isGlobal ? `${base.type}|${base.name}` : `${base.filePath}|${base.type}|${base.name}|${base.location?.start?.index ?? -1}-${base.location?.end?.index ?? -1}`;
+  return getXXHash().h64ToString(key).slice(0, ID_LENGTH2);
+}
+function stableRelationshipId(fromId, toId, type) {
+  return getXXHash().h64ToString(`${fromId}|${toId}|${type}`).slice(0, ID_LENGTH2);
+}
+
+// src/agents/indexer/external-placeholder.ts
+function parseExternalId(extId) {
+  let source = "unknown";
+  let symbol = "unknown";
+  if (extId.startsWith("external:")) {
+    const rest = extId.slice("external:".length);
+    if (/^[A-Za-z]:[\\/]/.test(rest)) {
+      const lastColonIdx = rest.lastIndexOf(":");
+      if (lastColonIdx > 2) {
+        source = rest.slice(0, lastColonIdx);
+        symbol = rest.slice(lastColonIdx + 1) || "unknown";
+      } else {
+        source = rest;
+      }
+    } else {
+      const colonIdx = rest.indexOf(":");
+      if (colonIdx !== -1) {
+        source = rest.slice(0, colonIdx);
+        symbol = rest.slice(colonIdx + 1) || "unknown";
+      } else {
+        source = rest;
+      }
+    }
+  }
+  return { source, symbol };
+}
+function createExternalPlaceholder(extId, seenExternal, placeholders) {
+  const { source, symbol } = parseExternalId(extId);
+  const isFilePath = source.includes("/") || source.includes("\\") || /\.\w+$/.test(source);
+  const qualifiedName = isFilePath || source === "unknown" ? symbol : `${source}.${symbol}`;
+  const placeholderBase = {
+    name: qualifiedName,
+    // Qualified name for cross-module resolution
+    type: "import" /* IMPORT */,
+    filePath: `external://${source}`,
+    location: {
+      start: { line: 0, column: 0, index: 0 },
+      end: { line: 0, column: 0, index: 0 }
+    },
+    metadata: { isExternal: true, source, symbol, qualifiedName },
+    hash: `external:${source}:${symbol}`
+  };
+  const placeholderId = stableEntityId(placeholderBase);
+  if (!seenExternal.has(extId)) {
+    seenExternal.set(extId, placeholderId);
+    placeholders.push({
+      ...placeholderBase,
+      id: placeholderId,
+      createdAt: Date.now(),
+      updatedAt: Date.now()
+    });
+  }
+  return placeholderId;
+}
+async function processExternalRelationships(relationships, stableRelationshipIdFn, lookupEntityByName) {
+  const seenExternal = /* @__PURE__ */ new Map();
+  const placeholders = [];
+  for (const rel of relationships) {
+    if (typeof rel.fromId === "string" && rel.fromId.startsWith("external:")) {
+      rel.fromId = await resolveOrCreatePlaceholder(rel.fromId, seenExternal, placeholders);
+    }
+    if (typeof rel.toId === "string" && rel.toId.startsWith("external:")) {
+      rel.toId = await resolveOrCreatePlaceholder(rel.toId, seenExternal, placeholders);
+    }
+    rel.id = stableRelationshipIdFn(rel.fromId, rel.toId, rel.type);
+  }
+  return placeholders;
+}
+async function resolveOrCreatePlaceholder(extId, seenExternal, placeholders, lookupEntityByName) {
+  const cached = seenExternal.get(extId);
+  if (cached) return cached;
+  parseExternalId(extId);
+  return createExternalPlaceholder(extId, seenExternal, placeholders);
+}
+init_logging();
+async function handleUncommittedChanges(files, ctx) {
+  if (!ctx.currentRepositoryPath || files.length === 0) {
+    return;
+  }
+  log.i("GITWATCHER", "uncommitted_changes", { cnt: files.length });
+  const absolutePaths = files.map((f) => isAbsolute(f) ? f : join(ctx.currentRepositoryPath, f));
+  for (const filePath of absolutePaths) {
+    knowledgeBus.publish(
+      "file:changed",
+      {
+        filePath,
+        changeType: "modified",
+        source: "git-watcher"
+      },
+      ctx.agentId
+    );
+  }
+  knowledgeBus.publish(
+    "indexer:files:changed",
+    {
+      files: absolutePaths,
+      count: absolutePaths.length,
+      repositoryPath: ctx.currentRepositoryPath,
+      source: "git-watcher-uncommitted"
+    },
+    ctx.agentId
+  );
+  log.d("GITWATCHER", "published_changes", { cnt: absolutePaths.length });
+}
+async function handleDebouncedEmbeddingGeneration(files, bulkMode, ctx) {
+  if (!ctx.currentRepositoryPath || files.length === 0) {
+    return;
+  }
+  log.d("GITWATCHER", "debounced_embed", { cnt: files.length, bulkMode });
+  knowledgeBus.publish(
+    "indexer:embeddings:generate",
+    {
+      files,
+      count: files.length,
+      bulkMode,
+      repositoryPath: ctx.currentRepositoryPath,
+      source: "git-watcher-debounced"
+    },
+    ctx.agentId
+  );
+  log.d("GITWATCHER", "embed_event_pub", { cnt: files.length, bulkMode });
+}
+function getChangedFilesBetweenBranches(oldBranch, newBranch, repoPath) {
+  try {
+    const output = execSync(`git diff --name-only ${oldBranch}...${newBranch}`, {
+      cwd: repoPath,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "ignore"],
+      windowsHide: true
+    });
+    const files = output.trim().split("\n").filter((f) => f.length > 0).map((f) => join(repoPath, f));
+    return files;
+  } catch (error) {
+    log.w("GITWATCHER", "get_branch_diff_fail", { err: String(error) });
+    return [];
+  }
+}
+async function handleBranchChange(newBranch, oldBranch, ctx) {
+  log.i("GITWATCHER", "branch_changed", { oldBranch, newBranch });
+  if (!ctx.branchManager || !ctx.currentRepositoryPath) {
+    log.w("GITWATCHER", "branch_mgr_not_init");
+    return;
+  }
+  try {
+    await ctx.branchManager.switchBranch(newBranch, ctx.currentRepositoryPath);
+    const changedFiles = getChangedFilesBetweenBranches(oldBranch, newBranch, ctx.currentRepositoryPath);
+    log.i("GITWATCHER", "branch_files_diff", { cnt: changedFiles.length, oldBranch, newBranch });
+    knowledgeBus.publish(
+      "indexer:branch:changed",
+      {
+        oldBranch,
+        newBranch,
+        repositoryPath: ctx.currentRepositoryPath,
+        changedFiles: changedFiles.length
+      },
+      ctx.agentId
+    );
+    if (changedFiles.length > 0) {
+      knowledgeBus.publish(
+        "indexer:files:changed",
+        {
+          files: changedFiles,
+          count: changedFiles.length,
+          repositoryPath: ctx.currentRepositoryPath,
+          source: "git-watcher-branch-switch"
+        },
+        ctx.agentId
+      );
+      log.i("GITWATCHER", "branch_reindex_triggered", { files: changedFiles.length });
+    }
+    log.i("GITWATCHER", "branch_switched", { newBranch });
+  } catch (error) {
+    log.e("GITWATCHER", "branch_change_fail", { err: String(error) });
+  }
+}
+async function runtimeSleep(ms) {
+  await sleep(ms);
+}
+function scheduleEmbeddingGeneration(ctx, onTrigger) {
+  if (ctx.abortController) {
+    ctx.abortController.abort();
+  }
+  const newAbortController = new AbortController();
+  ctx.setAbortController(newAbortController);
+  const signal = newAbortController.signal;
+  log.d("INDEXER", "embed_scheduled", { ms: ctx.debouncePeriodMs });
+  (async () => {
+    try {
+      const startTime = Date.now();
+      while (!signal.aborted && Date.now() - startTime < ctx.debouncePeriodMs) {
+        await runtimeSleep(1e3);
+      }
+      if (!signal.aborted) {
+        await onTrigger();
+      }
+    } catch (error) {
+    }
+  })();
+}
+async function triggerEmbeddingGeneration(ctx) {
+  if (ctx.pendingGeneration) {
+    log.d("INDEXER", "embed_pending_skip");
+    return;
+  }
+  ctx.setPendingGeneration(true);
+  log.i("INDEXER", "embed_batch_trigger");
+  knowledgeBus.publish(
+    "indexer:incremental:complete",
+    {
+      timestamp: Date.now(),
+      reason: "debounced_after_incremental_update"
+    },
+    ctx.agentId
+  );
+  await runtimeSleep(5e3);
+  ctx.setPendingGeneration(false);
+}
+async function buildRelationships(parsedEntities, storageEntities) {
+  const relationships = [];
+  const entityMap = /* @__PURE__ */ new Map();
+  for (const entity of storageEntities) {
+    entityMap.set(`${entity.name}:${entity.location.start.line}`, entity.id);
+  }
+  const len = Math.min(parsedEntities.length, storageEntities.length);
+  for (let i = 0; i < len; i++) {
+    const parsed = parsedEntities[i];
+    const entity = storageEntities[i];
+    if (parsed.type === "import" && parsed.importData) {
+      for (const specifier of parsed.importData.specifiers) {
+        relationships.push({
+          id: nanoid(12),
+          fromId: entity.id,
+          toId: `external:${parsed.importData.source}:${specifier.imported || specifier.local}`,
+          type: "imports" /* IMPORTS */,
+          metadata: {
+            line: parsed.location.start.line,
+            column: parsed.location.start.column,
+            context: `Import from ${parsed.importData.source}`
+          }
+        });
+      }
+    }
+    if (parsed.references) {
+      for (const ref of parsed.references) {
+        const refKey = Array.from(entityMap.keys()).find((key) => key.startsWith(`${ref}:`));
+        if (refKey) {
+          relationships.push({
+            id: nanoid(12),
+            fromId: entity.id,
+            toId: entityMap.get(refKey),
+            type: "references" /* REFERENCES */,
+            metadata: {
+              line: parsed.location.start.line,
+              column: parsed.location.start.column
+            }
+          });
+        }
+      }
+    }
+    if (parsed.children) {
+      for (const child of parsed.children) {
+        const childKey = `${child.name}:${child.location.start.line}`;
+        const childId = entityMap.get(childKey);
+        if (childId) {
+          relationships.push({
+            id: nanoid(12),
+            fromId: entity.id,
+            toId: childId,
+            type: "contains" /* CONTAINS */,
+            metadata: {
+              line: child.location.start.line,
+              column: child.location.start.column
+            }
+          });
+        }
+      }
+    }
+    if (parsed.inheritance) {
+      if (parsed.inheritance.baseClasses) {
+        for (const baseClass of parsed.inheritance.baseClasses) {
+          const baseKey = Array.from(entityMap.keys()).find((key) => key.startsWith(`${baseClass}:`));
+          const targetId = baseKey ? entityMap.get(baseKey) : `external:${baseClass}`;
+          relationships.push({
+            id: nanoid(12),
+            fromId: entity.id,
+            toId: targetId,
+            type: "extends" /* EXTENDS */,
+            metadata: {
+              line: parsed.location.start.line,
+              column: parsed.location.start.column,
+              context: `${parsed.name} extends ${baseClass}`
+            }
+          });
+        }
+      }
+      if (parsed.inheritance.interfaces) {
+        for (const iface of parsed.inheritance.interfaces) {
+          const ifaceKey = Array.from(entityMap.keys()).find((key) => key.startsWith(`${iface}:`));
+          const targetId = ifaceKey ? entityMap.get(ifaceKey) : `external:${iface}`;
+          relationships.push({
+            id: nanoid(12),
+            fromId: entity.id,
+            toId: targetId,
+            type: "implements" /* IMPLEMENTS */,
+            metadata: {
+              line: parsed.location.start.line,
+              column: parsed.location.start.column,
+              context: `${parsed.name} implements ${iface}`
+            }
+          });
+        }
+      }
+    }
+    if (parsed.relationships) {
+      for (const rel of parsed.relationships) {
+        const effectiveTarget = rel.target.startsWith("this.") ? rel.target.slice(5) : rel.target;
+        const targetKey = Array.from(entityMap.keys()).find((key) => {
+          const entityName = key.split(":")[0] ?? "";
+          if (entityName.startsWith("this.")) return false;
+          return key.startsWith(`${effectiveTarget}:`) || key.includes(`.${effectiveTarget}:`);
+        });
+        const targetId = targetKey ? entityMap.get(targetKey) : `external:${rel.target}`;
+        let relType;
+        switch (rel.type) {
+          case "calls":
+            relType = "calls" /* CALLS */;
+            break;
+          case "inherits":
+            relType = "extends" /* EXTENDS */;
+            break;
+          case "implements":
+            relType = "implements" /* IMPLEMENTS */;
+            break;
+          case "imports":
+            relType = "imports" /* IMPORTS */;
+            break;
+          case "contains":
+            relType = "contains" /* CONTAINS */;
+            break;
+          case "member_of":
+            relType = "member_of" /* MEMBER_OF */;
+            break;
+          case "depends_on":
+            relType = "depends_on" /* DEPENDS_ON */;
+            break;
+          case "produces_api":
+            relType = "produces_api" /* PRODUCES_API */;
+            break;
+          case "consumes_api":
+            relType = "consumes_api" /* CONSUMES_API */;
+            break;
+          case "generated_from":
+            relType = "generated_from" /* GENERATED_FROM */;
+            break;
+          default:
+            relType = "references" /* REFERENCES */;
+            break;
+        }
+        relationships.push({
+          id: nanoid(12),
+          fromId: entity.id,
+          toId: targetId,
+          type: relType,
+          metadata: {
+            line: parsed.location.start.line,
+            column: parsed.location.start.column,
+            context: `${parsed.name} ${rel.type} ${rel.target}`,
+            originalType: rel.type,
+            ...rel.metadata
+          }
+        });
+      }
+    }
+  }
+  return relationships;
+}
+
+// src/agents/indexer-agent.ts
+function getIndexerConfig() {
+  const config = getConfig();
+  return {
+    maxConcurrency: config.indexer?.maxConcurrency ?? 8,
+    memoryLimit: config.indexer?.memoryLimit ?? 512,
+    priority: config.indexer?.priority ?? 7,
+    batchSize: config.indexer?.batchSize ?? 1e3,
+    // OPTIMIZATION: Increased cache size from 50MB to 100MB for better performance
+    cacheSize: config.indexer?.cacheSize ?? 100 * 1024 * 1024,
+    cacheTTL: config.indexer?.cacheTTL ?? 5 * 60 * 1e3
+  };
+}
+var IndexerAgent = class extends BaseAgent {
+  graphStorage;
+  batchOps;
+  cacheManager;
+  branchManager = null;
+  /** Per-project GitWatchers — each project gets its own watcher */
+  gitWatchers = /* @__PURE__ */ new Map();
+  fileWatcher = null;
+  // Debounced embedding generation
+  pendingEmbeddingGeneration = false;
+  embeddingDebounceAbort = null;
+  EMBEDDING_DEBOUNCE_MS = 6e4;
+  // 1 minute
+  currentRepositoryPath = null;
+  subscriptionIds = [];
+  ready = false;
+  lastFileWatcherError = null;
+  indexingStats = {
+    entitiesIndexed: 0,
+    relationshipsCreated: 0,
+    filesProcessed: 0,
+    totalIndexTime: 0,
+    lastIndexTime: 0
+  };
+  // Batch accumulator for streaming indexing optimization
+  // Accumulates entities/relationships and flushes in batches to reduce DB operations
+  BATCH_FLUSH_THRESHOLD = 270;
+  // Flush every 270 files (was 200→50); 3 batches overlaps better with parsing
+  pendingStorageEntities = [];
+  pendingRelationships = [];
+  pendingParsedEntities = [];
+  pendingFilesCount = 0;
+  batchFlushPromise = null;
+  // Incremental entity name map — avoids O(n²) full rebuild on each file
+  entityNameMap = /* @__PURE__ */ new Map();
+  entitySuffixMap = /* @__PURE__ */ new Map();
+  // Idle flush timer - flushes pending batch if no activity for 10 seconds
+  idleFlushAbort = null;
+  IDLE_FLUSH_MS = 1e4;
+  constructor() {
+    super("indexer" /* INDEXER */, getIndexerConfig());
+    log.i("INDEXER", "created", { id: this.id });
+  }
+  /**
+   * Initialize the indexer agent
+   */
+  async onInitialize() {
+    const startTime = Date.now();
+    log.t("INDEXER", `[IndexerAgent] \u25B6 onInitialize() START`);
+    log.i("INDEXER", "init_start");
+    log.t("INDEXER", `[IndexerAgent] \u25B6 initXXHash`);
+    await initXXHash();
+    log.t("INDEXER", `[IndexerAgent] \u25C0 initXXHash (${Date.now() - startTime}ms)`);
+    const appConfig = getConfig();
+    {
+      log.d("INDEXER", "branch_aware_init");
+      const dataDir = appConfig.indexing.dataDir || getDataDir();
+      this.branchManager = new BranchManager({
+        enabled: true,
+        dataDir,
+        maxBranchesPerRepo: appConfig.indexing.maxBranchesPerRepo || 10,
+        maxTotalBranches: appConfig.indexing.maxTotalBranches || 50,
+        evictionStrategy: appConfig.indexing.evictionStrategy || "LRU"
+      });
+      await this.branchManager.initialize();
+      if (appConfig.git?.enabled && appConfig.git.watchBranchChanges) {
+        log.i("INDEXER", "git_watch_enabled");
+      }
+    }
+    log.t("INDEXER", `[IndexerAgent] \u25B6 getGraphStorage`);
+    const gsStart = Date.now();
+    this.graphStorage = await getGraphStorage();
+    log.t("INDEXER", `[IndexerAgent] \u25C0 getGraphStorage (${Date.now() - gsStart}ms)`);
+    if ("initialize" in this.graphStorage && typeof this.graphStorage.initialize === "function") {
+      log.t("INDEXER", `[IndexerAgent] \u25B6 graphStorage.initialize`);
+      await this.graphStorage.initialize();
+      log.t("INDEXER", `[IndexerAgent] \u25C0 graphStorage.initialize (${Date.now() - gsStart}ms)`);
+    }
+    const config = getIndexerConfig();
+    log.t("INDEXER", `[IndexerAgent] \u25B6 BatchOperationsLibSQL.initialize`);
+    const batchStart = Date.now();
+    const adapter = getLibSQLAdapter();
+    if (!adapter) {
+      throw new Error(
+        `[${this.id}] LibSQLAdapter is required but not available - ensure getGraphStorage() was called first`
+      );
+    }
+    this.batchOps = new BatchOperationsLibSQL(adapter, config.batchSize);
+    await this.batchOps.initialize();
+    log.t("INDEXER", `[IndexerAgent] \u25C0 BatchOperationsLibSQL.initialize (${Date.now() - batchStart}ms)`);
+    this.cacheManager = getCacheManager({
+      maxSize: config.cacheSize,
+      defaultTTL: config.cacheTTL
+    });
+    this.subscribeToParseEvents();
+    this.ready = true;
+    log.i("INDEXER", "init_done");
+  }
+  /**
+   * Set the project context for GraphStorage and BatchOperations.
+   * v3: Must be called before indexing to ensure correct project_hash.
+   */
+  setProjectContext(projectPath, branchName) {
+    log.i("INDEXER", "set_project_ctx", { path: projectPath });
+    if (this.graphStorage && typeof this.graphStorage.setProject === "function") {
+      this.graphStorage.setProject(projectPath, branchName);
+      log.d("INDEXER", "gs_ctx_set", { path: projectPath, branch: branchName || "main" });
+    } else {
+      log.w("INDEXER", "gs_ctx_not_ready");
+    }
+    if (this.batchOps && typeof this.batchOps.setProject === "function") {
+      this.batchOps.setProject(projectPath, branchName);
+      log.d("INDEXER", "batch_ctx_set", { path: projectPath, branch: branchName || "main" });
+    } else {
+      log.w("INDEXER", "batch_ctx_not_ready");
+    }
+    this.currentRepositoryPath = projectPath;
+    this.getOrCreateWatcher(projectPath);
+  }
+  /**
+   * Subscribe to parser events via knowledge bus
+   *
+   * NOTE: This is DISABLED because DevAgent directly calls indexerAgent.process()/enqueue()
+   * after parsing. Subscribing to events would cause DOUBLE processing of each file.
+   * Only enable this if IndexerAgent is used standalone without DevAgent.
+   */
+  subscribeToParseEvents() {
+    log.d("INDEXER", "parse_subs_disabled");
+  }
+  // NOTE: handleParseComplete and handleParseBatchComplete are removed because
+  // DevAgent calls indexerAgent.process()/enqueue() directly after parsing.
+  // Keeping these methods would cause unused code warnings.
+  /**
+   * Check if agent can process the task
+   */
+  canProcessTask(_task) {
+    return true;
+  }
+  /**
+   * Process indexer tasks
+   */
+  async processTask(task) {
+    const indexerTask = task;
+    switch (indexerTask.type) {
+      case "index:entities":
+        return await this.indexEntities(
+          indexerTask.payload.entities,
+          indexerTask.payload.filePath,
+          indexerTask.payload.relationships
+        );
+      case "index:incremental":
+        return await this.incrementalUpdate(indexerTask.payload.changes);
+      case "query:graph":
+        return await this.queryGraph(indexerTask.payload.query);
+      case "query:subgraph":
+        return await this.querySubgraph(indexerTask.payload.entityId, indexerTask.payload.depth || 2);
+      default:
+        throw new Error(`Unknown task type: ${indexerTask.type}`);
+    }
+  }
+  /**
+   * Index entities and build relationships
+   */
+  async indexEntities(entities, filePath, providedRelationships) {
+    const startTime = Date.now();
+    const flatEntities = flattenParsedEntities(entities);
+    const childrenExtracted = flatEntities.length - entities.length;
+    const withLang = flatEntities.filter((e) => e.language).length;
+    const langSample = flatEntities.filter((e) => e.language).slice(0, 2);
+    const noLangSample = flatEntities.filter((e) => !e.language).slice(0, 2);
+    log.i("INDEXER", "lang_check", {
+      total: flatEntities.length,
+      withLang,
+      langSample: langSample.map((e) => ({ n: e.name, l: e.language })),
+      noLangSample: noLangSample.map((e) => ({ n: e.name, t: e.type }))
+    });
+    log.d("INDEXER", "indexing", {
+      entities: entities.length,
+      flat: flatEntities.length,
+      children: childrenExtracted,
+      file: filePath
+    });
+    if (childrenExtracted > 0) {
+      const sampleChildren = flatEntities.slice(entities.length, entities.length + 3);
+      log.t("INDEXER", "sample_children", { sample: sampleChildren.map((c) => c.name).join(",") });
+    }
+    const storageEntities = [];
+    const validParsed = [];
+    const preErrors = [];
+    const fileHash = nanoid(8);
+    for (const parsed of flatEntities) {
+      try {
+        const hasValidStructure = parsed && typeof parsed === "object" && "name" in parsed && typeof parsed.name === "string" && "type" in parsed && parsed.type && "location" in parsed && parsed.location;
+        if (!hasValidStructure) {
+          const reasons = [];
+          if (!parsed) reasons.push("null/undefined");
+          else if (typeof parsed !== "object") reasons.push("not object");
+          else {
+            if (!("name" in parsed) || typeof parsed.name !== "string") reasons.push("no name");
+            if (!("type" in parsed) || !parsed.type) reasons.push("no type");
+            if (!("location" in parsed) || !parsed.location) reasons.push("no location");
+          }
+          const entityName = parsed && typeof parsed === "object" && "name" in parsed ? parsed.name : void 0;
+          log.t("INDEXER", "rejected_entity", { name: entityName, reasons: reasons.join(",") });
+          throw new Error("Invalid entity");
+        }
+        const isImport = parsed?.type === "import" && parsed?.importData?.source;
+        const hasName = typeof parsed.name === "string" && parsed.name.trim().length > 0;
+        const normalizedParsed = !hasName && isImport ? { ...parsed, name: `import:${parsed.importData?.source}` } : parsed;
+        const entityFilePath = normalizedParsed.filePath || filePath;
+        const base = parsedEntityToEntity(normalizedParsed, entityFilePath, fileHash);
+        const entity = {
+          ...base,
+          id: stableEntityId(base),
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        storageEntities.push(entity);
+        validParsed.push(normalizedParsed);
+      } catch (e) {
+        preErrors.push({ item: parsed, error: e.message });
+      }
+    }
+    const entityResult = await this.batchOps.insertEntities(storageEntities, (processed, total) => {
+      log.t("INDEXER", "entity_progress", { processed, total });
+    });
+    log.d("INDEXER", "entity_insert_done", {
+      processed: entityResult.processed,
+      failed: entityResult.failed,
+      errors: entityResult.errors.length
+    });
+    if (entityResult.failed > 0) {
+      log.w("INDEXER", "entity_errors", { errs: entityResult.errors.slice(0, 3).map((e) => e.error) });
+    }
+    if (validParsed.length) {
+      const entitiesWithPath = validParsed.map((entity, i) => ({
+        ...entity,
+        id: storageEntities[i]?.id || entity.id,
+        filePath
+      }));
+      knowledgeBus.publish("semantic:new_entities", entitiesWithPath, this.id);
+      log.d("INDEXER", `Published semantic:new_entities EARLY`, {
+        count: entitiesWithPath.length,
+        file: filePath
+      });
+    }
+    let relationships = [];
+    if (providedRelationships && providedRelationships.length > 0) {
+      const byName = buildEntityNameMap(storageEntities);
+      log.t("INDEXER", "entity_names_sample", { sample: Array.from(byName.keys()).slice(0, 10) });
+      const first3 = providedRelationships.slice(0, 3);
+      log.t("INDEXER", "raw_rels_sample", { sample: first3.map((r) => `${r.from}->${r.to}`) });
+      const relLoopStart = Date.now();
+      log.t("INDEXER", "process_rels", { cnt: providedRelationships.length });
+      let callsTotal = 0;
+      let callsFromResolved = 0;
+      let callsToResolved = 0;
+      const callsSample = [];
+      for (const rel of providedRelationships) {
+        const relSourceFile = rel.sourceFile || filePath;
+        const isContains = rel.type === "contains";
+        let fromId = resolveByNameAndLine(byName, rel.from, rel.metadata?.line, relSourceFile, isContains);
+        let toId = resolveByNameAndLine(byName, rel.to, rel.metadata?.line, rel.targetFile || relSourceFile);
+        if (rel.type === "calls") {
+          callsTotal++;
+          if (fromId) callsFromResolved++;
+          if (toId) callsToResolved++;
+          if (callsSample.length < 3) {
+            callsSample.push({
+              from: rel.from,
+              to: rel.to,
+              fromId: fromId || `EXT:${rel.from}`,
+              toId: toId || `EXT:${rel.to}`
+            });
+          }
+        }
+        if (relationships.length === 0) {
+          log.t("INDEXER", "first_rel_resolve", { from: rel.from, fromId, to: rel.to, toId });
+        }
+        if (!fromId) {
+          const src = rel.sourceFile || filePath || "unknown";
+          fromId = `external:${src}:${rel.from}`;
+        }
+        if (!toId) {
+          const src = rel.targetFile || "unknown";
+          toId = `external:${src}:${rel.to}`;
+        }
+        if (fromId && toId) {
+          relationships.push({
+            id: stableRelationshipId(fromId, toId, rel.type),
+            fromId,
+            toId,
+            type: rel.type,
+            metadata: { line: rel.metadata?.line, context: rel.type },
+            createdAt: Date.now()
+          });
+        } else {
+          log.t("INDEXER", "rel_skipped", { from: rel.from, to: rel.to, fromId, toId });
+        }
+      }
+      if (callsTotal > 0) {
+        log.i("INDEXER", "calls_resolution_stats", {
+          total: callsTotal,
+          fromResolved: callsFromResolved,
+          toResolved: callsToResolved,
+          fromPct: Math.round(callsFromResolved / callsTotal * 100),
+          toPct: Math.round(callsToResolved / callsTotal * 100)
+        });
+        if (callsSample.length > 0) {
+          log.i("INDEXER", "calls_sample", { sample: callsSample });
+        }
+        const entityNamesSample = Array.from(byName.keys()).slice(0, 5);
+        log.i("INDEXER", "entity_names_in_map", { sample: entityNamesSample, total: byName.size });
+      }
+      const relLoopMs = Date.now() - relLoopStart;
+      log.i("INDEXER", "RelationshipLoop", {
+        count: providedRelationships.length,
+        builtCount: relationships.length,
+        ms: relLoopMs
+      });
+      log.d("INDEXER", "using_provided_rels", { cnt: relationships.length, ms: relLoopMs });
+    } else {
+      relationships = await this.buildRelationshipsInternal(validParsed, storageEntities);
+      log.d("INDEXER", "built_auto_rels", { cnt: relationships.length });
+    }
+    const externalPlaceholders = await processExternalRelationships(
+      relationships,
+      stableRelationshipId
+      // No lookupEntityByName - just create placeholders (fast path)
+    );
+    if (externalPlaceholders.length > 0) {
+      await this.batchOps.insertEntities(externalPlaceholders);
+    }
+    let relResult = {
+      processed: 0,
+      failed: 0,
+      errors: []
+    };
+    let insertRelMs = 0;
+    if (relationships.length > 0) {
+      log.t("INDEXER", "insert_rels_start", { cnt: relationships.length });
+      const insertRelStart = Date.now();
+      relResult = await this.batchOps.insertRelationships(relationships);
+      insertRelMs = Date.now() - insertRelStart;
+      log.i("INDEXER", "InsertRelationships", {
+        count: relationships.length,
+        processed: relResult.processed,
+        ms: insertRelMs
+      });
+    }
+    const fileInfo = {
+      path: filePath,
+      hash: fileHash,
+      lastIndexed: Date.now(),
+      entityCount: storageEntities.length
+    };
+    await this.graphStorage.updateFileInfo(fileInfo);
+    this.cacheManager.clear();
+    const indexTime = Date.now() - startTime;
+    this.indexingStats.entitiesIndexed += entityResult.processed;
+    this.indexingStats.relationshipsCreated += relResult.processed;
+    this.indexingStats.filesProcessed++;
+    this.indexingStats.totalIndexTime += indexTime;
+    this.indexingStats.lastIndexTime = indexTime;
+    log.t("INDEXER", "pub_index_complete");
+    knowledgeBus.publish(
+      "index:complete",
+      {
+        filePath,
+        entities: entityResult.processed,
+        relationships: relResult.processed,
+        timeMs: indexTime
+      },
+      this.id
+    );
+    log.t("INDEXER", "index_complete_pubbed");
+    log.i("INDEXER", "indexed_done", { entities: entityResult.processed, rels: relResult.processed, ms: indexTime });
+    const failed = entityResult.failed + relResult.failed + preErrors.length;
+    const errors = [...entityResult.errors, ...relResult.errors, ...preErrors];
+    const { timeMs: _throwAway, ...restBase } = entityResult;
+    return {
+      ...restBase,
+      failed,
+      errors,
+      timeMs: indexTime,
+      entitiesIndexed: entityResult.processed,
+      relationshipsCreated: relResult.processed
+    };
+  }
+  /**
+   * Build relationships from parsed entities
+   * Delegates to extracted relationship-builder module
+   */
+  async buildRelationshipsInternal(parsedEntities, storageEntities) {
+    return buildRelationships(parsedEntities, storageEntities);
+  }
+  // ===========================================================================
+  // BATCH ACCUMULATOR METHODS - Optimized streaming indexing
+  // ===========================================================================
+  /**
+   * Reset idle flush timer - called when new entities are queued.
+   * After IDLE_FLUSH_MS of inactivity, pending batch will be flushed.
+   */
+  resetIdleFlushTimer() {
+    if (this.idleFlushAbort) {
+      this.idleFlushAbort.abort();
+    }
+    if (this.pendingFilesCount === 0) {
+      return;
+    }
+    const abortController = new AbortController();
+    this.idleFlushAbort = abortController;
+    (async () => {
+      await sleep(this.IDLE_FLUSH_MS);
+      if (!abortController.signal.aborted && this.pendingFilesCount > 0) {
+        log.d("INDEXER", "idle_flush", {
+          pending: this.pendingFilesCount,
+          entities: this.pendingStorageEntities.length,
+          relationships: this.pendingRelationships.length
+        });
+        logMemory("INDEXER", { pendingFiles: this.pendingFilesCount });
+        try {
+          await this.flushPendingBatch();
+          if (tryGarbageCollect(true)) {
+            log.d("INDEXER", "gc_after_idle_flush");
+          }
+        } catch (err) {
+          log.w("INDEXER", "Idle flush failed", { error: err.message });
+        }
+      }
+    })();
+  }
+  /**
+   * Queue entities for batch indexing (streaming mode optimization)
+   * Accumulates data and flushes in batches to reduce DB operations
+   */
+  queueForIndexing(entities, filePath, providedRelationships) {
+    if (!entities || entities.length === 0) return;
+    this.resetIdleFlushTimer();
+    if (filePath.endsWith(".py") || filePath.endsWith(".cs")) {
+      log.i("INDEXER", "queue_rels_debug", {
+        file: filePath.split(/[/\\]/).pop(),
+        entities: entities.length,
+        relationships: providedRelationships?.length ?? 0,
+        relSample: providedRelationships?.slice(0, 3).map((r) => `${r.from}->${r.to}:${r.type}`)
+      });
+    }
+    const flatEntities = flattenParsedEntities(entities);
+    const fileHash = nanoid(8);
+    const newEntities = [];
+    for (const parsed of flatEntities) {
+      try {
+        if (!parsed?.name || !parsed?.type || !parsed?.location) continue;
+        const entityFilePath = parsed.filePath || filePath;
+        const base = parsedEntityToEntity(parsed, entityFilePath, fileHash);
+        const entity = {
+          ...base,
+          id: stableEntityId(base),
+          createdAt: Date.now(),
+          updatedAt: Date.now()
+        };
+        newEntities.push(entity);
+        if (filePath.endsWith(".cs") && (parsed.type === "class" || parsed.type === "interface")) {
+          log.w("INDEXER", "csharp_entity_id_debug", {
+            name: entity.name,
+            type: entity.type,
+            id: entity.id,
+            entityFilePath: entityFilePath?.split(/[/\\]/).slice(-2).join("/"),
+            parsedFilePath: parsed.filePath?.split(/[/\\]/).slice(-2).join("/"),
+            paramFilePath: filePath?.split(/[/\\]/).slice(-2).join("/"),
+            pathMatch: entityFilePath === filePath,
+            startIndex: base.location?.start?.index,
+            endIndex: base.location?.end?.index
+          });
+        }
+      } catch {
+      }
+    }
+    this.pendingStorageEntities.push(...newEntities);
+    addEntitiesToNameMap(this.entityNameMap, this.entitySuffixMap, newEntities);
+    if (providedRelationships && providedRelationships.length > 0) {
+      if (filePath.endsWith(".swift")) {
+        const callsRels = providedRelationships.filter((r) => r.type === "calls" && r.metadata?.["crossModule"]);
+        if (callsRels.length > 0) {
+          log.w("XMOD", "swift_cross_module", {
+            file: filePath.split(/[/\\]/).pop(),
+            crossModuleCalls: callsRels.length,
+            pendingEntities: this.pendingStorageEntities.length,
+            byNameSize: this.entityNameMap.size,
+            serverPosterKeys: Array.from(this.entityNameMap.keys()).filter((k) => k.includes("ServerPoster")),
+            calls: callsRels.slice(0, 5).map((r) => ({
+              from: r.from,
+              to: r.to,
+              inByName: this.entityNameMap.has(r.to)
+            }))
+          });
+        }
+      }
+      let csResolved = 0;
+      let csUnresolved = 0;
+      for (const rel of providedRelationships) {
+        const relSourceFile = rel.sourceFile || filePath;
+        const isContains = rel.type === "contains";
+        let fromId = resolveByNameAndLine(
+          this.entityNameMap,
+          rel.from,
+          rel.metadata?.line,
+          relSourceFile,
+          isContains,
+          this.entitySuffixMap
+        );
+        let toId = resolveByNameAndLine(
+          this.entityNameMap,
+          rel.to,
+          rel.metadata?.line,
+          rel.targetFile || relSourceFile,
+          void 0,
+          this.entitySuffixMap
+        );
+        if (rel.metadata?.["crossModule"]) {
+          log.w("XMOD", "resolution", {
+            to: rel.to,
+            resolved: !!toId,
+            toId: toId || "UNRESOLVED"
+          });
+        }
+        if (!fromId) fromId = `external:${relSourceFile}:${rel.from}`;
+        if (!toId) toId = `external:${rel.targetFile || "unknown"}:${rel.to}`;
+        if (filePath.endsWith(".cs") && rel.type === "contains" && csResolved + csUnresolved < 5) {
+          log.w("INDEXER", "csharp_rel_id_debug", {
+            file: filePath.split(/[/\\]/).pop(),
+            from: rel.from,
+            to: rel.to,
+            fromId: fromId.slice(0, 16),
+            toId: toId.slice(0, 16),
+            fromIsExternal: fromId.startsWith("external:"),
+            toIsExternal: toId.startsWith("external:"),
+            sourceFile: relSourceFile?.split(/[/\\]/).slice(-2).join("/")
+          });
+        }
+        if (filePath.endsWith(".cs")) {
+          const fromResolved = !fromId.startsWith("external:");
+          const toResolved = !toId.startsWith("external:");
+          if (fromResolved && toResolved) csResolved++;
+          else csUnresolved++;
+        }
+        this.pendingRelationships.push({
+          id: stableRelationshipId(fromId, toId, rel.type),
+          fromId,
+          toId,
+          type: rel.type,
+          metadata: { line: rel.metadata?.line, context: rel.type },
+          createdAt: Date.now()
+        });
+      }
+      if (filePath.endsWith(".cs") && (csResolved > 0 || csUnresolved > 0)) {
+        log.i("INDEXER", "csharp_rel_resolution", {
+          file: filePath.split(/[/\\]/).pop(),
+          resolved: csResolved,
+          unresolved: csUnresolved,
+          pendingEntities: this.pendingStorageEntities.length,
+          byNameSize: this.entityNameMap.size,
+          pendingRels: this.pendingRelationships.length,
+          // Show entity names relevant to this file
+          fileEntityNames: this.pendingStorageEntities.filter((e) => e.filePath === filePath).slice(0, 10).map((e) => `${e.name}(${e.type})`)
+        });
+      }
+    }
+    this.pendingParsedEntities.push({ entities: flatEntities, filePath });
+    this.pendingFilesCount++;
+    if (this.pendingFilesCount >= this.BATCH_FLUSH_THRESHOLD) {
+      this.flushPendingBatch().catch((err) => {
+        log.w("INDEXER", "Auto-flush failed", { error: err.message });
+      });
+    }
+  }
+  /**
+   * Flush all pending entities/relationships to DB in one batch
+   * Returns stats about what was flushed
+   */
+  async flushPendingBatch() {
+    if (this.batchFlushPromise) {
+      await this.batchFlushPromise;
+    }
+    const entitiesToFlush = this.pendingStorageEntities;
+    const relationshipsToFlush = this.pendingRelationships;
+    const parsedToFlush = this.pendingParsedEntities;
+    const filesCount = this.pendingFilesCount;
+    this.pendingStorageEntities = [];
+    this.pendingRelationships = [];
+    this.pendingParsedEntities = [];
+    this.pendingFilesCount = 0;
+    this.entityNameMap = /* @__PURE__ */ new Map();
+    this.entitySuffixMap = /* @__PURE__ */ new Map();
+    if (entitiesToFlush.length === 0) {
+      return { entities: 0, relationships: 0, files: 0 };
+    }
+    const flushStart = Date.now();
+    this.batchFlushPromise = (async () => {
+      const entityResult = await this.batchOps.insertEntities(entitiesToFlush);
+      const stableIdLookup = /* @__PURE__ */ new Map();
+      for (const e of entitiesToFlush) {
+        stableIdLookup.set(`${e.name}|${e.type}|${e.filePath}`, e.id);
+      }
+      for (const { entities, filePath } of parsedToFlush) {
+        const entitiesWithPath = entities.map((e) => {
+          const fp = e.filePath || filePath;
+          const dbId = stableIdLookup.get(`${e.name}|${e.type}|${fp}`);
+          return { ...e, id: dbId || e.id, filePath: fp };
+        });
+        knowledgeBus.publish("semantic:new_entities", entitiesWithPath, this.id);
+      }
+      const externalPlaceholders = await processExternalRelationships(
+        relationshipsToFlush,
+        stableRelationshipId
+        // No lookupEntityByName - just create placeholders (fast path)
+      );
+      if (externalPlaceholders.length > 0) {
+        await this.batchOps.insertEntities(externalPlaceholders);
+      }
+      let relResult = { processed: 0 };
+      if (relationshipsToFlush.length > 0) {
+        const realRels = relationshipsToFlush.filter(
+          (r) => !r.fromId.startsWith("external:") && !r.toId.startsWith("external:")
+        );
+        const externalRels = relationshipsToFlush.length - realRels.length;
+        log.i("INDEXER", "flush_rels", {
+          count: relationshipsToFlush.length,
+          real: realRels.length,
+          external: externalRels,
+          sample: realRels.slice(0, 3).map((r) => `${r.fromId}->${r.toId}:${r.type}`)
+        });
+        const csEntities = entitiesToFlush.filter((e) => e.language === "csharp" && e.type === "class");
+        if (csEntities.length > 0) {
+          const csEntityIds = new Set(csEntities.map((e) => e.id));
+          const allEntityIds = new Set(entitiesToFlush.map((e) => e.id));
+          let csFromCount = 0;
+          let csToCount = 0;
+          let anyRefCount = 0;
+          for (const r of relationshipsToFlush) {
+            if (csEntityIds.has(r.fromId)) csFromCount++;
+            if (csEntityIds.has(r.toId)) csToCount++;
+            if (allEntityIds.has(r.fromId) || allEntityIds.has(r.toId)) anyRefCount++;
+          }
+          const samples = csEntities.slice(0, 3).map((e) => {
+            const rels = relationshipsToFlush.filter((r) => r.fromId === e.id || r.toId === e.id);
+            return {
+              name: e.name,
+              id: e.id,
+              filePath: e.filePath?.split(/[/\\]/).slice(-2).join("/"),
+              relsCount: rels.length,
+              relSample: rels.slice(0, 3).map((r) => `${r.fromId.slice(0, 8)}\u2192${r.toId.slice(0, 8)}:${r.type}`)
+            };
+          });
+          log.w("INDEXER", "flush_cs_crosscheck", {
+            csClasses: csEntities.length,
+            csClassRelsFrom: csFromCount,
+            csClassRelsTo: csToCount,
+            totalRels: relationshipsToFlush.length,
+            relsRefAnyEntity: anyRefCount,
+            samples
+          });
+        }
+        relResult = await this.batchOps.insertRelationships(relationshipsToFlush);
+      }
+      const fileEntityCounts = /* @__PURE__ */ new Map();
+      for (const { filePath, entities } of parsedToFlush) {
+        const current = fileEntityCounts.get(filePath) || 0;
+        fileEntityCounts.set(filePath, current + entities.length);
+      }
+      const fileInfoBatch = [];
+      const now = Date.now();
+      for (const [filePath, entityCount] of fileEntityCounts) {
+        fileInfoBatch.push({
+          path: filePath,
+          hash: nanoid(8),
+          lastIndexed: now,
+          entityCount
+        });
+      }
+      if (fileInfoBatch.length > 0) {
+        if ("batchUpdateFileInfo" in this.graphStorage && typeof this.graphStorage.batchUpdateFileInfo === "function") {
+          await this.graphStorage.batchUpdateFileInfo(fileInfoBatch);
+        } else {
+          for (const fi of fileInfoBatch) {
+            await this.graphStorage.updateFileInfo(fi);
+          }
+        }
+      }
+      this.indexingStats.entitiesIndexed += entityResult.processed;
+      this.indexingStats.relationshipsCreated += relResult.processed;
+      this.indexingStats.filesProcessed += filesCount;
+      log.i("INDEXER", "Batch flush completed", {
+        entities: entityResult.processed,
+        relationships: relResult.processed,
+        files: filesCount,
+        filesTracked: fileEntityCounts.size,
+        ms: Date.now() - flushStart
+      });
+    })();
+    await this.batchFlushPromise;
+    this.batchFlushPromise = null;
+    return {
+      entities: entitiesToFlush.length,
+      relationships: relationshipsToFlush.length,
+      files: filesCount
+    };
+  }
+  /**
+   * Get pending batch stats (for monitoring)
+   */
+  getPendingBatchStats() {
+    return {
+      entities: this.pendingStorageEntities.length,
+      relationships: this.pendingRelationships.length,
+      files: this.pendingFilesCount
+    };
+  }
+  /**
+   * Perform incremental update for changed entities
+   */
+  async incrementalUpdate(changes) {
+    log.d("INDEXER", "incr_update", { cnt: changes.length });
+    const toAdd = [];
+    const toUpdate = [];
+    const toDelete = [];
+    for (const change of changes) {
+      switch (change.type) {
+        case "added":
+          if (change.entity) {
+            toAdd.push(change.entity);
+          }
+          break;
+        case "modified":
+          if (change.entity && change.entityId) {
+            toUpdate.push({
+              id: change.entityId,
+              changes: change.entity
+            });
+          }
+          break;
+        case "deleted":
+          if (change.entityId) {
+            toDelete.push(change.entityId);
+          }
+          break;
+      }
+    }
+    let processed = 0;
+    let failed = 0;
+    const errors = [];
+    if (toAdd.length > 0) {
+      const result = await this.batchOps.insertEntities(toAdd);
+      processed += result.processed;
+      failed += result.failed;
+      errors.push(...result.errors);
+    }
+    if (toUpdate.length > 0) {
+      const result = await this.batchOps.updateEntities(toUpdate);
+      processed += result.processed;
+      failed += result.failed;
+      errors.push(...result.errors);
+    }
+    if (toDelete.length > 0) {
+      const result = await this.batchOps.deleteEntities(toDelete);
+      processed += result.processed;
+      failed += result.failed;
+      errors.push(...result.errors);
+    }
+    this.cacheManager.clear();
+    this.doScheduleEmbeddingGeneration();
+    return {
+      processed,
+      failed,
+      errors,
+      timeMs: 0
+    };
+  }
+  /**
+   * Get embedding scheduler context for extracted functions
+   */
+  getEmbeddingSchedulerContext() {
+    return {
+      agentId: this.id,
+      debouncePeriodMs: this.EMBEDDING_DEBOUNCE_MS,
+      abortController: this.embeddingDebounceAbort,
+      pendingGeneration: this.pendingEmbeddingGeneration,
+      setPendingGeneration: (value) => {
+        this.pendingEmbeddingGeneration = value;
+      },
+      setAbortController: (controller) => {
+        this.embeddingDebounceAbort = controller;
+      }
+    };
+  }
+  /**
+   * Schedule debounced embedding generation
+   * Waits 1 minute after last change before triggering generation
+   */
+  doScheduleEmbeddingGeneration() {
+    const ctx = this.getEmbeddingSchedulerContext();
+    scheduleEmbeddingGeneration(ctx, async () => {
+      await triggerEmbeddingGeneration(this.getEmbeddingSchedulerContext());
+    });
+  }
+  /**
+   * Query the graph
+   */
+  async queryGraph(query) {
+    const cacheKey = QueryCacheManager.createKey(query);
+    const cached = this.cacheManager.get(cacheKey);
+    if (cached) {
+      log.t("INDEXER", "cache_hit_query");
+      return cached;
+    }
+    log.t("INDEXER", "exec_query");
+    const result = await this.graphStorage.executeQuery(query);
+    this.cacheManager.set(cacheKey, result);
+    return result;
+  }
+  /**
+   * Query subgraph for an entity
+   */
+  async querySubgraph(entityId, depth) {
+    const cacheKey = QueryCacheManager.createKey({ entityId, depth });
+    const cached = this.cacheManager.get(cacheKey);
+    if (cached) {
+      log.t("INDEXER", "cache_hit_subgraph");
+      return cached;
+    }
+    log.t("INDEXER", "get_subgraph", { entityId, depth });
+    const result = await this.graphStorage.getSubgraph(entityId, depth);
+    this.cacheManager.set(cacheKey, result);
+    return result;
+  }
+  /**
+   * Handle incoming messages
+   */
+  async handleMessage(message) {
+    log.d("INDEXER", "recv_msg", { type: message.type, from: message.from });
+    switch (message.type) {
+      case "index:request": {
+        const task = {
+          id: message.id,
+          type: "index:entities",
+          priority: 5,
+          payload: message.payload,
+          createdAt: Date.now()
+        };
+        await this.process(task);
+        break;
+      }
+      case "query:request": {
+        const queryTask = {
+          id: message.id,
+          type: "query:graph",
+          priority: 8,
+          payload: message.payload,
+          createdAt: Date.now()
+        };
+        const result = await this.process(queryTask);
+        await this.send({
+          id: nanoid(12),
+          from: this.id,
+          to: message.from,
+          type: "query:response",
+          payload: result,
+          timestamp: Date.now(),
+          correlationId: message.id
+        });
+        break;
+      }
+      default:
+        log.w("INDEXER", "unknown_msg_type", { type: message.type });
+    }
+  }
+  /**
+   * Get Git event context for a specific project path
+   */
+  getGitEventContextForProject(projectPath) {
+    return {
+      agentId: this.id,
+      currentRepositoryPath: projectPath,
+      branchManager: this.branchManager
+    };
+  }
+  /**
+   * Get Git event context for extracted handlers (uses current project)
+   */
+  getGitEventContext() {
+    return this.getGitEventContextForProject(this.currentRepositoryPath);
+  }
+  /**
+   * Get or create a GitWatcher for a specific project path.
+   * Each project gets its own independent watcher so multi-session doesn't interfere.
+   */
+  getOrCreateWatcher(projectPath) {
+    const appConfig = getConfig();
+    if (!appConfig.git?.enabled || !appConfig.git.watchBranchChanges || !this.branchManager) {
+      return null;
+    }
+    const existing = this.gitWatchers.get(projectPath);
+    if (existing) {
+      return existing;
+    }
+    const watcher = new GitWatcher({
+      enabled: true,
+      pollIntervalMs: appConfig.git.pollIntervalMs || 5e3,
+      autoReindex: appConfig.git.autoReindex ?? true,
+      watchUncommitted: appConfig.git.watchUncommitted ?? true,
+      uncommittedPollIntervalMs: appConfig.git.uncommittedPollIntervalMs || 1e4,
+      includeUntracked: appConfig.git.includeUntracked ?? true,
+      debounceMs: appConfig.git.debounceMs ?? 6e4,
+      bulkModeThreshold: appConfig.git.bulkModeThreshold ?? 1e3
+    });
+    const ctx = () => this.getGitEventContextForProject(projectPath);
+    watcher.onBranchChange(async (newBranch, oldBranch) => {
+      await handleBranchChange(newBranch, oldBranch, ctx());
+    });
+    watcher.onUncommittedChange(async (files) => {
+      await handleUncommittedChanges(files, ctx());
+    });
+    watcher.onDebouncedChange(async (files, bulkMode) => {
+      await handleDebouncedEmbeddingGeneration(files, bulkMode, ctx());
+    });
+    this.gitWatchers.set(projectPath, watcher);
+    watcher.startWatching(projectPath);
+    log.i("INDEXER", "git_watcher_started", { repository: projectPath, totalWatchers: this.gitWatchers.size });
+    return watcher;
+  }
+  /**
+   * Get BranchManager instance
+   */
+  getBranchManager() {
+    return this.branchManager;
+  }
+  /**
+   * Get GitWatcher instance for current or specific project
+   */
+  getGitWatcher(projectPath) {
+    const path = projectPath || this.currentRepositoryPath;
+    return path ? this.gitWatchers.get(path) ?? null : null;
+  }
+  /**
+   * Get FileWatcher status for diagnostics
+   */
+  getFileWatcherStatus() {
+    if (!this.fileWatcher) {
+      return { exists: false, lastError: this.lastFileWatcherError };
+    }
+    return {
+      exists: true,
+      status: this.fileWatcher.getStatus(),
+      lastError: null
+    };
+  }
+  /**
+   * Set current repository path and start watching if Git is enabled
+   */
+  async setRepositoryPath(path) {
+    this.currentRepositoryPath = path;
+    this.getOrCreateWatcher(path);
+    log.d("INDEXER", "creating_filewatcher", { path });
+    try {
+      if (this.fileWatcher) {
+        log.d("INDEXER", "stopping_old_filewatcher");
+        await this.fileWatcher.stop();
+        this.fileWatcher = null;
+      }
+      const appConfig = getConfig();
+      this.fileWatcher = await createFileWatcher({
+        rootDir: path,
+        include: [
+          "**/*.ts",
+          "**/*.tsx",
+          "**/*.js",
+          "**/*.jsx",
+          "**/*.py",
+          "**/*.go",
+          "**/*.rs",
+          "**/*.java",
+          "**/*.kt",
+          "**/*.cpp",
+          "**/*.c",
+          "**/*.h",
+          "**/*.hpp"
+        ],
+        exclude: [
+          "**/node_modules/**",
+          "**/.git/**",
+          "**/dist/**",
+          "**/build/**",
+          "**/.ultracode/**",
+          "**/coverage/**",
+          "**/__pycache__/**",
+          "**/venv/**",
+          "**/.venv/**"
+        ],
+        debounceMs: 100,
+        bulkThreshold: appConfig.git?.bulkModeThreshold ?? 1e3
+      });
+      this.fileWatcher.on("change", (events, bulkMode) => {
+        this.handleFileWatcherChanges(events, bulkMode).catch((err) => {
+          log.e("INDEXER", "FileWatcher change handler error", { error: err.message });
+        });
+      });
+      this.fileWatcher.on("error", (err) => {
+        log.e("INDEXER", "FileWatcher error", { error: err.message });
+      });
+      log.i("INDEXER", "Started FileWatcher", { repository: path });
+      this.lastFileWatcherError = null;
+    } catch (err) {
+      this.lastFileWatcherError = err.message;
+      log.w("INDEXER", "Failed to start FileWatcher, using GitWatcher only", {
+        error: this.lastFileWatcherError
+      });
+    }
+  }
+  /**
+   * Handle file changes detected by FileWatcher
+   * Triggers incremental reindexing and debounced embedding generation
+   */
+  async handleFileWatcherChanges(events, bulkMode) {
+    if (events.length === 0) return;
+    const changedFiles = events.filter((e) => e.type === "add" || e.type === "change").map((e) => e.path);
+    const deletedFiles = events.filter((e) => e.type === "unlink").map((e) => e.path);
+    log.d("INDEXER", "FileWatcher detected changes", {
+      changed: changedFiles.length,
+      deleted: deletedFiles.length,
+      bulkMode
+    });
+    if (changedFiles.length > 0) {
+      await handleUncommittedChanges(changedFiles, this.getGitEventContext());
+    }
+    if (deletedFiles.length > 0) {
+      log.d("INDEXER", "Detected deleted files (cleaned on reindex)", {
+        count: deletedFiles.length,
+        files: deletedFiles.slice(0, 5)
+      });
+    }
+    if (!bulkMode) {
+      this.doScheduleEmbeddingGeneration();
+    } else {
+      await handleDebouncedEmbeddingGeneration(changedFiles, bulkMode, this.getGitEventContext());
+    }
+  }
+  /**
+   * Shutdown the indexer agent
+   */
+  async onShutdown() {
+    log.i("INDEXER", "Shutting down...");
+    if (this.idleFlushAbort) {
+      this.idleFlushAbort.abort();
+      this.idleFlushAbort = null;
+    }
+    if (this.pendingFilesCount > 0) {
+      log.d("INDEXER", "shutdown_flush_pending", { pending: this.pendingFilesCount });
+      try {
+        await this.flushPendingBatch();
+      } catch (err) {
+        log.w("INDEXER", "shutdown_flush_failed", { error: err.message });
+      }
+    }
+    if (this.fileWatcher) {
+      try {
+        await this.fileWatcher.stop();
+        this.fileWatcher = null;
+        log.d("INDEXER", "FileWatcher stopped");
+      } catch (err) {
+        log.w("INDEXER", "Error stopping FileWatcher", { error: err.message });
+      }
+    }
+    for (const [path, watcher] of this.gitWatchers) {
+      watcher.stopWatching();
+      log.d("INDEXER", "git_watcher_stopped", { repository: path });
+    }
+    this.gitWatchers.clear();
+    try {
+      for (const id of this.subscriptionIds) {
+        knowledgeBus.unsubscribe(id);
+      }
+    } catch {
+    }
+    if (this.ready) {
+      try {
+        await this.graphStorage.analyze();
+      } catch (e) {
+        log.w("INDEXER", "shutdown_analyze_skip", { err: e.message });
+      }
+    }
+    try {
+      this.cacheManager?.clear();
+    } catch {
+    }
+    log.i("INDEXER", "shutdown_done", this.indexingStats);
+  }
+  /**
+   * Get indexing statistics
+   */
+  getIndexingStats() {
+    return { ...this.indexingStats };
+  }
+  /**
+   * Get storage metrics
+   */
+  async getStorageMetrics() {
+    return await this.graphStorage.getMetrics();
+  }
+  /**
+   * Perform maintenance operations
+   */
+  async performMaintenance() {
+    log.i("INDEXER", "maint_start");
+    await this.graphStorage.vacuum();
+    await this.graphStorage.analyze();
+    this.cacheManager.prune();
+    const avgTime = this.indexingStats.totalIndexTime / Math.max(1, this.indexingStats.filesProcessed);
+    this.batchOps.optimizeBatchSize(avgTime);
+    log.i("INDEXER", "maint_done");
+  }
+};
+
+export { IndexerAgent };
+//# sourceMappingURL=chunk-NZFF4DQ4.js.map
+//# sourceMappingURL=chunk-NZFF4DQ4.js.map