@massa-ai/mcp-client 1.64.0 → 1.66.0

package/dist/index.js

@@ -35187,7 +35187,8 @@ var init_ignore_patterns = __esm(() => {
     "**/pnpm-lock.yaml",
     "**/package-lock.json",
     "**/bun.lockb",
-    "**/yarn.lock"
+    "**/yarn.lock",
+    "**/Pods/**"
   ];
 });
 
@@ -124305,6 +124306,33 @@ class ManagedRunRepositoryPg {
     `;
     return rows[0] ? toActive(rows[0]) : null;
   }
+  async getAnyActive() {
+    const rows = await getPrismaClient2().$queryRaw`
+      SELECT id, project_id, run_kind, event_id, content_hash, file_cursor,
+             status, lease_token, lease_expires_at, heartbeat_at,
+             created_at, completed_at
+      FROM managed_runs
+      WHERE status = 'active'
+        AND lease_expires_at > clock_timestamp()
+      ORDER BY lease_expires_at DESC
+      LIMIT 1
+    `;
+    return rows[0] ? toActive(rows[0]) : null;
+  }
+  async release(lease) {
+    const leaseToken = boundedText(lease.leaseToken, "leaseToken", MAX_LEASE_TOKEN);
+    const deleted = await getPrismaClient2().$queryRaw`
+      DELETE FROM managed_runs
+      WHERE id = ${BigInt(lease.runId)}
+        AND project_id = ${lease.projectId}
+        AND run_kind = ${lease.runKind}
+        AND lease_token = ${leaseToken}
+      RETURNING id
+    `;
+    if (!deleted[0])
+      return { status: "lease_lost" };
+    return { status: "aborted", runId: deleted[0].id.toString() };
+  }
 }
 var DEFAULT_LEASE_TTL_MS = 90000, MIN_LEASE_TTL_MS = 1000, MAX_LEASE_TTL_MS = 300000, HEARTBEAT_TTL_MS = 90000, MAX_PROJECT_ID = 512, MAX_EVENT_ID = 2000, MAX_CONTENT_HASH = 2000, MAX_LEASE_TOKEN = 512;
 var init_managed_run_repository_pg = __esm(() => {
@@ -124342,10 +124370,111 @@ var init_embedding_freshness = __esm(() => {
   };
 });
 
+// ../../packages/core/dist/services/jobs/heavy-work-lease.js
+import { randomUUID as randomUUID3 } from "crypto";
+import { setTimeout as delay2 } from "timers/promises";
+function repository() {
+  return repositoryOverride ?? ManagedRunRepositoryPg.getInstance();
+}
+async function withHeavyWorkLease(kind, label, fn) {
+  let repo;
+  let lease;
+  try {
+    repo = repository();
+    const outcome = await repo.begin({
+      projectId: `heavy-work:${label}:${randomUUID3()}`,
+      runKind: kind,
+      eventId: `heavy-work:${label}`
+    });
+    if (outcome.status === "acquired")
+      lease = outcome.lease;
+  } catch (error51) {
+    logger.warn("heavy-work lease unavailable; running without it", { label, error: error51 });
+  }
+  if (!repo || !lease)
+    return fn();
+  const heldRepo = repo;
+  const heldLease = lease;
+  const heartbeatController = new AbortController;
+  (async () => {
+    while (true) {
+      try {
+        await delay2(HEARTBEAT_MS, undefined, { signal: heartbeatController.signal });
+      } catch {
+        return;
+      }
+      try {
+        await heldRepo.heartbeat(heldLease);
+      } catch {}
+    }
+  })();
+  try {
+    return await fn();
+  } finally {
+    heartbeatController.abort();
+    try {
+      await heldRepo.release(heldLease);
+    } catch (error51) {
+      logger.warn("heavy-work lease release failed; it expires on its own", { label, error: error51 });
+    }
+  }
+}
+async function probeHeavyWork() {
+  let timer;
+  const timeout = new Promise((_, reject) => {
+    timer = setTimeout(() => reject(new Error(`heavy-work probe timed out after ${PROBE_TIMEOUT_MS}ms`)), PROBE_TIMEOUT_MS);
+  });
+  try {
+    const active = await Promise.race([repository().getAnyActive(), timeout]);
+    if (!active)
+      return { busy: false };
+    return { busy: true, reason: `${active.runKind} run ${active.runId} (${active.projectId})` };
+  } finally {
+    clearTimeout(timer);
+  }
+}
+var HEARTBEAT_MS = 30000, PROBE_TIMEOUT_MS = 5000, repositoryOverride = null;
+var init_heavy_work_lease = __esm(() => {
+  init_dist();
+  init_managed_run_repository_pg();
+});
+
+// ../../packages/core/dist/services/search/incremental-reindex.js
+import path21 from "path";
+function runIncrementalReindex(deps, projectId, projectPath, filesToReindex) {
+  return withHeavyWorkLease("reindex", `incremental-reindex:${projectId}`, async () => {
+    const centralityMap = await deps.symbolRepo.getCentrality(await getProjectIdentityAliasResolver().resolve(projectId));
+    let filesIndexed = 0;
+    let chunksIndexed = 0;
+    let errors4 = 0;
+    for (const relativeFilePath of filesToReindex) {
+      try {
+        const fullPath = path21.join(projectPath, relativeFilePath);
+        const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
+        filesIndexed++;
+        chunksIndexed += result.chunks;
+      } catch (error51) {
+        logger.error("Failed to reindex file", error51, {
+          file: relativeFilePath
+        });
+        errors4++;
+      }
+    }
+    await deps.indexManager.updateIndexMetadata(projectId, projectPath, filesToReindex);
+    await deps.searchCache.invalidateProject(projectId);
+    return { filesIndexed, chunksIndexed, errors: errors4 };
+  });
+}
+var init_incremental_reindex = __esm(() => {
+  init_dist();
+  init_alias_resolver();
+  init_heavy_work_lease();
+});
+
 // ../../packages/core/dist/services/search/project-indexer.js
 import fs15 from "fs/promises";
-import path21 from "path";
-import { randomUUID as randomUUID3 } from "crypto";
+import path22 from "path";
+import { randomUUID as randomUUID4 } from "crypto";
 async function runWithIndexLock(lockMap, projectId, work) {
   const prevLock = lockMap.get(projectId);
   const isQueued = prevLock !== undefined;
@@ -124387,7 +124516,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
       dot: false
     });
     const filteredFiles = files.filter((file2) => {
-      const relativePath = path21.relative(projectPath, file2);
+      const relativePath = path22.relative(projectPath, file2);
       const shouldIgnore = ig.ignores(relativePath);
       if (shouldIgnore) {
         logger.debug("Ignoring file per .gitignore during indexing", {
@@ -124427,7 +124556,7 @@ async function indexProjectInternal(deps, projectPath, projectId, options = {})
         });
       }
     }
-    const indexedFilesList = filteredFiles.map((f) => path21.relative(projectPath, f));
+    const indexedFilesList = filteredFiles.map((f) => path22.relative(projectPath, f));
     await deps.indexManager.updateIndexMetadata(projectId, projectPath, indexedFilesList);
     logger.info("Project indexing completed", {
       projectId,
@@ -124498,7 +124627,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
   if (needsFullReindex) {
     logger.info("Performing full reindex", { projectId });
     const managedRunRepo = ManagedRunRepositoryPg.getInstance();
-    const eventId = `reindex:${projectId}:${randomUUID3()}`;
+    const eventId = `reindex:${projectId}:${randomUUID4()}`;
     const beginOutcome = await managedRunRepo.begin({
       projectId,
       runKind: "indexing",
@@ -124551,25 +124680,7 @@ async function ensureFreshIndex(deps, projectId, projectPath, options = {}) {
     projectId,
     fileCount: filesToReindex.length
   });
-  const centralityMap = await deps.symbolRepo.getCentrality(await getProjectIdentityAliasResolver().resolve(projectId));
-  let filesIndexed = 0;
-  let chunksIndexed = 0;
-  let errors4 = 0;
-  for (const relativeFilePath of filesToReindex) {
-    try {
-      const fullPath = path21.join(projectPath, relativeFilePath);
-      const result = await deps.indexFile(fullPath, projectId, projectPath, centralityMap);
-      filesIndexed++;
-      chunksIndexed += result.chunks;
-    } catch (error51) {
-      logger.error("Failed to reindex file", error51, {
-        file: relativeFilePath
-      });
-      errors4++;
-    }
-  }
-  await deps.indexManager.updateIndexMetadata(projectId, projectPath, filesToReindex);
-  await deps.searchCache.invalidateProject(projectId);
+  const { filesIndexed, chunksIndexed, errors: errors4 } = await runIncrementalReindex(deps, projectId, projectPath, filesToReindex);
   logger.info("Incremental reindex completed", {
     projectId,
     filesIndexed,
@@ -124618,7 +124729,7 @@ async function checkSearchAdmission(deps, projectId, projectPath) {
 async function indexFile(deps, filePath, projectId, projectRoot, centralityMap) {
   projectId = await getProjectIdentityAliasResolver().resolve(projectId);
   const content = await fs15.readFile(filePath, "utf-8");
-  const relativePath = path21.relative(projectRoot, filePath);
+  const relativePath = path22.relative(projectRoot, filePath);
   const maxFileSize = config2.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -124638,7 +124749,7 @@ async function indexFile(deps, filePath, projectId, projectRoot, centralityMap)
       chunkIndex: i,
       totalChunks: chunks.length,
       type: chunk.type,
-      language: path21.extname(filePath).slice(1),
+      language: path22.extname(filePath).slice(1),
       lineStart: chunk.lineStart,
       lineEnd: chunk.lineEnd,
       label: chunk.label,
@@ -124663,6 +124774,7 @@ var init_project_indexer = __esm(() => {
   init_managed_run_repository_pg();
   init_symbol_repo_workspace();
   init_embedding_freshness();
+  init_incremental_reindex();
   globAsync2 = glob;
 });
 
@@ -126482,7 +126594,7 @@ var init_index_job_store = __esm(() => {
 });
 
 // ../../packages/core/dist/services/jobs/index-job-tracker.js
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 
 class IndexJobTracker {
   static instance;
@@ -126506,7 +126618,7 @@ class IndexJobTracker {
     return IndexJobTracker.instance;
   }
   createJob(projectId, projectPath) {
-    const jobId = randomUUID4();
+    const jobId = randomUUID5();
     const job = {
       jobId,
       projectId,
@@ -126596,7 +126708,9 @@ class IndexJobTracker {
     const cutoff = now2 - staleMs;
     let reaped = 0;
     for (const job of running) {
-      const hbMs = job.heartbeatAt?.getTime();
+      const live = this.jobs.get(job.jobId);
+      const liveHb = live?.heartbeatAt?.getTime();
+      const hbMs = liveHb ?? job.heartbeatAt?.getTime();
       const startedMs = job.startedAt?.getTime();
       const stale = hbMs != null && hbMs < cutoff || hbMs == null && startedMs != null && startedMs < cutoff;
       if (!stale)
@@ -126710,7 +126824,7 @@ function stripNul(content) {
 
 // ../../packages/core/dist/services/etl/stages/discover.js
 import fs16 from "fs/promises";
-import path22 from "path";
+import path23 from "path";
 import { createHash as createHash5 } from "crypto";
 
 class DiscoverStage {
@@ -126736,7 +126850,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path22.isAbsolute(p) ? path22.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path23.isAbsolute(p) ? path23.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -126795,7 +126909,7 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path22.join(ctx.projectPath, relativePath);
+    const absolutePath = path23.join(ctx.projectPath, relativePath);
     try {
       const stat = await fs16.stat(absolutePath);
       const content = stripNul(await fs16.readFile(absolutePath, "utf-8"));
@@ -126842,7 +126956,7 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path22.join(projectPath, ".gitignore");
+      const gitignorePath = path23.join(projectPath, ".gitignore");
       const gitignoreContent = await fs16.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
@@ -128198,8 +128312,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path23 = rustPathSegments(node, source);
-  return path23.length ? [{ path: [...prefix, ...path23] }] : [];
+  const path24 = rustPathSegments(node, source);
+  return path24.length ? [{ path: [...prefix, ...path24] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -129171,7 +129285,7 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path23 from "path";
+import path24 from "path";
 import fs17 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
@@ -129200,8 +129314,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h")
     ];
     const batches = phases.flatMap((phase) => Array.from({ length: Math.ceil(phase.length / BATCH_SIZE) }, (_, index) => phase.slice(index * BATCH_SIZE, (index + 1) * BATCH_SIZE)));
     for (const batch of batches) {
@@ -129239,19 +129353,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path23.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path23.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path24.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path24.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path23.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path24.extname(parsed.file.relativePath).toLowerCase();
       const key = extension === ".c" ? "cImporters" : [".cpp", ".hpp"].includes(extension) ? "cppImporters" : undefined;
       if (!key)
         continue;
       for (const imported of parsed.rawImports) {
         if (!["c_include", "cpp_include"].includes(imported.form) || imported.specifier.startsWith("<"))
           continue;
-        const header = path23.posix.normalize(path23.posix.join(path23.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path24.posix.normalize(path24.posix.join(path24.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -129262,7 +129376,7 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path23.extname(file2.relativePath).toLowerCase();
+      const extension = path24.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
         const content = file2.snapshotContent ?? await fs17.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
@@ -129277,7 +129391,7 @@ class ParseStage {
     }
     try {
       const content = file2.snapshotContent ?? await fs17.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path23.extname(file2.relativePath).toLowerCase();
+      const ext2 = path24.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -129832,7 +129946,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path24 from "path";
+import path25 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -129927,7 +130041,7 @@ function probe(base, known, dialect = "typescript") {
   const bases = /\.[cm]?jsx?$/u.test(base) ? [base.replace(/\.[cm]?jsx?$/u, ".ts"), base.replace(/\.[cm]?jsx?$/u, ".tsx"), base] : [base];
   for (const candidateBase of bases)
     for (const suffix of DIALECT_PROBES[dialect] ?? [""]) {
-      const value = path24.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path25.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -129936,7 +130050,7 @@ function probe(base, known, dialect = "typescript") {
 function resolveStructuralSpecifier(specifier, fromFile, build, dialect = "typescript") {
   const known = new Set(build.knownFiles.map(normalizeStructuralFile));
   if (specifier.startsWith("./") || specifier.startsWith("../")) {
-    return probe(path24.posix.join(path24.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path25.posix.join(path25.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -130200,7 +130314,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path25 from "path";
+import path26 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -130219,7 +130333,7 @@ var init_systems2 = __esm(() => {
           const bindings = item.bindings.map((binding) => binding.imported === "*" && binding.local === "*" && unresolvedTarget && !unresolvedTarget.qualifier ? { ...binding, imported: unresolvedTarget.name, local: unresolvedTarget.name } : binding);
           if (item.specifier === "crate" || item.specifier.startsWith("crate/")) {
             const crateRoot = file2.file.startsWith("src/") ? "src" : "";
-            return { ...item, bindings, specifier: `./${path25.posix.relative(path25.posix.dirname(file2.file), path25.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path26.posix.relative(path26.posix.dirname(file2.file), path26.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
           }
           if (item.specifier === "self" || item.specifier.startsWith("self/"))
             return { ...item, bindings, specifier: `./${item.specifier.replace(/^self\/?/u, "")}` };
@@ -130317,7 +130431,7 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path26 from "path";
+import path27 from "path";
 import fs18 from "fs";
 
 class ResolveStage {
@@ -130342,7 +130456,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path26.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path27.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -130354,13 +130468,13 @@ class ResolveStage {
       }];
     });
     const currentStructuralFiles = new Set(structuralDocuments.map((document2) => document2.file));
-    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path26.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
     const pathAliasesByFile = Object.fromEntries([...knownRelPaths].map((file2) => [
       file2,
       this.structuralAliasesFor(file2, rootAliases, monorepoPackages)
     ]));
     const buildMetadata = { knownFiles: [...knownRelPaths], pathAliasesByFile };
-    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path26.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
+    const seedRows = repositoryDefinitions.filter((definition) => STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(definition.file_path).toLowerCase())).filter((definition) => knownRelPaths.has(definition.file_path) && skippedStructuralFiles.has(definition.file_path)).filter((definition) => !currentStructuralFiles.has(definition.file_path));
     const seedIds = new Set;
     for (const definition of seedRows) {
       if (seedIds.has(definition.id))
@@ -130457,7 +130571,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path26.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path27.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -130509,7 +130623,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path26.dirname(path26.join(projectPath, parsed.file.relativePath));
+    const fromDir = path27.dirname(path27.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -130580,7 +130694,7 @@ class ResolveStage {
         index.set(def.name, `${def.file_path}#${def.name}`);
       }
     } catch (err) {
-      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path26.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path27.extname(file2.file.relativePath).toLowerCase()));
       if (skippedStructural)
         throw new Error("structural_repository_seed_failed", { cause: err });
       logger.warn("buildSymbolIndex: repo seed failed, in-batch only", {
@@ -130604,7 +130718,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path26.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path27.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -130612,8 +130726,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path26.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path26.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path27.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path27.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -130629,7 +130743,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path26.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path27.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -130637,7 +130751,7 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path26.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path27.join(projectPath, "tsconfig.json");
     try {
       const raw2 = fs18.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
@@ -130668,7 +130782,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path26.join(projectPath, packageRelPath);
+      const absPackagePath = path27.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -130698,7 +130812,7 @@ class ResolveStage {
   structuralAliasesFor(filePath, rootAliases, packages) {
     return [...this.getPackageAliases(filePath, packages), ...rootAliases].map((alias) => ({
       pattern: alias.prefix + (alias.targets.some((target) => target.includes("*")) ? "/*" : ""),
-      targets: alias.targets.map((target) => alias.packagePath ? path26.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path27.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -130762,7 +130876,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path27 from "path";
+import path28 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -131039,7 +131153,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path27.extname(filePath));
+      const manifest = getLanguageManifestEntry(path28.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -131091,7 +131205,7 @@ var init_load = __esm(() => {
 });
 
 // ../../packages/core/dist/data/graph-generation/graph-generation-repository-pg.js
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 function boundedText2(value, label, max = 512) {
   const normalized = value.normalize("NFC").trim();
   if (!normalized || normalized.length > max || normalized.includes("\x00")) {
@@ -131195,8 +131309,8 @@ class GraphGenerationRepositoryPg {
   }
   async begin(rawInput) {
     const input = validateBegin2(rawInput);
-    const generationId = randomUUID5();
-    const leaseToken = randomUUID5();
+    const generationId = randomUUID6();
+    const leaseToken = randomUUID6();
     return getPrismaClient2().$transaction(async (tx) => {
       const workspace = await lockWorkspace(tx, input.projectId);
       if (workspace.active_graph_generation_id !== input.expectedActiveGenerationId) {
@@ -131436,8 +131550,8 @@ function buildGraphInputSnapshotHash(files) {
 
 class GraphGenerationCoordinator {
   repository;
-  constructor(repository = getGraphGenerationRepository()) {
-    this.repository = repository;
+  constructor(repository2 = getGraphGenerationRepository()) {
+    this.repository = repository2;
   }
   async begin(input) {
     const deadline = Date.now() + GRAPH_GENERATION_LEASE_TTL_MS;
@@ -131493,609 +131607,6 @@ var init_graph_generation_coordinator = __esm(() => {
   init_with_deadlock_retry();
 });
 
-// ../../packages/core/dist/services/etl/pipeline.js
-import { createHash as createHash7 } from "crypto";
-import { setTimeout as delay2 } from "timers/promises";
-import path28 from "path";
-function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path28.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path28.posix.normalize(file2.relativePath)));
-  const mutable = new Map;
-  const entry2 = (header) => {
-    let value = mutable.get(header);
-    if (!value) {
-      value = { cImporters: new Set, cppImporters: new Set, build: new Set };
-      mutable.set(header, value);
-    }
-    return value;
-  };
-  for (const file2 of files) {
-    if (path28.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
-      continue;
-    let commands;
-    try {
-      commands = JSON.parse(file2.snapshotContent);
-    } catch {
-      continue;
-    }
-    if (!Array.isArray(commands))
-      continue;
-    for (const command of commands) {
-      if (!command || typeof command !== "object")
-        continue;
-      const record3 = command;
-      if (typeof record3.file !== "string")
-        continue;
-      const projectRoot = path28.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record3.directory === "string" ? path28.resolve(projectRoot, record3.directory) : projectRoot;
-      const absoluteInput = path28.resolve(commandDirectory, record3.file);
-      const relative2 = path28.relative(projectRoot, absoluteInput);
-      const header = path28.posix.normalize(relative2.replaceAll(path28.sep, "/"));
-      if (!headers.has(header))
-        continue;
-      const invocation = typeof record3.command === "string" ? record3.command : Array.isArray(record3.arguments) ? record3.arguments.join(" ") : "";
-      if (/(?:^|\s)(?:clang\+\+|g\+\+|c\+\+)(?:\s|$)|(?:^|\s)-x\s*c\+\+(?:\s|$)/u.test(invocation))
-        entry2(header).build.add("cpp");
-      else if (/(?:^|\s)(?:clang|gcc|cc)(?:\s|$)|(?:^|\s)-x\s*c(?:\s|$)/u.test(invocation))
-        entry2(header).build.add("c");
-    }
-  }
-  return Object.freeze(Object.fromEntries([...mutable.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([header, value]) => [header, Object.freeze({
-    ...value.cImporters.size ? { cImporters: Object.freeze([...value.cImporters].sort()) } : {},
-    ...value.cppImporters.size ? { cppImporters: Object.freeze([...value.cppImporters].sort()) } : {},
-    ...value.build.size ? { buildLanguage: value.build.size > 1 ? "conflict" : [...value.build][0] } : {}
-  })])));
-}
-function abortable(operation, signal) {
-  if (signal.aborted)
-    return Promise.reject(signal.reason);
-  return new Promise((resolve5, reject) => {
-    let abortReason;
-    const onAbort = () => {
-      abortReason = signal.reason;
-    };
-    signal.addEventListener("abort", onAbort, { once: true });
-    operation.then((value) => abortReason === undefined ? resolve5(value) : reject(abortReason), (error51) => reject(abortReason ?? error51)).finally(() => signal.removeEventListener("abort", onAbort));
-  });
-}
-var EtlPipeline;
-var init_pipeline = __esm(() => {
-  init_dist();
-  init_discover();
-  init_parse3();
-  init_resolve();
-  init_load();
-  init_event_bus();
-  init_symbol_repository_factory();
-  init_index_job_tracker();
-  init_cache_factory();
-  init_index_manager();
-  init_vector_store_factory();
-  init_keyword_search_factory();
-  init_alias_resolver();
-  init_symbol_repo_workspace();
-  init_project_indexer();
-  init_parser_readiness();
-  init_parse3();
-  init_language_manifest();
-  init_graph_generation_coordinator();
-  init_managed_run_repository_pg();
-  EtlPipeline = class EtlPipeline {
-    static instance = null;
-    static runTails = new Map;
-    discover = new DiscoverStage;
-    parse = new ParseStage;
-    resolve = new ResolveStage;
-    load = new LoadStage;
-    graphGenerations = new GraphGenerationCoordinator;
-    constructor() {}
-    static getInstance() {
-      if (!EtlPipeline.instance) {
-        EtlPipeline.instance = new EtlPipeline;
-      }
-      return EtlPipeline.instance;
-    }
-    async run(input) {
-      await assertParserReadyForIndexing();
-      const projectId = await getProjectIdentityAliasResolver().resolve(input.projectId);
-      const canonicalInput = projectId === input.projectId ? input : { ...input, projectId };
-      const previous = EtlPipeline.runTails.get(projectId);
-      let release;
-      const tail = new Promise((resolve5) => {
-        release = resolve5;
-      });
-      EtlPipeline.runTails.set(projectId, tail);
-      if (previous) {
-        logger.info("EtlPipeline: waiting for prior project run", {
-          projectId,
-          jobId: input.jobId
-        });
-        await previous;
-      }
-      try {
-        return await this.runInternal(canonicalInput);
-      } finally {
-        if (EtlPipeline.runTails.get(projectId) === tail) {
-          EtlPipeline.runTails.delete(projectId);
-        }
-        release();
-      }
-    }
-    async runInternal(input, generationRetry = 0) {
-      const projectId = await getProjectIdentityAliasResolver().resolve(input.projectId);
-      const { projectPath, jobId, forceReindex = false, filesToProcess, include_tests = false, managedRunLease } = input;
-      const t0 = performance.now();
-      const stageTimings = {
-        discover: 0,
-        parse: 0,
-        resolve: 0,
-        load: 0
-      };
-      if (forceReindex) {
-        const vectorStore = await getVectorStore();
-        const keywordSearch = getKeywordSearch();
-        await Promise.all([
-          vectorStore.deleteByProject(projectId),
-          keywordSearch.deleteByProject(projectId)
-        ]);
-      }
-      const managedRunRepository = managedRunLease ? ManagedRunRepositoryPg.getInstance() : undefined;
-      const ctx = {
-        projectId,
-        projectPath,
-        jobId,
-        resumeCursor: managedRunLease ? (await managedRunRepository?.getActive(projectId, "indexing"))?.fileCursor ?? undefined : undefined,
-        managedRunLease,
-        emit: (event) => {
-          if (event.type === "progress") {
-            const p = event.payload;
-            indexJobTracker.updateProgress(jobId, p.current, p.total);
-            eventBus.publish("indexing:progress", {
-              jobId,
-              projectId,
-              stage: event.stage,
-              current: p.current,
-              total: p.total,
-              percentage: p.percentage
-            });
-          } else if (event.type === "file_error") {
-            const p = event.payload;
-            eventBus.publish("indexing:file", {
-              jobId,
-              projectId,
-              filePath: p.filePath,
-              stage: event.stage,
-              status: "error",
-              error: p.error
-            });
-          } else if (event.type === "file_processed") {
-            const p = event.payload;
-            eventBus.publish("indexing:file", {
-              jobId,
-              projectId,
-              filePath: p.filePath,
-              stage: event.stage,
-              status: "ok"
-            });
-          }
-        }
-      };
-      eventBus.publish("indexing:started", { jobId, projectId, projectPath });
-      let graphGenerationLease;
-      let graphHeartbeat;
-      let graphHeartbeatFailure;
-      const graphAbortController = new AbortController;
-      const heartbeatTimerController = new AbortController;
-      let stopGraphHeartbeat = false;
-      let managedRunHeartbeat;
-      let managedRunLeaseLost;
-      let stopManagedRunHeartbeat = false;
-      const managedRunTimerController = new AbortController;
-      if (managedRunLease && managedRunRepository) {
-        managedRunHeartbeat = (async () => {
-          while (!stopManagedRunHeartbeat) {
-            try {
-              await delay2(30000, undefined, { signal: managedRunTimerController.signal });
-            } catch {
-              return;
-            }
-            if (stopManagedRunHeartbeat || !managedRunLease)
-              return;
-            try {
-              const outcome2 = await managedRunRepository.heartbeat(managedRunLease);
-              if (outcome2.status === "lease_lost") {
-                managedRunLeaseLost = new Error("managed_run_lease_lost");
-                graphAbortController.abort(managedRunLeaseLost);
-                return;
-              }
-            } catch (heartbeatError) {
-              managedRunLeaseLost = heartbeatError;
-              graphAbortController.abort(managedRunLeaseLost);
-              return;
-            }
-          }
-        })();
-      }
-      try {
-        const st1 = performance.now();
-        const discoveredSnapshot = await this.discover.run(ctx, { forceReindex, includeTests: include_tests });
-        ctx.structuralHeaderEvidenceByFile = buildHeaderLanguageEvidence(discoveredSnapshot);
-        stageTimings.discover = Math.round(performance.now() - st1);
-        const activeGraph = await getSymbolRepository().getActiveGraphSnapshot(projectId);
-        try {
-          graphGenerationLease = await this.graphGenerations.begin({
-            projectId,
-            expectedActiveGenerationId: activeGraph?.generationId ?? null,
-            fingerprint: `sha256:${createHash7("sha256").update(JSON.stringify(STRUCTURAL_FINGERPRINT_INPUTS)).digest("hex")}`,
-            inputSnapshotHash: buildGraphInputSnapshotHash(discoveredSnapshot),
-            expectedFilesCount: discoveredSnapshot.length
-          });
-        } catch (beginError) {
-          if (beginError.message.startsWith("graph_generation_stale_active:") && generationRetry < 3) {
-            stopManagedRunHeartbeat = true;
-            managedRunTimerController.abort();
-            if (managedRunHeartbeat)
-              await managedRunHeartbeat;
-            return this.runInternal(input, generationRetry + 1);
-          }
-          throw beginError;
-        }
-        ctx.graphGenerationLease = graphGenerationLease;
-        ctx.abortSignal = graphAbortController.signal;
-        graphHeartbeat = (async () => {
-          while (!stopGraphHeartbeat) {
-            try {
-              await delay2(30000, undefined, { signal: heartbeatTimerController.signal });
-            } catch {
-              return;
-            }
-            if (stopGraphHeartbeat || !graphGenerationLease)
-              return;
-            try {
-              await this.graphGenerations.heartbeat(graphGenerationLease);
-            } catch (heartbeatError) {
-              graphHeartbeatFailure = heartbeatError;
-              graphAbortController.abort(graphHeartbeatFailure);
-              return;
-            }
-          }
-        })();
-        const requestedPaths = new Set(filesToProcess ?? []);
-        const preparedFiles = discoveredSnapshot.map((file2) => ({
-          ...file2,
-          needsReparse: forceReindex || !activeGraph || file2.needsReparse || requestedPaths.has(file2.relativePath)
-        }));
-        if (activeGraph) {
-          for (const file2 of preparedFiles) {
-            if (file2.needsReparse)
-              continue;
-            const copied = await getSymbolRepository().copyFileGeneration(graphGenerationLease, activeGraph.generationId, file2.relativePath);
-            if (copied.status === "lease_lost")
-              throw new Error("graph_generation_lease_lost");
-            if (copied.status === "missing")
-              file2.needsReparse = true;
-          }
-        }
-        const discovered = preparedFiles.map((file2) => Object.freeze(file2));
-        eventBus.publish("indexing:started", {
-          jobId,
-          projectId,
-          projectPath,
-          totalFiles: discovered.filter((f) => f.needsReparse).length
-        });
-        const st2 = performance.now();
-        let remainingFiles = [...discovered];
-        let parsed = [];
-        const staleFailures = new Set;
-        while (remainingFiles.length > 0) {
-          try {
-            parsed.push(...await abortable(this.parse.run(ctx, remainingFiles), graphAbortController.signal));
-            break;
-          } catch (parseError) {
-            if (!activeGraph || forceReindex || !filesToProcess?.length || !(parseError instanceof StructuralEtlParseError) || staleFailures.has(parseError.filePath))
-              throw parseError;
-            staleFailures.add(parseError.filePath);
-            const stale = await getSymbolRepository().markFileStaleGeneration(graphGenerationLease, parseError.filePath, {
-              lastKnownGoodGenerationId: activeGraph.generationId,
-              diagnostics: parseError.diagnostics.length > 0 ? parseError.diagnostics.slice(0, 10).map((diagnostic2) => ({ ...diagnostic2 })) : [{ code: "incremental_structural_failure", message: parseError.message }],
-              parserErrorCount: parseError.diagnosticCount
-            });
-            if (stale.status !== "stale")
-              throw parseError;
-            remainingFiles = remainingFiles.filter((file2) => file2.relativePath !== parseError.filePath);
-          }
-        }
-        if (graphHeartbeatFailure)
-          throw graphHeartbeatFailure;
-        if (managedRunLeaseLost)
-          throw managedRunLeaseLost;
-        stageTimings.parse = Math.round(performance.now() - st2);
-        const st3 = performance.now();
-        const resolved = await abortable(this.resolve.run(ctx, parsed), graphAbortController.signal);
-        if (graphHeartbeatFailure)
-          throw graphHeartbeatFailure;
-        if (managedRunLeaseLost)
-          throw managedRunLeaseLost;
-        stageTimings.resolve = Math.round(performance.now() - st3);
-        const st4 = performance.now();
-        const loadResult = await abortable(this.load.run(ctx, resolved), graphAbortController.signal);
-        if (graphHeartbeatFailure)
-          throw graphHeartbeatFailure;
-        if (managedRunLeaseLost)
-          throw managedRunLeaseLost;
-        stageTimings.load = Math.round(performance.now() - st4);
-        if (loadResult.errors > 0) {
-          logger.warn("EtlPipeline: completed with file errors", {
-            projectId,
-            jobId,
-            errors: loadResult.errors,
-            fileErrors: (loadResult.fileErrors ?? []).slice(0, 10)
-          });
-        }
-        const activationSnapshot = await abortable(this.discover.run(ctx, { forceReindex, includeTests: include_tests }), graphAbortController.signal);
-        if (buildGraphInputSnapshotHash(activationSnapshot) !== graphGenerationLease.inputSnapshotHash) {
-          throw new Error("graph_generation_stale_snapshot");
-        }
-        if (graphHeartbeatFailure)
-          throw graphHeartbeatFailure;
-        if (managedRunLeaseLost)
-          throw managedRunLeaseLost;
-        stopGraphHeartbeat = true;
-        heartbeatTimerController.abort();
-        await graphHeartbeat;
-        stopManagedRunHeartbeat = true;
-        managedRunTimerController.abort();
-        if (managedRunHeartbeat)
-          await managedRunHeartbeat;
-        const activatedGraph = await this.graphGenerations.activate(graphGenerationLease);
-        const activeGraphSummary = await getSymbolRepository().getActiveGraphSnapshot(projectId);
-        if (!activeGraphSummary || activeGraphSummary.generationId !== activatedGraph.generationId) {
-          throw new Error("activated_graph_summary_mismatch");
-        }
-        const durationMs = Math.round(performance.now() - t0);
-        const result = {
-          filesDiscovered: discovered.length,
-          filesIndexed: loadResult.filesLoaded,
-          filesSkipped: discovered.filter((f) => !f.needsReparse).length,
-          chunksIndexed: loadResult.chunksLoaded,
-          symbolsIndexed: loadResult.symbolsLoaded,
-          errors: loadResult.errors,
-          durationMs,
-          stageTimings,
-          activatedGraphGenerationId: activatedGraph.generationId,
-          parserDiagnostics: {
-            diagnosticsCount: activeGraphSummary.diagnostics.errors,
-            recoveredFiles: activeGraphSummary.diagnostics.recovered,
-            hardFailureFiles: activeGraphSummary.diagnostics.hardFailures,
-            staleFiles: activeGraphSummary.diagnostics.staleFiles,
-            languages: activeGraphSummary.languages
-          }
-        };
-        await getSearchCache().invalidateProject(projectId);
-        try {
-          const admissionMarker = new IndexManager(await getVectorStore());
-          await admissionMarker.updateIndexMetadata(projectId, projectPath, discovered.map((file2) => file2.relativePath));
-        } catch (markerError) {
-          logger.warn("EtlPipeline: search-admission marker write failed", {
-            projectId,
-            jobId,
-            error: markerError
-          });
-        }
-        if (forceReindex) {
-          const liveFingerprint = currentEmbeddingFingerprint();
-          if (liveFingerprint !== null) {
-            try {
-              await stampEmbeddingFingerprint(projectId, liveFingerprint);
-            } catch (stampError) {
-              logger.warn("EtlPipeline: embedding fingerprint stamp failed", {
-                projectId,
-                jobId,
-                error: stampError
-              });
-            }
-          }
-        }
-        indexJobTracker.updateProgress(jobId, result.filesIndexed, result.filesIndexed);
-        await indexJobTracker.setResultAndFlush(jobId, {
-          filesIndexed: result.filesIndexed,
-          chunksIndexed: result.chunksIndexed,
-          errors: result.errors,
-          fileErrors: loadResult.fileErrors ?? [],
-          duration: durationMs,
-          activatedGraphGenerationId: result.activatedGraphGenerationId,
-          parserDiagnostics: result.parserDiagnostics
-        });
-        eventBus.publish("indexing:completed", {
-          jobId,
-          projectId,
-          filesIndexed: result.filesIndexed,
-          chunksIndexed: result.chunksIndexed,
-          symbolsIndexed: result.symbolsIndexed,
-          errors: result.errors,
-          durationMs,
-          activatedGraphGenerationId: result.activatedGraphGenerationId
-        });
-        await this.graphGenerations.cleanup(graphGenerationLease);
-        stopGraphHeartbeat = true;
-        heartbeatTimerController.abort();
-        await graphHeartbeat;
-        stopManagedRunHeartbeat = true;
-        managedRunTimerController.abort();
-        if (managedRunHeartbeat)
-          await managedRunHeartbeat;
-        if (managedRunLease && managedRunRepository) {
-          try {
-            await managedRunRepository.complete(managedRunLease);
-          } catch (completeError) {
-            logger.error("EtlPipeline: managed_runs complete failed", completeError, { projectId, jobId });
-          }
-        }
-        logger.info("EtlPipeline: run completed", { projectId, jobId, ...result });
-        return result;
-      } catch (err) {
-        const durationMs = Math.round(performance.now() - t0);
-        const error51 = err.message;
-        if (graphGenerationLease) {
-          try {
-            await this.graphGenerations.abort(graphGenerationLease, error51);
-          } catch (abortError) {
-            logger.error("EtlPipeline: pending generation abort failed", abortError, { projectId, jobId });
-          }
-        }
-        stopGraphHeartbeat = true;
-        heartbeatTimerController.abort();
-        graphAbortController.abort();
-        await graphHeartbeat;
-        stopManagedRunHeartbeat = true;
-        managedRunTimerController.abort();
-        if (managedRunHeartbeat)
-          await managedRunHeartbeat;
-        if (managedRunLease && managedRunRepository) {
-          try {
-            const outcome2 = await managedRunRepository.abort(managedRunLease);
-            if (outcome2.status === "lease_lost") {
-              logger.warn("EtlPipeline: managed_runs abort saw lease_lost", { projectId, jobId });
-            }
-          } catch (abortError) {
-            logger.error("EtlPipeline: managed_runs abort failed", abortError, { projectId, jobId });
-          }
-        }
-        eventBus.publish("indexing:failed", { jobId, projectId, error: error51, durationMs });
-        indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: durationMs }, error51);
-        logger.error("EtlPipeline: run failed", err, { projectId, jobId, durationMs });
-        throw err;
-      }
-    }
-  };
-});
-
-// ../../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 path29 from "path";
-async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
-  return canonicalize(path29.resolve(projectPath));
-}
-async function assertProjectRootReuse(options) {
-  if (!options.storedProjectPath || options.forceReindex)
-    return;
-  const canonicalize = options.canonicalize ?? realpath2;
-  let storedCanonical;
-  try {
-    storedCanonical = await canonicalize(path29.resolve(options.storedProjectPath));
-  } catch {
-    storedCanonical = path29.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) {
@@ -132116,8 +131627,8 @@ function toSymbolIdentityResolution(result) {
 
 class DefinitionLookupService {
   repository;
-  constructor(repository = getSymbolRepository) {
-    this.repository = repository;
+  constructor(repository2 = getSymbolRepository) {
+    this.repository = repository2;
   }
   async lookup(projectId, query) {
     const repo = this.repository();
@@ -132831,16 +132342,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path30 = e.route;
-    if (!path30)
+    const path29 = e.route;
+    if (!path29)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path30;
+    const key = method + " " + path29;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path30,
+      path: path29,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -132851,12 +132362,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path30 = parsed?.path ?? d.name;
-    const key = method + " " + path30;
+    const path29 = parsed?.path ?? d.name;
+    const key = method + " " + path29;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path30, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path29, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -133077,7 +132588,7 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path30 from "path";
+import path29 from "path";
 import fs19 from "fs/promises";
 
 class SymbolGraphService {
@@ -133431,7 +132942,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path30.resolve(root, relativePath) : relativePath;
+    return root ? path29.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -133545,7 +133056,7 @@ class WorkspaceManager {
     return matches[0];
   }
   async removeWorkspace(projectId) {
-    await getSymbolRepository().clearProject(projectId);
+    await withHeavyWorkLease("maintenance", `workspace-remove:${projectId}`, () => getSymbolRepository().clearProject(projectId));
     logger.info("WorkspaceManager: workspace removed", { projectId });
   }
   subscribeToEvents() {
@@ -133570,11 +133081,633 @@ var init_workspace_manager = __esm(() => {
   init_symbol_repository_factory();
   init_event_bus();
   init_symbol_graph_service();
+  init_heavy_work_lease();
   workspaceManager = WorkspaceManager.getInstance();
 });
 
-// ../../packages/core/dist/tools/index_project.js
+// ../../packages/core/dist/services/etl/pipeline.js
+import { createHash as createHash7 } from "crypto";
+import { setTimeout as delay3 } from "timers/promises";
+import path30 from "path";
+function buildHeaderLanguageEvidence(files) {
+  const headers = new Set(files.filter((file2) => path30.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path30.posix.normalize(file2.relativePath)));
+  const mutable = new Map;
+  const entry2 = (header) => {
+    let value = mutable.get(header);
+    if (!value) {
+      value = { cImporters: new Set, cppImporters: new Set, build: new Set };
+      mutable.set(header, value);
+    }
+    return value;
+  };
+  for (const file2 of files) {
+    if (path30.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+      continue;
+    let commands;
+    try {
+      commands = JSON.parse(file2.snapshotContent);
+    } catch {
+      continue;
+    }
+    if (!Array.isArray(commands))
+      continue;
+    for (const command of commands) {
+      if (!command || typeof command !== "object")
+        continue;
+      const record3 = command;
+      if (typeof record3.file !== "string")
+        continue;
+      const projectRoot = path30.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record3.directory === "string" ? path30.resolve(projectRoot, record3.directory) : projectRoot;
+      const absoluteInput = path30.resolve(commandDirectory, record3.file);
+      const relative2 = path30.relative(projectRoot, absoluteInput);
+      const header = path30.posix.normalize(relative2.replaceAll(path30.sep, "/"));
+      if (!headers.has(header))
+        continue;
+      const invocation = typeof record3.command === "string" ? record3.command : Array.isArray(record3.arguments) ? record3.arguments.join(" ") : "";
+      if (/(?:^|\s)(?:clang\+\+|g\+\+|c\+\+)(?:\s|$)|(?:^|\s)-x\s*c\+\+(?:\s|$)/u.test(invocation))
+        entry2(header).build.add("cpp");
+      else if (/(?:^|\s)(?:clang|gcc|cc)(?:\s|$)|(?:^|\s)-x\s*c(?:\s|$)/u.test(invocation))
+        entry2(header).build.add("c");
+    }
+  }
+  return Object.freeze(Object.fromEntries([...mutable.entries()].sort(([a], [b]) => a.localeCompare(b)).map(([header, value]) => [header, Object.freeze({
+    ...value.cImporters.size ? { cImporters: Object.freeze([...value.cImporters].sort()) } : {},
+    ...value.cppImporters.size ? { cppImporters: Object.freeze([...value.cppImporters].sort()) } : {},
+    ...value.build.size ? { buildLanguage: value.build.size > 1 ? "conflict" : [...value.build][0] } : {}
+  })])));
+}
+function abortable(operation, signal) {
+  if (signal.aborted)
+    return Promise.reject(signal.reason);
+  return new Promise((resolve5, reject) => {
+    let abortReason;
+    const onAbort = () => {
+      abortReason = signal.reason;
+    };
+    signal.addEventListener("abort", onAbort, { once: true });
+    operation.then((value) => abortReason === undefined ? resolve5(value) : reject(abortReason), (error51) => reject(abortReason ?? error51)).finally(() => signal.removeEventListener("abort", onAbort));
+  });
+}
+var EtlPipeline;
+var init_pipeline = __esm(() => {
+  init_dist();
+  init_discover();
+  init_parse3();
+  init_resolve();
+  init_load();
+  init_event_bus();
+  init_symbol_repository_factory();
+  init_index_job_tracker();
+  init_cache_factory();
+  init_index_manager();
+  init_vector_store_factory();
+  init_keyword_search_factory();
+  init_alias_resolver();
+  init_symbol_repo_workspace();
+  init_project_indexer();
+  init_parser_readiness();
+  init_parse3();
+  init_language_manifest();
+  init_graph_generation_coordinator();
+  init_managed_run_repository_pg();
+  init_workspace_manager();
+  EtlPipeline = class EtlPipeline {
+    static instance = null;
+    static runTails = new Map;
+    discover = new DiscoverStage;
+    parse = new ParseStage;
+    resolve = new ResolveStage;
+    load = new LoadStage;
+    graphGenerations = new GraphGenerationCoordinator;
+    constructor() {}
+    static getInstance() {
+      if (!EtlPipeline.instance) {
+        EtlPipeline.instance = new EtlPipeline;
+      }
+      return EtlPipeline.instance;
+    }
+    async run(input) {
+      await assertParserReadyForIndexing();
+      const projectId = await getProjectIdentityAliasResolver().resolve(input.projectId);
+      const canonicalInput = projectId === input.projectId ? input : { ...input, projectId };
+      const previous = EtlPipeline.runTails.get(projectId);
+      let release;
+      const tail = new Promise((resolve5) => {
+        release = resolve5;
+      });
+      EtlPipeline.runTails.set(projectId, tail);
+      if (previous) {
+        logger.info("EtlPipeline: waiting for prior project run", {
+          projectId,
+          jobId: input.jobId
+        });
+        await previous;
+      }
+      try {
+        return await this.runInternal(canonicalInput);
+      } finally {
+        if (EtlPipeline.runTails.get(projectId) === tail) {
+          EtlPipeline.runTails.delete(projectId);
+        }
+        release();
+      }
+    }
+    async runInternal(input, generationRetry = 0) {
+      const projectId = await getProjectIdentityAliasResolver().resolve(input.projectId);
+      const { projectPath, jobId, forceReindex = false, filesToProcess, include_tests = false, managedRunLease } = input;
+      const t0 = performance.now();
+      const stageTimings = {
+        discover: 0,
+        parse: 0,
+        resolve: 0,
+        load: 0
+      };
+      if (forceReindex) {
+        const vectorStore = await getVectorStore();
+        const keywordSearch = getKeywordSearch();
+        await Promise.all([
+          vectorStore.deleteByProject(projectId),
+          keywordSearch.deleteByProject(projectId)
+        ]);
+      }
+      const managedRunRepository = managedRunLease ? ManagedRunRepositoryPg.getInstance() : undefined;
+      const ctx = {
+        projectId,
+        projectPath,
+        jobId,
+        resumeCursor: managedRunLease ? (await managedRunRepository?.getActive(projectId, "indexing"))?.fileCursor ?? undefined : undefined,
+        managedRunLease,
+        emit: (event) => {
+          if (event.type === "progress") {
+            const p = event.payload;
+            indexJobTracker.updateProgress(jobId, p.current, p.total);
+            eventBus.publish("indexing:progress", {
+              jobId,
+              projectId,
+              stage: event.stage,
+              current: p.current,
+              total: p.total,
+              percentage: p.percentage
+            });
+          } else if (event.type === "file_error") {
+            const p = event.payload;
+            eventBus.publish("indexing:file", {
+              jobId,
+              projectId,
+              filePath: p.filePath,
+              stage: event.stage,
+              status: "error",
+              error: p.error
+            });
+          } else if (event.type === "file_processed") {
+            const p = event.payload;
+            eventBus.publish("indexing:file", {
+              jobId,
+              projectId,
+              filePath: p.filePath,
+              stage: event.stage,
+              status: "ok"
+            });
+          }
+        }
+      };
+      eventBus.publish("indexing:started", { jobId, projectId, projectPath });
+      let graphGenerationLease;
+      let graphHeartbeat;
+      let graphHeartbeatFailure;
+      const graphAbortController = new AbortController;
+      const heartbeatTimerController = new AbortController;
+      let stopGraphHeartbeat = false;
+      let managedRunHeartbeat;
+      let managedRunLeaseLost;
+      let stopManagedRunHeartbeat = false;
+      const managedRunTimerController = new AbortController;
+      if (managedRunLease && managedRunRepository) {
+        managedRunHeartbeat = (async () => {
+          while (!stopManagedRunHeartbeat) {
+            try {
+              await delay3(30000, undefined, { signal: managedRunTimerController.signal });
+            } catch {
+              return;
+            }
+            if (stopManagedRunHeartbeat || !managedRunLease)
+              return;
+            try {
+              const outcome2 = await managedRunRepository.heartbeat(managedRunLease);
+              if (outcome2.status === "lease_lost") {
+                managedRunLeaseLost = new Error("managed_run_lease_lost");
+                graphAbortController.abort(managedRunLeaseLost);
+                return;
+              }
+            } catch (heartbeatError) {
+              managedRunLeaseLost = heartbeatError;
+              graphAbortController.abort(managedRunLeaseLost);
+              return;
+            }
+          }
+        })();
+      }
+      const jobHeartbeatController = new AbortController;
+      (async () => {
+        while (true) {
+          try {
+            await delay3(30000, undefined, { signal: jobHeartbeatController.signal });
+          } catch {
+            return;
+          }
+          try {
+            indexJobTracker.heartbeat(jobId);
+          } catch {}
+        }
+      })();
+      try {
+        const st1 = performance.now();
+        const discoveredSnapshot = await this.discover.run(ctx, { forceReindex, includeTests: include_tests });
+        ctx.structuralHeaderEvidenceByFile = buildHeaderLanguageEvidence(discoveredSnapshot);
+        stageTimings.discover = Math.round(performance.now() - st1);
+        await workspaceManager.markIndexing(projectId, projectPath);
+        const activeGraph = await getSymbolRepository().getActiveGraphSnapshot(projectId);
+        try {
+          graphGenerationLease = await this.graphGenerations.begin({
+            projectId,
+            expectedActiveGenerationId: activeGraph?.generationId ?? null,
+            fingerprint: `sha256:${createHash7("sha256").update(JSON.stringify(STRUCTURAL_FINGERPRINT_INPUTS)).digest("hex")}`,
+            inputSnapshotHash: buildGraphInputSnapshotHash(discoveredSnapshot),
+            expectedFilesCount: discoveredSnapshot.length
+          });
+        } catch (beginError) {
+          if (beginError.message.startsWith("graph_generation_stale_active:") && generationRetry < 3) {
+            stopManagedRunHeartbeat = true;
+            managedRunTimerController.abort();
+            jobHeartbeatController.abort();
+            if (managedRunHeartbeat)
+              await managedRunHeartbeat;
+            return this.runInternal(input, generationRetry + 1);
+          }
+          throw beginError;
+        }
+        ctx.graphGenerationLease = graphGenerationLease;
+        ctx.abortSignal = graphAbortController.signal;
+        graphHeartbeat = (async () => {
+          while (!stopGraphHeartbeat) {
+            try {
+              await delay3(30000, undefined, { signal: heartbeatTimerController.signal });
+            } catch {
+              return;
+            }
+            if (stopGraphHeartbeat || !graphGenerationLease)
+              return;
+            try {
+              await this.graphGenerations.heartbeat(graphGenerationLease);
+            } catch (heartbeatError) {
+              graphHeartbeatFailure = heartbeatError;
+              graphAbortController.abort(graphHeartbeatFailure);
+              return;
+            }
+          }
+        })();
+        const requestedPaths = new Set(filesToProcess ?? []);
+        const preparedFiles = discoveredSnapshot.map((file2) => ({
+          ...file2,
+          needsReparse: forceReindex || !activeGraph || file2.needsReparse || requestedPaths.has(file2.relativePath)
+        }));
+        if (activeGraph) {
+          for (const file2 of preparedFiles) {
+            if (file2.needsReparse)
+              continue;
+            const copied = await getSymbolRepository().copyFileGeneration(graphGenerationLease, activeGraph.generationId, file2.relativePath);
+            if (copied.status === "lease_lost")
+              throw new Error("graph_generation_lease_lost");
+            if (copied.status === "missing")
+              file2.needsReparse = true;
+          }
+        }
+        const discovered = preparedFiles.map((file2) => Object.freeze(file2));
+        eventBus.publish("indexing:started", {
+          jobId,
+          projectId,
+          projectPath,
+          totalFiles: discovered.filter((f) => f.needsReparse).length
+        });
+        const st2 = performance.now();
+        let remainingFiles = [...discovered];
+        let parsed = [];
+        const staleFailures = new Set;
+        while (remainingFiles.length > 0) {
+          try {
+            parsed.push(...await abortable(this.parse.run(ctx, remainingFiles), graphAbortController.signal));
+            break;
+          } catch (parseError) {
+            if (!activeGraph || forceReindex || !filesToProcess?.length || !(parseError instanceof StructuralEtlParseError) || staleFailures.has(parseError.filePath))
+              throw parseError;
+            staleFailures.add(parseError.filePath);
+            const stale = await getSymbolRepository().markFileStaleGeneration(graphGenerationLease, parseError.filePath, {
+              lastKnownGoodGenerationId: activeGraph.generationId,
+              diagnostics: parseError.diagnostics.length > 0 ? parseError.diagnostics.slice(0, 10).map((diagnostic2) => ({ ...diagnostic2 })) : [{ code: "incremental_structural_failure", message: parseError.message }],
+              parserErrorCount: parseError.diagnosticCount
+            });
+            if (stale.status !== "stale")
+              throw parseError;
+            remainingFiles = remainingFiles.filter((file2) => file2.relativePath !== parseError.filePath);
+          }
+        }
+        if (graphHeartbeatFailure)
+          throw graphHeartbeatFailure;
+        if (managedRunLeaseLost)
+          throw managedRunLeaseLost;
+        stageTimings.parse = Math.round(performance.now() - st2);
+        const st3 = performance.now();
+        const resolved = await abortable(this.resolve.run(ctx, parsed), graphAbortController.signal);
+        if (graphHeartbeatFailure)
+          throw graphHeartbeatFailure;
+        if (managedRunLeaseLost)
+          throw managedRunLeaseLost;
+        stageTimings.resolve = Math.round(performance.now() - st3);
+        const st4 = performance.now();
+        const loadResult = await abortable(this.load.run(ctx, resolved), graphAbortController.signal);
+        if (graphHeartbeatFailure)
+          throw graphHeartbeatFailure;
+        if (managedRunLeaseLost)
+          throw managedRunLeaseLost;
+        stageTimings.load = Math.round(performance.now() - st4);
+        if (loadResult.errors > 0) {
+          logger.warn("EtlPipeline: completed with file errors", {
+            projectId,
+            jobId,
+            errors: loadResult.errors,
+            fileErrors: (loadResult.fileErrors ?? []).slice(0, 10)
+          });
+        }
+        const activationSnapshot = await abortable(this.discover.run(ctx, { forceReindex, includeTests: include_tests }), graphAbortController.signal);
+        if (buildGraphInputSnapshotHash(activationSnapshot) !== graphGenerationLease.inputSnapshotHash) {
+          throw new Error("graph_generation_stale_snapshot");
+        }
+        if (graphHeartbeatFailure)
+          throw graphHeartbeatFailure;
+        if (managedRunLeaseLost)
+          throw managedRunLeaseLost;
+        stopGraphHeartbeat = true;
+        heartbeatTimerController.abort();
+        await graphHeartbeat;
+        stopManagedRunHeartbeat = true;
+        managedRunTimerController.abort();
+        if (managedRunHeartbeat)
+          await managedRunHeartbeat;
+        const activatedGraph = await this.graphGenerations.activate(graphGenerationLease);
+        const activeGraphSummary = await getSymbolRepository().getActiveGraphSnapshot(projectId);
+        if (!activeGraphSummary || activeGraphSummary.generationId !== activatedGraph.generationId) {
+          throw new Error("activated_graph_summary_mismatch");
+        }
+        const durationMs = Math.round(performance.now() - t0);
+        const result = {
+          filesDiscovered: discovered.length,
+          filesIndexed: loadResult.filesLoaded,
+          filesSkipped: discovered.filter((f) => !f.needsReparse).length,
+          chunksIndexed: loadResult.chunksLoaded,
+          symbolsIndexed: loadResult.symbolsLoaded,
+          errors: loadResult.errors,
+          durationMs,
+          stageTimings,
+          activatedGraphGenerationId: activatedGraph.generationId,
+          parserDiagnostics: {
+            diagnosticsCount: activeGraphSummary.diagnostics.errors,
+            recoveredFiles: activeGraphSummary.diagnostics.recovered,
+            hardFailureFiles: activeGraphSummary.diagnostics.hardFailures,
+            staleFiles: activeGraphSummary.diagnostics.staleFiles,
+            languages: activeGraphSummary.languages
+          }
+        };
+        await getSearchCache().invalidateProject(projectId);
+        try {
+          const admissionMarker = new IndexManager(await getVectorStore());
+          await admissionMarker.updateIndexMetadata(projectId, projectPath, discovered.map((file2) => file2.relativePath));
+        } catch (markerError) {
+          logger.warn("EtlPipeline: search-admission marker write failed", {
+            projectId,
+            jobId,
+            error: markerError
+          });
+        }
+        if (forceReindex) {
+          const liveFingerprint = currentEmbeddingFingerprint();
+          if (liveFingerprint !== null) {
+            try {
+              await stampEmbeddingFingerprint(projectId, liveFingerprint);
+            } catch (stampError) {
+              logger.warn("EtlPipeline: embedding fingerprint stamp failed", {
+                projectId,
+                jobId,
+                error: stampError
+              });
+            }
+          }
+        }
+        indexJobTracker.updateProgress(jobId, result.filesIndexed, result.filesIndexed);
+        await indexJobTracker.setResultAndFlush(jobId, {
+          filesIndexed: result.filesIndexed,
+          chunksIndexed: result.chunksIndexed,
+          errors: result.errors,
+          fileErrors: loadResult.fileErrors ?? [],
+          duration: durationMs,
+          activatedGraphGenerationId: result.activatedGraphGenerationId,
+          parserDiagnostics: result.parserDiagnostics
+        });
+        eventBus.publish("indexing:completed", {
+          jobId,
+          projectId,
+          filesIndexed: result.filesIndexed,
+          chunksIndexed: result.chunksIndexed,
+          symbolsIndexed: result.symbolsIndexed,
+          errors: result.errors,
+          durationMs,
+          activatedGraphGenerationId: result.activatedGraphGenerationId
+        });
+        await this.graphGenerations.cleanup(graphGenerationLease);
+        jobHeartbeatController.abort();
+        stopGraphHeartbeat = true;
+        heartbeatTimerController.abort();
+        await graphHeartbeat;
+        stopManagedRunHeartbeat = true;
+        managedRunTimerController.abort();
+        if (managedRunHeartbeat)
+          await managedRunHeartbeat;
+        if (managedRunLease && managedRunRepository) {
+          try {
+            await managedRunRepository.complete(managedRunLease);
+          } catch (completeError) {
+            logger.error("EtlPipeline: managed_runs complete failed", completeError, { projectId, jobId });
+          }
+        }
+        logger.info("EtlPipeline: run completed", { projectId, jobId, ...result });
+        return result;
+      } catch (err) {
+        const durationMs = Math.round(performance.now() - t0);
+        const error51 = err.message;
+        if (graphGenerationLease) {
+          try {
+            await this.graphGenerations.abort(graphGenerationLease, error51);
+          } catch (abortError) {
+            logger.error("EtlPipeline: pending generation abort failed", abortError, { projectId, jobId });
+          }
+        }
+        jobHeartbeatController.abort();
+        stopGraphHeartbeat = true;
+        heartbeatTimerController.abort();
+        graphAbortController.abort();
+        await graphHeartbeat;
+        stopManagedRunHeartbeat = true;
+        managedRunTimerController.abort();
+        if (managedRunHeartbeat)
+          await managedRunHeartbeat;
+        if (managedRunLease && managedRunRepository) {
+          try {
+            const outcome2 = await managedRunRepository.abort(managedRunLease);
+            if (outcome2.status === "lease_lost") {
+              logger.warn("EtlPipeline: managed_runs abort saw lease_lost", { projectId, jobId });
+            }
+          } catch (abortError) {
+            logger.error("EtlPipeline: managed_runs abort failed", abortError, { projectId, jobId });
+          }
+        }
+        eventBus.publish("indexing:failed", { jobId, projectId, error: error51, durationMs });
+        indexJobTracker.setResult(jobId, { filesIndexed: 0, chunksIndexed: 0, errors: 1, duration: durationMs }, error51);
+        logger.error("EtlPipeline: run failed", err, { projectId, jobId, durationMs });
+        throw err;
+      }
+    }
+  };
+});
+
+// ../../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 path31 from "path";
+async function canonicalizeProjectRoot(projectPath, canonicalize = realpath2) {
+  return canonicalize(path31.resolve(projectPath));
+}
+async function assertProjectRootReuse(options) {
+  if (!options.storedProjectPath || options.forceReindex)
+    return;
+  const canonicalize = options.canonicalize ?? realpath2;
+  let storedCanonical;
+  try {
+    storedCanonical = await canonicalize(path31.resolve(options.storedProjectPath));
+  } catch {
+    storedCanonical = path31.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/tools/index_project.js
+import path32 from "path";
 
 class IndexProjectTool {
   name = "index_project";
@@ -133622,7 +133755,7 @@ class IndexProjectTool {
     try {
       await assertParserReadyForIndexing();
       const canonicalProjectPath = await canonicalizeProjectRoot(projectPath);
-      const finalProjectId = projectId || path31.basename(canonicalProjectPath) || "default";
+      const finalProjectId = projectId || path32.basename(canonicalProjectPath) || "default";
       const existing = await workspaceManager.getWorkspace(finalProjectId);
       await assertProjectRootReuse({
         projectId: finalProjectId,
@@ -134175,17 +134308,17 @@ function applyReplacer(root, replacer) {
     return transformChildren(root, replacer, []);
   return transformChildren(normalizeValue(replacedRoot), replacer, []);
 }
-function transformChildren(value, replacer, path32) {
+function transformChildren(value, replacer, path33) {
   if (isJsonObject(value))
-    return transformObject(value, replacer, path32);
+    return transformObject(value, replacer, path33);
   if (isJsonArray(value))
-    return transformArray(value, replacer, path32);
+    return transformArray(value, replacer, path33);
   return value;
 }
-function transformObject(obj, replacer, path32) {
+function transformObject(obj, replacer, path33) {
   const result = {};
   for (const [key, value] of Object.entries(obj)) {
-    const childPath = [...path32, key];
+    const childPath = [...path33, key];
     const replacedValue = replacer(key, value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -134193,11 +134326,11 @@ function transformObject(obj, replacer, path32) {
   }
   return result;
 }
-function transformArray(arr, replacer, path32) {
+function transformArray(arr, replacer, path33) {
   const result = [];
   for (let i = 0;i < arr.length; i++) {
     const value = arr[i];
-    const childPath = [...path32, i];
+    const childPath = [...path33, i];
     const replacedValue = replacer(String(i), value, childPath);
     if (replacedValue === undefined)
       continue;
@@ -135635,7 +135768,7 @@ __export(exports_memory_consolidation_job, {
   memoryConsolidationJob: () => memoryConsolidationJob,
   MemoryConsolidationJob: () => MemoryConsolidationJob
 });
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } from "crypto";
 async function addSupercedesEdge(store3, newId, sourceId, batchId) {
   const evidence = JSON.stringify({ batchId, consolidated: true });
   await store3.createEdge({
@@ -135779,11 +135912,11 @@ class MemoryConsolidationJob {
       });
       return { merged: 0, batchesCreated: 0 };
     }
-    const batch = await consolidateWindow(rowsToCandidates(candidates2), this.llm, { idFactory: () => `batch-${now2}-${randomUUID6().slice(0, 8)}` }).catch(() => null);
+    const batch = await consolidateWindow(rowsToCandidates(candidates2), this.llm, { idFactory: () => `batch-${now2}-${randomUUID7().slice(0, 8)}` }).catch(() => null);
     if (!batch)
       return { merged: 0, batchesCreated: 0 };
     const sourceRows = candidates2.filter((c) => batch.sourceIds.includes(c.id));
-    const newId = `mem-${now2}-${randomUUID6().slice(0, 8)}`;
+    const newId = `mem-${now2}-${randomUUID7().slice(0, 8)}`;
     const importance = sourceRows.length ? Math.min(1, Math.max(...sourceRows.map((r) => r.importance))) : 0.7;
     const projectId = sourceRows.find((r) => r.project_id)?.project_id ?? null;
     try {
@@ -139290,7 +139423,7 @@ var init_session_pin_store = __esm(() => {
 // ../../packages/core/dist/services/hooks/attribution-resolver.js
 import fs20 from "fs";
 import os9 from "os";
-import path32 from "path";
+import path33 from "path";
 
 class PgWorkspaceRootProvider {
   cache = null;
@@ -139340,7 +139473,7 @@ class AttributionResolver {
     this.pins = options.pins ?? new SessionPinStore;
     this.canonicalize = options.canonicalize ?? defaultCanonicalize;
     this.homedir = options.homedir ?? os9.homedir;
-    this.fsRoot = options.fsRoot ?? (() => path32.parse(path32.sep).root);
+    this.fsRoot = options.fsRoot ?? (() => path33.parse(path33.sep).root);
   }
   async resolve(input) {
     const caller = input.callerProjectId;
@@ -139391,7 +139524,7 @@ class AttributionResolver {
     }
     let bestPath = null;
     for (const candidate2 of byPath.keys()) {
-      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path32.sep) ? candidate2 : candidate2 + path32.sep)) {
+      if (canonicalCwd === candidate2 || canonicalCwd.startsWith(candidate2.endsWith(path33.sep) ? candidate2 : candidate2 + path33.sep)) {
         if (bestPath === null || candidate2.length > bestPath.length) {
           bestPath = candidate2;
         }
@@ -139414,7 +139547,7 @@ class AttributionResolver {
       return projectPath2;
     const fsRoot = this.fsRoot();
     let normalized = projectPath2;
-    while (normalized.length > fsRoot.length && normalized.endsWith(path32.sep)) {
+    while (normalized.length > fsRoot.length && normalized.endsWith(path33.sep)) {
       normalized = normalized.slice(0, -1);
     }
     return normalized;
@@ -139425,7 +139558,7 @@ function defaultCanonicalize(cwd) {
     return fs20.realpathSync(cwd);
   } catch {
     try {
-      return path32.resolve(cwd);
+      return path33.resolve(cwd);
     } catch {
       return;
     }
@@ -140174,31 +140307,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path33) => {
+    const walk = (fqn, path34) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path33.join("\u2192");
+      const key = path34.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path33.length > 1)
-          chains.push(path33.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path34.length > 1)
+          chains.push(path34.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path33.includes(child)) {
-          const cycled = [...path33, `${this.fqnToName(child)}\u21BA`];
+        if (path34.includes(child)) {
+          const cycled = [...path34, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path33, child]);
+        walk(child, [...path34, child]);
       }
     };
     for (const seed of seeds) {
@@ -141081,7 +141214,7 @@ var init_file_content_cache = __esm(() => {
 });
 
 // ../../packages/core/dist/services/file-read/file-metadata.js
-import path33 from "path";
+import path34 from "path";
 
 class FileMetadataExtractor {
   symbolGraph;
@@ -141117,7 +141250,7 @@ class FileMetadataExtractor {
     return metadata;
   }
   detectLanguage(filePath) {
-    const ext2 = path33.extname(filePath).toLowerCase();
+    const ext2 = path34.extname(filePath).toLowerCase();
     const languageMap2 = {
       ".ts": "TypeScript",
       ".tsx": "TypeScript",
@@ -141239,7 +141372,7 @@ var init_line_range = __esm(() => {
 });
 
 // ../../packages/core/dist/services/file-read/path-containment.js
-import path34 from "path";
+import path35 from "path";
 
 class PathContainment {
   projectRoots;
@@ -141247,14 +141380,14 @@ class PathContainment {
     this.projectRoots = projectRoots;
   }
   async resolveFilePath(filePath, projectId) {
-    if (path34.isAbsolute(filePath)) {
-      return path34.resolve(filePath);
+    if (path35.isAbsolute(filePath)) {
+      return path35.resolve(filePath);
     }
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root) {
         const cleaned = sanitizeFilePath(filePath);
-        return path34.resolve(root, cleaned);
+        return path35.resolve(root, cleaned);
       }
       return null;
     }
@@ -141265,17 +141398,17 @@ class PathContainment {
     if (projectId) {
       const root = await this.projectRoots.getProjectRoot(projectId);
       if (root)
-        roots.push(path34.resolve(root));
+        roots.push(path35.resolve(root));
     }
-    roots.push(path34.resolve(process.cwd()));
+    roots.push(path35.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(path34.resolve(extra));
+      roots.push(path35.resolve(extra));
     }
-    const target = path34.resolve(absoluteFilePath);
+    const target = path35.resolve(absoluteFilePath);
     for (const root of roots) {
-      const rel = path34.relative(root, target);
-      if (rel !== "" && !rel.startsWith("..") && !path34.isAbsolute(rel)) {
+      const rel = path35.relative(root, target);
+      if (rel !== "" && !rel.startsWith("..") && !path35.isAbsolute(rel)) {
         return { allowed: true };
       }
       if (rel === "")
@@ -144220,12 +144353,13 @@ function createProjectIdentityService(options = {}) {
       }
     },
     apply(input) {
-      return applyService.apply(input);
+      return withHeavyWorkLease("maintenance", "project-identity", () => applyService.apply(input));
     }
   };
 }
 var init_service = __esm(() => {
   init_db_connection();
+  init_heavy_work_lease();
   init_apply();
   init_errors4();
   init_planner();
@@ -144523,7 +144657,7 @@ var init_inference_probe = __esm(() => {
 // ../../packages/core/dist/services/health/local-health-checker.js
 import fs22 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path35 from "path";
+import path36 from "path";
 
 class LocalHealthChecker {
   dataDir = config2.get("dataDir");
@@ -144602,7 +144736,7 @@ class LocalHealthChecker {
     try {
       if (!existsSync3(this.dataDir))
         await fs22.mkdir(this.dataDir, { recursive: true });
-      const probe2 = path35.join(this.dataDir, ".health-check-test");
+      const probe2 = path36.join(this.dataDir, ".health-check-test");
       await fs22.writeFile(probe2, "ok");
       await fs22.unlink(probe2);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
@@ -144948,6 +145082,9 @@ class PgScheduledJobStore {
     }, "save");
     this.ensureHydrated();
   }
+  async ready() {
+    await this.ensureHydrated();
+  }
   get(id) {
     this.ensureHydrated();
     return this.mirror.get(id) ?? null;
@@ -145024,10 +145161,18 @@ class Scheduler {
   handlers = new Map;
   cronCache = new Map;
   running = new Set;
+  heavyWorkProbe;
+  deferred = new Set;
+  heavyWorkReason = null;
+  lastProbeError = null;
+  consecutiveProbeFailures = 0;
+  evaluating = false;
+  pendingTickAt = null;
   timer = null;
   started = false;
   constructor(opts = {}) {
     this.store = opts.store ?? getScheduledJobStore();
+    this.heavyWorkProbe = opts.heavyWorkProbe ?? probeHeavyWork;
     const schedulerConfig = config2.get("scheduler");
     this.tickIntervalMs = opts.tickIntervalMs ?? envPositiveInt(process.env.MASSA_AI_SCHEDULER_TICK_MS) ?? schedulerConfig?.tickMs ?? DEFAULTS.tickMs;
     this.maxConcurrent = opts.maxConcurrent ?? envPositiveInt(process.env.MASSA_AI_SCHEDULER_MAX_CONCURRENT) ?? schedulerConfig?.maxConcurrent ?? DEFAULTS.maxConcurrent;
@@ -145128,31 +145273,43 @@ class Scheduler {
     this.timer.unref?.();
     this.tick().catch(() => {});
   }
-  catchUpMissedJobs(now2 = Date.now()) {
-    if (!this.enabled)
-      return { caughtUp: 0, skipped: 0 };
+  async catchUpMissedJobs(now2 = Date.now()) {
+    if (!this.enabled || this.evaluating)
+      return { caughtUp: 0, skipped: 0, deferred: 0 };
+    this.evaluating = true;
+    try {
+      return await this.catchUpOnce(now2);
+    } finally {
+      this.evaluating = false;
+    }
+  }
+  async catchUpOnce(now2) {
     const jobs = this.store.listEnabled();
-    let caughtUp = 0;
     let skipped = 0;
+    const missed = [];
     for (const job of jobs) {
       if (this.running.has(job.jobKind)) {
         skipped++;
         continue;
       }
-      const overdueMs = now2 - job.nextRunAt;
-      if (overdueMs <= this.tickIntervalMs) {
-        continue;
-      }
+      if (now2 - job.nextRunAt > this.tickIntervalMs)
+        missed.push(job);
+    }
+    if (missed.length > 0 && await this.heavyWorkBusy()) {
+      for (const job of missed)
+        this.deferred.add(job.id);
+      return { caughtUp: 0, skipped, deferred: missed.length };
+    }
+    for (const job of missed) {
       logger.info("Scheduler: catch-up tick for missed job", {
         id: job.id,
         name: job.name,
         jobKind: job.jobKind,
-        overdueMs
+        overdueMs: now2 - job.nextRunAt
       });
       this.fireJob(job, now2);
-      caughtUp++;
     }
-    return { caughtUp, skipped };
+    return { caughtUp: missed.length, skipped, deferred: 0 };
   }
   stop() {
     if (this.timer) {
@@ -145160,17 +145317,47 @@ class Scheduler {
       this.timer = null;
     }
     this.started = false;
+    this.pendingTickAt = null;
     logger.info("Scheduler stopped");
   }
   isRunning() {
     return this.started && this.timer !== null;
   }
   async tick(now2 = Date.now()) {
-    const result = { evaluated: 0, fired: 0, skipped: 0, errors: 0 };
+    const result = { evaluated: 0, fired: 0, skipped: 0, errors: 0, deferred: 0 };
     if (!this.enabled)
       return result;
-    const jobs = this.store.listEnabled();
+    if (this.evaluating) {
+      this.pendingTickAt = now2;
+      return result;
+    }
+    this.evaluating = true;
+    try {
+      return await this.tickOnce(now2, result);
+    } finally {
+      this.evaluating = false;
+      const pending = this.pendingTickAt;
+      this.pendingTickAt = null;
+      if (pending !== null) {
+        this.tick(pending).catch((e) => {
+          logger.warn("Scheduler tick failed (swallowed)", { error: e });
+        });
+      }
+    }
+  }
+  async tickOnce(now2, result) {
+    let jobs = this.store.listEnabled();
     result.evaluated = jobs.length;
+    const due = jobs.filter((job) => !this.running.has(job.jobKind) && job.nextRunAt <= now2);
+    if (due.length > 0) {
+      if (await this.heavyWorkBusy()) {
+        for (const job of due)
+          this.deferred.add(job.id);
+        result.deferred = due.length;
+        return result;
+      }
+      jobs = this.store.listEnabled();
+    }
     for (const job of jobs) {
       if (this.running.has(job.jobKind)) {
         result.skipped++;
@@ -145180,7 +145367,7 @@ class Scheduler {
         continue;
       }
       const overdueMs = now2 - job.nextRunAt;
-      const isMissed = overdueMs > this.tickIntervalMs;
+      const isMissed = overdueMs > this.tickIntervalMs && !this.deferred.has(job.id);
       if (isMissed) {
         logger.warn("Scheduler: missed run (skipping, rescheduling)", {
           id: job.id,
@@ -145202,7 +145389,42 @@ class Scheduler {
     }
     return result;
   }
+  async heavyWorkBusy() {
+    let state;
+    try {
+      state = await this.heavyWorkProbe();
+    } catch (e) {
+      this.consecutiveProbeFailures++;
+      this.lastProbeError = e.message;
+      if (this.consecutiveProbeFailures === 1 || this.consecutiveProbeFailures % PROBE_FAILURE_WARN_EVERY === 0) {
+        logger.warn("Scheduler: heavy-work probe failed; deferring due jobs", {
+          consecutiveFailures: this.consecutiveProbeFailures,
+          error: e
+        });
+      }
+      return true;
+    }
+    this.consecutiveProbeFailures = 0;
+    this.lastProbeError = null;
+    if (state.busy) {
+      if (this.heavyWorkReason === null) {
+        logger.info("Scheduler: heavy database work in progress; deferring due jobs", {
+          reason: state.reason ?? "unknown"
+        });
+      }
+      this.heavyWorkReason = state.reason ?? "unknown";
+      return true;
+    }
+    if (this.heavyWorkReason !== null) {
+      logger.info("Scheduler: heavy database work finished; running deferred jobs", {
+        deferred: this.deferred.size
+      });
+      this.heavyWorkReason = null;
+    }
+    return false;
+  }
   fireJob(job, firedAt) {
+    this.deferred.delete(job.id);
     const handler = this.handlers.get(job.jobKind);
     if (!handler) {
       logger.warn("Scheduler: no handler registered for jobKind", {
@@ -145262,6 +145484,9 @@ class Scheduler {
       }
     })();
   }
+  async ready() {
+    await this.store.ready?.();
+  }
   status(now2 = Date.now()) {
     const jobs = this.store.listAll();
     return {
@@ -145276,10 +145501,17 @@ class Scheduler {
         nextRunAt: j.nextRunAt,
         lastRunAt: j.lastRunAt,
         lastSuccessAt: j.lastSuccessAt ?? null,
+        lastFailureAt: j.lastFailureAt ?? null,
         consecutiveFailures: j.consecutiveFailures ?? 0,
+        lastError: j.lastError ?? null,
         due: j.enabled && j.nextRunAt <= now2,
-        currentlyRunning: this.running.has(j.jobKind)
-      }))
+        currentlyRunning: this.running.has(j.jobKind),
+        deferred: this.deferred.has(j.id)
+      })),
+      heavyWork: {
+        lastProbeError: this.lastProbeError,
+        consecutiveProbeFailures: this.consecutiveProbeFailures
+      }
     };
   }
   isJobRunning(jobKind) {
@@ -145298,12 +145530,13 @@ function resetScheduler() {
   }
   resetScheduledJobStore();
 }
-var DEFAULTS, cachedScheduler = null;
+var DEFAULTS, PROBE_FAILURE_WARN_EVERY = 5, cachedScheduler = null;
 var init_scheduler = __esm(() => {
   init_dist();
   init_config();
   init_scheduler_cron();
   init_scheduler_store_factory();
+  init_heavy_work_lease();
   DEFAULTS = {
     tickMs: 60000,
     maxConcurrent: 2
@@ -145992,7 +146225,7 @@ var init_auto_improve_llm = __esm(() => {
 });
 
 // ../../packages/core/dist/services/jobs/auto-improve-apply.js
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function validateCreatePayload(p) {
   if ("type" in p && p.type !== undefined && p.type !== null) {
     if (typeof p.type !== "string" || !VALID_MEMORY_TYPES.has(p.type)) {
@@ -146033,7 +146266,7 @@ function buildUpdatePatch(p) {
   return patch;
 }
 async function applyProposal(job, record3) {
-  const memId = record3.targetMemoryId ?? `proposal-mem-${record3.id}-${randomUUID7().slice(0, 8)}`;
+  const memId = record3.targetMemoryId ?? `proposal-mem-${record3.id}-${randomUUID8().slice(0, 8)}`;
   const p = record3.payload;
   if (record3.kind === "memory.create") {
     validateCreatePayload(p);
@@ -146300,8 +146533,8 @@ __export(exports_auto_improve_job, {
 
 class AutoImproveJob {
   llm;
-  observationStore;
-  proposalStore;
+  injectedObservationStore;
+  injectedProposalStore;
   memoryRepo;
   thresholds;
   minObservations;
@@ -146312,10 +146545,16 @@ class AutoImproveJob {
   lastRunAt = 0;
   newSinceRun = 0;
   runCalls = 0;
+  get observationStore() {
+    return this.injectedObservationStore ?? getObservationStore();
+  }
+  get proposalStore() {
+    return this.injectedProposalStore ?? getProposalStore();
+  }
   constructor(opts = {}) {
     this.llm = opts.llm ?? llm;
-    this.observationStore = opts.observationStore ?? getObservationStore();
-    this.proposalStore = opts.proposalStore ?? getProposalStore();
+    this.injectedObservationStore = opts.observationStore;
+    this.injectedProposalStore = opts.proposalStore;
     this.thresholds = { ...DEFAULT_THRESHOLDS, ...opts.thresholds };
     this.reviewGateOverride = opts.reviewGate;
     this.idFactory = opts.idFactory ?? (() => newProposalId());
@@ -146395,7 +146634,7 @@ __export(exports_observation_consolidation_job, {
   observationConsolidationJob: () => observationConsolidationJob,
   ObservationConsolidationJob: () => ObservationConsolidationJob
 });
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function readBridgeConfig() {
   try {
     const c = config2.get("hooks")?.bridge;
@@ -146413,7 +146652,7 @@ function readBridgeConfig() {
 
 class ObservationConsolidationJob {
   llm;
-  store;
+  injectedStore;
   memoryRepo;
   minObservations;
   minIntervalMs;
@@ -146421,9 +146660,12 @@ class ObservationConsolidationJob {
   lastRunAt = 0;
   newSinceRun = 0;
   runCalls = 0;
+  get store() {
+    return this.injectedStore ?? getObservationStore();
+  }
   constructor(opts = {}) {
     this.llm = opts.llm ?? llm;
-    this.store = opts.store ?? getObservationStore();
+    this.injectedStore = opts.store;
     const injected = opts.memoryRepo;
     this.memoryRepo = injected ?? { insert: (i) => getMemoryRepository().insert(i) };
     const cfg = readBridgeConfig();
@@ -146485,7 +146727,7 @@ class ObservationConsolidationJob {
     if (observations.length < 2)
       return noop2;
     const window2 = observations.slice(0, this.maxWindow);
-    const batchId = `obs-batch-${Date.now()}-${randomUUID8().slice(0, 8)}`;
+    const batchId = `obs-batch-${Date.now()}-${randomUUID9().slice(0, 8)}`;
     const prompt = buildObservationPrompt(window2);
     let batch;
     try {
@@ -146511,7 +146753,7 @@ class ObservationConsolidationJob {
     }
     if (!batch)
       return noop2;
-    const newId = `mem-${Date.now()}-${randomUUID8().slice(0, 8)}`;
+    const newId = `mem-${Date.now()}-${randomUUID9().slice(0, 8)}`;
     const importance = 0.7;
     try {
       await Promise.resolve(this.memoryRepo.insert({
@@ -146743,7 +146985,7 @@ var init_scheduler2 = __esm(() => {
 // ../../packages/core/dist/services/pricing/models-dev-client.js
 import fs23 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path36 from "path";
+import path37 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -146763,7 +147005,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config2.get("dataDir");
-      return path36.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path37.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -146798,7 +147040,7 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path36.dirname(cachePath);
+        const dir = path37.dirname(cachePath);
         await fs23.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
@@ -152694,33 +152936,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path37) {
-        if (!path37)
-          return path37;
+      function remove_dot_segments(path38) {
+        if (!path38)
+          return path38;
         var output = "";
-        while (path37.length > 0) {
-          if (path37 === "." || path37 === "..") {
-            path37 = "";
+        while (path38.length > 0) {
+          if (path38 === "." || path38 === "..") {
+            path38 = "";
             break;
           }
-          var twochars = path37.substring(0, 2);
-          var threechars = path37.substring(0, 3);
-          var fourchars = path37.substring(0, 4);
+          var twochars = path38.substring(0, 2);
+          var threechars = path38.substring(0, 3);
+          var fourchars = path38.substring(0, 4);
           if (threechars === "../") {
-            path37 = path37.substring(3);
+            path38 = path38.substring(3);
           } else if (twochars === "./") {
-            path37 = path37.substring(2);
+            path38 = path38.substring(2);
           } else if (threechars === "/./") {
-            path37 = "/" + path37.substring(3);
-          } else if (twochars === "/." && path37.length === 2) {
-            path37 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path37.length === 3) {
-            path37 = "/" + path37.substring(4);
+            path38 = "/" + path38.substring(3);
+          } else if (twochars === "/." && path38.length === 2) {
+            path38 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path38.length === 3) {
+            path38 = "/" + path38.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path37.match(/(\/?([^\/]*))/)[0];
+            var segment = path38.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path37 = path37.substring(segment.length);
+            path38 = path38.substring(segment.length);
           }
         }
         return output;
@@ -164790,21 +165032,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path37, out) {
+function walk(val, path38, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path37, content: `**${path37}** = _[]_` });
+      out.push({ path: path38, content: `**${path38}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path37}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path38}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path37, content: `**${path37}**
+    out.push({ path: path38, content: `**${path38}**
 
 ${items}` });
     return;
@@ -164812,16 +165054,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path37, content: `**${path37}** = _{}_` });
+      out.push({ path: path38, content: `**${path38}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path37}.${safeKey}`, out);
+      walk(v, `${path38}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path37, content: `**${path37}** = \`${String(val)}\`` });
+  out.push({ path: path38, content: `**${path38}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -165161,6 +165403,7 @@ var init_services = __esm(() => {
   init_embeddings();
   init_local_health_checker();
   init_index_job_tracker();
+  init_heavy_work_lease();
   init_scheduler2();
   init_models_dev_client();
   init_memory_graph_service();
@@ -165587,9 +165830,9 @@ var init_hook_service = __esm(() => {
 });
 
 // ../../packages/core/dist/services/bootstrap/bootstrap-service.js
-import { randomUUID as randomUUID9 } from "crypto";
+import { randomUUID as randomUUID10 } from "crypto";
 import fs24 from "fs";
-import path37 from "path";
+import path38 from "path";
 import { spawn as spawn2 } from "child_process";
 function readBootstrapConfig() {
   try {
@@ -165689,7 +165932,7 @@ class BootstrapService {
       return { ...noopResult("no-signals"), signalCount };
     }
     const capped = seeds.slice(0, cfg.maxSeedMemories);
-    const bootstrapId = `boot-${Date.now()}-${randomUUID9().slice(0, 8)}`;
+    const bootstrapId = `boot-${Date.now()}-${randomUUID10().slice(0, 8)}`;
     let ids;
     try {
       ids = await storeSeeds(this.memoryRepo, projectId, bootstrapId, capped, signals);
@@ -165749,7 +165992,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of README_CANDIDATES) {
-      const p = path37.join(projectRoot, name26);
+      const p = path38.join(projectRoot, name26);
       if (fs24.existsSync(p) && fs24.statSync(p).isFile()) {
         const buf = fs24.readFileSync(p);
         signals.readme = buf.slice(0, MAX_README_BYTES).toString("utf8");
@@ -165760,14 +166003,14 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
     logger.debug("bootstrap scan: README read failed", { error: e.message });
   }
   try {
-    const docsDir = path37.join(projectRoot, "docs");
+    const docsDir = path38.join(projectRoot, "docs");
     if (fs24.existsSync(docsDir) && fs24.statSync(docsDir).isDirectory()) {
       const entries = walkMarkdown(docsDir).slice(0, MAX_DOCS);
       for (const rel of entries) {
         try {
           const buf = fs24.readFileSync(rel);
           signals.docs.push({
-            path: path37.relative(projectRoot, rel),
+            path: path38.relative(projectRoot, rel),
             snippet: buf.slice(0, MAX_DOC_BYTES).toString("utf8")
           });
         } catch {}
@@ -165778,7 +166021,7 @@ async function scanSignals(_projectId, projectRoot, caps, symbolGraph, gitRunner
   }
   try {
     for (const name26 of MANIFEST_FILES) {
-      const p = path37.join(projectRoot, name26);
+      const p = path38.join(projectRoot, name26);
       if (!fs24.existsSync(p) || !fs24.statSync(p).isFile())
         continue;
       const raw2 = fs24.readFileSync(p).slice(0, MAX_MANIFEST_BYTES).toString("utf8");
@@ -165826,7 +166069,7 @@ function walkMarkdown(dir) {
       continue;
     }
     for (const e of entries) {
-      const full = path37.join(cur, e.name);
+      const full = path38.join(cur, e.name);
       if (e.isDirectory()) {
         if (e.name === "node_modules" || e.name.startsWith("."))
           continue;
@@ -165943,7 +166186,7 @@ async function storeSeeds(memoryRepo, projectId, bootstrapId, seeds, signals) {
   const ids = [];
   const signalCount = countSignals(signals);
   for (const seed of seeds) {
-    const id = `seed-${Date.now()}-${randomUUID9().slice(0, 8)}`;
+    const id = `seed-${Date.now()}-${randomUUID10().slice(0, 8)}`;
     const input = {
       id,
       content: truncate3(seed.summary, MAX_SUMMARY_CHARS),
@@ -166057,7 +166300,7 @@ var init_bootstrap_service = __esm(() => {
   MAX_DOC_BYTES = 2 * 1024;
   MAX_MANIFEST_BYTES = 2 * 1024;
   SeedMemorySchema = exports_external.object({
-    summary: exports_external.string().min(1).max(MAX_SUMMARY_CHARS),
+    summary: exports_external.string().min(1),
     type: exports_external.enum(["pattern", "code", "decision"]),
     level: exports_external.union([exports_external.literal(0), exports_external.literal(1), exports_external.literal(2)]),
     importance: exports_external.number().min(0).max(1),
@@ -166650,7 +166893,9 @@ var init_handoff_auto_injector = __esm(() => {
 var exports_dist = {};
 __export(exports_dist, {
   workspaceManager: () => workspaceManager,
+  withHeavyWorkLease: () => withHeavyWorkLease,
   validateEvent: () => validateEvent,
+  validateEnum: () => validateEnum,
   validateAllGrammars: () => validateAllGrammars,
   tracePathService: () => tracePathService,
   toSymbolIdentityResolution: () => toSymbolIdentityResolution,
@@ -166694,6 +166939,7 @@ __export(exports_dist, {
   recordSearchDegradation: () => recordSearchDegradation,
   quoteDiscoveredIdentifier: () => quoteDiscoveredIdentifier,
   projectNotIndexed: () => projectNotIndexed,
+  probeHeavyWork: () => probeHeavyWork,
   payloadStorePolicies: () => payloadStorePolicies,
   parseStructuralFqn: () => parseStructuralFqn,
   parseProjectIdentityPreviewRequest: () => parseProjectIdentityPreviewRequest,
@@ -166824,6 +167070,7 @@ __export(exports_dist, {
   UNKNOWN_ACTOR: () => UNKNOWN_ACTOR,
   TracePathTool: () => TracePathTool,
   TracePathService: () => TracePathService,
+  ToolError: () => ToolError,
   TokenMetrics: () => TokenMetrics,
   TaskEnvelopeService: () => TaskEnvelopeService,
   TYPESCRIPT_RESOLVER_VERSION: () => TYPESCRIPT_RESOLVER_VERSION,
@@ -167000,6 +167247,7 @@ var init_dist15 = __esm(() => {
   init_proposal_repository();
   init_proposal_payload_validation();
   init_auto_improve_job();
+  init_enum_validation();
   init_tools();
   init_services();
   init_graph_generation();
@@ -169467,7 +169715,7 @@ init_dist();
 init_dist15();
 init_dist();
 import fs25 from "fs/promises";
-import path38 from "path";
+import path39 from "path";
 var _indexProjectTool = null;
 function indexProjectTool() {
   if (!_indexProjectTool)
@@ -169770,7 +170018,7 @@ class EmbeddedApiClient {
         } else {
           end = start + 20;
         }
-        const absolutePath = path38.join(workspace.project_path, file2);
+        const absolutePath = path39.join(workspace.project_path, file2);
         const content = await fs25.readFile(absolutePath, "utf-8");
         const lines = content.split(/\r?\n/);
         const slice = lines.slice(start - 1, Math.min(lines.length, end));
@@ -170026,21 +170274,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 || path38.join(getGlobalDataDir(), "uploads");
-    const stagingDir = path38.resolve(uploadRoot, finalProjectId);
+    const uploadRoot = process.env.MASSA_AI_UPLOAD_DIR || path39.join(getGlobalDataDir(), "uploads");
+    const stagingDir = path39.resolve(uploadRoot, finalProjectId);
     await fs25.rm(stagingDir, { recursive: true, force: true });
     await fs25.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 (path38.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
+        if (path39.isAbsolute(file2.relativePath) || file2.relativePath.includes("..")) {
           throw new Error(`Invalid file path: ${file2.relativePath}`);
         }
-        const dest = path38.resolve(stagingDir, file2.relativePath.replace(/\//g, path38.sep));
-        if (!dest.startsWith(stagingDir + path38.sep)) {
+        const dest = path39.resolve(stagingDir, file2.relativePath.replace(/\//g, path39.sep));
+        if (!dest.startsWith(stagingDir + path39.sep)) {
           throw new Error(`Path escapes staging directory: ${file2.relativePath}`);
         }
-        await fs25.mkdir(path38.dirname(dest), { recursive: true });
+        await fs25.mkdir(path39.dirname(dest), { recursive: true });
         await fs25.writeFile(dest, file2.content, "utf-8");
       }));
     }
@@ -170100,37 +170348,39 @@ class EmbeddedApiClient {
       return { success: false, error: "projectId is required" };
     const result = {};
     const errors4 = [];
-    if (clearVectors) {
-      try {
-        const vectorStore = await getVectorStore();
-        const keywordSearch = getKeywordSearch();
-        const [vectorsDeleted, keywordsDeleted] = await Promise.all([
-          vectorStore.deleteByProject(projectId),
-          keywordSearch.deleteByProject(projectId)
-        ]);
-        result.vectorsDeleted = vectorsDeleted;
-        result.keywordsDeleted = keywordsDeleted;
-      } catch (e) {
-        errors4.push(`vectors: ${e.message}`);
+    await withHeavyWorkLease("maintenance", `project-reset:${projectId}`, async () => {
+      if (clearVectors) {
+        try {
+          const vectorStore = await getVectorStore();
+          const keywordSearch = getKeywordSearch();
+          const [vectorsDeleted, keywordsDeleted] = await Promise.all([
+            vectorStore.deleteByProject(projectId),
+            keywordSearch.deleteByProject(projectId)
+          ]);
+          result.vectorsDeleted = vectorsDeleted;
+          result.keywordsDeleted = keywordsDeleted;
+        } catch (e) {
+          errors4.push(`vectors: ${e.message}`);
+        }
       }
-    }
-    if (clearSymbols) {
-      try {
-        await workspaceManager.removeWorkspace(projectId);
-        result.symbolsDeleted = "ok";
-      } catch (e) {
-        errors4.push(`symbols: ${e.message}`);
+      if (clearSymbols) {
+        try {
+          await workspaceManager.removeWorkspace(projectId);
+          result.symbolsDeleted = "ok";
+        } catch (e) {
+          errors4.push(`symbols: ${e.message}`);
+        }
       }
-    }
-    if (clearMemories) {
-      try {
-        const repo = getMemoryRepository();
-        const deleted = await repo.deleteByProject(projectId);
-        result.memoriesDeleted = deleted;
-      } catch (e) {
-        errors4.push(`memories: ${e.message}`);
+      if (clearMemories) {
+        try {
+          const repo = getMemoryRepository();
+          const deleted = await repo.deleteByProject(projectId);
+          result.memoriesDeleted = deleted;
+        } catch (e) {
+          errors4.push(`memories: ${e.message}`);
+        }
       }
-    }
+    });
     return {
       success: errors4.length === 0,
       data: { projectId, ...result, errors: errors4, message: `Project '${projectId}' reset complete.` }
@@ -170542,7 +170792,7 @@ class EmbeddedApiClient {
 // src/file-collector.ts
 init_config();
 import fs26 from "fs/promises";
-import path39 from "path";
+import path40 from "path";
 var SKIP_DIRS = new Set([
   "node_modules",
   ".git",
@@ -170558,11 +170808,21 @@ var SKIP_DIRS = new Set([
   ".cache",
   "vendor",
   ".svn",
-  ".hg"
+  ".hg",
+  "Pods"
 ]);
 var MAX_FILE_BYTES = 512 * 1024;
-var MAX_TOTAL_BYTES = 50 * 1024 * 1024;
-var MAX_FILES = 3000;
+var MAX_TOTAL_BYTES = 150 * 1024 * 1024;
+var MAX_FILES = 15000;
+async function getIncludeDirs(projectPath2) {
+  try {
+    const raw2 = await fs26.readFile(path40.join(projectPath2, ".massa-ai-collect"), "utf-8");
+    return raw2.split(`
+`).map((s) => s.trim().replace(/^\/+|\/+$/g, "")).filter((s) => s && !s.startsWith("#"));
+  } catch {
+    return [];
+  }
+}
 function getAllowedExtensions() {
   try {
     const list = config2.get("security").allowedExtensions;
@@ -170575,7 +170835,16 @@ async function collectFiles(projectPath2) {
   const files = [];
   const state = { totalBytes: 0 };
   const allowed = getAllowedExtensions();
-  await walk2(projectPath2, projectPath2, files, state, allowed);
+  const includeDirs = await getIncludeDirs(projectPath2);
+  if (includeDirs.length === 0) {
+    await walk2(projectPath2, projectPath2, files, state, allowed);
+  } else {
+    for (const top of includeDirs) {
+      if (files.length >= MAX_FILES || state.totalBytes >= MAX_TOTAL_BYTES)
+        break;
+      await walk2(projectPath2, path40.join(projectPath2, top), files, state, allowed);
+    }
+  }
   return files;
 }
 async function walk2(root2, dir, files, state, allowed) {
@@ -170592,13 +170861,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, path39.join(dir, entry2.name), files, state, allowed);
+        await walk2(root2, path40.join(dir, entry2.name), files, state, allowed);
       }
     } else if (entry2.isFile()) {
-      const ext2 = path39.extname(entry2.name).toLowerCase();
+      const ext2 = path40.extname(entry2.name).toLowerCase();
       if (!allowed.has(ext2))
         continue;
-      const fullPath = path39.join(dir, entry2.name);
+      const fullPath = path40.join(dir, entry2.name);
       try {
         const stat = await fs26.stat(fullPath);
         if (stat.size > MAX_FILE_BYTES)
@@ -170607,7 +170876,7 @@ async function walk2(root2, dir, files, state, allowed) {
           continue;
         const content = await fs26.readFile(fullPath, "utf-8");
         state.totalBytes += stat.size;
-        const relativePath = path39.relative(root2, fullPath).split(path39.sep).join("/");
+        const relativePath = path40.relative(root2, fullPath).split(path40.sep).join("/");
         files.push({ relativePath, content });
       } catch {}
     }