@massa-ai/mcp-client 1.63.1 → 1.65.0

package/dist/config-cli.js

@@ -3540,22 +3540,15 @@ var BOOTSTRAP_RULE_IDS, RETIRED_RULE_IDS, BOOTSTRAP_RULES, RULES_BY_ID, Bootstra
 };
 var init_rules = __esm(() => {
   BOOTSTRAP_RULE_IDS = [
-    "caveman",
     "massa-ai-router",
     "dedupe-guardrails",
-    "plan-challenge",
     "conversation-feedback",
     "indexing-hygiene",
     "english-code",
     "code-comments"
   ];
-  RETIRED_RULE_IDS = ["persona-router"];
+  RETIRED_RULE_IDS = ["persona-router", "caveman", "plan-challenge"];
   BOOTSTRAP_RULES = [
-    {
-      id: "caveman",
-      defaultEnabled: true,
-      description: "Keep communication compressed while preserving technical accuracy."
-    },
     {
       id: "massa-ai-router",
       defaultEnabled: true,
@@ -3566,11 +3559,6 @@ var init_rules = __esm(() => {
       defaultEnabled: true,
       description: "Reuse already-loaded massa-ai context instead of bulk-loading workflows or references."
     },
-    {
-      id: "plan-challenge",
-      defaultEnabled: true,
-      description: "Run The Fool as a post-plan challenge gate per the configured policy."
-    },
     {
       id: "conversation-feedback",
       defaultEnabled: true,
@@ -10202,7 +10190,8 @@ var init_ignore_patterns = __esm(() => {
     "**/pnpm-lock.yaml",
     "**/package-lock.json",
     "**/bun.lockb",
-    "**/yarn.lock"
+    "**/yarn.lock",
+    "**/Pods/**"
   ];
 });
 
@@ -117758,6 +117747,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(() => {
@@ -117795,10 +117811,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;
@@ -117840,7 +117957,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", {
@@ -117880,7 +117997,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,
@@ -117951,7 +118068,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",
@@ -118004,25 +118121,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,
@@ -118071,7 +118170,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 = config.get("security").maxFileSize || 1024 * 1024;
   if (content.length > maxFileSize) {
     logger.warn("File too large, skipping", {
@@ -118091,7 +118190,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,
@@ -118116,6 +118215,7 @@ var init_project_indexer = __esm(() => {
   init_managed_run_repository_pg();
   init_symbol_repo_workspace();
   init_embedding_freshness();
+  init_incremental_reindex();
   globAsync2 = glob;
 });
 
@@ -120483,7 +120583,7 @@ __export(exports_memory_consolidation_job, {
   memoryConsolidationJob: () => memoryConsolidationJob,
   MemoryConsolidationJob: () => MemoryConsolidationJob
 });
-import { randomUUID as randomUUID4 } from "crypto";
+import { randomUUID as randomUUID5 } from "crypto";
 async function addSupercedesEdge(store2, newId, sourceId, batchId) {
   const evidence = JSON.stringify({ batchId, consolidated: true });
   await store2.createEdge({
@@ -120627,11 +120727,11 @@ class MemoryConsolidationJob {
       });
       return { merged: 0, batchesCreated: 0 };
     }
-    const batch = await consolidateWindow(rowsToCandidates(candidates), this.llm, { idFactory: () => `batch-${now2}-${randomUUID4().slice(0, 8)}` }).catch(() => null);
+    const batch = await consolidateWindow(rowsToCandidates(candidates), this.llm, { idFactory: () => `batch-${now2}-${randomUUID5().slice(0, 8)}` }).catch(() => null);
     if (!batch)
       return { merged: 0, batchesCreated: 0 };
     const sourceRows = candidates.filter((c) => batch.sourceIds.includes(c.id));
-    const newId = `mem-${now2}-${randomUUID4().slice(0, 8)}`;
+    const newId = `mem-${now2}-${randomUUID5().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 {
@@ -121828,8 +121928,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();
@@ -121939,7 +122039,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() {
@@ -121964,6 +122064,7 @@ var init_workspace_manager = __esm(() => {
   init_symbol_repository_factory();
   init_event_bus();
   init_symbol_graph_service();
+  init_heavy_work_lease();
   workspaceManager = WorkspaceManager.getInstance();
 });
 
@@ -122649,16 +122750,16 @@ function detectRoutes(httpEdges, defs, opts = {}) {
   const seen = new Set;
   const out = [];
   for (const e of httpEdges) {
-    const path22 = e.route;
-    if (!path22)
+    const path23 = e.route;
+    if (!path23)
       continue;
     const method = (e.method ?? "ANY").toUpperCase();
-    const key = method + " " + path22;
+    const key = method + " " + path23;
     if (seen.has(key))
       continue;
     seen.add(key);
     out.push({
-      path: path22,
+      path: path23,
       method: e.method,
       file: e.fromFile,
       handler: e.targetFqn ?? e.symbolName
@@ -122669,12 +122770,12 @@ function detectRoutes(httpEdges, defs, opts = {}) {
       continue;
     const parsed = parseRouteName(d.name);
     const method = parsed?.method ?? "ANY";
-    const path22 = parsed?.path ?? d.name;
-    const key = method + " " + path22;
+    const path23 = parsed?.path ?? d.name;
+    const key = method + " " + path23;
     if (seen.has(key))
       continue;
     seen.add(key);
-    out.push({ path: path22, method: parsed?.method, file: d.filePath, handler: d.name });
+    out.push({ path: path23, method: parsed?.method, file: d.filePath, handler: d.name });
   }
   for (const d of defs) {
     const parsed = parseRouteName(d.name);
@@ -122895,7 +122996,7 @@ __export(exports_symbol_graph_service, {
   symbolGraphService: () => symbolGraphService,
   SymbolGraphService: () => SymbolGraphService
 });
-import path22 from "path";
+import path23 from "path";
 import fs16 from "fs/promises";
 
 class SymbolGraphService {
@@ -123249,7 +123350,7 @@ class SymbolGraphService {
   }
   async resolveToAbsolute(relativePath, projectId) {
     const root = await this.getProjectRoot(projectId);
-    return root ? path22.resolve(root, relativePath) : relativePath;
+    return root ? path23.resolve(root, relativePath) : relativePath;
   }
   async getProjectRoot(projectId) {
     const cached2 = this.projectRootCache.get(projectId);
@@ -125032,31 +125133,31 @@ class TracePathService {
     const chains = [];
     const seen = new Set;
     let walks = 0;
-    const walk = (fqn, path23) => {
+    const walk = (fqn, path24) => {
       if (chains.length >= CHAIN_CAP)
         return;
       if (walks >= MAX_WALKS)
         return;
       walks++;
-      const key = path23.join("\u2192");
+      const key = path24.join("\u2192");
       if (seen.has(key))
         return;
       seen.add(key);
       const next = adj.get(fqn);
       if (!next || next.length === 0 || !whoHasChild.has(fqn)) {
-        if (path23.length > 1)
-          chains.push(path23.map((n) => this.fqnToName(n)).join(" \u2192 "));
+        if (path24.length > 1)
+          chains.push(path24.map((n) => this.fqnToName(n)).join(" \u2192 "));
         return;
       }
       for (const child of next) {
         if (chains.length >= CHAIN_CAP || walks >= MAX_WALKS)
           return;
-        if (path23.includes(child)) {
-          const cycled = [...path23, `${this.fqnToName(child)}\u21BA`];
+        if (path24.includes(child)) {
+          const cycled = [...path24, `${this.fqnToName(child)}\u21BA`];
           chains.push(cycled.map((n) => n).join(" \u2192 "));
           continue;
         }
-        walk(child, [...path23, child]);
+        walk(child, [...path24, child]);
       }
     };
     for (const seed of seeds) {
@@ -126778,12 +126879,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();
@@ -127081,7 +127183,7 @@ var init_inference_probe = __esm(() => {
 // ../../packages/core/dist/services/health/local-health-checker.js
 import fs17 from "fs/promises";
 import { existsSync as existsSync3 } from "fs";
-import path23 from "path";
+import path24 from "path";
 
 class LocalHealthChecker {
   dataDir = config.get("dataDir");
@@ -127160,7 +127262,7 @@ class LocalHealthChecker {
     try {
       if (!existsSync3(this.dataDir))
         await fs17.mkdir(this.dataDir, { recursive: true });
-      const probe = path23.join(this.dataDir, ".health-check-test");
+      const probe = path24.join(this.dataDir, ".health-check-test");
       await fs17.writeFile(probe, "ok");
       await fs17.unlink(probe);
       return { available: true, latency: Date.now() - start, details: { path: this.dataDir, writable: true } };
@@ -127550,7 +127652,7 @@ var init_index_job_store = __esm(() => {
 });
 
 // ../../packages/core/dist/services/jobs/index-job-tracker.js
-import { randomUUID as randomUUID5 } from "crypto";
+import { randomUUID as randomUUID6 } from "crypto";
 
 class IndexJobTracker {
   static instance;
@@ -127574,7 +127676,7 @@ class IndexJobTracker {
     return IndexJobTracker.instance;
   }
   createJob(projectId, projectPath) {
-    const jobId = randomUUID5();
+    const jobId = randomUUID6();
     const job = {
       jobId,
       projectId,
@@ -127664,7 +127766,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)
@@ -128064,6 +128168,9 @@ class PgScheduledJobStore {
     }, "save");
     this.ensureHydrated();
   }
+  async ready() {
+    await this.ensureHydrated();
+  }
   get(id) {
     this.ensureHydrated();
     return this.mirror.get(id) ?? null;
@@ -128140,10 +128247,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 = config.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;
@@ -128244,31 +128359,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) {
@@ -128276,17 +128403,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++;
@@ -128296,7 +128453,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,
@@ -128318,7 +128475,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", {
@@ -128378,6 +128570,9 @@ class Scheduler {
       }
     })();
   }
+  async ready() {
+    await this.store.ready?.();
+  }
   status(now2 = Date.now()) {
     const jobs = this.store.listAll();
     return {
@@ -128392,10 +128587,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) {
@@ -128414,12 +128616,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
@@ -129328,7 +129531,7 @@ var init_auto_improve_llm = __esm(() => {
 });
 
 // ../../packages/core/dist/services/jobs/auto-improve-apply.js
-import { randomUUID as randomUUID6 } from "crypto";
+import { randomUUID as randomUUID7 } 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)) {
@@ -129369,7 +129572,7 @@ function buildUpdatePatch(p) {
   return patch;
 }
 async function applyProposal(job, record2) {
-  const memId = record2.targetMemoryId ?? `proposal-mem-${record2.id}-${randomUUID6().slice(0, 8)}`;
+  const memId = record2.targetMemoryId ?? `proposal-mem-${record2.id}-${randomUUID7().slice(0, 8)}`;
   const p = record2.payload;
   if (record2.kind === "memory.create") {
     validateCreatePayload(p);
@@ -129636,8 +129839,8 @@ __export(exports_auto_improve_job, {
 
 class AutoImproveJob {
   llm;
-  observationStore;
-  proposalStore;
+  injectedObservationStore;
+  injectedProposalStore;
   memoryRepo;
   thresholds;
   minObservations;
@@ -129648,10 +129851,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());
@@ -129731,7 +129940,7 @@ __export(exports_observation_consolidation_job, {
   observationConsolidationJob: () => observationConsolidationJob,
   ObservationConsolidationJob: () => ObservationConsolidationJob
 });
-import { randomUUID as randomUUID7 } from "crypto";
+import { randomUUID as randomUUID8 } from "crypto";
 function readBridgeConfig() {
   try {
     const c = config.get("hooks")?.bridge;
@@ -129749,7 +129958,7 @@ function readBridgeConfig() {
 
 class ObservationConsolidationJob {
   llm;
-  store;
+  injectedStore;
   memoryRepo;
   minObservations;
   minIntervalMs;
@@ -129757,9 +129966,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();
@@ -129821,7 +130033,7 @@ class ObservationConsolidationJob {
     if (observations.length < 2)
       return noop2;
     const window2 = observations.slice(0, this.maxWindow);
-    const batchId = `obs-batch-${Date.now()}-${randomUUID7().slice(0, 8)}`;
+    const batchId = `obs-batch-${Date.now()}-${randomUUID8().slice(0, 8)}`;
     const prompt = buildObservationPrompt(window2);
     let batch;
     try {
@@ -129847,7 +130059,7 @@ class ObservationConsolidationJob {
     }
     if (!batch)
       return noop2;
-    const newId = `mem-${Date.now()}-${randomUUID7().slice(0, 8)}`;
+    const newId = `mem-${Date.now()}-${randomUUID8().slice(0, 8)}`;
     const importance = 0.7;
     try {
       await Promise.resolve(this.memoryRepo.insert({
@@ -130465,7 +130677,7 @@ var init_scheduler2 = __esm(() => {
 // ../../packages/core/dist/services/pricing/models-dev-client.js
 import fs18 from "fs/promises";
 import { existsSync as existsSync4 } from "fs";
-import path24 from "path";
+import path25 from "path";
 function getModelsDevClient() {
   if (!clientInstance) {
     clientInstance = new ModelsDevClient;
@@ -130485,7 +130697,7 @@ var init_models_dev_client = __esm(() => {
     memoryCacheTimestamp = 0;
     getLocalCachePath() {
       const dataDir = config.get("dataDir");
-      return path24.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
+      return path25.join(dataDir, ModelsDevClient.LOCAL_CACHE_FILE);
     }
     async loadLocalCache() {
       const cachePath = this.getLocalCachePath();
@@ -130520,7 +130732,7 @@ var init_models_dev_client = __esm(() => {
     async saveLocalCache(models) {
       const cachePath = this.getLocalCachePath();
       try {
-        const dir = path24.dirname(cachePath);
+        const dir = path25.dirname(cachePath);
         await fs18.mkdir(dir, { recursive: true });
         const data = {
           timestamp: Date.now(),
@@ -131462,7 +131674,7 @@ function stripNul(content) {
 
 // ../../packages/core/dist/services/etl/stages/discover.js
 import fs19 from "fs/promises";
-import path25 from "path";
+import path26 from "path";
 import { createHash as createHash8 } from "crypto";
 
 class DiscoverStage {
@@ -131488,7 +131700,7 @@ class DiscoverStage {
         dot: false,
         absolute: false
       });
-      relPaths = found.map((p) => path25.isAbsolute(p) ? path25.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
+      relPaths = found.map((p) => path26.isAbsolute(p) ? path26.relative(ctx.projectPath, p) : p).filter((p) => !ig.ignores(p) && applyPolicy(p, policy) !== "Drop");
     }
     if (ctx.resumeCursor?.path) {
       const cursorPath = ctx.resumeCursor.path;
@@ -131547,7 +131759,7 @@ class DiscoverStage {
     return discovered;
   }
   async processFile(ctx, relativePath, forceReindex) {
-    const absolutePath = path25.join(ctx.projectPath, relativePath);
+    const absolutePath = path26.join(ctx.projectPath, relativePath);
     try {
       const stat = await fs19.stat(absolutePath);
       const content = stripNul(await fs19.readFile(absolutePath, "utf-8"));
@@ -131594,7 +131806,7 @@ class DiscoverStage {
       ig.add(pattern);
     }
     try {
-      const gitignorePath = path25.join(projectPath, ".gitignore");
+      const gitignorePath = path26.join(projectPath, ".gitignore");
       const gitignoreContent = await fs19.readFile(gitignorePath, "utf8");
       const rules = gitignoreContent.split(`
 `).map((line) => line.trim()).filter((line) => line && !line.startsWith("#"));
@@ -132950,8 +133162,8 @@ function rustUseLeaves(node, source, prefix = []) {
   }
   if (node.type === "use_wildcard")
     return [{ path: [...prefix, "*"], glob: true }];
-  const path26 = rustPathSegments(node, source);
-  return path26.length ? [{ path: [...prefix, ...path26] }] : [];
+  const path27 = rustPathSegments(node, source);
+  return path27.length ? [{ path: [...prefix, ...path27] }] : [];
 }
 function functionalCaptures(captures, source, family) {
   if (family !== "clojure")
@@ -133923,7 +134135,7 @@ var init_structural_runtime = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/parse.js
-import path26 from "path";
+import path27 from "path";
 import fs20 from "fs/promises";
 function resolveChunkerMaxChars() {
   const global2 = Number(process.env.EMBEDDING_MAX_CHARS);
@@ -133952,8 +134164,8 @@ class ParseStage {
     const results = new Map;
     let processed = 0;
     const phases = [
-      files.filter((file2) => path26.extname(file2.relativePath).toLowerCase() !== ".h"),
-      files.filter((file2) => path26.extname(file2.relativePath).toLowerCase() === ".h")
+      files.filter((file2) => path27.extname(file2.relativePath).toLowerCase() !== ".h"),
+      files.filter((file2) => path27.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) {
@@ -133991,19 +134203,19 @@ class ParseStage {
     return files.map((file2) => results.get(file2.relativePath));
   }
   recordHeaderImporterEvidence(ctx, files, parsedFiles) {
-    const knownHeaders = new Set(files.filter((file2) => path26.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path26.posix.normalize(file2.relativePath)));
+    const knownHeaders = new Set(files.filter((file2) => path27.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path27.posix.normalize(file2.relativePath)));
     const mutable = {
       ...ctx.structuralHeaderEvidenceByFile
     };
     for (const parsed of parsedFiles) {
-      const extension = path26.extname(parsed.file.relativePath).toLowerCase();
+      const extension = path27.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 = path26.posix.normalize(path26.posix.join(path26.posix.dirname(parsed.file.relativePath), imported.specifier));
+        const header = path27.posix.normalize(path27.posix.join(path27.posix.dirname(parsed.file.relativePath), imported.specifier));
         if (!knownHeaders.has(header))
           continue;
         const existing = mutable[header] ?? {};
@@ -134014,7 +134226,7 @@ class ParseStage {
   }
   async parseFile(ctx, file2) {
     if (!file2.needsReparse) {
-      const extension = path26.extname(file2.relativePath).toLowerCase();
+      const extension = path27.extname(file2.relativePath).toLowerCase();
       if ([".c", ".cpp", ".hpp"].includes(extension)) {
         const content = file2.snapshotContent ?? await fs20.readFile(file2.absolutePath, "utf8");
         const outcome = await this.runtime.parse({ extension, source: Buffer.from(content) });
@@ -134029,7 +134241,7 @@ class ParseStage {
     }
     try {
       const content = file2.snapshotContent ?? await fs20.readFile(file2.absolutePath, "utf-8");
-      const ext2 = path26.extname(file2.relativePath).toLowerCase();
+      const ext2 = path27.extname(file2.relativePath).toLowerCase();
       const chunkerMaxChars = resolveChunkerMaxChars();
       const chunks = smartChunk(content, file2.relativePath, chunkerMaxChars ? { maxChunkChars: chunkerMaxChars } : {});
       let symbols;
@@ -134584,7 +134796,7 @@ var init_resolver = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/typescript.js
-import path27 from "path";
+import path28 from "path";
 function candidates(identities) {
   return Object.freeze(identities.map((identity) => Object.freeze({
     fqn: identity.fqn,
@@ -134679,7 +134891,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 = path27.posix.normalize(`${candidateBase}${suffix}`);
+      const value = path28.posix.normalize(`${candidateBase}${suffix}`);
       if (!value.startsWith("../") && value !== ".." && known.has(value))
         return value;
     }
@@ -134688,7 +134900,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(path27.posix.join(path27.posix.dirname(fromFile), specifier), known, dialect);
+    return probe(path28.posix.join(path28.posix.dirname(fromFile), specifier), known, dialect);
   }
   const aliases = build.pathAliasesByFile?.[normalizeStructuralFile(fromFile)] ?? build.pathAliases ?? [];
   for (const alias of aliases) {
@@ -134952,7 +135164,7 @@ var init_scripting2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/structural/resolvers/systems.js
-import path28 from "path";
+import path29 from "path";
 var DIALECTS, SYSTEMS_LANGUAGE_RESOLVER;
 var init_systems2 = __esm(() => {
   init_typescript2();
@@ -134971,7 +135183,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: `./${path28.posix.relative(path28.posix.dirname(file2.file), path28.posix.join(crateRoot, item.specifier.replace(/^crate\/?/u, "")))}` };
+            return { ...item, bindings, specifier: `./${path29.posix.relative(path29.posix.dirname(file2.file), path29.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, "")}` };
@@ -135069,7 +135281,7 @@ var init_data_document2 = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/resolve.js
-import path29 from "path";
+import path30 from "path";
 import fs21 from "fs";
 
 class ResolveStage {
@@ -135094,7 +135306,7 @@ class ResolveStage {
     const structuralDocuments = files.flatMap((file2) => {
       if (!file2.structure)
         return [];
-      const language = resolveStructuralLanguage(path29.extname(file2.file.relativePath));
+      const language = resolveStructuralLanguage(path30.extname(file2.file.relativePath));
       if (language.status !== "supported")
         throw new Error(`structural_manifest_missing:${file2.file.relativePath}`);
       return [{
@@ -135106,13 +135318,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(path29.extname(item.file.relativePath).toLowerCase())).map((item) => item.file.relativePath));
+    const skippedStructuralFiles = new Set(files.filter((item) => !item.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path30.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(path29.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(path30.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))
@@ -135209,7 +135421,7 @@ class ResolveStage {
     if (parsed.file !== definition.file_path) {
       throw new Error(`structural_repository_seed_file_mismatch:${definition.id}`);
     }
-    const language = resolveStructuralLanguage(path29.extname(definition.file_path));
+    const language = resolveStructuralLanguage(path30.extname(definition.file_path));
     if (language.status !== "supported")
       throw new Error(`structural_repository_seed_language:${definition.id}`);
     let identity;
@@ -135261,7 +135473,7 @@ class ResolveStage {
     });
   }
   resolveFile(parsed, projectPath, knownRelPaths, rootAliases, monorepoPackages, symbolIndex, knownFqns) {
-    const fromDir = path29.dirname(path29.join(projectPath, parsed.file.relativePath));
+    const fromDir = path30.dirname(path30.join(projectPath, parsed.file.relativePath));
     const packageAliases = this.getPackageAliases(parsed.file.relativePath, monorepoPackages);
     const allAliases = [...packageAliases, ...rootAliases];
     const resolvedImports = parsed.rawImports.map((raw2) => {
@@ -135332,7 +135544,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(path29.extname(file2.file.relativePath).toLowerCase()));
+      const skippedStructural = files.some((file2) => !file2.file.needsReparse && STRUCTURAL_SEED_EXTENSIONS.has(path30.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", {
@@ -135356,7 +135568,7 @@ class ResolveStage {
   }
   resolveSpecifier(specifier, fromDir, projectPath, knownRelPaths, aliases) {
     if (specifier.startsWith("./") || specifier.startsWith("../")) {
-      const resolved = this.probeExtensions(path29.resolve(fromDir, specifier), projectPath, knownRelPaths);
+      const resolved = this.probeExtensions(path30.resolve(fromDir, specifier), projectPath, knownRelPaths);
       return { resolvedPath: resolved, external: false };
     }
     for (const alias of aliases) {
@@ -135364,8 +135576,8 @@ class ResolveStage {
         const suffix = specifier.slice(alias.prefix.length);
         for (const target of alias.targets) {
           const cleanTarget = target.replace(/\/\*$/, "");
-          const basePath = alias.packagePath ? path29.join(projectPath, alias.packagePath) : projectPath;
-          const absPath = path29.join(basePath, cleanTarget + suffix);
+          const basePath = alias.packagePath ? path30.join(projectPath, alias.packagePath) : projectPath;
+          const absPath = path30.join(basePath, cleanTarget + suffix);
           const resolved = this.probeExtensions(absPath, projectPath, knownRelPaths);
           if (resolved)
             return { resolvedPath: resolved, external: false };
@@ -135381,7 +135593,7 @@ class ResolveStage {
       ...TS_EXTENSIONS.map((ext2) => absPath.replace(/\.[^.]+$/, ext2))
     ];
     for (const candidate2 of candidates2) {
-      const rel = path29.relative(projectPath, candidate2).replace(/\\/g, "/");
+      const rel = path30.relative(projectPath, candidate2).replace(/\\/g, "/");
       if (knownRelPaths.has(rel))
         return rel;
     }
@@ -135389,7 +135601,7 @@ class ResolveStage {
   }
   loadTsConfigPaths(projectPath, packageBase) {
     const aliases = [];
-    const tsconfigPath = path29.join(projectPath, "tsconfig.json");
+    const tsconfigPath = path30.join(projectPath, "tsconfig.json");
     try {
       const raw2 = fs21.readFileSync(tsconfigPath, "utf-8");
       const stripped = raw2.replace(/\/\/[^\n]*/g, "").replace(/\/\*[\s\S]*?\*\//g, "");
@@ -135420,7 +135632,7 @@ class ResolveStage {
       }
     }
     for (const packageRelPath of packagePaths) {
-      const absPackagePath = path29.join(projectPath, packageRelPath);
+      const absPackagePath = path30.join(projectPath, packageRelPath);
       const aliases = this.loadTsConfigPaths(absPackagePath, packageRelPath);
       if (aliases.length > 0) {
         packages.push({
@@ -135450,7 +135662,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 ? path29.posix.join(alias.packagePath, target) : target)
+      targets: alias.targets.map((target) => alias.packagePath ? path30.posix.join(alias.packagePath, target) : target)
     }));
   }
 }
@@ -135514,7 +135726,7 @@ var init_with_deadlock_retry = __esm(() => {
 });
 
 // ../../packages/core/dist/services/etl/stages/load.js
-import path30 from "path";
+import path31 from "path";
 function formatDuration(ms) {
   const totalSec = Math.max(0, Math.round(ms / 1000));
   if (totalSec < 60)
@@ -135791,7 +136003,7 @@ class LoadStage {
     const filePath = file2.file.relativePath;
     const batch = buildSymbolPersistenceBatch(ctx.projectId, file2);
     if (ctx.graphGenerationLease) {
-      const manifest = getLanguageManifestEntry(path30.extname(filePath));
+      const manifest = getLanguageManifestEntry(path31.extname(filePath));
       const diagnostics2 = (file2.structuralDiagnostics ?? []).slice(0, 10).map((diagnostic2) => ({
         code: diagnostic2.code,
         severity: diagnostic2.severity,
@@ -135843,7 +136055,7 @@ var init_load = __esm(() => {
 });
 
 // ../../packages/core/dist/data/graph-generation/graph-generation-repository-pg.js
-import { randomUUID as randomUUID8 } from "crypto";
+import { randomUUID as randomUUID9 } from "crypto";
 function boundedText2(value, label, max = 512) {
   const normalized = value.normalize("NFC").trim();
   if (!normalized || normalized.length > max || normalized.includes("\x00")) {
@@ -135947,8 +136159,8 @@ class GraphGenerationRepositoryPg {
   }
   async begin(rawInput) {
     const input = validateBegin2(rawInput);
-    const generationId = randomUUID8();
-    const leaseToken = randomUUID8();
+    const generationId = randomUUID9();
+    const leaseToken = randomUUID9();
     return getPrismaClient2().$transaction(async (tx) => {
       const workspace = await lockWorkspace(tx, input.projectId);
       if (workspace.active_graph_generation_id !== input.expectedActiveGenerationId) {
@@ -136188,8 +136400,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;
@@ -136247,10 +136459,10 @@ var init_graph_generation_coordinator = __esm(() => {
 
 // ../../packages/core/dist/services/etl/pipeline.js
 import { createHash as createHash10 } from "crypto";
-import { setTimeout as delay2 } from "timers/promises";
-import path31 from "path";
+import { setTimeout as delay3 } from "timers/promises";
+import path32 from "path";
 function buildHeaderLanguageEvidence(files) {
-  const headers = new Set(files.filter((file2) => path31.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path31.posix.normalize(file2.relativePath)));
+  const headers = new Set(files.filter((file2) => path32.posix.extname(file2.relativePath).toLowerCase() === ".h").map((file2) => path32.posix.normalize(file2.relativePath)));
   const mutable = new Map;
   const entry2 = (header) => {
     let value = mutable.get(header);
@@ -136261,7 +136473,7 @@ function buildHeaderLanguageEvidence(files) {
     return value;
   };
   for (const file2 of files) {
-    if (path31.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
+    if (path32.posix.basename(file2.relativePath) !== "compile_commands.json" || file2.snapshotContent === undefined)
       continue;
     let commands;
     try {
@@ -136277,11 +136489,11 @@ function buildHeaderLanguageEvidence(files) {
       const record2 = command;
       if (typeof record2.file !== "string")
         continue;
-      const projectRoot = path31.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
-      const commandDirectory = typeof record2.directory === "string" ? path31.resolve(projectRoot, record2.directory) : projectRoot;
-      const absoluteInput = path31.resolve(commandDirectory, record2.file);
-      const relative3 = path31.relative(projectRoot, absoluteInput);
-      const header = path31.posix.normalize(relative3.replaceAll(path31.sep, "/"));
+      const projectRoot = path32.resolve(file2.absolutePath, ...file2.relativePath.split("/").map(() => ".."));
+      const commandDirectory = typeof record2.directory === "string" ? path32.resolve(projectRoot, record2.directory) : projectRoot;
+      const absoluteInput = path32.resolve(commandDirectory, record2.file);
+      const relative3 = path32.relative(projectRoot, absoluteInput);
+      const header = path32.posix.normalize(relative3.replaceAll(path32.sep, "/"));
       if (!headers.has(header))
         continue;
       const invocation = typeof record2.command === "string" ? record2.command : Array.isArray(record2.arguments) ? record2.arguments.join(" ") : "";
@@ -136331,6 +136543,7 @@ var init_pipeline = __esm(() => {
   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;
@@ -136446,7 +136659,7 @@ var init_pipeline = __esm(() => {
         managedRunHeartbeat = (async () => {
           while (!stopManagedRunHeartbeat) {
             try {
-              await delay2(30000, undefined, { signal: managedRunTimerController.signal });
+              await delay3(30000, undefined, { signal: managedRunTimerController.signal });
             } catch {
               return;
             }
@@ -136467,11 +136680,25 @@ var init_pipeline = __esm(() => {
           }
         })();
       }
+      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({
@@ -136485,6 +136712,7 @@ var init_pipeline = __esm(() => {
           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);
@@ -136496,7 +136724,7 @@ var init_pipeline = __esm(() => {
         graphHeartbeat = (async () => {
           while (!stopGraphHeartbeat) {
             try {
-              await delay2(30000, undefined, { signal: heartbeatTimerController.signal });
+              await delay3(30000, undefined, { signal: heartbeatTimerController.signal });
             } catch {
               return;
             }
@@ -136668,6 +136896,7 @@ var init_pipeline = __esm(() => {
           activatedGraphGenerationId: result.activatedGraphGenerationId
         });
         await this.graphGenerations.cleanup(graphGenerationLease);
+        jobHeartbeatController.abort();
         stopGraphHeartbeat = true;
         heartbeatTimerController.abort();
         await graphHeartbeat;
@@ -136694,6 +136923,7 @@ var init_pipeline = __esm(() => {
             logger.error("EtlPipeline: pending generation abort failed", abortError, { projectId, jobId });
           }
         }
+        jobHeartbeatController.abort();
         stopGraphHeartbeat = true;
         heartbeatTimerController.abort();
         graphAbortController.abort();
@@ -142166,33 +142396,33 @@ var require_URL = __commonJS((exports, module) => {
         else
           return basepath.substring(0, lastslash + 1) + refpath;
       }
-      function remove_dot_segments(path32) {
-        if (!path32)
-          return path32;
+      function remove_dot_segments(path33) {
+        if (!path33)
+          return path33;
         var output = "";
-        while (path32.length > 0) {
-          if (path32 === "." || path32 === "..") {
-            path32 = "";
+        while (path33.length > 0) {
+          if (path33 === "." || path33 === "..") {
+            path33 = "";
             break;
           }
-          var twochars = path32.substring(0, 2);
-          var threechars = path32.substring(0, 3);
-          var fourchars = path32.substring(0, 4);
+          var twochars = path33.substring(0, 2);
+          var threechars = path33.substring(0, 3);
+          var fourchars = path33.substring(0, 4);
           if (threechars === "../") {
-            path32 = path32.substring(3);
+            path33 = path33.substring(3);
           } else if (twochars === "./") {
-            path32 = path32.substring(2);
+            path33 = path33.substring(2);
           } else if (threechars === "/./") {
-            path32 = "/" + path32.substring(3);
-          } else if (twochars === "/." && path32.length === 2) {
-            path32 = "/";
-          } else if (fourchars === "/../" || threechars === "/.." && path32.length === 3) {
-            path32 = "/" + path32.substring(4);
+            path33 = "/" + path33.substring(3);
+          } else if (twochars === "/." && path33.length === 2) {
+            path33 = "/";
+          } else if (fourchars === "/../" || threechars === "/.." && path33.length === 3) {
+            path33 = "/" + path33.substring(4);
             output = output.replace(/\/?[^\/]*$/, "");
           } else {
-            var segment = path32.match(/(\/?([^\/]*))/)[0];
+            var segment = path33.match(/(\/?([^\/]*))/)[0];
             output += segment;
-            path32 = path32.substring(segment.length);
+            path33 = path33.substring(segment.length);
           }
         }
         return output;
@@ -154262,21 +154492,21 @@ function jsonToKeyPathChunks(value, label = "$") {
   walk(value, label, out);
   return out;
 }
-function walk(val, path32, out) {
+function walk(val, path33, out) {
   if (val === null || val === undefined)
     return;
   if (Array.isArray(val)) {
     if (val.length === 0) {
-      out.push({ path: path32, content: `**${path32}** = _[]_` });
+      out.push({ path: path33, content: `**${path33}** = _[]_` });
       return;
     }
     if (val.every((v) => v !== null && typeof v === "object")) {
-      val.forEach((v, i) => walk(v, `${path32}[${i}]`, out));
+      val.forEach((v, i) => walk(v, `${path33}[${i}]`, out));
       return;
     }
     const items = val.map((v) => `- \`${String(v)}\``).join(`
 `);
-    out.push({ path: path32, content: `**${path32}**
+    out.push({ path: path33, content: `**${path33}**
 
 ${items}` });
     return;
@@ -154284,16 +154514,16 @@ ${items}` });
   if (typeof val === "object") {
     const entries = Object.entries(val);
     if (entries.length === 0) {
-      out.push({ path: path32, content: `**${path32}** = _{}_` });
+      out.push({ path: path33, content: `**${path33}** = _{}_` });
       return;
     }
     for (const [k, v] of entries) {
       const safeKey = /^[A-Za-z_$][\w$]*$/.test(k) ? k : JSON.stringify(k);
-      walk(v, `${path32}.${safeKey}`, out);
+      walk(v, `${path33}.${safeKey}`, out);
     }
     return;
   }
-  out.push({ path: path32, content: `**${path32}** = \`${String(val)}\`` });
+  out.push({ path: path33, content: `**${path33}** = \`${String(val)}\`` });
 }
 var gfm, STRIP_SELECTORS, tdCache = null;
 var init_html_to_md = __esm(() => {
@@ -154633,6 +154863,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();
@@ -154721,7 +154952,7 @@ init_config();
 init_dist();
 init_inference_providers();
 import os9 from "os";
-import path32 from "path";
+import path33 from "path";
 var WRITABLE_PROVIDERS = ["ollama", "lmstudio", "mistral", "openai", "google", "cohere"];
 var GENERATOR_MARKER = "scripts/generate-subagent-artifacts.ts";
 var GENERATOR_MARKER_MAX_LEVELS = 6;
@@ -154792,7 +155023,7 @@ Examples:
   massa-ai-config doctor
   massa-ai-config doctor --fix
   massa-ai-config bootstrap list
-  massa-ai-config bootstrap disable caveman
+  massa-ai-config bootstrap enable code-comments
 `);
 }
 function parseOptions(args) {
@@ -155150,7 +155381,7 @@ Using defaults:`);
           return 1;
         }
         const targetOpt = typeof options.target === "string" ? options.target : undefined;
-        const targetHome = targetOpt === undefined ? os9.homedir() : path32.resolve(targetOpt);
+        const targetHome = targetOpt === undefined ? os9.homedir() : path33.resolve(targetOpt);
         if (targetHome !== os9.homedir() && options.yes !== true) {
           console.error(`Error: --target ${targetHome} is not your home (${os9.homedir()}) \u2014 pass --yes to confirm writing there`);
           return 1;
@@ -155170,7 +155401,7 @@ Using defaults:`);
           const report = applyBootstrapState({
             targetHome,
             dryRun,
-            sourcePath: repoRoot === null ? undefined : path32.join(repoRoot, "skills", "AGENTS.md")
+            sourcePath: repoRoot === null ? undefined : path33.join(repoRoot, "skills", "AGENTS.md")
           });
           console.log(formatBootstrapReport(report));
           return bootstrapReportSucceeded(report) ? 0 : 1;