@massa-ai/tools-api 1.16.0 → 1.18.0

package/dist/index.js

@@ -13109,7 +13109,7 @@ var init_ignore_patterns = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/data/db-connection.js
+// ../../packages/core/dist/kernel/db-connection.js
 import { Pool } from "pg";
 function getDbConfig() {
   return {
@@ -13137,7 +13137,7 @@ var init_db_connection = __esm(() => {
   init_config();
 });
 
-// ../../packages/core/dist/services/project-identity/alias-resolver.js
+// ../../packages/core/dist/kernel/alias-resolver.js
 class ProjectIdentityAliasResolver {
   ttlMs;
   resolveTimeoutMs;
@@ -13461,6 +13461,16 @@ var init_index_manager = __esm(() => {
   globAsync = glob;
 });
 
+// ../../packages/core/dist/services/cache/lru-evict.js
+function evictOldest(cache, maxRetained) {
+  while (cache.size > maxRetained) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+  }
+}
+
 // ../../packages/core/dist/services/search/file-filter-cache.js
 class FileFilterCache {
   cache = new Map;
@@ -13529,18 +13539,7 @@ class FileFilterCache {
     return parts.join("|");
   }
   evictOldest() {
-    let oldestKey = null;
-    let oldestTime = Infinity;
-    for (const [key, entry] of this.cache.entries()) {
-      if (entry.createdAt < oldestTime) {
-        oldestTime = entry.createdAt;
-        oldestKey = key;
-      }
-    }
-    if (oldestKey) {
-      this.cache.delete(oldestKey);
-      logger.debug("Evicted oldest filter cache entry", { key: oldestKey });
-    }
+    evictOldest(this.cache, this.MAX_CACHE_SIZE);
   }
   invalidateProject(projectId) {
     let removed = 0;
@@ -104662,7 +104661,7 @@ model ManagedRun {
   Object.assign(exports, Prisma);
 });
 
-// ../../packages/core/dist/services/query/prisma-client.js
+// ../../packages/core/dist/kernel/prisma-client.js
 var exports_prisma_client = {};
 __export(exports_prisma_client, {
   getPrismaClient: () => getPrismaClient2,
@@ -105473,7 +105472,7 @@ var init_query_understanding = __esm(() => {
   HYDE_SYSTEM = "You write a hypothetical implementation paragraph that a code-knowledge " + "search system will embed and match against real documents. Write ONE " + "concise paragraph (3-6 sentences) of plausible implementation detail " + "(types, function signatures, control flow) that a relevant document would " + "contain. No preamble, no markdown.";
 });
 
-// ../../packages/core/dist/services/structural/types.js
+// ../../packages/core/dist/kernel/types.js
 var STRUCTURAL_TAXONOMY_VERSION = "1.0.0", SOURCE_SPAN_SCHEMA_VERSION = "1.0.0", STRUCTURAL_FQN_SCHEMA_VERSION = "1.0.0";
 var init_types3 = __esm(() => {
   init_dist();
@@ -106565,7 +106564,7 @@ answer = 42
   });
 });
 
-// ../../packages/core/dist/services/project-identity/registry.js
+// ../../packages/core/dist/kernel/registry.js
 function directStorePolicy(tableName, columnName) {
   if (/^vector_documents(?:_\d+d)?$/.test(tableName) && columnName === "project_id") {
     return { storeId: tableName, identityColumn: columnName, mutable: true };
@@ -106626,7 +106625,7 @@ var init_registry = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/services/project-identity/identity-guard-installer.js
+// ../../packages/core/dist/kernel/identity-guard-installer.js
 async function installGuardOnTable(client, schema, table, column) {
   try {
     await client.query(`SELECT project_identity_install_guard($1::regclass, $2)`, [`${schema}.${table}`, column]);
@@ -106691,7 +106690,7 @@ var init_identity_guard_installer = __esm(() => {
   init_registry();
 });
 
-// ../../packages/core/dist/services/search/lexical-search.js
+// ../../packages/core/dist/kernel/lexical-search.js
 function dedupeTokens(tokens) {
   const seen = new Set;
   const out = [];
@@ -107355,9 +107354,16 @@ var init_keyword_search_factory = __esm(() => {
 // ../../packages/core/dist/data/vector/base-vector-store.js
 class BaseVectorStore {
   embeddingProviderPromise = null;
+  embeddingProviderFactory;
+  constructor(options) {
+    this.embeddingProviderFactory = options?.embeddingProviderFactory;
+  }
   getEmbeddingProvider() {
     if (!this.embeddingProviderPromise) {
-      this.embeddingProviderPromise = createEmbeddingProvider({ cache: true });
+      if (!this.embeddingProviderFactory) {
+        throw new Error("BaseVectorStore: no embeddingProviderFactory was supplied. Construct this store " + "via services/vector/vector-store-factory.ts (getVectorStore), or pass an explicit " + "embeddingProviderFactory to the constructor.");
+      }
+      this.embeddingProviderPromise = this.embeddingProviderFactory();
     }
     return this.embeddingProviderPromise;
   }
@@ -107403,7 +107409,6 @@ class BaseVectorStore {
   }
 }
 var init_base_vector_store = __esm(() => {
-  init_embeddings();
   init_dist();
 });
 
@@ -107529,7 +107534,7 @@ var init_postgres_vector_store = __esm(() => {
     tableName = "vector_documents";
     bqEnabled = false;
     constructor(config3) {
-      super();
+      super(config3.embeddingProviderFactory ? { embeddingProviderFactory: config3.embeddingProviderFactory } : undefined);
       this.config = {
         poolSize: 10,
         indexType: "hnsw",
@@ -107985,7 +107990,7 @@ var init_postgres_vector_store = __esm(() => {
   };
 });
 
-// ../../packages/core/dist/data/vector/vector-store-factory.js
+// ../../packages/core/dist/services/vector/vector-store-factory.js
 async function getVectorStore(config3) {
   if (cachedStore)
     return cachedStore;
@@ -108002,6 +108007,7 @@ async function getVectorStore(config3) {
       ...ivfflatLists ? { lists: ivfflatLists } : {}
     };
     const store = new PostgresVectorStore({
+      embeddingProviderFactory: () => createEmbeddingProvider({ cache: true }),
       connectionString,
       poolSize: Number.parseInt(process.env.POSTGRES_VECTOR_POOL_SIZE || "10", 10),
       indexType: process.env.POSTGRES_VECTOR_INDEX || "hnsw",
@@ -108028,6 +108034,7 @@ var init_vector_store_factory = __esm(() => {
   init_dist();
   init_config();
   init_postgres_vector_store();
+  init_embeddings();
 });
 
 // ../../packages/core/dist/services/search/search-cache-pg.js
@@ -108599,7 +108606,7 @@ var init_analytics_factory = __esm(() => {
   init_dist();
 });
 
-// ../../packages/core/dist/services/structural/schema-version.js
+// ../../packages/core/dist/kernel/schema-version.js
 function parseSemver(version3) {
   const match2 = SEMVER_PATTERN.exec(version3.trim());
   if (!match2)
@@ -108638,7 +108645,7 @@ var init_schema_version = __esm(() => {
   SEMVER_PATTERN = /^(\d+)\.(\d+)\.(\d+)$/u;
 });
 
-// ../../packages/core/dist/services/structural/fqn-codec.js
+// ../../packages/core/dist/kernel/fqn-codec.js
 import { createHash as createHash3 } from "crypto";
 function normalizedNfcText(value, label) {
   const normalized = value.normalize("NFC").trim();
@@ -110955,7 +110962,7 @@ var init_memory_repository_factory = __esm(() => {
   init_memory_repository_pg();
 });
 
-// ../../packages/core/dist/services/graph/graph-store-pg.js
+// ../../packages/core/dist/services/memory-graph/graph-store-pg.js
 function metadataForEdge(edge) {
   return {
     autoExtracted: edge.autoExtracted ?? false,
@@ -111271,7 +111278,7 @@ var init_graph_store_pg = __esm(() => {
   graphStorePg = GraphStorePg.getInstance();
 });
 
-// ../../packages/core/dist/services/graph/graph-store-factory.js
+// ../../packages/core/dist/services/memory-graph/graph-store-factory.js
 function getGraphStore() {
   if (cachedStore2)
     return cachedStore2;
@@ -112877,7 +112884,7 @@ var init_reranker = __esm(() => {
   });
 });
 
-// ../../packages/core/dist/tools/enum-validation.js
+// ../../packages/core/dist/kernel/enum-validation.js
 function validateEnum(paramName, value, validValues) {
   if (typeof value !== "string" || !validValues.includes(value)) {
     throw new ToolError(`Invalid ${paramName} value: ${String(value)}. Valid values: ${validValues.join(", ")}.`);
@@ -112949,7 +112956,7 @@ var init_filter_validation = __esm(() => {
   init_enum_validation();
 });
 
-// ../../packages/core/dist/controllers/search-controller.js
+// ../../packages/core/dist/services/search/search-controller.js
 var exports_search_controller = {};
 __export(exports_search_controller, {
   SearchController: () => SearchController
@@ -113694,7 +113701,7 @@ var init_session_bias = __esm(() => {
   init_synapse();
 });
 
-// ../../packages/core/dist/services/search/search-diagnostics.js
+// ../../packages/core/dist/kernel/search-diagnostics.js
 function searchBackendUnavailable(component, cause) {
   return cause instanceof SearchServiceError ? cause : new SearchServiceError("SEARCH_BACKEND_UNAVAILABLE", component, { cause });
 }
@@ -122205,16 +122212,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path18 = e.route;
-    if (!path18)
+    const path19 = e.route;
+    if (!path19)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path18;
+    const key = method + " " + path19;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path18,
+      path: path19,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -122225,12 +122232,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path18 = parsed?.path ?? d.name;
-    const key = method + " " + path18;
+    const path19 = parsed?.path ?? d.name;
+    const key = method + " " + path19;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path18, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path19, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -122451,7 +122458,7 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path18 from "path";
+import path19 from "path";
 import fs9 from "fs/promises";
 
 class SymbolGraphService {
@@ -122805,7 +122812,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path18.resolve(root, relativePath) : relativePath;
+    return root ? path19.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -122825,12 +122832,7 @@ class SymbolGraphService {
     return null;
   }
   evictOldestProjectRoot() {
-    while (this.projectRootCache.size >= this.PROJECT_ROOT_CACHE_MAX_ENTRIES) {
-      const oldest = this.projectRootCache.keys().next().value;
-      if (oldest === undefined)
-        break;
-      this.projectRootCache.delete(oldest);
-    }
+    evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
   }
   clearProjectRoot(projectId) {
     this.projectRootCache.delete(projectId);
@@ -123122,7 +123124,7 @@ var init_memory_service = __esm(() => {
   init_decay();
 });
 
-// ../../packages/core/dist/services/graph/relation-extractor.js
+// ../../packages/core/dist/services/memory-graph/relation-extractor.js
 class RelationExtractor {
   graphStore;
   constructor(graphStore) {
@@ -123360,7 +123362,7 @@ var init_relation_extractor = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/services/graph/graph-queries.js
+// ../../packages/core/dist/services/memory-graph/graph-queries.js
 class GraphQueries {
   graphStore;
   constructor(graphStore) {
@@ -123580,7 +123582,7 @@ var init_graph_queries = __esm(() => {
   };
 });
 
-// ../../packages/core/dist/services/graph/memory-graph.service.js
+// ../../packages/core/dist/services/memory-graph/memory-graph.service.js
 class MemoryGraphService {
   static instance = null;
   store;
@@ -124146,7 +124148,7 @@ var init_salience_judge = __esm(() => {
   });
 });
 
-// ../../packages/core/dist/controllers/memory-controller.js
+// ../../packages/core/dist/services/memory/memory-controller.js
 class MemoryController {
   static instance = null;
   repo;
@@ -124783,6 +124785,45 @@ var init_code_compressor = __esm(() => {
   init_llm_client();
 });
 
+// ../../packages/core/dist/services/compression/compress-with-metrics.js
+async function compressWithMetrics(compressor, content, strategy, options = {}) {
+  const { language, targetRatio } = options;
+  const unit = language || "code";
+  const originalTokens = estimateTokens(content, unit);
+  logger.info("Compressing context", {
+    originalTokens,
+    strategy,
+    targetRatio
+  });
+  const result = await compressor.compress(content, strategy);
+  const compressedTokens = estimateTokens(result.compressed, unit);
+  const compressionRatio = 1 - compressedTokens / originalTokens;
+  const tokensSaved = originalTokens - compressedTokens;
+  logger.info("Context compressed", {
+    originalTokens,
+    compressedTokens,
+    tokensSaved,
+    actualRatio: compressionRatio.toFixed(2),
+    targetRatio
+  });
+  return {
+    compressed: result.compressed,
+    originalTokens,
+    compressedTokens,
+    tokensSaved,
+    compressionRatio
+  };
+}
+var init_compress_with_metrics = __esm(() => {
+  init_dist();
+});
+
+// ../../packages/core/dist/services/compression/index.js
+var init_compression = __esm(() => {
+  init_code_compressor();
+  init_compress_with_metrics();
+});
+
 // ../../packages/core/dist/services/metrics/token-metrics.js
 class TokenMetrics {
   static instance = null;
@@ -125116,6 +125157,340 @@ var init_session_file_cache = __esm(() => {
   SESSION_TTL_MS = 4 * 60 * 60 * 1000;
 });
 
+// ../../packages/core/dist/services/context/context-controller.js
+class ContextController {
+  static instance = null;
+  searchCtrl;
+  memoryCtrl;
+  compressor;
+  sessionCache;
+  constructor() {
+    this.searchCtrl = SearchController.getInstance();
+    this.memoryCtrl = MemoryController.getInstance();
+    this.compressor = new CodeCompressor;
+    this.sessionCache = SessionFileCache.getInstance();
+  }
+  static getInstance() {
+    if (!ContextController.instance) {
+      ContextController.instance = new ContextController;
+    }
+    return ContextController.instance;
+  }
+  async getOptimizedContext(input) {
+    const { query, projectId, projectPath: projectPath2, maxTokens = 4000, maxResults = 5, workingMemoryBudget, userId, sessionId, includeMemories = true, memoryBudgetRatio = 0.2 } = input;
+    const clampedRatio = Math.max(0, Math.min(0.5, memoryBudgetRatio));
+    const memoryTokenBudget = includeMemories ? Math.floor(maxTokens * clampedRatio) : 0;
+    const codeTokenBudget = maxTokens - memoryTokenBudget;
+    const wmBudget = workingMemoryBudget || Math.floor(codeTokenBudget * 0.8);
+    logger.info("Getting optimized context", {
+      query: query.slice(0, 50),
+      projectId,
+      maxTokens,
+      includeMemories,
+      memoryTokenBudget,
+      codeTokenBudget,
+      workingMemoryBudget: wmBudget
+    });
+    let graphContextSection = "";
+    let graphBoostFiles = [];
+    if (projectId && await symbolGraphService.hasData(projectId) && looksLikeSymbol(query)) {
+      try {
+        const [defs, refs] = await Promise.all([
+          symbolGraphService.goToDefinition(projectId, query),
+          symbolGraphService.getReferences(projectId, query)
+        ]);
+        if (defs.length > 0) {
+          const graphTokenBudget = Math.floor(codeTokenBudget * 0.2);
+          graphContextSection = formatGraphContext(defs, refs, graphTokenBudget);
+          graphBoostFiles = [
+            ...new Set([
+              ...defs.map((d) => d.file),
+              ...refs.slice(0, 10).map((r2) => r2.fromFile)
+            ])
+          ];
+          logger.debug("Graph prefilter hit", {
+            query,
+            defs: defs.length,
+            refs: refs.length,
+            boostFiles: graphBoostFiles.length
+          });
+        }
+      } catch (err) {
+        logger.warn("Graph prefilter failed", { query, error: err.message });
+      }
+    }
+    const [searchResult, memories] = await Promise.all([
+      this.searchCtrl.searchProject({
+        query,
+        projectId,
+        projectPath: projectPath2,
+        maxResults,
+        responseMode: "full",
+        autoReindex: false,
+        minScore: 0.4,
+        boostFiles: graphBoostFiles.length > 0 ? graphBoostFiles : undefined
+      }),
+      includeMemories ? this.searchMemoriesSafe(query, {
+        projectId,
+        userId,
+        sessionId,
+        limit: 5
+      }) : Promise.resolve([])
+    ]);
+    const codeResults = searchResult.results;
+    const workingSet = this.selectWorkingSet(codeResults, wmBudget);
+    const memorySection = this.formatMemorySection(memories, memoryTokenBudget);
+    if (workingSet.length === 0 && memories.length === 0) {
+      return {
+        context: `No relevant code or memories found for query: "${query}"`,
+        sources: [],
+        resultsCount: 0,
+        memoriesCount: 0,
+        tokensSaved: 0,
+        compressionRatio: 0,
+        sessionCacheHits: 0,
+        tokensSavedBySessionCache: 0
+      };
+    }
+    let sessionCacheHits = 0;
+    let tokensSavedBySessionCache = 0;
+    const deliveryPlan = workingSet.map((r2) => {
+      if (!sessionId) {
+        return { result: r2, kind: "full", tokensSaved: 0 };
+      }
+      const content = r2.content || r2.preview || "";
+      const key = this.sessionCache.chunkKey(r2.filePath || "unknown", r2.lineStart ?? 0, r2.lineEnd ?? 0);
+      const check3 = this.sessionCache.check(sessionId, key, content);
+      if (check3.status === "unchanged") {
+        sessionCacheHits++;
+        tokensSavedBySessionCache += check3.tokensSaved;
+        return { result: r2, kind: "ref", tokensSaved: check3.tokensSaved };
+      }
+      if (check3.status === "changed" && check3.diff !== undefined) {
+        sessionCacheHits++;
+        tokensSavedBySessionCache += check3.tokensSaved;
+        return { result: r2, kind: "diff", diff: check3.diff, tokensSaved: check3.tokensSaved };
+      }
+      return { result: r2, kind: "full", tokensSaved: 0 };
+    });
+    const parts = [`# Context for: ${query}
+`];
+    if (graphContextSection) {
+      parts.push(graphContextSection, "");
+    }
+    if (memorySection) {
+      parts.push(memorySection, "");
+    }
+    if (deliveryPlan.length > 0) {
+      const fullCount = deliveryPlan.filter((d) => d.kind === "full").length;
+      const refCount = deliveryPlan.filter((d) => d.kind === "ref").length;
+      const diffCount = deliveryPlan.filter((d) => d.kind === "diff").length;
+      parts.push(`## Code (${deliveryPlan.length} sections \u2014 ${fullCount} full, ${refCount} cached, ${diffCount} diff | WM budget: ${wmBudget} tokens)
+`);
+      deliveryPlan.forEach(({ result: r2, kind, diff }, idx) => {
+        const filePath = r2.filePath || "Unknown";
+        const scoreLabel = (r2.score * 100).toFixed(1);
+        const lineRange = `${r2.lineStart ?? "?"}-${r2.lineEnd ?? "?"}`;
+        parts.push(`### ${idx + 1}. ${filePath} (score: ${scoreLabel}%)`);
+        parts.push(`Lines ${lineRange}
+`);
+        if (kind === "ref") {
+          parts.push(`[CACHED: ${filePath}:${lineRange}]
+`);
+        } else if (kind === "diff" && diff) {
+          parts.push("```diff");
+          parts.push(diff);
+          parts.push("```\n");
+        } else {
+          parts.push("```" + (r2.language || ""));
+          parts.push(r2.content || r2.preview || "(no content)");
+          parts.push("```\n");
+        }
+      });
+    }
+    const rawContext = parts.join(`
+`);
+    const rawTokens = estimateTokens(rawContext, "code");
+    let finalContext = rawContext;
+    let compressionRatio = 0;
+    let tokensSaved = 0;
+    if (rawTokens > maxTokens) {
+      logger.info("Context exceeds maxTokens, compressing", {
+        rawTokens,
+        maxTokens
+      });
+      try {
+        const metrics2 = await compressWithMetrics(this.compressor, rawContext, "code_structure", { targetRatio: 0.6 });
+        finalContext = metrics2.compressed;
+        compressionRatio = metrics2.compressionRatio || 0;
+        tokensSaved = metrics2.tokensSaved || 0;
+      } catch (error51) {
+        logger.error("Failed to compress context", error51, {
+          strategy: "code_structure",
+          contentLength: rawContext.length
+        });
+      }
+    }
+    const finalTokens = estimateTokens(finalContext, "code");
+    const totalTokensSaved = rawTokens - finalTokens;
+    const compressionSavings = tokensSaved;
+    TokenMetrics.getInstance().recordContextRequest(rawTokens, finalTokens, tokensSavedBySessionCache, compressionSavings);
+    logger.info("Optimized context retrieved", {
+      rawTokens,
+      finalTokens,
+      tokensSaved: totalTokensSaved,
+      compressionRatio,
+      codeSources: workingSet.length,
+      memoriesIncluded: memories.length,
+      wmBudget,
+      sessionCacheHits,
+      tokensSavedBySessionCache
+    });
+    return {
+      context: finalContext,
+      sources: workingSet.map((r2) => r2.filePath || "unknown"),
+      resultsCount: workingSet.length,
+      memoriesCount: memories.length,
+      tokensSaved: totalTokensSaved,
+      compressionRatio,
+      sessionCacheHits,
+      tokensSavedBySessionCache
+    };
+  }
+  async searchMemoriesSafe(query, opts) {
+    try {
+      const result = await this.memoryCtrl.search({
+        query,
+        projectId: opts.projectId,
+        userId: opts.userId,
+        sessionId: opts.sessionId,
+        includePersistent: true,
+        minImportance: 0.3,
+        limit: opts.limit
+      });
+      return result.memories;
+    } catch (error51) {
+      logger.warn("Memory search failed, continuing without memories", {
+        error: error51.message,
+        query: query.slice(0, 30)
+      });
+      return [];
+    }
+  }
+  formatMemorySection(memories, tokenBudget) {
+    if (memories.length === 0 || tokenBudget <= 0)
+      return null;
+    const parts = [
+      `## Relevant Memories (from previous sessions)
+`
+    ];
+    let usedTokens = estimateTokens(parts[0], "text");
+    for (const memory of memories) {
+      const typeLabel = (memory.type || "unknown").toUpperCase();
+      const score = memory.score ? ` (relevance: ${(memory.score * 100).toFixed(0)}%)` : "";
+      const importance = memory.importance ? ` [importance: ${(memory.importance * 100).toFixed(0)}%]` : "";
+      const agent = memory.agentId ? ` (by: ${memory.agentId})` : "";
+      const entry2 = `- **[${typeLabel}]**${score}${importance}${agent}: ${memory.content}`;
+      const entryTokens = estimateTokens(entry2, "text");
+      if (usedTokens + entryTokens > tokenBudget)
+        break;
+      parts.push(entry2);
+      usedTokens += entryTokens;
+    }
+    return parts.length <= 1 ? null : parts.join(`
+`);
+  }
+  selectWorkingSet(results, tokenBudget) {
+    if (!results.length || tokenBudget <= 0)
+      return [];
+    const selected = [];
+    const selectedFiles = new Set;
+    let usedTokens = 0;
+    const sorted = [...results].sort((a12, b) => (b.score || 0) - (a12.score || 0));
+    for (const result of sorted) {
+      const filePath = result.filePath || "unknown";
+      if (selectedFiles.has(filePath))
+        continue;
+      const content = result.content || result.preview || "";
+      const tokens = estimateTokens(content, "code");
+      if (usedTokens + tokens > tokenBudget)
+        continue;
+      selected.push(result);
+      selectedFiles.add(filePath);
+      usedTokens += tokens;
+    }
+    for (const result of sorted) {
+      if (selected.includes(result))
+        continue;
+      const content = result.content || result.preview || "";
+      const tokens = estimateTokens(content, "code");
+      if (usedTokens + tokens > tokenBudget)
+        continue;
+      selected.push(result);
+      usedTokens += tokens;
+    }
+    return selected;
+  }
+}
+function looksLikeSymbol(query) {
+  if (query.length > 80)
+    return false;
+  const words = query.trim().split(/\s+/);
+  if (words.length > 3)
+    return false;
+  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(words[0]);
+}
+function formatGraphContext(defs, refs, tokenBudget) {
+  const parts = [`## Symbol Graph
+`];
+  if (defs.length > 0) {
+    parts.push(`### Definition(s)
+`);
+    for (const def of defs.slice(0, 3)) {
+      parts.push(`- **${def.kind}** \`${def.name}\` \u2192 \`${def.file}\` L${def.lineStart}\u2013${def.lineEnd}`);
+      if (def.docComment)
+        parts.push(`  > ${def.docComment.slice(0, 120)}`);
+      if (def.snippet) {
+        parts.push("  ```");
+        parts.push(def.snippet.split(`
+`).slice(0, 8).join(`
+`));
+        parts.push("  ```");
+      }
+    }
+    parts.push("");
+  }
+  if (refs.length > 0) {
+    parts.push(`### References (${refs.length} total)
+`);
+    const byFile = new Map;
+    for (const r2 of refs.slice(0, 30)) {
+      const arr = byFile.get(r2.fromFile) ?? [];
+      arr.push(r2.fromLine);
+      byFile.set(r2.fromFile, arr);
+    }
+    for (const [file3, lines] of byFile) {
+      parts.push(`- \`${file3}\` L${lines.join(", ")}`);
+    }
+    parts.push("");
+  }
+  const section = parts.join(`
+`);
+  const charBudget = tokenBudget * 4;
+  return section.length > charBudget ? section.slice(0, charBudget) + `
+...
+` : section;
+}
+var init_context_controller = __esm(() => {
+  init_dist();
+  init_search_controller();
+  init_memory_controller();
+  init_compression();
+  init_session_file_cache();
+  init_symbol_graph_service();
+  init_token_metrics();
+});
+
 // ../../packages/core/dist/services/checkpoint/checkpoint-store-pg.js
 function toNum2(v) {
   if (v == null)
@@ -126427,31 +126802,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path21) => {
+    const walk = (fqn, path22) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path21.join("\u2192");
+      const key = path22.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path21.length > 1)
-          chains.push(path21.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
+        if (path22.length > 1)
+          chains.push(path22.map((n2) => this.fqnToName(n2)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path21.includes(child)) {
-          const cycled = [...path21, `${this.fqnToName(child)}\u21BA`];
+        if (path22.includes(child)) {
+          const cycled = [...path22, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n2) => n2).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path21, child]);
+        walk(child, [...path22, child]);
       }
     };
     for (const seed of seeds) {
@@ -127847,6 +128222,319 @@ var init_executor2 = __esm(() => {
   init_intent_search();
 });
 
+// ../../packages/core/dist/services/executor/executor-controller.js
+import { cpus as cpus2 } from "os";
+function applyIntent(result, intent) {
+  if (!intent || !result.stdout)
+    return result;
+  const ir = intentSearch(result.stdout, intent);
+  if (!ir.searched)
+    return result;
+  const rendered = renderIntentResult(ir, intent);
+  return {
+    ...result,
+    stdout: `${rendered}
+
+--- tail (last 512 chars) ---
+${result.stdout.slice(-512)}`
+  };
+}
+
+class ExecutorController {
+  static instance = null;
+  executor;
+  constructor(executor) {
+    this.executor = executor ?? new PolyglotExecutor;
+  }
+  static getInstance() {
+    if (!ExecutorController.instance) {
+      ExecutorController.instance = new ExecutorController;
+    }
+    return ExecutorController.instance;
+  }
+  static resetInstance() {
+    ExecutorController.instance?.executor.cleanupBackgrounded();
+    ExecutorController.instance = null;
+  }
+  get runtimes() {
+    return this.executor.runtimes;
+  }
+  async execute(params) {
+    try {
+      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
+      const result = await this.executor.execute({
+        language,
+        code: params.code,
+        timeout: params.timeout,
+        background: params.background,
+        cwd: params.cwd
+      });
+      const finalResult = applyIntent(result, params.intent);
+      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
+      return {
+        success: ok,
+        data: {
+          stdout: finalResult.stdout,
+          stderr: finalResult.stderr,
+          exitCode: finalResult.exitCode,
+          timedOut: finalResult.timedOut,
+          backgrounded: finalResult.backgrounded ?? false,
+          command: finalResult.command,
+          cwd: finalResult.cwd,
+          sandboxMode: finalResult.sandboxMode
+        }
+      };
+    } catch (error51) {
+      logger.error("execute failed", error51, {
+        language: params.language
+      });
+      return {
+        success: false,
+        error: `execute failed: ${error51.message}`
+      };
+    }
+  }
+  async executeFile(params) {
+    try {
+      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
+      const result = await this.executor.executeFile({
+        path: params.path,
+        language,
+        code: params.code,
+        timeout: params.timeout
+      });
+      const blocked = result.stderr?.startsWith("Blocked:");
+      if (blocked) {
+        return { success: false, error: result.stderr };
+      }
+      const finalResult = applyIntent(result, params.intent);
+      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
+      return {
+        success: ok,
+        data: {
+          stdout: finalResult.stdout,
+          stderr: finalResult.stderr,
+          exitCode: finalResult.exitCode,
+          timedOut: finalResult.timedOut,
+          command: finalResult.command,
+          cwd: finalResult.cwd,
+          sandboxMode: finalResult.sandboxMode
+        }
+      };
+    } catch (error51) {
+      logger.error("execute_file failed", error51, {
+        path: params.path,
+        language: params.language
+      });
+      return {
+        success: false,
+        error: `execute_file failed: ${error51.message}`
+      };
+    }
+  }
+  async batchExecute(params) {
+    const { commands, concurrency, cwd, timeout } = params;
+    if (!Array.isArray(commands) || commands.length === 0) {
+      return { success: false, error: "commands must be a non-empty array." };
+    }
+    if (commands.length > MAX_BATCH_COMMANDS) {
+      return {
+        success: false,
+        error: `batch_execute accepts at most ${MAX_BATCH_COMMANDS} commands; received ${commands.length}. Split the batch or reduce the payload.`
+      };
+    }
+    const effectiveConcurrency = concurrency && concurrency > 0 ? concurrency : Math.max(1, cpus2().length);
+    const perTimeout = timeout ?? DEFAULT_TIMEOUT_MS2;
+    try {
+      const poolResult = await runPool(commands.map((cmd) => ({
+        run: () => this.executor.execute({
+          language: "shell",
+          code: cmd,
+          timeout: perTimeout,
+          cwd
+        })
+      })), { concurrency: effectiveConcurrency });
+      const results = poolResult.settled.map((s, i) => {
+        if (s.status === "fulfilled") {
+          const r2 = s.value;
+          return {
+            command: commands[i],
+            stdout: r2.stdout,
+            stderr: r2.stderr,
+            exitCode: r2.exitCode,
+            timedOut: r2.timedOut,
+            sandboxMode: r2.sandboxMode
+          };
+        }
+        return {
+          command: commands[i],
+          stdout: "",
+          stderr: String(s.reason ?? "unknown error"),
+          exitCode: null,
+          timedOut: false,
+          sandboxMode: getSandboxMode()
+        };
+      });
+      const anyFailed = results.some((r2) => r2.exitCode !== 0 || r2.timedOut);
+      return {
+        success: !anyFailed,
+        data: {
+          results,
+          concurrency: poolResult.effectiveConcurrency,
+          capped: poolResult.capped
+        }
+      };
+    } catch (error51) {
+      logger.error("batch_execute failed", error51);
+      return {
+        success: false,
+        error: `batch_execute failed: ${error51.message}`
+      };
+    }
+  }
+  static get MAX_TIMEOUT_MS() {
+    return MAX_TIMEOUT_MS;
+  }
+}
+var EXECUTOR_LANGUAGES, MAX_BATCH_COMMANDS = 256;
+var init_executor_controller = __esm(() => {
+  init_dist();
+  init_executor2();
+  init_enum_validation();
+  EXECUTOR_LANGUAGES = [
+    "javascript",
+    "typescript",
+    "python",
+    "shell",
+    "ruby",
+    "go",
+    "rust",
+    "php",
+    "perl",
+    "r"
+  ];
+});
+
+// ../../packages/core/dist/services/symbol/graph-controller.js
+class GraphController {
+  static instance = null;
+  constructor() {}
+  static getInstance() {
+    if (!GraphController.instance) {
+      GraphController.instance = new GraphController;
+    }
+    return GraphController.instance;
+  }
+  async tracePath(input) {
+    const projectId = input.projectId;
+    const seed = input.function_name ?? input.symbol ?? input.qualifiedName;
+    if (!projectId)
+      throw new Error("projectId is required");
+    if (!seed)
+      throw new Error("function_name (or symbol/qualifiedName) is required");
+    const t0 = performance.now();
+    const result = await tracePathService.tracePath({
+      symbol: input.function_name ?? input.symbol ?? "",
+      function_name: input.function_name,
+      qualifiedName: input.qualifiedName,
+      projectId,
+      direction: input.direction,
+      mode: input.mode,
+      depth: input.depth,
+      include_tests: input.include_tests,
+      edge_types: input.edge_types
+    });
+    logger.info("GraphController: trace_path", {
+      projectId,
+      symbol: seed,
+      mode: result.mode,
+      direction: result.direction,
+      seeds: result.seeds.length,
+      nodes: result.nodes.length,
+      edges: result.edges.length,
+      durationMs: Math.round(performance.now() - t0)
+    });
+    if (result.seeds.length === 0) {
+      return {
+        found: false,
+        symbol: seed,
+        projectId,
+        ...result.identityResolution ? { identityResolution: result.identityResolution } : {},
+        hint: "Use search_definitions(search=...) to find the exact name, or pass a fully-qualified name (qualifiedName='rel/path.ts#Name')."
+      };
+    }
+    return {
+      found: true,
+      result: {
+        projectId: result.projectId,
+        symbol: result.symbol,
+        mode: result.mode,
+        direction: result.direction,
+        edgeTypes: result.edgeTypes,
+        seeds: result.seeds,
+        truncated: result.truncated,
+        nodes_total: result.nodes_total,
+        nodes_shown: result.nodes_shown,
+        nodes_omitted: result.nodes_omitted,
+        nodeCount: result.nodes.length,
+        edgeCount: result.edges.length,
+        chains: result.chains,
+        nodes: result.nodes,
+        edges: result.edges,
+        ...result.identityResolution ? { identity: toSymbolIdentityResolution(result.identityResolution) } : {}
+      }
+    };
+  }
+  async analyzeImpact(input) {
+    if (!input.projectId)
+      throw new Error("projectId is required");
+    if (!input.projectPath)
+      throw new Error("projectPath is required");
+    const t0 = performance.now();
+    const result = await impactAnalysisService.analyze({
+      projectId: input.projectId,
+      projectPath: input.projectPath,
+      scope: input.scope ?? "unstaged",
+      baseBranch: input.base_branch,
+      since: input.since,
+      depth: input.depth,
+      paths: input.paths,
+      diffRunner: input.diffRunner
+    });
+    logger.info("GraphController: impact_analysis", {
+      projectId: input.projectId,
+      scope: result.scope,
+      changedFiles: result.changedFiles.length,
+      impacted: result.impacted.length,
+      truncated: result.truncated,
+      durationMs: Math.round(performance.now() - t0)
+    });
+    return {
+      projectId: result.projectId,
+      scope: result.scope,
+      baseBranch: result.baseBranch,
+      since: result.since,
+      depth: result.depth,
+      changedFileCount: result.changedFiles.length,
+      changedFiles: result.changedFiles,
+      impactedCount: result.impacted.length,
+      truncated: result.truncated,
+      impacted: result.impacted,
+      untrackedFiltered: result.untrackedFiltered,
+      impacted_total: result.impacted_total,
+      impacted_shown: result.impacted_shown,
+      impacted_omitted: result.impacted_omitted,
+      note: result.note
+    };
+  }
+}
+var init_graph_controller = __esm(() => {
+  init_dist();
+  init_trace_path();
+  init_impact_analysis();
+  init_definition_lookup();
+});
+
 // ../../packages/core/dist/services/project-identity/errors.js
 var ERROR_MESSAGES, ERROR_STATUS, ProjectIdentityError;
 var init_errors4 = __esm(() => {
@@ -129282,7 +129970,7 @@ var init_l1_memory_cache = __esm(() => {
 // ../../packages/core/dist/services/health/local-health-checker.js
 import fs12 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path22 from "path";
+import path24 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -129317,7 +130005,7 @@ class LocalHealthChecker {
     try {
       if (!existsSync3(this.dataDir))
         await fs12.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path22.join(this.dataDir, ".health-check-test");
+      const probe2 = path24.join(this.dataDir, ".health-check-test");
       await fs12.writeFile(probe2, "ok");
       await fs12.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
@@ -131231,7 +131919,7 @@ var init_scheduler2 = __esm(() => {
 // ../../packages/core/dist/services/pricing/models-dev-client.js
 import fs13 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path23 from "path";
+import path25 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -131251,7 +131939,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path23.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path25.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -131286,7 +131974,7 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path23.dirname(cachePath);
+        const dir = path25.dirname(cachePath);
         await fs13.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
@@ -137177,33 +137865,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path24) {
-        if (!path24)
-          return path24;
+      function remove_dot_segments(path26) {
+        if (!path26)
+          return path26;
         var output = "";
-        while (path24.length > 0) {
-          if (path24 === "." || path24 === "..") {
-            path24 = "";
+        while (path26.length > 0) {
+          if (path26 === "." || path26 === "..") {
+            path26 = "";
             break;
           }
-          var twochars = path24.substring(0, 2);
-          var threechars = path24.substring(0, 3);
-          var fourchars = path24.substring(0, 4);
+          var twochars = path26.substring(0, 2);
+          var threechars = path26.substring(0, 3);
+          var fourchars = path26.substring(0, 4);
           if (threechars === "../") {
-            path24 = path24.substring(3);
+            path26 = path26.substring(3);
           } else if (twochars === "./") {
-            path24 = path24.substring(2);
+            path26 = path26.substring(2);
           } else if (threechars === "/./") {
-            path24 = "/" + path24.substring(3);
-          } else if (twochars === "/." && path24.length === 2) {
-            path24 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path24.length === 3) {
-            path24 = "/" + path24.substring(4);
+            path26 = "/" + path26.substring(3);
+          } else if (twochars === "/." && path26.length === 2) {
+            path26 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path26.length === 3) {
+            path26 = "/" + path26.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path24.match(/(\/?([^\/]*))/)[0];
+            var segment = path26.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path24 = path24.substring(segment.length);
+            path26 = path26.substring(segment.length);
           }
         }
         return output;
@@ -149273,21 +149961,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path24, out) {
+function walk(val, path26, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _[]_` });
+      out.push({ path: path26, content: `**${path26}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path24}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path26}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path24, content: `**${path24}**
+    out.push({ path: path26, content: `**${path26}**
 
 ${items}` });
     return;
@@ -149295,16 +149983,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path24, content: `**${path24}** = _{}_` });
+      out.push({ path: path26, content: `**${path26}** = _{}_` });
       return;
     }
     for (const [k2, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k2) ? k2 : JSON.stringify(k2);
-      walk(v, `${path24}.${safeKey}`, out);
+      walk(v, `${path26}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path24, content: `**${path24}** = \`${String(val)}\`` });
+  out.push({ path: path26, content: `**${path26}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -149570,12 +150258,7 @@ class WebController {
       markIndexed: (key, ts) => {
         this.cache.delete(key);
         this.cache.set(key, ts);
-        while (this.cache.size > WEB_CACHE_MAX_ENTRIES) {
-          const oldest = this.cache.keys().next().value;
-          if (oldest === undefined)
-            break;
-          this.cache.delete(oldest);
-        }
+        evictOldest(this.cache, WEB_CACHE_MAX_ENTRIES);
       }
     };
   }
@@ -149777,6 +150460,7 @@ __export(exports_services, {
   SessionFileCache: () => SessionFileCache,
   SearchSessionHook: () => SearchSessionHook,
   SearchServiceError: () => SearchServiceError,
+  SearchController: () => SearchController,
   SearchCachePg: () => SearchCachePg,
   SearchAnalyticsPg: () => SearchAnalyticsPg,
   Scheduler: () => Scheduler,
@@ -149810,6 +150494,7 @@ __export(exports_services, {
   ModelsDevClient: () => ModelsDevClient,
   MemoryService: () => MemoryService,
   MemoryGraphService: () => MemoryGraphService,
+  MemoryController: () => MemoryController,
   MemoryClustering: () => MemoryClustering,
   MAX_TIMEOUT_MS: () => MAX_TIMEOUT_MS,
   MAX_STRUCTURAL_PARSER_CAPACITY: () => MAX_STRUCTURAL_PARSER_CAPACITY,
@@ -149828,10 +150513,12 @@ __export(exports_services, {
   ImpactAnalysisService: () => ImpactAnalysisService,
   GraphStorePg: () => GraphStorePg,
   GraphQueries: () => GraphQueries,
+  GraphController: () => GraphController,
   GO_QUERY_PACK: () => GO_QUERY_PACK,
   FqnHashCollisionError: () => FqnHashCollisionError,
   FUNCTIONAL_QUERY_PACKS: () => FUNCTIONAL_QUERY_PACKS,
   FUNCTIONAL_LANGUAGE_RESOLVER: () => FUNCTIONAL_LANGUAGE_RESOLVER,
+  ExecutorController: () => ExecutorController,
   EventBus: () => TypedEventBus,
   EtlPipeline: () => EtlPipeline,
   EmbeddingCachePg: () => EmbeddingCachePg,
@@ -149853,6 +150540,7 @@ __export(exports_services, {
   DATA_DOCUMENT_QUERY_PACKS: () => DATA_DOCUMENT_QUERY_PACKS,
   DATA_DOCUMENT_LANGUAGE_RESOLVER: () => DATA_DOCUMENT_LANGUAGE_RESOLVER,
   ContextualSearchRLM: () => ContextualSearchRLM,
+  ContextController: () => ContextController,
   CompactionSnapshotService: () => CompactionSnapshotService,
   CodeCompressor: () => CodeCompressor,
   CoRetrievalHook: () => CoRetrievalHook,
@@ -149869,6 +150557,11 @@ var init_services = __esm(() => {
   init_search_analytics_pg();
   init_index_manager();
   init_search_diagnostics();
+  init_memory_controller();
+  init_search_controller();
+  init_context_controller();
+  init_executor_controller();
+  init_graph_controller();
   init_l1_memory_cache();
   init_embedding_cache_pg();
   init_code_compressor();
@@ -172180,14 +172873,113 @@ var cors = (config2) => {
 init_contextual_search_rlm();
 init_dist();
 init_index_job_tracker();
+
+// ../../packages/core/dist/services/indexing/execute-indexing.js
+init_dist();
+init_index_job_tracker();
 init_pipeline();
-init_workspace_manager();
-init_parser_readiness();
+async function executeIndexing(request) {
+  const { jobId, projectId, projectPath, forceReindex, warmCache, warmupQueries, include_tests = false, managedRunLease, warmupCache: warmupCache2 } = request;
+  const startTime = Date.now();
+  try {
+    indexJobTracker.updateStatus(jobId, "running");
+    logger.info("Starting project indexing via ETL Pipeline", {
+      jobId,
+      projectPath,
+      projectId,
+      forceReindex,
+      warmCache,
+      include_tests
+    });
+    const etlResult = await EtlPipeline.getInstance().run({
+      projectId,
+      projectPath,
+      jobId,
+      forceReindex,
+      include_tests,
+      managedRunLease
+    });
+    const duration3 = Date.now() - startTime;
+    logger.info("ETL Pipeline completed", {
+      jobId,
+      projectId,
+      duration: duration3,
+      filesIndexed: etlResult.filesIndexed,
+      filesSkipped: etlResult.filesSkipped,
+      chunksIndexed: etlResult.chunksIndexed,
+      symbolsIndexed: etlResult.symbolsIndexed,
+      errors: etlResult.errors,
+      stageTimings: etlResult.stageTimings
+    });
+    if (warmCache) {
+      logger.info("Starting cache warmup", { jobId, projectId });
+      const warmupStats = await warmupCache2(projectId, projectPath, warmupQueries);
+      logger.info("Cache warmup completed", { jobId, projectId, ...warmupStats });
+    }
+    indexJobTracker.updateProgress(jobId, etlResult.filesIndexed, etlResult.filesIndexed);
+    await indexJobTracker.setResultAndFlush(jobId, {
+      filesIndexed: etlResult.filesIndexed,
+      chunksIndexed: etlResult.chunksIndexed,
+      errors: etlResult.errors,
+      duration: duration3,
+      activatedGraphGenerationId: etlResult.activatedGraphGenerationId,
+      parserDiagnostics: etlResult.parserDiagnostics
+    });
+  } catch (error51) {
+    const duration3 = Date.now() - startTime;
+    logger.error("Project indexing failed", error51, {
+      jobId,
+      projectPath,
+      projectId,
+      duration: duration3
+    });
+    indexJobTracker.setResult(jobId, {
+      filesIndexed: 0,
+      chunksIndexed: 0,
+      errors: 1,
+      duration: duration3
+    }, error51.message);
+  }
+}
+
+// ../../packages/core/dist/services/indexing/acquire-indexing-lease.js
+init_dist();
+init_index_job_tracker();
 init_managed_run_repository_pg();
+async function acquireIndexingLease(request) {
+  const { jobId, projectId } = request;
+  const eventId = `index:${jobId}`;
+  const managedRunRepo = ManagedRunRepositoryPg.getInstance();
+  try {
+    const beginOutcome = await managedRunRepo.begin({
+      projectId,
+      runKind: "indexing",
+      eventId
+    });
+    if (beginOutcome.status === "busy") {
+      indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 0, duration: 0 }, `indexing_busy:${beginOutcome.activeRunId}`);
+      return {
+        status: "busy",
+        activeRunId: beginOutcome.activeRunId,
+        leaseExpiresAt: beginOutcome.leaseExpiresAt
+      };
+    }
+    return { status: "acquired", lease: beginOutcome.lease };
+  } catch (beginError) {
+    logger.error("managed_runs begin failed", beginError, {
+      jobId,
+      projectId
+    });
+    indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: 0 }, `managed_runs_begin_failed:${beginError.message}`);
+    return { status: "failed", message: beginError.message };
+  }
+}
+
+// ../../packages/core/dist/services/project-identity/project-root-identity.js
 import { realpath as realpath2 } from "fs/promises";
-import path19 from "path";
+import path18 from "path";
 async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path19.resolve(projectPath));
+  return canonicalize(path18.resolve(projectPath));
 }
 async function assertProjectRootReuse(options) {
   if (!options.storedProjectPath || options.forceReindex)
@@ -172195,15 +172987,20 @@ async function assertProjectRootReuse(options) {
   const canonicalize = options.canonicalize ?? realpath2;
   let storedCanonical;
   try {
-    storedCanonical = await canonicalize(path19.resolve(options.storedProjectPath));
+    storedCanonical = await canonicalize(path18.resolve(options.storedProjectPath));
   } catch {
-    storedCanonical = path19.resolve(options.storedProjectPath);
+    storedCanonical = path18.resolve(options.storedProjectPath);
   }
   if (storedCanonical !== options.canonicalProjectPath) {
     throw new Error(`Project ID "${options.projectId}" already indexes canonical root ` + `"${storedCanonical}", not "${options.canonicalProjectPath}"; ` + "use forceReindex only after verifying ownership of the existing project");
   }
 }
 
+// ../../packages/core/dist/tools/index_project.js
+init_workspace_manager();
+init_parser_readiness();
+import path20 from "path";
+
 class IndexProjectTool {
   name = "index_project";
   description = "Index a project directory for contextual code search with semantic embeddings";
@@ -172250,7 +173047,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path19.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path20.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -172264,40 +173061,42 @@ class IndexProjectTool {
         projectPath: canonicalProjectPath,
         projectId: finalProjectId
       });
-      const eventId = `index:${job.jobId}`;
-      const managedRunRepo = ManagedRunRepositoryPg.getInstance();
-      let lease;
-      try {
-        const beginOutcome = await managedRunRepo.begin({
-          projectId: finalProjectId,
-          runKind: "indexing",
-          eventId
-        });
-        if (beginOutcome.status === "busy") {
-          indexJobTracker.setResult(job.jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 0, duration: 0 }, `indexing_busy:${beginOutcome.activeRunId}`);
-          return {
-            success: false,
-            error: `indexing_busy:${beginOutcome.activeRunId}`,
-            data: {
-              jobId: job.jobId,
-              projectId: finalProjectId,
-              status: "busy",
-              activeRunId: beginOutcome.activeRunId,
-              leaseExpiresAt: beginOutcome.leaseExpiresAt,
-              message: "Another indexing run is active for this project. Poll get_index_status(activeRunId)."
-            }
-          };
-        }
-        lease = beginOutcome.lease;
-      } catch (beginError) {
-        logger.error("managed_runs begin failed", beginError, { jobId: job.jobId, projectId: finalProjectId });
-        indexJobTracker.setResult(job.jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: 0 }, `managed_runs_begin_failed:${beginError.message}`);
+      const leaseOutcome = await acquireIndexingLease({
+        jobId: job.jobId,
+        projectId: finalProjectId
+      });
+      if (leaseOutcome.status === "busy") {
+        return {
+          success: false,
+          error: `indexing_busy:${leaseOutcome.activeRunId}`,
+          data: {
+            jobId: job.jobId,
+            projectId: finalProjectId,
+            status: "busy",
+            activeRunId: leaseOutcome.activeRunId,
+            leaseExpiresAt: leaseOutcome.leaseExpiresAt,
+            message: "Another indexing run is active for this project. Poll get_index_status(activeRunId)."
+          }
+        };
+      }
+      if (leaseOutcome.status === "failed") {
         return {
           success: false,
-          error: `Failed to acquire indexing lease: ${beginError.message}`
+          error: `Failed to acquire indexing lease: ${leaseOutcome.message}`
         };
       }
-      this.executeIndexing(job.jobId, finalProjectId, canonicalProjectPath, forceReindex, warmCache, warmupQueries, include_tests, lease).catch((error51) => {
+      const lease = leaseOutcome.lease;
+      executeIndexing({
+        jobId: job.jobId,
+        projectId: finalProjectId,
+        projectPath: canonicalProjectPath,
+        forceReindex,
+        warmCache,
+        warmupQueries,
+        include_tests,
+        managedRunLease: lease,
+        warmupCache: this.contextualSearch.warmupCache.bind(this.contextualSearch)
+      }).catch((error51) => {
         logger.error("Background indexing failed", error51, {
           jobId: job.jobId
         });
@@ -172324,68 +173123,6 @@ class IndexProjectTool {
       };
     }
   }
-  async executeIndexing(jobId, projectId, projectPath, forceReindex, warmCache, warmupQueries, include_tests = false, managedRunLease) {
-    const startTime = Date.now();
-    try {
-      indexJobTracker.updateStatus(jobId, "running");
-      logger.info("Starting project indexing via ETL Pipeline", {
-        jobId,
-        projectPath,
-        projectId,
-        forceReindex,
-        warmCache,
-        include_tests
-      });
-      const etlResult = await EtlPipeline.getInstance().run({
-        projectId,
-        projectPath,
-        jobId,
-        forceReindex,
-        include_tests,
-        managedRunLease
-      });
-      const duration3 = Date.now() - startTime;
-      logger.info("ETL Pipeline completed", {
-        jobId,
-        projectId,
-        duration: duration3,
-        filesIndexed: etlResult.filesIndexed,
-        filesSkipped: etlResult.filesSkipped,
-        chunksIndexed: etlResult.chunksIndexed,
-        symbolsIndexed: etlResult.symbolsIndexed,
-        errors: etlResult.errors,
-        stageTimings: etlResult.stageTimings
-      });
-      if (warmCache) {
-        logger.info("Starting cache warmup", { jobId, projectId });
-        const warmupStats = await this.contextualSearch.warmupCache(projectId, projectPath, warmupQueries);
-        logger.info("Cache warmup completed", { jobId, projectId, ...warmupStats });
-      }
-      indexJobTracker.updateProgress(jobId, etlResult.filesIndexed, etlResult.filesIndexed);
-      await indexJobTracker.setResultAndFlush(jobId, {
-        filesIndexed: etlResult.filesIndexed,
-        chunksIndexed: etlResult.chunksIndexed,
-        errors: etlResult.errors,
-        duration: duration3,
-        activatedGraphGenerationId: etlResult.activatedGraphGenerationId,
-        parserDiagnostics: etlResult.parserDiagnostics
-      });
-    } catch (error51) {
-      const duration3 = Date.now() - startTime;
-      logger.error("Project indexing failed", error51, {
-        jobId,
-        projectPath,
-        projectId,
-        duration: duration3
-      });
-      indexJobTracker.setResult(jobId, {
-        filesIndexed: 0,
-        chunksIndexed: 0,
-        errors: 1,
-        duration: duration3
-      }, error51.message);
-    }
-  }
 }
 // ../../packages/core/dist/tools/get_index_status.js
 init_index_job_tracker();
@@ -172864,17 +173601,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path20) {
+function transformChildren(value, replacer, path21) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path20);
+    return transformObject(value, replacer, path21);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path20);
+    return transformArray(value, replacer, path21);
   return value;
 }
-function transformObject(obj, replacer, path20) {
+function transformObject(obj, replacer, path21) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path20, key];
+    const childPath = [...path21, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -172882,11 +173619,11 @@ function transformObject(obj, replacer, path20) {
   }
   return result;
 }
-function transformArray(arr, replacer, path20) {
+function transformArray(arr, replacer, path21) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path20, i];
+    const childPath = [...path21, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -173418,438 +174155,7 @@ class GetAnalyticsTool {
 }
 // ../../packages/core/dist/tools/get_optimized_context.js
 init_dist();
-
-// ../../packages/core/dist/controllers/context-controller.js
-init_dist();
-init_search_controller();
-init_memory_controller();
-
-// ../../packages/core/dist/tools/compress_context.js
-init_code_compressor();
-init_dist();
-init_dist();
-init_enum_validation();
-
-class CompressContextTool {
-  name = "compress_context";
-  description = "Compress context using semantic compression (keeps structure, removes details)";
-  inputSchema = {
-    type: "object",
-    properties: {
-      content: {
-        type: "string",
-        description: "Content to compress"
-      },
-      strategy: {
-        type: "string",
-        enum: [
-          "code_structure",
-          "conversation_summary",
-          "semantic_dedup",
-          "hierarchical"
-        ],
-        description: "Compression strategy",
-        default: "code_structure"
-      },
-      language: {
-        type: "string",
-        description: "Programming language (for code compression)"
-      },
-      targetRatio: {
-        type: "number",
-        description: "Target compression ratio (0-1, e.g., 0.7 = 70% reduction)",
-        default: 0.7
-      }
-    },
-    required: ["content"]
-  };
-  compressor;
-  constructor() {
-    this.compressor = new CodeCompressor;
-  }
-  async handle(params) {
-    const { content, language, targetRatio = 0.7 } = params;
-    const strategy = validateEnum("strategy", params.strategy ?? "code_structure", [
-      "code_structure",
-      "conversation_summary",
-      "semantic_dedup",
-      "hierarchical"
-    ]);
-    try {
-      const originalTokens = estimateTokens(content, language || "code");
-      logger.info("Compressing context", {
-        originalTokens,
-        strategy,
-        targetRatio
-      });
-      const result = await this.compressor.compress(content, strategy);
-      const compressedTokens = estimateTokens(result.compressed, language || "code");
-      const actualRatio = 1 - compressedTokens / originalTokens;
-      const tokensSaved = originalTokens - compressedTokens;
-      logger.info("Context compressed", {
-        originalTokens,
-        compressedTokens,
-        tokensSaved,
-        actualRatio: actualRatio.toFixed(2),
-        targetRatio
-      });
-      return {
-        success: true,
-        data: {
-          compressed: result.compressed,
-          originalLength: content.length,
-          compressedLength: result.compressed.length,
-          originalTokens,
-          compressedTokens,
-          strategy
-        },
-        metadata: {
-          tokensSaved,
-          compressionRatio: actualRatio
-        }
-      };
-    } catch (error51) {
-      logger.error("Failed to compress context", error51, {
-        strategy,
-        contentLength: typeof content === "string" ? content.length : 0
-      });
-      return {
-        success: false,
-        error: `Failed to compress context: ${error51.message}`
-      };
-    }
-  }
-}
-
-// ../../packages/core/dist/controllers/context-controller.js
-init_session_file_cache();
-init_symbol_graph_service();
-init_token_metrics();
-
-class ContextController {
-  static instance = null;
-  searchCtrl;
-  memoryCtrl;
-  compressor;
-  sessionCache;
-  constructor() {
-    this.searchCtrl = SearchController.getInstance();
-    this.memoryCtrl = MemoryController.getInstance();
-    this.compressor = new CompressContextTool;
-    this.sessionCache = SessionFileCache.getInstance();
-  }
-  static getInstance() {
-    if (!ContextController.instance) {
-      ContextController.instance = new ContextController;
-    }
-    return ContextController.instance;
-  }
-  async getOptimizedContext(input) {
-    const { query, projectId, projectPath: projectPath2, maxTokens = 4000, maxResults = 5, workingMemoryBudget, userId, sessionId, includeMemories = true, memoryBudgetRatio = 0.2 } = input;
-    const clampedRatio = Math.max(0, Math.min(0.5, memoryBudgetRatio));
-    const memoryTokenBudget = includeMemories ? Math.floor(maxTokens * clampedRatio) : 0;
-    const codeTokenBudget = maxTokens - memoryTokenBudget;
-    const wmBudget = workingMemoryBudget || Math.floor(codeTokenBudget * 0.8);
-    logger.info("Getting optimized context", {
-      query: query.slice(0, 50),
-      projectId,
-      maxTokens,
-      includeMemories,
-      memoryTokenBudget,
-      codeTokenBudget,
-      workingMemoryBudget: wmBudget
-    });
-    let graphContextSection = "";
-    let graphBoostFiles = [];
-    if (projectId && await symbolGraphService.hasData(projectId) && looksLikeSymbol(query)) {
-      try {
-        const [defs, refs] = await Promise.all([
-          symbolGraphService.goToDefinition(projectId, query),
-          symbolGraphService.getReferences(projectId, query)
-        ]);
-        if (defs.length > 0) {
-          const graphTokenBudget = Math.floor(codeTokenBudget * 0.2);
-          graphContextSection = formatGraphContext(defs, refs, graphTokenBudget);
-          graphBoostFiles = [
-            ...new Set([
-              ...defs.map((d) => d.file),
-              ...refs.slice(0, 10).map((r2) => r2.fromFile)
-            ])
-          ];
-          logger.debug("Graph prefilter hit", {
-            query,
-            defs: defs.length,
-            refs: refs.length,
-            boostFiles: graphBoostFiles.length
-          });
-        }
-      } catch (err) {
-        logger.warn("Graph prefilter failed", { query, error: err.message });
-      }
-    }
-    const [searchResult, memories] = await Promise.all([
-      this.searchCtrl.searchProject({
-        query,
-        projectId,
-        projectPath: projectPath2,
-        maxResults,
-        responseMode: "full",
-        autoReindex: false,
-        minScore: 0.4,
-        boostFiles: graphBoostFiles.length > 0 ? graphBoostFiles : undefined
-      }),
-      includeMemories ? this.searchMemoriesSafe(query, {
-        projectId,
-        userId,
-        sessionId,
-        limit: 5
-      }) : Promise.resolve([])
-    ]);
-    const codeResults = searchResult.results;
-    const workingSet = this.selectWorkingSet(codeResults, wmBudget);
-    const memorySection = this.formatMemorySection(memories, memoryTokenBudget);
-    if (workingSet.length === 0 && memories.length === 0) {
-      return {
-        context: `No relevant code or memories found for query: "${query}"`,
-        sources: [],
-        resultsCount: 0,
-        memoriesCount: 0,
-        tokensSaved: 0,
-        compressionRatio: 0,
-        sessionCacheHits: 0,
-        tokensSavedBySessionCache: 0
-      };
-    }
-    let sessionCacheHits = 0;
-    let tokensSavedBySessionCache = 0;
-    const deliveryPlan = workingSet.map((r2) => {
-      if (!sessionId) {
-        return { result: r2, kind: "full", tokensSaved: 0 };
-      }
-      const content = r2.content || r2.preview || "";
-      const key = this.sessionCache.chunkKey(r2.filePath || "unknown", r2.lineStart ?? 0, r2.lineEnd ?? 0);
-      const check3 = this.sessionCache.check(sessionId, key, content);
-      if (check3.status === "unchanged") {
-        sessionCacheHits++;
-        tokensSavedBySessionCache += check3.tokensSaved;
-        return { result: r2, kind: "ref", tokensSaved: check3.tokensSaved };
-      }
-      if (check3.status === "changed" && check3.diff !== undefined) {
-        sessionCacheHits++;
-        tokensSavedBySessionCache += check3.tokensSaved;
-        return { result: r2, kind: "diff", diff: check3.diff, tokensSaved: check3.tokensSaved };
-      }
-      return { result: r2, kind: "full", tokensSaved: 0 };
-    });
-    const parts = [`# Context for: ${query}
-`];
-    if (graphContextSection) {
-      parts.push(graphContextSection, "");
-    }
-    if (memorySection) {
-      parts.push(memorySection, "");
-    }
-    if (deliveryPlan.length > 0) {
-      const fullCount = deliveryPlan.filter((d) => d.kind === "full").length;
-      const refCount = deliveryPlan.filter((d) => d.kind === "ref").length;
-      const diffCount = deliveryPlan.filter((d) => d.kind === "diff").length;
-      parts.push(`## Code (${deliveryPlan.length} sections \u2014 ${fullCount} full, ${refCount} cached, ${diffCount} diff | WM budget: ${wmBudget} tokens)
-`);
-      deliveryPlan.forEach(({ result: r2, kind, diff }, idx) => {
-        const filePath = r2.filePath || "Unknown";
-        const scoreLabel = (r2.score * 100).toFixed(1);
-        const lineRange = `${r2.lineStart ?? "?"}-${r2.lineEnd ?? "?"}`;
-        parts.push(`### ${idx + 1}. ${filePath} (score: ${scoreLabel}%)`);
-        parts.push(`Lines ${lineRange}
-`);
-        if (kind === "ref") {
-          parts.push(`[CACHED: ${filePath}:${lineRange}]
-`);
-        } else if (kind === "diff" && diff) {
-          parts.push("```diff");
-          parts.push(diff);
-          parts.push("```\n");
-        } else {
-          parts.push("```" + (r2.language || ""));
-          parts.push(r2.content || r2.preview || "(no content)");
-          parts.push("```\n");
-        }
-      });
-    }
-    const rawContext = parts.join(`
-`);
-    const rawTokens = estimateTokens(rawContext, "code");
-    let finalContext = rawContext;
-    let compressionRatio = 0;
-    let tokensSaved = 0;
-    if (rawTokens > maxTokens) {
-      logger.info("Context exceeds maxTokens, compressing", {
-        rawTokens,
-        maxTokens
-      });
-      const resp = await this.compressor.handle({
-        content: rawContext,
-        strategy: "code_structure",
-        targetRatio: 0.6
-      });
-      if (resp.success && resp.data) {
-        finalContext = resp.data.compressed;
-        compressionRatio = resp.metadata?.compressionRatio || 0;
-        tokensSaved = resp.metadata?.tokensSaved || 0;
-      }
-    }
-    const finalTokens = estimateTokens(finalContext, "code");
-    const totalTokensSaved = rawTokens - finalTokens;
-    const compressionSavings = tokensSaved;
-    TokenMetrics.getInstance().recordContextRequest(rawTokens, finalTokens, tokensSavedBySessionCache, compressionSavings);
-    logger.info("Optimized context retrieved", {
-      rawTokens,
-      finalTokens,
-      tokensSaved: totalTokensSaved,
-      compressionRatio,
-      codeSources: workingSet.length,
-      memoriesIncluded: memories.length,
-      wmBudget,
-      sessionCacheHits,
-      tokensSavedBySessionCache
-    });
-    return {
-      context: finalContext,
-      sources: workingSet.map((r2) => r2.filePath || "unknown"),
-      resultsCount: workingSet.length,
-      memoriesCount: memories.length,
-      tokensSaved: totalTokensSaved,
-      compressionRatio,
-      sessionCacheHits,
-      tokensSavedBySessionCache
-    };
-  }
-  async searchMemoriesSafe(query, opts) {
-    try {
-      const result = await this.memoryCtrl.search({
-        query,
-        projectId: opts.projectId,
-        userId: opts.userId,
-        sessionId: opts.sessionId,
-        includePersistent: true,
-        minImportance: 0.3,
-        limit: opts.limit
-      });
-      return result.memories;
-    } catch (error51) {
-      logger.warn("Memory search failed, continuing without memories", {
-        error: error51.message,
-        query: query.slice(0, 30)
-      });
-      return [];
-    }
-  }
-  formatMemorySection(memories, tokenBudget) {
-    if (memories.length === 0 || tokenBudget <= 0)
-      return null;
-    const parts = [
-      `## Relevant Memories (from previous sessions)
-`
-    ];
-    let usedTokens = estimateTokens(parts[0], "text");
-    for (const memory of memories) {
-      const typeLabel = (memory.type || "unknown").toUpperCase();
-      const score = memory.score ? ` (relevance: ${(memory.score * 100).toFixed(0)}%)` : "";
-      const importance = memory.importance ? ` [importance: ${(memory.importance * 100).toFixed(0)}%]` : "";
-      const agent = memory.agentId ? ` (by: ${memory.agentId})` : "";
-      const entry2 = `- **[${typeLabel}]**${score}${importance}${agent}: ${memory.content}`;
-      const entryTokens = estimateTokens(entry2, "text");
-      if (usedTokens + entryTokens > tokenBudget)
-        break;
-      parts.push(entry2);
-      usedTokens += entryTokens;
-    }
-    return parts.length <= 1 ? null : parts.join(`
-`);
-  }
-  selectWorkingSet(results, tokenBudget) {
-    if (!results.length || tokenBudget <= 0)
-      return [];
-    const selected = [];
-    const selectedFiles = new Set;
-    let usedTokens = 0;
-    const sorted = [...results].sort((a12, b) => (b.score || 0) - (a12.score || 0));
-    for (const result of sorted) {
-      const filePath = result.filePath || "unknown";
-      if (selectedFiles.has(filePath))
-        continue;
-      const content = result.content || result.preview || "";
-      const tokens = estimateTokens(content, "code");
-      if (usedTokens + tokens > tokenBudget)
-        continue;
-      selected.push(result);
-      selectedFiles.add(filePath);
-      usedTokens += tokens;
-    }
-    for (const result of sorted) {
-      if (selected.includes(result))
-        continue;
-      const content = result.content || result.preview || "";
-      const tokens = estimateTokens(content, "code");
-      if (usedTokens + tokens > tokenBudget)
-        continue;
-      selected.push(result);
-      usedTokens += tokens;
-    }
-    return selected;
-  }
-}
-function looksLikeSymbol(query) {
-  if (query.length > 80)
-    return false;
-  const words = query.trim().split(/\s+/);
-  if (words.length > 3)
-    return false;
-  return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(words[0]);
-}
-function formatGraphContext(defs, refs, tokenBudget) {
-  const parts = [`## Symbol Graph
-`];
-  if (defs.length > 0) {
-    parts.push(`### Definition(s)
-`);
-    for (const def of defs.slice(0, 3)) {
-      parts.push(`- **${def.kind}** \`${def.name}\` \u2192 \`${def.file}\` L${def.lineStart}\u2013${def.lineEnd}`);
-      if (def.docComment)
-        parts.push(`  > ${def.docComment.slice(0, 120)}`);
-      if (def.snippet) {
-        parts.push("  ```");
-        parts.push(def.snippet.split(`
-`).slice(0, 8).join(`
-`));
-        parts.push("  ```");
-      }
-    }
-    parts.push("");
-  }
-  if (refs.length > 0) {
-    parts.push(`### References (${refs.length} total)
-`);
-    const byFile = new Map;
-    for (const r2 of refs.slice(0, 30)) {
-      const arr = byFile.get(r2.fromFile) ?? [];
-      arr.push(r2.fromLine);
-      byFile.set(r2.fromFile, arr);
-    }
-    for (const [file3, lines] of byFile) {
-      parts.push(`- \`${file3}\` L${lines.join(", ")}`);
-    }
-    parts.push("");
-  }
-  const section = parts.join(`
-`);
-  const charBudget = tokenBudget * 4;
-  return section.length > charBudget ? section.slice(0, charBudget) + `
-...
-` : section;
-}
-
-// ../../packages/core/dist/tools/get_optimized_context.js
+init_context_controller();
 class GetOptimizedContextTool {
   name = "get_optimized_context";
   description = "Retrieve code context + persistent memories with maximum token efficiency (search + memories + compress)";
@@ -173949,6 +174255,86 @@ class GetOptimizedContextTool {
     }
   }
 }
+// ../../packages/core/dist/tools/compress_context.js
+init_code_compressor();
+init_compress_with_metrics();
+init_dist();
+init_enum_validation();
+
+class CompressContextTool {
+  name = "compress_context";
+  description = "Compress context using semantic compression (keeps structure, removes details)";
+  inputSchema = {
+    type: "object",
+    properties: {
+      content: {
+        type: "string",
+        description: "Content to compress"
+      },
+      strategy: {
+        type: "string",
+        enum: [
+          "code_structure",
+          "conversation_summary",
+          "semantic_dedup",
+          "hierarchical"
+        ],
+        description: "Compression strategy",
+        default: "code_structure"
+      },
+      language: {
+        type: "string",
+        description: "Programming language (for code compression)"
+      },
+      targetRatio: {
+        type: "number",
+        description: "Target compression ratio (0-1, e.g., 0.7 = 70% reduction)",
+        default: 0.7
+      }
+    },
+    required: ["content"]
+  };
+  compressor;
+  constructor() {
+    this.compressor = new CodeCompressor;
+  }
+  async handle(params) {
+    const { content, language, targetRatio = 0.7 } = params;
+    const strategy = validateEnum("strategy", params.strategy ?? "code_structure", [
+      "code_structure",
+      "conversation_summary",
+      "semantic_dedup",
+      "hierarchical"
+    ]);
+    try {
+      const metrics2 = await compressWithMetrics(this.compressor, content, strategy, { language, targetRatio });
+      return {
+        success: true,
+        data: {
+          compressed: metrics2.compressed,
+          originalLength: content.length,
+          compressedLength: metrics2.compressed.length,
+          originalTokens: metrics2.originalTokens,
+          compressedTokens: metrics2.compressedTokens,
+          strategy
+        },
+        metadata: {
+          tokensSaved: metrics2.tokensSaved,
+          compressionRatio: metrics2.compressionRatio
+        }
+      };
+    } catch (error51) {
+      logger.error("Failed to compress context", error51, {
+        strategy,
+        contentLength: typeof content === "string" ? content.length : 0
+      });
+      return {
+        success: false,
+        error: `Failed to compress context: ${error51.message}`
+      };
+    }
+  }
+}
 // ../../packages/core/dist/tools/store_memory.js
 init_dist();
 init_memory_controller();
@@ -174619,7 +175005,7 @@ init_db_connection();
 init_alias_resolver();
 import fs10 from "fs";
 import os3 from "os";
-import path20 from "path";
+import path21 from "path";
 
 // ../../packages/core/dist/services/hooks/session-pin-store.js
 var DEFAULT_MAX_SIZE = 1000;
@@ -174721,7 +175107,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os3.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path20.parse(path20.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path21.parse(path21.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -174774,7 +175160,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path20.sep) ? candidate2 : candidate2 + path20.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path21.sep) ? candidate2 : candidate2 + path21.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -174797,7 +175183,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path20.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path21.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -174808,7 +175194,7 @@ function defaultCanonicalize(cwd) {
     return fs10.realpathSync(cwd);
   } catch {
     try {
-      return path20.resolve(cwd);
+      return path21.resolve(cwd);
     } catch {
       return;
     }
@@ -175329,310 +175715,22 @@ class GetArchitectureTool {
 }
 // ../../packages/core/dist/tools/read_file.js
 init_dist();
+
+// ../../packages/core/dist/services/file-read/read-file.service.js
 init_dist();
 init_code_compressor();
-init_event_bus();
-init_workspace_manager();
+
+// ../../packages/core/dist/services/file-read/file-content-cache.js
+init_dist();
 import fs11 from "fs/promises";
-import path21 from "path";
-var MASSA_AI_READ_FILE_MAX_LINES = (() => {
-  const v = Number(process.env.MASSA_AI_READ_FILE_MAX_LINES);
-  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 500;
-})();
 
-class ReadFileTool {
-  name = "read_file";
-  description = "Read file with automatic compression, caching, and symbol metadata. " + "Use with search results for 60% token savings.";
-  inputSchema = {
-    type: "object",
-    properties: {
-      filePath: {
-        type: "string",
-        description: "File path (absolute or relative to project root)"
-      },
-      projectId: {
-        type: "string",
-        description: "Project ID for symbol metadata (optional)"
-      },
-      offset: {
-        type: "number",
-        description: "Start line number (1-indexed)"
-      },
-      limit: {
-        type: "number",
-        description: "Number of lines to read"
-      },
-      lineStart: {
-        type: "number",
-        description: "Start line (alternative to offset)"
-      },
-      lineEnd: {
-        type: "number",
-        description: "End line (alternative to limit)"
-      },
-      compress: {
-        type: "boolean",
-        description: "Auto-compress content > 100 lines (default: true)",
-        default: true
-      },
-      targetRatio: {
-        type: "number",
-        description: "Compression target ratio (0.3 = 70% reduction)",
-        default: 0.3
-      },
-      format: {
-        type: "string",
-        enum: ["json", "toon"],
-        description: "Output format",
-        default: "json"
-      },
-      fields: {
-        type: "array",
-        items: { type: "string" },
-        description: "Projection \u2014 keep only these keys (dotted paths supported, e.g. ['nodes.symbol']). Absent/empty \u2192 full data."
-      },
-      includeSymbols: {
-        type: "boolean",
-        description: "Include symbol metadata from graph (default: true)",
-        default: true
-      },
-      includeImports: {
-        type: "boolean",
-        description: "Extract and show import statements (default: true)",
-        default: true
-      }
-    },
-    required: ["filePath"]
-  };
-  compressor;
-  symbolGraph;
+class FileContentCache {
+  extractMetadata;
   fileCache = new Map;
-  projectRootCache = new Map;
   CACHE_TTL = 60000;
-  ROOT_CACHE_TTL = 300000;
   FILE_CACHE_MAX_ENTRIES = 512;
-  constructor(symbolGraph) {
-    this.compressor = new CodeCompressor;
-    this.symbolGraph = symbolGraph;
-    eventBus.subscribe("indexing:started", ({ projectId, projectPath: projectPath2 }) => {
-      this.projectRootCache.delete(projectId);
-      this.evictOldest(this.projectRootCache);
-      this.projectRootCache.set(projectId, projectPath2);
-    });
-  }
-  async handle(params) {
-    const p = params;
-    const shouldCompress = p.compress !== false;
-    const targetRatio = p.targetRatio || 0.3;
-    const format = p.format || "json";
-    const { fields } = p;
-    const includeSymbols = p.includeSymbols !== false;
-    const includeImports = p.includeImports !== false;
-    try {
-      const resolved = await this.resolveFilePath(p.filePath, p.projectId);
-      if (resolved === null) {
-        return {
-          success: false,
-          error: "Relative filePath requires a projectId (to resolve against the workspace) or an absolute path."
-        };
-      }
-      const filePath = resolved;
-      const containment = await this.checkPathContainment(filePath, p.projectId);
-      if (!containment.allowed) {
-        return {
-          success: false,
-          error: containment.error
-        };
-      }
-      const relativePath = p.filePath;
-      const range = this.calculateRange(p);
-      const { content, metadata } = await this.readFileWithCache(filePath, {
-        includeSymbols,
-        includeImports,
-        projectId: p.projectId,
-        relativePath
-      });
-      const lines = content.split(`
-`);
-      const totalLines = lines.length;
-      const adjustedRange = this.adjustRange(range, totalLines);
-      let selectedContent = this.extractLines(lines, adjustedRange);
-      let selectedLineCount = selectedContent.split(`
-`).length;
-      let source_clipped = false;
-      if (selectedLineCount > MASSA_AI_READ_FILE_MAX_LINES) {
-        const cappedLines = lines.slice(adjustedRange.start - 1, adjustedRange.start - 1 + MASSA_AI_READ_FILE_MAX_LINES);
-        selectedContent = cappedLines.join(`
-`);
-        selectedLineCount = selectedContent.split(`
-`).length;
-        source_clipped = true;
-      }
-      const shouldAutoCompress = shouldCompress && selectedLineCount > 100 && targetRatio < 1;
-      const result = {
-        filePath: p.filePath,
-        absolutePath: filePath,
-        lineRange: {
-          requested: {
-            start: range.start,
-            end: range.end === Infinity ? null : range.end
-          },
-          actual: {
-            start: adjustedRange.start,
-            end: source_clipped ? adjustedRange.start + selectedLineCount - 1 : adjustedRange.end,
-            total: totalLines
-          },
-          selected: selectedLineCount
-        },
-        source_clipped,
-        metadata: {
-          totalLines,
-          language: metadata.language,
-          ...metadata.symbols && { symbols: metadata.symbols },
-          ...metadata.imports && { imports: metadata.imports }
-        },
-        compressed: shouldAutoCompress,
-        recommendations: []
-      };
-      if (shouldAutoCompress) {
-        const compressed = await this.compressor.compress(selectedContent, "code_structure");
-        const originalTokens = estimateTokens(selectedContent, "code");
-        const compressedTokens = estimateTokens(compressed.compressed, "code");
-        const actualRatio = compressedTokens / originalTokens;
-        result.content = compressed.compressed;
-        result.tokens = {
-          original: originalTokens,
-          compressed: compressedTokens,
-          saved: originalTokens - compressedTokens,
-          savingsPercent: Math.round((1 - actualRatio) * 100)
-        };
-        result.compressionRatio = actualRatio;
-        result.recommendations.push(`\u2713 Auto-compressed ${selectedLineCount} lines (${result.tokens.savingsPercent}% reduction)`);
-      } else {
-        result.content = selectedContent;
-        result.tokens = {
-          original: estimateTokens(selectedContent, "code"),
-          compressed: estimateTokens(selectedContent, "code"),
-          saved: 0,
-          savingsPercent: 0
-        };
-        if (selectedLineCount > 100) {
-          result.recommendations.push("\uD83D\uDCA1 Content > 100 lines. Consider compress=true for token savings");
-        }
-      }
-      if (range.start === 1 && range.end === Infinity) {
-        result.recommendations.push("\uD83D\uDCA1 Use lineStart/lineEnd or offset/limit to read specific sections (60% token savings)");
-      }
-      if (metadata.symbols && metadata.symbols.definitions > 0) {
-        result.recommendations.push(`\uD83D\uDCA1 Use get_references() to find usages of ${metadata.symbols.definitions} symbols in this file`);
-      }
-      return serializeToolResponse(result, { format, fields });
-    } catch (error51) {
-      logger.error("Failed to read file", error51, {
-        filePath: p.filePath
-      });
-      return {
-        success: false,
-        error: `Failed to read file: ${error51.message}`
-      };
-    }
-  }
-  async resolveFilePath(filePath, projectId) {
-    if (path21.isAbsolute(filePath)) {
-      return path21.resolve(filePath);
-    }
-    if (projectId) {
-      const root = await this.getProjectRoot(projectId);
-      if (root) {
-        const cleaned = sanitizeFilePath(filePath);
-        return path21.resolve(root, cleaned);
-      }
-      return null;
-    }
-    return null;
-  }
-  async checkPathContainment(absoluteFilePath, projectId) {
-    const roots = [];
-    if (projectId) {
-      const root = await this.getProjectRoot(projectId);
-      if (root)
-        roots.push(path21.resolve(root));
-    }
-    roots.push(path21.resolve(process.cwd()));
-    const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
-    for (const extra of envRoots) {
-      roots.push(path21.resolve(extra));
-    }
-    const target = path21.resolve(absoluteFilePath);
-    for (const root of roots) {
-      const rel = path21.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path21.isAbsolute(rel)) {
-        return { allowed: true };
-      }
-      if (rel === "")
-        return { allowed: true };
-    }
-    const validRootsList = roots.map((r2) => `  - ${r2}`).join(`
-`);
-    return {
-      allowed: false,
-      error: `read_file path containment: "${target}" is outside the allowed roots.
-` + `Valid roots (project root + cwd + MASSA_AI_READ_FILE_ROOTS):
-${validRootsList}
-` + `Provide a filePath that resolves under one of these roots.`
-    };
-  }
-  async getProjectRoot(projectId) {
-    const cached2 = this.projectRootCache.get(projectId);
-    if (cached2 !== undefined) {
-      this.projectRootCache.delete(projectId);
-      this.projectRootCache.set(projectId, cached2);
-      return cached2;
-    }
-    try {
-      const workspace = await workspaceManager.getWorkspace(projectId);
-      if (workspace?.project_path) {
-        this.evictOldest(this.projectRootCache);
-        this.projectRootCache.set(projectId, workspace.project_path);
-        return workspace.project_path;
-      }
-    } catch (error51) {
-      logger.warn("Failed to look up project root", { projectId, error: error51.message });
-    }
-    return null;
-  }
-  evictOldest(cache) {
-    while (cache.size >= this.FILE_CACHE_MAX_ENTRIES) {
-      const oldest = cache.keys().next().value;
-      if (oldest === undefined)
-        break;
-      cache.delete(oldest);
-    }
-  }
-  calculateRange(params) {
-    if (params.lineStart !== undefined && params.lineEnd !== undefined) {
-      return {
-        start: Math.max(1, params.lineStart),
-        end: params.lineEnd
-      };
-    }
-    if (params.offset !== undefined) {
-      const offset = Math.max(1, params.offset);
-      const limit = params.limit || 1000;
-      return {
-        start: offset,
-        end: offset + limit - 1
-      };
-    }
-    return {
-      start: 1,
-      end: Infinity
-    };
-  }
-  adjustRange(range, totalLines) {
-    const start = Math.max(1, Math.min(range.start, totalLines));
-    const end = range.end === Infinity ? totalLines : Math.min(range.end, totalLines);
-    return { start, end };
+  constructor(extractMetadata) {
+    this.extractMetadata = extractMetadata;
   }
   async readFileWithCache(filePath, options) {
     const cacheKey = JSON.stringify({
@@ -175659,7 +175757,7 @@ ${validRootsList}
     }
     const content = await fs11.readFile(filePath, "utf-8");
     const metadata = await this.extractMetadata(content, filePath, options);
-    this.evictOldest(this.fileCache);
+    evictOldest(this.fileCache, this.FILE_CACHE_MAX_ENTRIES - 1);
     this.fileCache.set(cacheKey, {
       content,
       timestamp: Date.now(),
@@ -175668,6 +175766,17 @@ ${validRootsList}
     logger.debug("File read and cached", { filePath });
     return { content, metadata };
   }
+}
+
+// ../../packages/core/dist/services/file-read/file-metadata.js
+init_dist();
+import path22 from "path";
+
+class FileMetadataExtractor {
+  symbolGraph;
+  constructor(symbolGraph) {
+    this.symbolGraph = symbolGraph;
+  }
   async extractMetadata(content, filePath, options) {
     const lines = content.split(`
 `);
@@ -175696,18 +175805,8 @@ ${validRootsList}
     }
     return metadata;
   }
-  extractLines(lines, range) {
-    const start = range.start - 1;
-    const end = range.end;
-    const selectedLines = lines.slice(start, end);
-    return selectedLines.map((line, index) => {
-      const lineNum = start + index + 1;
-      return `${lineNum.toString().padStart(6, " ")}: ${line}`;
-    }).join(`
-`);
-  }
   detectLanguage(filePath) {
-    const ext2 = path21.extname(filePath).toLowerCase();
+    const ext2 = path22.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -175765,6 +175864,366 @@ ${validRootsList}
     return imports;
   }
 }
+
+// ../../packages/core/dist/services/file-read/line-range.js
+var MASSA_AI_READ_FILE_MAX_LINES = (() => {
+  const v = Number(process.env.MASSA_AI_READ_FILE_MAX_LINES);
+  return Number.isFinite(v) && v > 0 ? Math.floor(v) : 500;
+})();
+function calculateRange(params) {
+  if (params.lineStart !== undefined && params.lineEnd !== undefined) {
+    return {
+      start: Math.max(1, params.lineStart),
+      end: params.lineEnd
+    };
+  }
+  if (params.offset !== undefined) {
+    const offset = Math.max(1, params.offset);
+    const limit = params.limit || 1000;
+    return {
+      start: offset,
+      end: offset + limit - 1
+    };
+  }
+  return {
+    start: 1,
+    end: Infinity
+  };
+}
+function adjustRange(range, totalLines) {
+  const start = Math.max(1, Math.min(range.start, totalLines));
+  const end = range.end === Infinity ? totalLines : Math.min(range.end, totalLines);
+  return { start, end };
+}
+function extractLines(lines, range) {
+  const start = range.start - 1;
+  const end = range.end;
+  const selectedLines = lines.slice(start, end);
+  return selectedLines.map((line, index) => {
+    const lineNum = start + index + 1;
+    return `${lineNum.toString().padStart(6, " ")}: ${line}`;
+  }).join(`
+`);
+}
+function selectLines(lines, range) {
+  let content = extractLines(lines, range);
+  let lineCount = content.split(`
+`).length;
+  let clipped = false;
+  if (lineCount > MASSA_AI_READ_FILE_MAX_LINES) {
+    const cappedLines = lines.slice(range.start - 1, range.start - 1 + MASSA_AI_READ_FILE_MAX_LINES);
+    content = cappedLines.join(`
+`);
+    lineCount = content.split(`
+`).length;
+    clipped = true;
+  }
+  return { content, lineCount, clipped };
+}
+
+// ../../packages/core/dist/services/file-read/path-containment.js
+init_dist();
+import path23 from "path";
+
+class PathContainment {
+  projectRoots;
+  constructor(projectRoots) {
+    this.projectRoots = projectRoots;
+  }
+  async resolveFilePath(filePath, projectId) {
+    if (path23.isAbsolute(filePath)) {
+      return path23.resolve(filePath);
+    }
+    if (projectId) {
+      const root = await this.projectRoots.getProjectRoot(projectId);
+      if (root) {
+        const cleaned = sanitizeFilePath(filePath);
+        return path23.resolve(root, cleaned);
+      }
+      return null;
+    }
+    return null;
+  }
+  async checkPathContainment(absoluteFilePath, projectId) {
+    const roots = [];
+    if (projectId) {
+      const root = await this.projectRoots.getProjectRoot(projectId);
+      if (root)
+        roots.push(path23.resolve(root));
+    }
+    roots.push(path23.resolve(process.cwd()));
+    const envRoots = (process.env.MASSA_AI_READ_FILE_ROOTS ?? "").split(":").map((s) => s.trim()).filter((s) => s.length > 0);
+    for (const extra of envRoots) {
+      roots.push(path23.resolve(extra));
+    }
+    const target = path23.resolve(absoluteFilePath);
+    for (const root of roots) {
+      const rel = path23.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path23.isAbsolute(rel)) {
+        return { allowed: true };
+      }
+      if (rel === "")
+        return { allowed: true };
+    }
+    const validRootsList = roots.map((r2) => `  - ${r2}`).join(`
+`);
+    return {
+      allowed: false,
+      error: `read_file path containment: "${target}" is outside the allowed roots.
+` + `Valid roots (project root + cwd + MASSA_AI_READ_FILE_ROOTS):
+${validRootsList}
+` + `Provide a filePath that resolves under one of these roots.`
+    };
+  }
+}
+
+// ../../packages/core/dist/services/file-read/project-root-cache.js
+init_dist();
+init_event_bus();
+init_workspace_manager();
+
+class ProjectRootCache {
+  projectRootCache = new Map;
+  ROOT_CACHE_TTL = 300000;
+  PROJECT_ROOT_CACHE_MAX_ENTRIES = 512;
+  constructor() {
+    eventBus.subscribe("indexing:started", ({ projectId, projectPath: projectPath2 }) => {
+      this.projectRootCache.delete(projectId);
+      evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+      this.projectRootCache.set(projectId, projectPath2);
+    });
+  }
+  async getProjectRoot(projectId) {
+    const cached2 = this.projectRootCache.get(projectId);
+    if (cached2 !== undefined) {
+      this.projectRootCache.delete(projectId);
+      this.projectRootCache.set(projectId, cached2);
+      return cached2;
+    }
+    try {
+      const workspace = await workspaceManager.getWorkspace(projectId);
+      if (workspace?.project_path) {
+        evictOldest(this.projectRootCache, this.PROJECT_ROOT_CACHE_MAX_ENTRIES - 1);
+        this.projectRootCache.set(projectId, workspace.project_path);
+        return workspace.project_path;
+      }
+    } catch (error51) {
+      logger.warn("Failed to look up project root", { projectId, error: error51.message });
+    }
+    return null;
+  }
+}
+
+// ../../packages/core/dist/services/file-read/read-file.service.js
+function readFileOptions(p) {
+  const shouldCompress = p.compress !== false;
+  const targetRatio = p.targetRatio || 0.3;
+  const format = p.format || "json";
+  const { fields } = p;
+  const includeSymbols = p.includeSymbols !== false;
+  const includeImports = p.includeImports !== false;
+  return { shouldCompress, targetRatio, format, fields, includeSymbols, includeImports };
+}
+
+class ReadFileService {
+  compressor;
+  symbolGraph;
+  projectRoots;
+  pathContainment;
+  fileMetadata;
+  fileContent;
+  constructor(symbolGraph) {
+    this.compressor = new CodeCompressor;
+    this.symbolGraph = symbolGraph;
+    this.projectRoots = new ProjectRootCache;
+    this.pathContainment = new PathContainment(this.projectRoots);
+    this.fileMetadata = new FileMetadataExtractor(symbolGraph);
+    this.fileContent = new FileContentCache((content, filePath, options) => this.fileMetadata.extractMetadata(content, filePath, options));
+  }
+  async read(p, options) {
+    const { shouldCompress, targetRatio, includeSymbols, includeImports } = options;
+    const resolved = await this.pathContainment.resolveFilePath(p.filePath, p.projectId);
+    if (resolved === null) {
+      return {
+        ok: false,
+        error: "Relative filePath requires a projectId (to resolve against the workspace) or an absolute path."
+      };
+    }
+    const filePath = resolved;
+    const containment = await this.pathContainment.checkPathContainment(filePath, p.projectId);
+    if (!containment.allowed) {
+      return {
+        ok: false,
+        error: containment.error
+      };
+    }
+    const relativePath = p.filePath;
+    const range = calculateRange(p);
+    const { content, metadata } = await this.fileContent.readFileWithCache(filePath, {
+      includeSymbols,
+      includeImports,
+      projectId: p.projectId,
+      relativePath
+    });
+    const lines = content.split(`
+`);
+    const totalLines = lines.length;
+    const adjustedRange = adjustRange(range, totalLines);
+    const { content: selectedContent, lineCount: selectedLineCount, clipped: source_clipped } = selectLines(lines, adjustedRange);
+    const shouldAutoCompress = shouldCompress && selectedLineCount > 100 && targetRatio < 1;
+    const result = {
+      filePath: p.filePath,
+      absolutePath: filePath,
+      lineRange: {
+        requested: {
+          start: range.start,
+          end: range.end === Infinity ? null : range.end
+        },
+        actual: {
+          start: adjustedRange.start,
+          end: source_clipped ? adjustedRange.start + selectedLineCount - 1 : adjustedRange.end,
+          total: totalLines
+        },
+        selected: selectedLineCount
+      },
+      source_clipped,
+      metadata: {
+        totalLines,
+        language: metadata.language,
+        ...metadata.symbols && { symbols: metadata.symbols },
+        ...metadata.imports && { imports: metadata.imports }
+      },
+      compressed: shouldAutoCompress,
+      recommendations: []
+    };
+    if (shouldAutoCompress) {
+      const compressed = await this.compressor.compress(selectedContent, "code_structure");
+      const originalTokens = estimateTokens(selectedContent, "code");
+      const compressedTokens = estimateTokens(compressed.compressed, "code");
+      const actualRatio = compressedTokens / originalTokens;
+      result.content = compressed.compressed;
+      result.tokens = {
+        original: originalTokens,
+        compressed: compressedTokens,
+        saved: originalTokens - compressedTokens,
+        savingsPercent: Math.round((1 - actualRatio) * 100)
+      };
+      result.compressionRatio = actualRatio;
+      result.recommendations.push(`\u2713 Auto-compressed ${selectedLineCount} lines (${result.tokens.savingsPercent}% reduction)`);
+    } else {
+      result.content = selectedContent;
+      result.tokens = {
+        original: estimateTokens(selectedContent, "code"),
+        compressed: estimateTokens(selectedContent, "code"),
+        saved: 0,
+        savingsPercent: 0
+      };
+      if (selectedLineCount > 100) {
+        result.recommendations.push("\uD83D\uDCA1 Content > 100 lines. Consider compress=true for token savings");
+      }
+    }
+    if (range.start === 1 && range.end === Infinity) {
+      result.recommendations.push("\uD83D\uDCA1 Use lineStart/lineEnd or offset/limit to read specific sections (60% token savings)");
+    }
+    if (metadata.symbols && metadata.symbols.definitions > 0) {
+      result.recommendations.push(`\uD83D\uDCA1 Use get_references() to find usages of ${metadata.symbols.definitions} symbols in this file`);
+    }
+    return { ok: true, data: result };
+  }
+}
+
+// ../../packages/core/dist/tools/read_file.js
+class ReadFileTool {
+  name = "read_file";
+  description = "Read file with automatic compression, caching, and symbol metadata. " + "Use with search results for 60% token savings.";
+  inputSchema = {
+    type: "object",
+    properties: {
+      filePath: {
+        type: "string",
+        description: "File path (absolute or relative to project root)"
+      },
+      projectId: {
+        type: "string",
+        description: "Project ID for symbol metadata (optional)"
+      },
+      offset: {
+        type: "number",
+        description: "Start line number (1-indexed)"
+      },
+      limit: {
+        type: "number",
+        description: "Number of lines to read"
+      },
+      lineStart: {
+        type: "number",
+        description: "Start line (alternative to offset)"
+      },
+      lineEnd: {
+        type: "number",
+        description: "End line (alternative to limit)"
+      },
+      compress: {
+        type: "boolean",
+        description: "Auto-compress content > 100 lines (default: true)",
+        default: true
+      },
+      targetRatio: {
+        type: "number",
+        description: "Compression target ratio (0.3 = 70% reduction)",
+        default: 0.3
+      },
+      format: {
+        type: "string",
+        enum: ["json", "toon"],
+        description: "Output format",
+        default: "json"
+      },
+      fields: {
+        type: "array",
+        items: { type: "string" },
+        description: "Projection \u2014 keep only these keys (dotted paths supported, e.g. ['nodes.symbol']). Absent/empty \u2192 full data."
+      },
+      includeSymbols: {
+        type: "boolean",
+        description: "Include symbol metadata from graph (default: true)",
+        default: true
+      },
+      includeImports: {
+        type: "boolean",
+        description: "Extract and show import statements (default: true)",
+        default: true
+      }
+    },
+    required: ["filePath"]
+  };
+  service;
+  constructor(symbolGraph) {
+    this.service = new ReadFileService(symbolGraph);
+  }
+  async handle(params) {
+    const p = params;
+    const options = readFileOptions(p);
+    try {
+      const outcome2 = await this.service.read(p, options);
+      if (!outcome2.ok) {
+        return { success: false, error: outcome2.error };
+      }
+      return serializeToolResponse(outcome2.data, {
+        format: options.format,
+        fields: options.fields
+      });
+    } catch (error51) {
+      logger.error("Failed to read file", error51, {
+        filePath: p.filePath
+      });
+      return {
+        success: false,
+        error: `Failed to read file: ${error51.message}`
+      };
+    }
+  }
+}
 // ../../packages/core/dist/tools/execute.js
 class ExecuteTool {
   name = "execute";
@@ -175963,331 +176422,12 @@ class FetchAndIndexTool {
     return this.run(params);
   }
 }
-// ../../packages/core/dist/controllers/index.js
-init_memory_controller();
-init_search_controller();
-
-// ../../packages/core/dist/controllers/executor-controller.js
-init_dist();
-init_executor2();
-init_enum_validation();
-import { cpus as cpus2 } from "os";
-var EXECUTOR_LANGUAGES = [
-  "javascript",
-  "typescript",
-  "python",
-  "shell",
-  "ruby",
-  "go",
-  "rust",
-  "php",
-  "perl",
-  "r"
-];
-var MAX_BATCH_COMMANDS = 256;
-function applyIntent(result, intent) {
-  if (!intent || !result.stdout)
-    return result;
-  const ir = intentSearch(result.stdout, intent);
-  if (!ir.searched)
-    return result;
-  const rendered = renderIntentResult(ir, intent);
-  return {
-    ...result,
-    stdout: `${rendered}
-
---- tail (last 512 chars) ---
-${result.stdout.slice(-512)}`
-  };
-}
-
-class ExecutorController {
-  static instance = null;
-  executor;
-  constructor(executor) {
-    this.executor = executor ?? new PolyglotExecutor;
-  }
-  static getInstance() {
-    if (!ExecutorController.instance) {
-      ExecutorController.instance = new ExecutorController;
-    }
-    return ExecutorController.instance;
-  }
-  static resetInstance() {
-    ExecutorController.instance?.executor.cleanupBackgrounded();
-    ExecutorController.instance = null;
-  }
-  get runtimes() {
-    return this.executor.runtimes;
-  }
-  async execute(params) {
-    try {
-      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
-      const result = await this.executor.execute({
-        language,
-        code: params.code,
-        timeout: params.timeout,
-        background: params.background,
-        cwd: params.cwd
-      });
-      const finalResult = applyIntent(result, params.intent);
-      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
-      return {
-        success: ok,
-        data: {
-          stdout: finalResult.stdout,
-          stderr: finalResult.stderr,
-          exitCode: finalResult.exitCode,
-          timedOut: finalResult.timedOut,
-          backgrounded: finalResult.backgrounded ?? false,
-          command: finalResult.command,
-          cwd: finalResult.cwd,
-          sandboxMode: finalResult.sandboxMode
-        }
-      };
-    } catch (error51) {
-      logger.error("execute failed", error51, {
-        language: params.language
-      });
-      return {
-        success: false,
-        error: `execute failed: ${error51.message}`
-      };
-    }
-  }
-  async executeFile(params) {
-    try {
-      const language = validateEnum("language", params.language, EXECUTOR_LANGUAGES);
-      const result = await this.executor.executeFile({
-        path: params.path,
-        language,
-        code: params.code,
-        timeout: params.timeout
-      });
-      const blocked = result.stderr?.startsWith("Blocked:");
-      if (blocked) {
-        return { success: false, error: result.stderr };
-      }
-      const finalResult = applyIntent(result, params.intent);
-      const ok = !finalResult.timedOut && finalResult.exitCode === 0;
-      return {
-        success: ok,
-        data: {
-          stdout: finalResult.stdout,
-          stderr: finalResult.stderr,
-          exitCode: finalResult.exitCode,
-          timedOut: finalResult.timedOut,
-          command: finalResult.command,
-          cwd: finalResult.cwd,
-          sandboxMode: finalResult.sandboxMode
-        }
-      };
-    } catch (error51) {
-      logger.error("execute_file failed", error51, {
-        path: params.path,
-        language: params.language
-      });
-      return {
-        success: false,
-        error: `execute_file failed: ${error51.message}`
-      };
-    }
-  }
-  async batchExecute(params) {
-    const { commands, concurrency, cwd, timeout } = params;
-    if (!Array.isArray(commands) || commands.length === 0) {
-      return { success: false, error: "commands must be a non-empty array." };
-    }
-    if (commands.length > MAX_BATCH_COMMANDS) {
-      return {
-        success: false,
-        error: `batch_execute accepts at most ${MAX_BATCH_COMMANDS} commands; received ${commands.length}. Split the batch or reduce the payload.`
-      };
-    }
-    const effectiveConcurrency = concurrency && concurrency > 0 ? concurrency : Math.max(1, cpus2().length);
-    const perTimeout = timeout ?? DEFAULT_TIMEOUT_MS2;
-    try {
-      const poolResult = await runPool(commands.map((cmd) => ({
-        run: () => this.executor.execute({
-          language: "shell",
-          code: cmd,
-          timeout: perTimeout,
-          cwd
-        })
-      })), { concurrency: effectiveConcurrency });
-      const results = poolResult.settled.map((s, i) => {
-        if (s.status === "fulfilled") {
-          const r2 = s.value;
-          return {
-            command: commands[i],
-            stdout: r2.stdout,
-            stderr: r2.stderr,
-            exitCode: r2.exitCode,
-            timedOut: r2.timedOut,
-            sandboxMode: r2.sandboxMode
-          };
-        }
-        return {
-          command: commands[i],
-          stdout: "",
-          stderr: String(s.reason ?? "unknown error"),
-          exitCode: null,
-          timedOut: false,
-          sandboxMode: getSandboxMode()
-        };
-      });
-      const anyFailed = results.some((r2) => r2.exitCode !== 0 || r2.timedOut);
-      return {
-        success: !anyFailed,
-        data: {
-          results,
-          concurrency: poolResult.effectiveConcurrency,
-          capped: poolResult.capped
-        }
-      };
-    } catch (error51) {
-      logger.error("batch_execute failed", error51);
-      return {
-        success: false,
-        error: `batch_execute failed: ${error51.message}`
-      };
-    }
-  }
-  static get MAX_TIMEOUT_MS() {
-    return MAX_TIMEOUT_MS;
-  }
-}
-// ../../packages/core/dist/controllers/graph-controller.js
-init_dist();
-init_trace_path();
-init_impact_analysis();
-init_definition_lookup();
-
-class GraphController {
-  static instance = null;
-  constructor() {}
-  static getInstance() {
-    if (!GraphController.instance) {
-      GraphController.instance = new GraphController;
-    }
-    return GraphController.instance;
-  }
-  async tracePath(input) {
-    const projectId = input.projectId;
-    const seed = input.function_name ?? input.symbol ?? input.qualifiedName;
-    if (!projectId)
-      throw new Error("projectId is required");
-    if (!seed)
-      throw new Error("function_name (or symbol/qualifiedName) is required");
-    const t0 = performance.now();
-    const result = await tracePathService.tracePath({
-      symbol: input.function_name ?? input.symbol ?? "",
-      function_name: input.function_name,
-      qualifiedName: input.qualifiedName,
-      projectId,
-      direction: input.direction,
-      mode: input.mode,
-      depth: input.depth,
-      include_tests: input.include_tests,
-      edge_types: input.edge_types
-    });
-    logger.info("GraphController: trace_path", {
-      projectId,
-      symbol: seed,
-      mode: result.mode,
-      direction: result.direction,
-      seeds: result.seeds.length,
-      nodes: result.nodes.length,
-      edges: result.edges.length,
-      durationMs: Math.round(performance.now() - t0)
-    });
-    if (result.seeds.length === 0) {
-      return {
-        found: false,
-        symbol: seed,
-        projectId,
-        ...result.identityResolution ? { identityResolution: result.identityResolution } : {},
-        hint: "Use search_definitions(search=...) to find the exact name, or pass a fully-qualified name (qualifiedName='rel/path.ts#Name')."
-      };
-    }
-    return {
-      found: true,
-      result: {
-        projectId: result.projectId,
-        symbol: result.symbol,
-        mode: result.mode,
-        direction: result.direction,
-        edgeTypes: result.edgeTypes,
-        seeds: result.seeds,
-        truncated: result.truncated,
-        nodes_total: result.nodes_total,
-        nodes_shown: result.nodes_shown,
-        nodes_omitted: result.nodes_omitted,
-        nodeCount: result.nodes.length,
-        edgeCount: result.edges.length,
-        chains: result.chains,
-        nodes: result.nodes,
-        edges: result.edges,
-        ...result.identityResolution ? { identity: toSymbolIdentityResolution(result.identityResolution) } : {}
-      }
-    };
-  }
-  async analyzeImpact(input) {
-    if (!input.projectId)
-      throw new Error("projectId is required");
-    if (!input.projectPath)
-      throw new Error("projectPath is required");
-    const t0 = performance.now();
-    const result = await impactAnalysisService.analyze({
-      projectId: input.projectId,
-      projectPath: input.projectPath,
-      scope: input.scope ?? "unstaged",
-      baseBranch: input.base_branch,
-      since: input.since,
-      depth: input.depth,
-      paths: input.paths,
-      diffRunner: input.diffRunner
-    });
-    logger.info("GraphController: impact_analysis", {
-      projectId: input.projectId,
-      scope: result.scope,
-      changedFiles: result.changedFiles.length,
-      impacted: result.impacted.length,
-      truncated: result.truncated,
-      durationMs: Math.round(performance.now() - t0)
-    });
-    return {
-      projectId: result.projectId,
-      scope: result.scope,
-      baseBranch: result.baseBranch,
-      since: result.since,
-      depth: result.depth,
-      changedFileCount: result.changedFiles.length,
-      changedFiles: result.changedFiles,
-      impactedCount: result.impacted.length,
-      truncated: result.truncated,
-      impacted: result.impacted,
-      untrackedFiltered: result.untrackedFiltered,
-      impacted_total: result.impacted_total,
-      impacted_shown: result.impacted_shown,
-      impacted_omitted: result.impacted_omitted,
-      note: result.note
-    };
-  }
-}
 // ../../packages/core/dist/index.js
 init_memory_repository_pg();
 init_memory_repository_factory();
-init_services();
-
-// ../../packages/core/dist/data/vector/hybrid-search.js
 init_vector_store_factory();
-init_keyword_search_pg();
-init_dist();
+init_services();
 
-// ../../packages/core/dist/data/vector/index.js
-init_vector_store_factory();
-init_base_vector_store();
 // ../../packages/core/dist/data/graph-generation/index.js
 init_graph_generation_repository_pg();
 init_graph_generation_repository_factory();
@@ -176648,7 +176788,7 @@ init_llm_client();
 init_symbol_graph_service();
 import { randomUUID as randomUUID9 } from "crypto";
 import fs14 from "fs";
-import path24 from "path";
+import path26 from "path";
 import { spawn as spawn2 } from "child_process";
 var FALLBACK_BOOTSTRAP = {
   enabled: true,
@@ -176832,7 +176972,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path24.join(projectRoot, name26);
+      const p = path26.join(projectRoot, name26);
       if (fs14.existsSync(p) && fs14.statSync(p).isFile()) {
         const buf = fs14.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
@@ -176843,14 +176983,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path24.join(projectRoot, "docs");
+    const docsDir = path26.join(projectRoot, "docs");
     if (fs14.existsSync(docsDir) && fs14.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
           const buf = fs14.readFileSync(rel);
           signals.docs.push({
-            path: path24.relative(projectRoot, rel),
+            path: path26.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -176861,7 +177001,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path24.join(projectRoot, name26);
+      const p = path26.join(projectRoot, name26);
       if (!fs14.existsSync(p) || !fs14.statSync(p).isFile())
         continue;
       const raw2 = fs14.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
@@ -176909,7 +177049,7 @@ function walkMarkdown(dir) {
       continue;
     }
     for (const e of entries) {
-      const full = path24.join(cur, e.name);
+      const full = path26.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -177943,7 +178083,7 @@ var checkpointRoutes = new Elysia({ prefix: "/api/v1/checkpoints" }).post("/list
 // src/routes/project.ts
 init_dist();
 import fs15 from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 var indexProjectTool = null;
 var indexStatusTool = null;
 var projectIdentityService = null;
@@ -178152,21 +178292,21 @@ var projectRoutes = new Elysia({ prefix: "/api/v1/project" }).get("/list", async
 }).post("/upload-and-index", async ({ body }) => {
   const rawBase = body.projectId || body.projectPath.replace(/\\/g, "/").split("/").filter(Boolean).pop() || "default";
   const finalProjectId = rawBase.replace(/[^a-zA-Z0-9_.-]/g, "_").slice(0, 128);
-  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path25.join(getGlobalDataDir(), "uploads");
-  const stagingDir = path25.resolve(uploadRoot, finalProjectId);
+  const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path27.join(getGlobalDataDir(), "uploads");
+  const stagingDir = path27.resolve(uploadRoot, finalProjectId);
   await fs15.rm(stagingDir, { recursive: true, force: true });
   await fs15.mkdir(stagingDir, { recursive: true });
   const WRITE_BATCH = 20;
   for (let i = 0;i < body.files.length; i += WRITE_BATCH) {
     await Promise.all(body.files.slice(i, i + WRITE_BATCH).map(async (file3) => {
-      if (path25.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
+      if (path27.isAbsolute(file3.relativePath) || file3.relativePath.includes("..")) {
         throw new Error(`Invalid file path: ${file3.relativePath}`);
       }
-      const dest = path25.resolve(stagingDir, file3.relativePath.replace(/\//g, path25.sep));
-      if (!dest.startsWith(stagingDir + path25.sep)) {
+      const dest = path27.resolve(stagingDir, file3.relativePath.replace(/\//g, path27.sep));
+      if (!dest.startsWith(stagingDir + path27.sep)) {
         throw new Error(`Path escapes staging directory: ${file3.relativePath}`);
       }
-      await fs15.mkdir(path25.dirname(dest), { recursive: true });
+      await fs15.mkdir(path27.dirname(dest), { recursive: true });
       await fs15.writeFile(dest, file3.content, "utf-8");
     }));
   }
@@ -178321,7 +178461,7 @@ var analyticsRoutes = new Elysia({ prefix: "/api/v1/analytics" }).post("/", asyn
 
 // src/routes/system.ts
 init_dist();
-import path26 from "path";
+import path28 from "path";
 import fs16 from "fs";
 import os4 from "os";
 function databaseUrlParts() {
@@ -178396,7 +178536,7 @@ var systemRoutes = new Elysia({ prefix: "/api/v1/system" }).get("/info", async (
     description: "Check PostgreSQL, pgvector, Ollama, and local artifact directory health"
   }
 }).get("/metrics", async () => {
-  const metricsPath = path26.join(process.cwd(), "data", "metrics.json");
+  const metricsPath = path28.join(process.cwd(), "data", "metrics.json");
   let metrics2 = {};
   if (fs16.existsSync(metricsPath)) {
     try {
@@ -178551,7 +178691,7 @@ var eventsRoutes = new Elysia({ prefix: "/api/v1" }).get("/events", async ({ que
 
 // src/routes/workspace.ts
 import fs17 from "fs/promises";
-import path27 from "path";
+import path29 from "path";
 import { realpathSync as realpathSync4 } from "fs";
 var indexProjectTool2 = null;
 function getIndexProjectTool2() {
@@ -178593,7 +178733,7 @@ function realpathSafe(p) {
   try {
     return realpathSync4(p);
   } catch {
-    return path27.resolve(p);
+    return path29.resolve(p);
   }
 }
 var graphController = null;
@@ -178944,8 +179084,8 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     }
     const registeredRoot = realpathSafe(workspace.project_path);
     const callerRoot = realpathSafe(projectPath2);
-    const rel = path27.relative(registeredRoot, callerRoot);
-    const escapes = rel.startsWith("..") || path27.isAbsolute(rel);
+    const rel = path29.relative(registeredRoot, callerRoot);
+    const escapes = rel.startsWith("..") || path29.isAbsolute(rel);
     if (registeredRoot !== callerRoot && escapes) {
       return {
         success: false,
@@ -179075,7 +179215,7 @@ var workspaceRoutes = new Elysia({ prefix: "/api/v1" }).get("/workspace/list", a
     } else {
       end = start + 20;
     }
-    const absolutePath = path27.join(workspace.project_path, file3);
+    const absolutePath = path29.join(workspace.project_path, file3);
     const content = await fs17.readFile(absolutePath, "utf-8");
     const lines = content.split(/\r?\n/);
     const slice = lines.slice(start - 1, Math.min(lines.length, end));
@@ -179992,7 +180132,7 @@ var webRoutes = new Elysia({ prefix: "/api/v1/web" }).post("/fetch_and_index", a
 
 // src/routes/web-ui.ts
 import fs18 from "fs/promises";
-import path28 from "path";
+import path30 from "path";
 import { fileURLToPath as fileURLToPath3 } from "url";
 
 // src/web-ui-trust.ts
@@ -180036,9 +180176,9 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   for (const root2 of [moduleDir, cwd]) {
     let dir = root2;
     for (let i = 0;i < 10; i++) {
-      candidates2.push(path28.resolve(dir, "apps/web-ui/src/static"));
-      candidates2.push(path28.resolve(dir, "web-ui/src/static"));
-      const parent = path28.dirname(dir);
+      candidates2.push(path30.resolve(dir, "apps/web-ui/src/static"));
+      candidates2.push(path30.resolve(dir, "web-ui/src/static"));
+      const parent = path30.dirname(dir);
       if (parent === dir)
         break;
       dir = parent;
@@ -180046,7 +180186,7 @@ function buildStaticDirCandidates(moduleDir, cwd) {
   }
   return [...new Set(candidates2)];
 }
-var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path28.dirname(fileURLToPath3(import.meta.url)), process.cwd());
+var STATIC_DIR_CANDIDATES = buildStaticDirCandidates(path30.dirname(fileURLToPath3(import.meta.url)), process.cwd());
 async function resolveStaticDir() {
   for (const dir of STATIC_DIR_CANDIDATES) {
     try {
@@ -180071,7 +180211,7 @@ var CONTENT_TYPES = {
   ".woff2": "font/woff2"
 };
 function contentTypeFor(filePath) {
-  const ext2 = path28.extname(filePath).toLowerCase();
+  const ext2 = path30.extname(filePath).toLowerCase();
   return CONTENT_TYPES[ext2] ?? "application/octet-stream";
 }
 function webUiDisabled() {
@@ -180082,9 +180222,9 @@ function webUiDisabled() {
 }
 async function resolveSafePath(staticDir, sub) {
   const cleaned = sub.replace(/^\/+/, "");
-  const abs = path28.resolve(staticDir, cleaned);
-  const rel = path28.relative(staticDir, abs);
-  if (rel.startsWith("..") || path28.isAbsolute(rel)) {
+  const abs = path30.resolve(staticDir, cleaned);
+  const rel = path30.relative(staticDir, abs);
+  if (rel.startsWith("..") || path30.isAbsolute(rel)) {
     return null;
   }
   try {
@@ -180128,7 +180268,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     set3.status = 500;
     return { status: 500, error: "web ui static dir not found" };
   }
-  const indexPath = path28.join(dir, "index.html");
+  const indexPath = path30.join(dir, "index.html");
   try {
     const body = await readShell(indexPath, remoteAddressOf(request));
     set3.headers["content-type"] = contentTypeFor(indexPath);
@@ -180170,7 +180310,7 @@ var webUiRoutes = new Elysia().get("/ui", async ({ set: set3, request }) => {
     }
   }
   try {
-    const body = await readShell(path28.join(dir, "index.html"), remoteAddressOf(request));
+    const body = await readShell(path30.join(dir, "index.html"), remoteAddressOf(request));
     set3.headers["content-type"] = "text/html; charset=utf-8";
     return body;
   } catch {