@massa-ai/mcp-client 1.16.0 → 1.18.0

package/dist/index.js

@@ -37759,7 +37759,7 @@ var init_esm6 = __esm(() => {
   esm_default = import_lib.default;
 });
 
-// ../../packages/core/dist/data/db-connection.js
+// ../../packages/core/dist/kernel/db-connection.js
 function getDbConfig() {
   return {
     connectionString: requirePostgresDatabaseUrl(),
@@ -37787,7 +37787,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;
@@ -38111,6 +38111,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;
@@ -38179,18 +38189,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;
@@ -112233,7 +112232,7 @@ var require_dist9 = __commonJS((exports, module) => {
   };
 });
 
-// ../../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,
@@ -113044,7 +113043,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();
@@ -114136,7 +114135,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 };
@@ -114197,7 +114196,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]);
@@ -114262,7 +114261,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 = [];
@@ -114926,9 +114925,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;
   }
@@ -114974,7 +114980,6 @@ class BaseVectorStore {
   }
 }
 var init_base_vector_store = __esm(() => {
-  init_embeddings();
   init_dist();
 });
 
@@ -115100,7 +115105,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",
@@ -115556,7 +115561,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;
@@ -115573,6 +115578,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",
@@ -115605,6 +115611,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
@@ -116176,7 +116183,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)
@@ -116215,7 +116222,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();
@@ -118532,7 +118539,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,
@@ -118848,7 +118855,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;
@@ -120454,7 +120461,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(", ")}.`);
@@ -120526,7 +120533,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
@@ -121271,7 +121278,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 });
 }
@@ -129047,6 +129054,133 @@ var init_pipeline = __esm(() => {
   };
 });
 
+// ../../packages/core/dist/services/indexing/execute-indexing.js
+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);
+  }
+}
+var init_execute_indexing = __esm(() => {
+  init_dist();
+  init_index_job_tracker();
+  init_pipeline();
+});
+
+// ../../packages/core/dist/services/indexing/acquire-indexing-lease.js
+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 };
+  }
+}
+var init_acquire_indexing_lease = __esm(() => {
+  init_dist();
+  init_index_job_tracker();
+  init_managed_run_repository_pg();
+});
+
+// ../../packages/core/dist/services/project-identity/project-root-identity.js
+import { realpath as realpath2 } from "fs/promises";
+import path17 from "path";
+async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
+  return canonicalize(path17.resolve(projectPath));
+}
+async function assertProjectRootReuse(options) {
+  if (!options.storedProjectPath || options.forceReindex)
+    return;
+  const canonicalize = options.canonicalize ?? realpath2;
+  let storedCanonical;
+  try {
+    storedCanonical = await canonicalize(path17.resolve(options.storedProjectPath));
+  } catch {
+    storedCanonical = path17.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");
+  }
+}
+var init_project_root_identity = () => {};
+
 // ../../packages/core/dist/services/symbol/definition-lookup.js
 function toSymbolIdentityResolution(result) {
   switch (result.status) {
@@ -129782,16 +129916,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path17 = e.route;
-    if (!path17)
+    const path18 = e.route;
+    if (!path18)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path17;
+    const key = method + " " + path18;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path17,
+      path: path18,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -129802,12 +129936,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path17 = parsed?.path ?? d.name;
-    const key = method + " " + path17;
+    const path18 = parsed?.path ?? d.name;
+    const key = method + " " + path18;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path17, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path18, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -130028,7 +130162,7 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path17 from "path";
+import path18 from "path";
 import fs8 from "fs/promises";
 
 class SymbolGraphService {
@@ -130382,7 +130516,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path17.resolve(root, relativePath) : relativePath;
+    return root ? path18.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -130402,12 +130536,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);
@@ -130530,25 +130659,7 @@ var init_workspace_manager = __esm(() => {
 });
 
 // ../../packages/core/dist/tools/index_project.js
-import { realpath as realpath2 } from "fs/promises";
-import path18 from "path";
-async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path18.resolve(projectPath));
-}
-async function assertProjectRootReuse(options) {
-  if (!options.storedProjectPath || options.forceReindex)
-    return;
-  const canonicalize = options.canonicalize ?? realpath2;
-  let storedCanonical;
-  try {
-    storedCanonical = await canonicalize(path18.resolve(options.storedProjectPath));
-  } catch {
-    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");
-  }
-}
+import path19 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -130596,7 +130707,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path18.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path19.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -130610,40 +130721,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
         });
@@ -130670,77 +130783,16 @@ 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);
-    }
-  }
 }
 var init_index_project = __esm(() => {
   init_contextual_search_rlm();
   init_dist();
   init_index_job_tracker();
-  init_pipeline();
+  init_execute_indexing();
+  init_acquire_indexing_lease();
+  init_project_root_identity();
   init_workspace_manager();
   init_parser_readiness();
-  init_managed_run_repository_pg();
 });
 
 // ../../packages/core/dist/tools/get_index_status.js
@@ -131208,17 +131260,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path19) {
+function transformChildren(value, replacer, path20) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path19);
+    return transformObject(value, replacer, path20);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path19);
+    return transformArray(value, replacer, path20);
   return value;
 }
-function transformObject(obj, replacer, path19) {
+function transformObject(obj, replacer, path20) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path19, key];
+    const childPath = [...path20, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -131226,11 +131278,11 @@ function transformObject(obj, replacer, path19) {
   }
   return result;
 }
-function transformArray(arr, replacer, path19) {
+function transformArray(arr, replacer, path20) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path19, i];
+    const childPath = [...path20, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -131953,7 +132005,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) {
@@ -132191,7 +132243,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) {
@@ -132411,7 +132463,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;
@@ -132977,7 +133029,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;
@@ -133614,102 +133666,43 @@ var init_code_compressor = __esm(() => {
   init_llm_client();
 });
 
-// ../../packages/core/dist/tools/compress_context.js
-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"]
+// ../../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
   };
-  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}`
-      };
-    }
-  }
 }
-var init_compress_context = __esm(() => {
-  init_code_compressor();
-  init_dist();
+var init_compress_with_metrics = __esm(() => {
   init_dist();
-  init_enum_validation();
+});
+
+// ../../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
@@ -134045,7 +134038,7 @@ var init_session_file_cache = __esm(() => {
   SESSION_TTL_MS = 4 * 60 * 60 * 1000;
 });
 
-// ../../packages/core/dist/controllers/context-controller.js
+// ../../packages/core/dist/services/context/context-controller.js
 class ContextController {
   static instance = null;
   searchCtrl;
@@ -134055,7 +134048,7 @@ class ContextController {
   constructor() {
     this.searchCtrl = SearchController.getInstance();
     this.memoryCtrl = MemoryController.getInstance();
-    this.compressor = new CompressContextTool;
+    this.compressor = new CodeCompressor;
     this.sessionCache = SessionFileCache.getInstance();
   }
   static getInstance() {
@@ -134207,15 +134200,16 @@ class ContextController {
         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;
+      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");
@@ -134372,7 +134366,7 @@ var init_context_controller = __esm(() => {
   init_dist();
   init_search_controller();
   init_memory_controller();
-  init_compress_context();
+  init_compression();
   init_session_file_cache();
   init_symbol_graph_service();
   init_token_metrics();
@@ -134484,6 +134478,88 @@ var init_get_optimized_context = __esm(() => {
   init_serialize();
 });
 
+// ../../packages/core/dist/tools/compress_context.js
+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}`
+      };
+    }
+  }
+}
+var init_compress_context = __esm(() => {
+  init_code_compressor();
+  init_compress_with_metrics();
+  init_dist();
+  init_enum_validation();
+});
+
 // ../../packages/core/dist/tools/store_memory.js
 class StoreMemoryTool {
   name = "store_memory";
@@ -136274,7 +136350,7 @@ var init_session_pin_store = __esm(() => {
 // ../../packages/core/dist/services/hooks/attribution-resolver.js
 import fs9 from "fs";
 import os3 from "os";
-import path19 from "path";
+import path20 from "path";
 
 class PgWorkspaceRootProvider {
   cache = null;
@@ -136326,7 +136402,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os3.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path19.parse(path19.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path20.parse(path20.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -136379,7 +136455,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path19.sep) ? candidate2 : candidate2 + path19.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path20.sep) ? candidate2 : candidate2 + path20.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -136402,7 +136478,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path19.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path20.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -136413,7 +136489,7 @@ function defaultCanonicalize(cwd) {
     return fs9.realpathSync(cwd);
   } catch {
     try {
-      return path19.resolve(cwd);
+      return path20.resolve(cwd);
     } catch {
       return;
     }
@@ -137152,31 +137228,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path20) => {
+    const walk = (fqn, path21) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path20.join("\u2192");
+      const key = path21.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path20.length > 1)
-          chains.push(path20.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path21.length > 1)
+          chains.push(path21.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path20.includes(child)) {
-          const cycled = [...path20, `${this.fqnToName(child)}\u21BA`];
+        if (path21.includes(child)) {
+          const cycled = [...path21, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path20, child]);
+        walk(child, [...path21, child]);
       }
     };
     for (const seed of seeds) {
@@ -138008,303 +138084,16 @@ var init_get_architecture = __esm(() => {
   init_architecture();
 });
 
-// ../../packages/core/dist/tools/read_file.js
+// ../../packages/core/dist/services/file-read/file-content-cache.js
 import fs10 from "fs/promises";
-import path20 from "path";
 
-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 (path20.isAbsolute(filePath)) {
-      return path20.resolve(filePath);
-    }
-    if (projectId) {
-      const root = await this.getProjectRoot(projectId);
-      if (root) {
-        const cleaned = sanitizeFilePath(filePath);
-        return path20.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(path20.resolve(root));
-    }
-    roots.push(path20.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(path20.resolve(extra));
-    }
-    const target = path20.resolve(absoluteFilePath);
-    for (const root of roots) {
-      const rel = path20.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path20.isAbsolute(rel)) {
-        return { allowed: true };
-      }
-      if (rel === "")
-        return { allowed: true };
-    }
-    const validRootsList = roots.map((r) => `  - ${r}`).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({
@@ -138331,7 +138120,7 @@ ${validRootsList}
     }
     const content = await fs10.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(),
@@ -138340,6 +138129,19 @@ ${validRootsList}
     logger.debug("File read and cached", { filePath });
     return { content, metadata };
   }
+}
+var init_file_content_cache = __esm(() => {
+  init_dist();
+});
+
+// ../../packages/core/dist/services/file-read/file-metadata.js
+import path21 from "path";
+
+class FileMetadataExtractor {
+  symbolGraph;
+  constructor(symbolGraph) {
+    this.symbolGraph = symbolGraph;
+  }
   async extractMetadata(content, filePath, options) {
     const lines = content.split(`
 `);
@@ -138368,18 +138170,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 = path20.extname(filePath).toLowerCase();
+    const ext2 = path21.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -138437,20 +138229,390 @@ ${validRootsList}
     return imports;
   }
 }
-var MASSA_AI_READ_FILE_MAX_LINES;
-var init_read_file = __esm(() => {
+var init_file_metadata = __esm(() => {
   init_dist();
-  init_dist();
-  init_code_compressor();
-  init_serialize();
-  init_event_bus();
-  init_workspace_manager();
+});
+
+// ../../packages/core/dist/services/file-read/line-range.js
+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 };
+}
+var MASSA_AI_READ_FILE_MAX_LINES;
+var init_line_range = __esm(() => {
   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;
   })();
 });
 
+// ../../packages/core/dist/services/file-read/path-containment.js
+import path22 from "path";
+
+class PathContainment {
+  projectRoots;
+  constructor(projectRoots) {
+    this.projectRoots = projectRoots;
+  }
+  async resolveFilePath(filePath, projectId) {
+    if (path22.isAbsolute(filePath)) {
+      return path22.resolve(filePath);
+    }
+    if (projectId) {
+      const root = await this.projectRoots.getProjectRoot(projectId);
+      if (root) {
+        const cleaned = sanitizeFilePath(filePath);
+        return path22.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(path22.resolve(root));
+    }
+    roots.push(path22.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(path22.resolve(extra));
+    }
+    const target = path22.resolve(absoluteFilePath);
+    for (const root of roots) {
+      const rel = path22.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path22.isAbsolute(rel)) {
+        return { allowed: true };
+      }
+      if (rel === "")
+        return { allowed: true };
+    }
+    const validRootsList = roots.map((r) => `  - ${r}`).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.`
+    };
+  }
+}
+var init_path_containment = __esm(() => {
+  init_dist();
+});
+
+// ../../packages/core/dist/services/file-read/project-root-cache.js
+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;
+  }
+}
+var init_project_root_cache = __esm(() => {
+  init_dist();
+  init_event_bus();
+  init_workspace_manager();
+});
+
+// ../../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 };
+  }
+}
+var init_read_file_service = __esm(() => {
+  init_dist();
+  init_code_compressor();
+  init_file_content_cache();
+  init_file_metadata();
+  init_line_range();
+  init_path_containment();
+  init_project_root_cache();
+});
+
+// ../../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}`
+      };
+    }
+  }
+}
+var init_read_file = __esm(() => {
+  init_dist();
+  init_serialize();
+  init_read_file_service();
+});
+
 // ../../packages/core/dist/tools/execute.js
 class ExecuteTool {
   name = "execute";
@@ -139635,7 +139797,7 @@ var init_executor2 = __esm(() => {
   init_intent_search();
 });
 
-// ../../packages/core/dist/controllers/executor-controller.js
+// ../../packages/core/dist/services/executor/executor-controller.js
 import { cpus as cpus2 } from "os";
 function applyIntent(result, intent) {
   if (!intent || !result.stdout)
@@ -139828,7 +139990,7 @@ var init_executor_controller = __esm(() => {
   ];
 });
 
-// ../../packages/core/dist/controllers/graph-controller.js
+// ../../packages/core/dist/services/symbol/graph-controller.js
 class GraphController {
   static instance = null;
   constructor() {}
@@ -139948,15 +140110,6 @@ var init_graph_controller = __esm(() => {
   init_definition_lookup();
 });
 
-// ../../packages/core/dist/controllers/index.js
-var init_controllers = __esm(() => {
-  init_memory_controller();
-  init_search_controller();
-  init_context_controller();
-  init_executor_controller();
-  init_graph_controller();
-});
-
 // ../../packages/core/dist/services/project-identity/errors.js
 var ERROR_MESSAGES, ERROR_STATUS, ProjectIdentityError;
 var init_errors4 = __esm(() => {
@@ -141392,7 +141545,7 @@ var init_l1_memory_cache = __esm(() => {
 // ../../packages/core/dist/services/health/local-health-checker.js
 import fs11 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path21 from "path";
+import path23 from "path";
 
 class LocalHealthChecker {
   ollamaBaseUrl = process.env.OLLAMA_BASE_URL || "http://localhost:11434";
@@ -141427,7 +141580,7 @@ class LocalHealthChecker {
     try {
       if (!existsSync3(this.dataDir))
         await fs11.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path21.join(this.dataDir, ".health-check-test");
+      const probe2 = path23.join(this.dataDir, ".health-check-test");
       await fs11.writeFile(probe2, "ok");
       await fs11.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
@@ -143370,7 +143523,7 @@ var init_scheduler2 = __esm(() => {
 // ../../packages/core/dist/services/pricing/models-dev-client.js
 import fs12 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path22 from "path";
+import path24 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -143390,7 +143543,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config2.get("dataDir");
-      return path22.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path24.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -143425,7 +143578,7 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path22.dirname(cachePath);
+        const dir = path24.dirname(cachePath);
         await fs12.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
@@ -149316,33 +149469,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path23) {
-        if (!path23)
-          return path23;
+      function remove_dot_segments(path25) {
+        if (!path25)
+          return path25;
         var output = "";
-        while (path23.length > 0) {
-          if (path23 === "." || path23 === "..") {
-            path23 = "";
+        while (path25.length > 0) {
+          if (path25 === "." || path25 === "..") {
+            path25 = "";
             break;
           }
-          var twochars = path23.substring(0, 2);
-          var threechars = path23.substring(0, 3);
-          var fourchars = path23.substring(0, 4);
+          var twochars = path25.substring(0, 2);
+          var threechars = path25.substring(0, 3);
+          var fourchars = path25.substring(0, 4);
           if (threechars === "../") {
-            path23 = path23.substring(3);
+            path25 = path25.substring(3);
           } else if (twochars === "./") {
-            path23 = path23.substring(2);
+            path25 = path25.substring(2);
           } else if (threechars === "/./") {
-            path23 = "/" + path23.substring(3);
-          } else if (twochars === "/." && path23.length === 2) {
-            path23 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path23.length === 3) {
-            path23 = "/" + path23.substring(4);
+            path25 = "/" + path25.substring(3);
+          } else if (twochars === "/." && path25.length === 2) {
+            path25 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path25.length === 3) {
+            path25 = "/" + path25.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path23.match(/(\/?([^\/]*))/)[0];
+            var segment = path25.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path23 = path23.substring(segment.length);
+            path25 = path25.substring(segment.length);
           }
         }
         return output;
@@ -161412,21 +161565,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path23, out) {
+function walk(val, path25, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path23, content: `**${path23}** = _[]_` });
+      out.push({ path: path25, content: `**${path25}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path23}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path25}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path23, content: `**${path23}**
+    out.push({ path: path25, content: `**${path25}**
 
 ${items}` });
     return;
@@ -161434,16 +161587,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path23, content: `**${path23}** = _{}_` });
+      out.push({ path: path25, content: `**${path25}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path23}.${safeKey}`, out);
+      walk(v, `${path25}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path23, content: `**${path23}** = \`${String(val)}\`` });
+  out.push({ path: path25, content: `**${path25}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -161709,12 +161862,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);
       }
     };
   }
@@ -161773,6 +161921,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();
@@ -161834,20 +161987,6 @@ var init_services = __esm(() => {
   init_project_identity();
 });
 
-// ../../packages/core/dist/data/vector/hybrid-search.js
-var init_hybrid_search2 = __esm(() => {
-  init_vector_store_factory();
-  init_keyword_search_pg();
-  init_dist();
-});
-
-// ../../packages/core/dist/data/vector/index.js
-var init_vector = __esm(() => {
-  init_hybrid_search2();
-  init_vector_store_factory();
-  init_base_vector_store();
-});
-
 // ../../packages/core/dist/data/graph-generation/index.js
 var init_graph_generation = __esm(() => {
   init_graph_generation_repository_pg();
@@ -162211,7 +162350,7 @@ var init_hook_service = __esm(() => {
 // ../../packages/core/dist/services/bootstrap/bootstrap-service.js
 import { randomUUID as randomUUID9 } from "crypto";
 import fs13 from "fs";
-import path23 from "path";
+import path25 from "path";
 import { spawn as spawn2 } from "child_process";
 function readBootstrapConfig() {
   try {
@@ -162371,7 +162510,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path23.join(projectRoot, name26);
+      const p = path25.join(projectRoot, name26);
       if (fs13.existsSync(p) && fs13.statSync(p).isFile()) {
         const buf = fs13.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
@@ -162382,14 +162521,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path23.join(projectRoot, "docs");
+    const docsDir = path25.join(projectRoot, "docs");
     if (fs13.existsSync(docsDir) && fs13.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
           const buf = fs13.readFileSync(rel);
           signals.docs.push({
-            path: path23.relative(projectRoot, rel),
+            path: path25.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -162400,7 +162539,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path23.join(projectRoot, name26);
+      const p = path25.join(projectRoot, name26);
       if (!fs13.existsSync(p) || !fs13.statSync(p).isFile())
         continue;
       const raw2 = fs13.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
@@ -162448,7 +162587,7 @@ function walkMarkdown(dir) {
       continue;
     }
     for (const e of entries) {
-      const full = path23.join(cur, e.name);
+      const full = path25.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -163484,7 +163623,7 @@ __export(exports_dist, {
 var init_dist15 = __esm(() => {
   init_memory_repository_pg();
   init_memory_repository_factory();
-  init_vector();
+  init_vector_store_factory();
   init_operation_log_pg();
   init_operation_log_factory();
   init_operation_log_contract();
@@ -163501,7 +163640,6 @@ var init_dist15 = __esm(() => {
   init_proposal_repository();
   init_auto_improve_job();
   init_tools();
-  init_controllers();
   init_services();
   init_graph_generation();
 });
@@ -165967,7 +166105,7 @@ init_dist();
 init_dist15();
 init_dist();
 import fs14 from "fs/promises";
-import path24 from "path";
+import path26 from "path";
 var _indexProjectTool = null;
 function indexProjectTool() {
   if (!_indexProjectTool)
@@ -166237,7 +166375,7 @@ class EmbeddedApiClient {
         } else {
           end = start + 20;
         }
-        const absolutePath = path24.join(workspace.project_path, file2);
+        const absolutePath = path26.join(workspace.project_path, file2);
         const content = await fs14.readFile(absolutePath, "utf-8");
         const lines = content.split(/\r?\n/);
         const slice = lines.slice(start - 1, Math.min(lines.length, end));
@@ -166461,21 +166599,21 @@ class EmbeddedApiClient {
   async uploadAndIndex(params) {
     const rawBase = params.projectId || params.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 || path24.join(getGlobalDataDir(), "uploads");
-    const stagingDir = path24.resolve(uploadRoot, finalProjectId);
+    const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path26.join(getGlobalDataDir(), "uploads");
+    const stagingDir = path26.resolve(uploadRoot, finalProjectId);
     await fs14.rm(stagingDir, { recursive: true, force: true });
     await fs14.mkdir(stagingDir, { recursive: true });
     const WRITE_BATCH = 20;
     for (let i = 0;i < params.files.length; i += WRITE_BATCH) {
       await Promise.all(params.files.slice(i, i + WRITE_BATCH).map(async (file2) => {
-        if (path24.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
+        if (path26.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
           throw new Error(`Invalid file path: ${file2.relativePath}`);
         }
-        const dest = path24.resolve(stagingDir, file2.relativePath.replace(/\//g, path24.sep));
-        if (!dest.startsWith(stagingDir + path24.sep)) {
+        const dest = path26.resolve(stagingDir, file2.relativePath.replace(/\//g, path26.sep));
+        if (!dest.startsWith(stagingDir + path26.sep)) {
           throw new Error(`Path escapes staging directory: ${file2.relativePath}`);
         }
-        await fs14.mkdir(path24.dirname(dest), { recursive: true });
+        await fs14.mkdir(path26.dirname(dest), { recursive: true });
         await fs14.writeFile(dest, file2.content, "utf-8");
       }));
     }
@@ -166809,7 +166947,7 @@ class EmbeddedApiClient {
 // src/file-collector.ts
 init_config();
 import fs15 from "fs/promises";
-import path25 from "path";
+import path27 from "path";
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -166859,13 +166997,13 @@ async function walk2(root2, dir, files, state, allowed) {
       break;
     if (entry2.isDirectory()) {
       if (!SKIP_DIRS.has(entry2.name) && !entry2.name.startsWith(".")) {
-        await walk2(root2, path25.join(dir, entry2.name), files, state, allowed);
+        await walk2(root2, path27.join(dir, entry2.name), files, state, allowed);
       }
     } else if (entry2.isFile()) {
-      const ext2 = path25.extname(entry2.name).toLowerCase();
+      const ext2 = path27.extname(entry2.name).toLowerCase();
       if (!allowed.has(ext2))
         continue;
-      const fullPath = path25.join(dir, entry2.name);
+      const fullPath = path27.join(dir, entry2.name);
       try {
         const stat = await fs15.stat(fullPath);
         if (stat.size > MAX_FILE_BYTES)
@@ -166874,7 +167012,7 @@ async function walk2(root2, dir, files, state, allowed) {
           continue;
         const content = await fs15.readFile(fullPath, "utf-8");
         state.totalBytes += stat.size;
-        const relativePath = path25.relative(root2, fullPath).split(path25.sep).join("/");
+        const relativePath = path27.relative(root2, fullPath).split(path27.sep).join("/");
         files.push({ relativePath, content });
       } catch {}
     }