@cortexkit/pi-magic-context 0.49.11 → 0.49.13

package/dist/{index-78c864c8.js → index-nwbhe6qv.js}

@@ -1,30 +1,28 @@
-import {
-  getHarness2
-} from "./index-0h2mkab2.js";
-import {
-  sanitizeDiagnosticText,
-  log2
-} from "./index-gycf3sp7.js";
-import {
-  isUserHomeDirectory,
-  setBootQuietPeriodForTests
-} from "./index-gqxsds3q.js";
 import {
   inRootAsyncContext2,
+  getSqliteDatabasePath2,
   withSqliteBackgroundWriter2,
   withoutSqliteTransformPass2,
   isTransientSqliteError2
 } from "./index-asrxgdt4.js";
 import {
   estimateTokens
-} from "./index-4pxydwvg.js";
+} from "./index-g4jf772p.js";
+import {
+  getHarness2
+} from "./index-0h2mkab2.js";
+import {
+  sanitizeDiagnosticText,
+  log2
+} from "./index-7bqrfyny.js";
 import {
   SYNAPSE_DEFAULT_MODEL,
   isSynapseEmbeddingTruncated,
   getSynapseBatchRequestKey,
   SynapseEmbeddingProvider
-} from "./index-szh001qb.js";
+} from "./index-6dz2ed1v.js";
 import {
+  DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS,
   CHUNK_WINDOW_SAFETY_RATIO,
   normalizeCompartmentChunkMaxInputTokens,
   buildCanonicalChunkTextFromFts,
@@ -40,20 +38,31 @@ import {
   countSessionCompartmentEmbedCoverage,
   countSessionCompartmentEmbedCoveragePolite,
   countUnembeddedSessionCompartmentsPolite
-} from "./index-drah07tf.js";
+} from "./index-7qc73yk5.js";
 import {
   DEFAULT_LOCAL_EMBEDDING_MODEL
-} from "./index-ta0ed2nc.js";
+} from "./index-1k729e4f.js";
 import {
   embeddingModelsMatch,
   resolveEmbeddingTextPrefixes,
   getEmbeddingProviderIdentity,
   dominantEmbeddingFailure,
   LocalEmbeddingProvider
-} from "./index-8yjhda46.js";
+} from "./index-9jvktm7k.js";
+import {
+  setBootQuietPeriodForTests
+} from "./index-6ex901g3.js";
 import {
   isEmbeddingHostBusy2
 } from "./index-9p40dgkm.js";
+import {
+  findMisScopedCompartmentChunkEmbeddingIdsForProject,
+  recordSessionProjectIdentity,
+  repairMisScopedCompartmentChunkEmbeddingsForProject,
+  acquireGitSweepLease,
+  renewGitSweepLease,
+  releaseGitSweepLease
+} from "./index-1mrvw9en.js";
 import {
   saveEmbeddingIfHashMatches,
   getMemoryEmbedCoverage,
@@ -61,84 +70,34 @@ import {
 } from "./index-yhzhdp3m.js";
 import {
   logSlowWriteTransaction
-} from "./index-43zqh10z.js";
+} from "./index-d4dt19md.js";
 
-// ../plugin/src/features/magic-context/session-project-storage.ts
-var SESSION_CHUNK_REPAIR_BATCH_SIZE = 100;
-var upsertSessionProjectStatements = new WeakMap;
-var repairSessionChunkProjectStatements = new WeakMap;
-var misScopedProjectChunkStatements = new WeakMap;
-var MIS_SCOPED_PROJECT_CHUNK_IDS_SQL = `
-    SELECT e.id FROM compartment_chunk_embeddings e
-    JOIN session_projects sp ON sp.session_id = e.session_id AND sp.harness = e.harness
-    WHERE e.project_path = ? AND sp.project_path <> e.project_path
-    UNION ALL
-    SELECT e.id FROM session_projects sp
-    JOIN compartment_chunk_embeddings e ON e.session_id = sp.session_id
-    WHERE sp.project_path = ? AND e.harness = sp.harness AND e.project_path <> sp.project_path`;
-function getUpsertSessionProjectStatement(db) {
-  let stmt = upsertSessionProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`INSERT INTO session_projects (session_id, harness, project_path, updated_at)
-             VALUES (?, ?, ?, ?)
-             ON CONFLICT(session_id, harness) DO UPDATE SET
-                 project_path = excluded.project_path,
-                 updated_at = excluded.updated_at
-             WHERE session_projects.project_path <> excluded.project_path`);
-    upsertSessionProjectStatements.set(db, stmt);
-  }
-  return stmt;
-}
-function getRepairSessionChunkProjectStatement(db) {
-  let stmt = repairSessionChunkProjectStatements.get(db);
-  if (!stmt) {
-    stmt = db.prepare(`UPDATE compartment_chunk_embeddings
-             SET project_path = ?
-             WHERE id IN (
-                 SELECT id
-                 FROM compartment_chunk_embeddings
-                 WHERE session_id = ?
-                   AND harness = ?
-                   AND project_path <> ?
-                 LIMIT ?
-             )`);
-    repairSessionChunkProjectStatements.set(db, stmt);
+// ../plugin/src/hooks/magic-context/embed-session-state.ts
+var embedPauseBySession = new Set;
+var embedRunStateBySession = new Map;
+var activeEmbeddingSessions = new Map;
+var autoEmbedAttemptedBySession = new Set;
+var autoEmbedIdentityBySession = new Map;
+var autoEmbedRetryAfterBySession = new Map;
+function invalidateAutoEmbedSession(sessionId) {
+  autoEmbedAttemptedBySession.delete(sessionId);
+  autoEmbedIdentityBySession.delete(sessionId);
+  autoEmbedRetryAfterBySession.delete(sessionId);
+}
+function getEmbedDrainUiStatus(sessionId, progress) {
+  if (embedPauseBySession.has(sessionId)) {
+    return { status: "paused" };
+  }
+  const activeRun = embedRunStateBySession.get(sessionId);
+  if (activeRun && !activeRun.signal.aborted || progress?.kind === "embed" && progress.phase === "recomp") {
+    return { status: "running" };
+  }
+  if (progress?.kind === "embed" && (progress.phase === "failed" || progress.phase === "skipped") && progress.message) {
+    if (/provider/i.test(progress.message)) {
+      return { status: "stopped", detail: progress.message };
+    }
   }
-  return stmt;
-}
-function findMisScopedCompartmentChunkEmbeddingIdsForProject(db, projectPath) {
-  return db.prepare(`SELECT id FROM (${MIS_SCOPED_PROJECT_CHUNK_IDS_SQL}) LIMIT 25`).all(projectPath, projectPath).map(({ id }) => id);
-}
-function recordSessionProjectIdentity(db, sessionId, projectPath) {
-  if (!sessionId || !projectPath)
-    return;
-  if (!projectPath.startsWith("git:") && !projectPath.startsWith("dir:") && isUserHomeDirectory(projectPath))
-    return;
-  const harness = getHarness2();
-  const now = Date.now();
-  let previousProjectPath;
-  db.transaction(() => {
-    const existing = db.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = ?").get(sessionId, harness);
-    previousProjectPath = existing?.project_path;
-    getUpsertSessionProjectStatement(db).run(sessionId, harness, projectPath, now);
-    getRepairSessionChunkProjectStatement(db).run(projectPath, sessionId, harness, projectPath, SESSION_CHUNK_REPAIR_BATCH_SIZE);
-  }).immediate();
-  return previousProjectPath === projectPath ? undefined : { previousProjectPath, projectPath };
-}
-function repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectPath, ids = findMisScopedCompartmentChunkEmbeddingIdsForProject(db, projectPath)) {
-  if (!projectPath || ids.length === 0)
-    return 0;
-  return db.prepare(`UPDATE compartment_chunk_embeddings
-        SET project_path = (SELECT sp.project_path FROM session_projects sp
-            WHERE sp.session_id = compartment_chunk_embeddings.session_id
-              AND sp.harness = compartment_chunk_embeddings.harness)
-        WHERE id IN (${ids.map(() => "?").join(",")}) AND EXISTS (
-            SELECT 1 FROM session_projects sp
-            WHERE sp.session_id = compartment_chunk_embeddings.session_id
-              AND sp.harness = compartment_chunk_embeddings.harness
-              AND sp.project_path <> compartment_chunk_embeddings.project_path
-              AND (sp.project_path = ? OR compartment_chunk_embeddings.project_path = ?)
-        )`).run(...ids, projectPath, projectPath).changes;
+  return { status: "idle" };
 }
 
 // ../plugin/src/shared/background-batch-drain.ts
@@ -219,6 +178,9 @@ function pruneSynapseBatchLedgerForProject(db, projectIdentity, ttlMs = SYNAPSE_
   return db.prepare(`DELETE FROM synapse_batch_ledger WHERE ${predicate}`).run(projectIdentity, shadow, cutoff).changes;
 }
 
+// ../plugin/src/features/magic-context/memory/embedding-openai.ts
+import { createHash as createHash2 } from "node:crypto";
+
 // ../plugin/src/features/magic-context/memory/embedding-ssrf.ts
 var METADATA_HOSTNAMES = new Set(["metadata.google.internal", "metadata.goog"]);
 var IPV6_METADATA_HOSTS = new Set(["fd00:ec2::254"]);
@@ -318,6 +280,55 @@ var FAILURE_THRESHOLD = 3;
 var FAILURE_WINDOW_MS = 60000;
 var OPEN_DURATION_MS = 5 * 60000;
 var FETCH_TIMEOUT_MS = 30000;
+var RETRY_AFTER_CAP_MS = 60000;
+var RATE_LIMIT_BACKOFF_BASE_MS = 1000;
+var RATE_LIMIT_BACKOFF_CAP_MS = 30000;
+var RATE_LIMIT_BACKOFF_JITTER = 0.25;
+var rateLimitStates = new Map;
+function rateLimitStateKey(endpoint, apiKey) {
+  const keyHash = apiKey ? createHash2("sha256").update(apiKey).digest("hex").slice(0, 16) : "";
+  return `${endpoint}\x00${keyHash}`;
+}
+function parseRetryAfterMs(value, nowMs) {
+  const trimmed = value?.trim() ?? "";
+  if (!trimmed)
+    return null;
+  let delayMs;
+  if (/^\d+(?:\.\d+)?$/.test(trimmed)) {
+    delayMs = Number(trimmed) * 1000;
+  } else {
+    const at = Date.parse(trimmed);
+    if (!Number.isFinite(at))
+      return null;
+    delayMs = at - nowMs;
+  }
+  if (!(delayMs > 0))
+    return null;
+  return Math.min(Math.ceil(delayMs), RETRY_AFTER_CAP_MS);
+}
+function rateLimitBackoffMs(consecutive, random = Math.random) {
+  const exponent = Math.min(Math.max(0, Math.floor(consecutive)), 30);
+  const nominal = Math.min(RATE_LIMIT_BACKOFF_CAP_MS, RATE_LIMIT_BACKOFF_BASE_MS * 2 ** exponent);
+  const jitter = Math.min(1, Math.max(0, random())) * RATE_LIMIT_BACKOFF_JITTER;
+  return Math.min(RATE_LIMIT_BACKOFF_CAP_MS, Math.round(nominal * (1 + jitter)));
+}
+function sleepUnlessAborted(ms, signal) {
+  if (signal?.aborted)
+    return Promise.resolve(false);
+  return new Promise((resolve) => {
+    const onAbort = () => {
+      clearTimeout(timer);
+      resolve(false);
+    };
+    const timer = setTimeout(() => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve(true);
+    }, ms);
+    signal?.addEventListener("abort", onAbort, { once: true });
+  });
+}
+var RATE_LIMITED = Symbol("rate-limited");
+var maxInputTokensWarnings = new Set;
 
 class OpenAICompatibleEmbeddingProvider {
   modelId;
@@ -338,6 +349,7 @@ class OpenAICompatibleEmbeddingProvider {
   lastFailureReason = null;
   halfOpenProbeInFlight = false;
   queryTruncationLogged = false;
+  rateLimitKey;
   constructor(options) {
     this.endpoint = normalizeEndpoint(options.endpoint);
     this.model = options.model?.trim() ?? "";
@@ -348,7 +360,16 @@ class OpenAICompatibleEmbeddingProvider {
     this.queryPrefix = prefixes.queryPrefix;
     this.documentPrefix = prefixes.documentPrefix;
     this.truncate = options.truncate?.trim() ?? "";
-    this.maxInputTokens = typeof options.maxInputTokens === "number" && Number.isFinite(options.maxInputTokens) ? Math.max(1, Math.floor(options.maxInputTokens)) : 512;
+    this.rateLimitKey = rateLimitStateKey(this.endpoint, this.apiKey);
+    const maxInputTokensSet = typeof options.maxInputTokens === "number" && Number.isFinite(options.maxInputTokens);
+    this.maxInputTokens = maxInputTokensSet ? Math.max(1, Math.floor(options.maxInputTokens)) : DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS;
+    if (!maxInputTokensSet && this.endpoint && this.model) {
+      const warningKey = `${this.endpoint}\x00${this.model}`;
+      if (!maxInputTokensWarnings.has(warningKey)) {
+        maxInputTokensWarnings.add(warningKey);
+        log2(`[magic-context] embedding.max_input_tokens is not set for openai-compatible model "${sanitizeDiagnosticText(this.model)}"; chunk embeddings use the ${DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS}-token default, which is sized for the bundled local model and splits history into small pieces. Set embedding.max_input_tokens to the model's input limit (changing it re-embeds stored chunks once).`);
+      }
+    }
     this.modelId = getEmbeddingProviderIdentity({
       provider: "openai-compatible",
       endpoint: this.endpoint,
@@ -406,6 +427,23 @@ class OpenAICompatibleEmbeddingProvider {
     if (signal?.aborted) {
       return Array.from({ length: texts.length }, () => null);
     }
+    const isQuery = purpose === "query";
+    for (;; ) {
+      if (Date.now() < this.rateLimit.until) {
+        if (isQuery)
+          return Array.from({ length: texts.length }, () => null);
+        if (!await this.waitForRateLimitCooldown(signal)) {
+          return Array.from({ length: texts.length }, () => null);
+        }
+      }
+      const outcome = await this.requestOnce(texts, requestTexts, signal, purpose);
+      if (outcome !== RATE_LIMITED)
+        return outcome;
+      if (isQuery)
+        return Array.from({ length: texts.length }, () => null);
+    }
+  }
+  async requestOnce(texts, requestTexts, signal, purpose) {
     let isProbe = false;
     let internalController;
     let timeoutHandle;
@@ -438,9 +476,14 @@ class OpenAICompatibleEmbeddingProvider {
         redirect: "error",
         signal: internalController.signal
       });
+      if (response.status === 429) {
+        await response.text().catch(() => "");
+        this.noteRateLimit(response.headers.get("retry-after"));
+        return RATE_LIMITED;
+      }
       if (!response.ok) {
         const excerpt = await response.text().catch(() => "");
-        const failure = this.failure("http_error", `HTTP ${response.status} from endpoint${this.bodyExcerpt(excerpt)}`, response.status >= 500 || response.status === 408 || response.status === 429);
+        const failure = this.failure("http_error", `HTTP ${response.status} from endpoint${this.bodyExcerpt(excerpt)}`, response.status >= 500 || response.status === 408);
         log2(`[magic-context] openai-compatible embedding request failed: ${failure.reason}`);
         this.recordFailure(isProbe, failure);
         return Array.from({ length: texts.length }, () => null);
@@ -539,6 +582,36 @@ class OpenAICompatibleEmbeddingProvider {
   isLoaded() {
     return this.initialized;
   }
+  get rateLimit() {
+    let state = rateLimitStates.get(this.rateLimitKey);
+    if (!state) {
+      state = { until: 0, consecutive: 0 };
+      rateLimitStates.set(this.rateLimitKey, state);
+    }
+    return state;
+  }
+  async waitForRateLimitCooldown(signal) {
+    for (;; ) {
+      const remaining = this.rateLimit.until - Date.now();
+      if (remaining <= 0)
+        return true;
+      if (!await sleepUnlessAborted(remaining, signal))
+        return false;
+    }
+  }
+  noteRateLimit(retryAfter) {
+    const state = this.rateLimit;
+    const now = Date.now();
+    const headerDelayMs = parseRetryAfterMs(retryAfter, now);
+    const delayMs = headerDelayMs ?? rateLimitBackoffMs(state.consecutive);
+    state.consecutive += 1;
+    const alreadyCoolingDown = now < state.until;
+    state.until = Math.max(state.until, now + delayMs);
+    const seconds = Math.ceil(delayMs / 1000);
+    if (!alreadyCoolingDown) {
+      log2(`[magic-context] openai-compatible embedding rate limited (HTTP 429): pausing requests for ${seconds}s (${headerDelayMs !== null ? "Retry-After" : "backoff"}); background embedding resumes after the pause and searches run lexical-only until then`);
+    }
+  }
   claimProbeOrShortCircuit() {
     if (this.circuitOpenUntil === 0) {
       return "allow";
@@ -593,6 +666,7 @@ class OpenAICompatibleEmbeddingProvider {
     this.circuitOpenUntil = 0;
     this.openLogged = false;
     this.lastFailureReason = null;
+    this.rateLimit.consecutive = 0;
   }
   getLastFailureReason() {
     return this.lastFailureReason;
@@ -608,6 +682,9 @@ class OpenAICompatibleEmbeddingProvider {
   _getFailureCount() {
     return this.failureTimes.length;
   }
+  _getRateLimitedUntil() {
+    return this.rateLimit.until;
+  }
   _resetCircuit() {
     this.failureTimes = [];
     this.circuitOpenUntil = 0;
@@ -618,7 +695,85 @@ class OpenAICompatibleEmbeddingProvider {
 }
 
 // ../plugin/src/features/magic-context/project-embedding-registry.ts
-import { createHash as createHash2, randomUUID } from "node:crypto";
+import { createHash as createHash3, randomUUID } from "node:crypto";
+
+// ../plugin/src/features/magic-context/chunk-embedding-writer.ts
+import { Worker } from "node:worker_threads";
+function createChunkEmbeddingWriter(db) {
+  const path = getSqliteDatabasePath2(db);
+  if (!path)
+    return null;
+  if (path.startsWith("file:"))
+    throw new Error("chunk embedding writer requires a filesystem path");
+  const entry = new URL(import.meta.url.endsWith(".ts") ? "./chunk-embedding-write-worker.ts" : "./chunk-embedding-write-worker.js", import.meta.url);
+  const timeout = db.prepare("PRAGMA busy_timeout").get().timeout;
+  const worker = inRootAsyncContext2(() => new Worker(entry, { workerData: { path, harness: getHarness2(), timeout } }));
+  let pending;
+  let failure;
+  let deadline;
+  worker.on("message", (reply) => {
+    clearTimeout(deadline);
+    const request = pending;
+    pending = undefined;
+    if (reply.error)
+      request?.reject(new Error(reply.error));
+    else
+      request?.resolve(reply.value);
+  });
+  const fail = (error) => {
+    clearTimeout(deadline);
+    failure = error;
+    pending?.reject(error);
+    pending = undefined;
+  };
+  worker.on("error", fail);
+  worker.on("exit", (code) => fail(new Error(`chunk embedding writer exited (${code})`)));
+  worker.unref();
+  let queue = Promise.resolve();
+  const request = (message) => {
+    const result = queue.then(() => {
+      if (failure)
+        throw failure;
+      return new Promise((resolve, reject) => {
+        pending = { resolve, reject };
+        deadline = inRootAsyncContext2(() => setTimeout(() => {
+          fail(new Error("chunk embedding database operation timed out; coverage will be rechecked"));
+          worker.terminate();
+        }, 30000));
+        deadline.unref();
+        worker.postMessage(message);
+      });
+    });
+    queue = result.catch(() => {});
+    return result;
+  };
+  return {
+    async replace(rows, sourceKey) {
+      if (rows.some((row) => isSynapseEmbeddingTruncated(row.vector)))
+        return;
+      await request({ kind: "replace", rows, sourceKey });
+    },
+    project: (project, session) => request({ kind: "project", project, session }),
+    count: (project, session, model, tokens) => request({ kind: "count", project, session, model, tokens }),
+    candidates: (project, session, model, limit, excluded, tokens) => request({
+      kind: "candidates",
+      project,
+      session,
+      model,
+      limit,
+      excluded,
+      tokens
+    }),
+    backoff: (candidate, project, model) => request({ kind: "backoff", candidate, project, model }),
+    acquire: (project, holder) => request({ kind: "acquire", project, holder }),
+    renew: (project, holder) => request({ kind: "renew", project, holder }),
+    release: (project, holder) => request({ kind: "release", project, holder }),
+    async close() {
+      clearTimeout(deadline);
+      await worker.terminate();
+    }
+  };
+}
 
 // ../plugin/src/features/magic-context/git-commits/storage-git-commit-embeddings.ts
 var saveStatements = new WeakMap;
@@ -802,142 +957,6 @@ function enforceProjectCap(db, projectPath, maxCommits) {
   return evicted;
 }
 
-// ../plugin/src/features/magic-context/git-commits/sweep-coordinator.ts
-var GIT_SWEEP_COOLDOWN_MS = 10 * 60 * 1000;
-var GIT_SWEEP_LEASE_TTL_MS = 5 * 60 * 1000;
-var GIT_SWEEP_NON_INDEXABLE_REPROBE_MS = 24 * 60 * 60 * 1000;
-var GIT_SWEEP_LEASE_RENEWAL_MS = 60 * 1000;
-function runImmediate(db, body) {
-  db.exec("BEGIN IMMEDIATE");
-  const transactionStartedAt = performance.now();
-  let committed = false;
-  try {
-    const result = body();
-    db.exec("COMMIT");
-    committed = true;
-    logSlowWriteTransaction("git_sweep_lease", transactionStartedAt);
-    return result;
-  } finally {
-    if (!committed) {
-      try {
-        db.exec("ROLLBACK");
-      } catch {}
-    }
-  }
-}
-function rowToState(row) {
-  return {
-    projectPath: row.project_path,
-    leaseHolder: row.lease_holder,
-    leaseExpiresAt: row.lease_expires_at,
-    lastSweptAt: row.last_swept_at
-  };
-}
-function getGitSweepCoordinatorState(db, projectPath) {
-  const row = db.prepare(`SELECT project_path, lease_holder, lease_expires_at, last_swept_at
-             FROM git_sweep_coordinator
-             WHERE project_path = ?`).get(projectPath);
-  return row ? rowToState(row) : null;
-}
-function acquireGitSweepLease(db, projectPath, holderId, options = {}) {
-  const cooldownMs = options.cooldownMs ?? GIT_SWEEP_COOLDOWN_MS;
-  const leaseTtlMs = options.leaseTtlMs ?? GIT_SWEEP_LEASE_TTL_MS;
-  return runImmediate(db, () => {
-    const now = Date.now();
-    const row = getGitSweepCoordinatorState(db, projectPath);
-    if (row?.leaseHolder && row.leaseExpiresAt !== null && row.leaseExpiresAt > now) {
-      return {
-        acquired: false,
-        projectPath,
-        reason: "lease_active",
-        leaseHolder: row.leaseHolder,
-        leaseExpiresAt: row.leaseExpiresAt,
-        lastSweptAt: row.lastSweptAt,
-        nextAllowedAt: null
-      };
-    }
-    if (!options.ignoreCooldown && row?.lastSweptAt !== null && row?.lastSweptAt !== undefined) {
-      const nextAllowedAt = row.lastSweptAt + cooldownMs;
-      if (nextAllowedAt > now) {
-        return {
-          acquired: false,
-          projectPath,
-          reason: "cooldown_active",
-          leaseHolder: row.leaseHolder,
-          leaseExpiresAt: row.leaseExpiresAt,
-          lastSweptAt: row.lastSweptAt,
-          nextAllowedAt
-        };
-      }
-    }
-    const leaseExpiresAt = now + leaseTtlMs;
-    db.prepare(`INSERT INTO git_sweep_coordinator (
-                 project_path,
-                 lease_holder,
-                 lease_expires_at,
-                 last_swept_at
-             ) VALUES (?, ?, ?, NULL)
-             ON CONFLICT(project_path) DO UPDATE SET
-                 lease_holder = excluded.lease_holder,
-                 lease_expires_at = excluded.lease_expires_at`).run(projectPath, holderId, leaseExpiresAt);
-    return {
-      acquired: true,
-      projectPath,
-      holderId,
-      acquiredAt: now,
-      leaseExpiresAt
-    };
-  });
-}
-function renewGitSweepLease(db, projectPath, holderId, leaseTtlMs = GIT_SWEEP_LEASE_TTL_MS) {
-  return runImmediate(db, () => {
-    const now = Date.now();
-    const leaseExpiresAt = now + leaseTtlMs;
-    const result = db.prepare(`UPDATE git_sweep_coordinator
-                 SET lease_expires_at = ?
-                 WHERE project_path = ?
-                   AND lease_holder = ?
-                   AND lease_expires_at > ?`).run(leaseExpiresAt, projectPath, holderId, now);
-    return result.changes === 1;
-  });
-}
-function markGitSweepSuccessAndRelease(db, projectPath, holderId) {
-  return runImmediate(db, () => {
-    const now = Date.now();
-    const result = db.prepare(`UPDATE git_sweep_coordinator
-                 SET lease_holder = NULL,
-                     lease_expires_at = NULL,
-                     last_swept_at = ?
-                 WHERE project_path = ?
-                   AND lease_holder = ?
-                   AND lease_expires_at > ?`).run(now, projectPath, holderId, now);
-    return result.changes === 1;
-  });
-}
-function parkGitSweepNonIndexable(db, projectPath, holderId, reprobeMs = GIT_SWEEP_NON_INDEXABLE_REPROBE_MS) {
-  return runImmediate(db, () => {
-    const now = Date.now();
-    const sweptAt = now + reprobeMs - GIT_SWEEP_COOLDOWN_MS;
-    const result = db.prepare(`UPDATE git_sweep_coordinator
-                 SET lease_holder = NULL,
-                     lease_expires_at = NULL,
-                     last_swept_at = ?
-                 WHERE project_path = ?
-                   AND lease_holder = ?
-                   AND lease_expires_at > ?`).run(sweptAt, projectPath, holderId, now);
-    return result.changes === 1;
-  });
-}
-function releaseGitSweepLease(db, projectPath, holderId) {
-  runImmediate(db, () => {
-    db.prepare(`UPDATE git_sweep_coordinator
-             SET lease_holder = NULL,
-                 lease_expires_at = NULL
-             WHERE project_path = ?
-               AND lease_holder = ?`).run(projectPath, holderId);
-  });
-}
-
 // ../plugin/src/features/magic-context/shadow-backfill-state.ts
 var SHADOW_BACKFILL_PROVENANCE_KEY = "_magicContextShadowBackfill";
 function parseJsonRecord(value) {
@@ -1301,10 +1320,10 @@ function stableStringify(value) {
   return JSON.stringify(value);
 }
 function sha256Prefix(value, length = 16) {
-  return createHash2("sha256").update(value).digest("hex").slice(0, length);
+  return createHash3("sha256").update(value).digest("hex").slice(0, length);
 }
 function contentSha2562(value) {
-  return createHash2("sha256").update(value).digest("hex");
+  return createHash3("sha256").update(value).digest("hex");
 }
 function getRuntimeFingerprint(config) {
   if (config.provider === "off") {
@@ -2628,22 +2647,31 @@ async function drainCommitBacklogForProject2(db, projectIdentity, deadline) {
   }
   return total;
 }
-async function embedCompartmentChunkBatch(db, projectIdentity, batchSize) {
+async function embedCompartmentChunkBatch(db, projectIdentity, batchSize, signal) {
   const snapshot = getProjectEmbeddingSnapshot2(projectIdentity);
   if (!snapshot?.historyEnabled || snapshot.chunkModelId === "off")
     return 0;
   repairMisScopedCompartmentChunkEmbeddingsForProject(db, projectIdentity);
-  const candidates = await loadUnembeddedCompartmentChunkCandidatesPolite(db, projectIdentity, snapshot.chunkModelId, batchSize, getProjectEmbeddingMaxInputTokens2(projectIdentity), true);
+  const priorModels = db.prepare(`SELECT COUNT(*) AS total,
+        COALESCE(MAX(model_id = ?), 0) AS current
+        FROM compartment_chunk_embeddings WHERE compartment_id = ?`);
+  const candidates = await loadUnembeddedCompartmentChunkCandidatesPolite(db, projectIdentity, snapshot.chunkModelId, batchSize, getProjectEmbeddingMaxInputTokens2(projectIdentity), true, (candidate) => {
+    const activity = activeEmbeddingSessions.get(candidate.sessionId);
+    if (activity?.project === projectIdentity && activity.model === snapshot.chunkModelId && !embedPauseBySession.has(candidate.sessionId))
+      return true;
+    const prior = priorModels.get(snapshot.chunkModelId, candidate.id);
+    return prior.total === 0 || prior.current !== 0;
+  });
   if (candidates.length === 0)
     return 0;
-  const { embedded } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates);
+  const { embedded } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, signal);
   return embedded;
 }
 function getLastEmbeddingFailureForProject(projectIdentity) {
   const registration = projectRegistrations.get(projectIdentity);
   return registration?.provider?.getLastFailureReason?.() ?? null;
 }
-async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal) {
+async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates, signal, writer) {
   const noWork = [];
   const failed = [];
   const failureReasons = [];
@@ -2658,7 +2686,10 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       continue;
     const canonicalText = mappedText || buildCompartmentSummaryFallbackText(db, candidate.id);
     if (canonicalText.length === 0) {
-      recordChunkEmbedBackoff(db, candidate, projectIdentity, modelId);
+      if (writer)
+        await writer.backoff(candidate, projectIdentity, modelId);
+      else
+        recordChunkEmbedBackoff(db, candidate, projectIdentity, modelId);
       noWork.push(candidate.id);
       continue;
     }
@@ -2715,6 +2746,8 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
       if (result) {
         let writeSliceStarted = performance.now();
         for (const item of slice) {
+          if (signal?.aborted || getProjectChunkEmbeddingModelId2(projectIdentity) !== modelId)
+            break;
           if (persistedIds.has(item.candidate.id))
             continue;
           const vectors = item.windows.map((window) => result.vectors.get(`chunk:${item.candidate.id}:${window.windowIndex}`));
@@ -2729,7 +2762,10 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
             modelId,
             vector: vectors[index]
           }));
-          replaceCompartmentChunkEmbeddings(db, rows, item.windowSourceKey);
+          if (writer)
+            await writer.replace(rows, item.windowSourceKey);
+          else
+            replaceCompartmentChunkEmbeddings(db, rows, item.windowSourceKey);
           persistedIds.add(item.candidate.id);
           enqueueShadowEmbeddingItems2(projectIdentity, "chunk", [
             String(item.candidate.id)
@@ -2754,7 +2790,10 @@ async function embedCandidateChunkBatch(db, projectIdentity, modelId, candidates
     if (!signal?.aborted) {
       for (const item of slice) {
         if (!persistedIds.has(item.candidate.id)) {
-          recordChunkEmbedBackoff(db, item.candidate, projectIdentity, modelId);
+          if (writer)
+            await writer.backoff(item.candidate, projectIdentity, modelId);
+          else
+            recordChunkEmbedBackoff(db, item.candidate, projectIdentity, modelId);
           failed.push(item.candidate.id);
         }
       }
@@ -2773,6 +2812,9 @@ async function drainCompartmentChunkBacklogForProject(db, projectIdentity, deadl
   }
   let total = 0;
   let leaseLost = false;
+  const drainAbort = new AbortController;
+  const deadlineTimer = setTimeout(() => drainAbort.abort(), Math.max(0, deadline - Date.now()));
+  deadlineTimer.unref?.();
   const renewal = inRootAsyncContext2(() => setInterval(() => {
     try {
       if (!renewGitSweepLease(db, projectIdentity, holderId))
@@ -2781,8 +2823,8 @@ async function drainCompartmentChunkBacklogForProject(db, projectIdentity, deadl
   }, SESSION_EMBED_LEASE_RENEWAL_MS));
   renewal.unref?.();
   try {
-    while (!leaseLost && !isEmbeddingHostBusy2() && Date.now() < deadline && total < CHUNK_DRAIN_MAX_PER_SWEEP) {
-      const embedded = await embedCompartmentChunkBatch(db, projectIdentity, CHUNK_DRAIN_BATCH_SIZE);
+    while (!leaseLost && !drainAbort.signal.aborted && !isEmbeddingHostBusy2() && Date.now() < deadline && total < CHUNK_DRAIN_MAX_PER_SWEEP) {
+      const embedded = await embedCompartmentChunkBatch(db, projectIdentity, CHUNK_DRAIN_BATCH_SIZE, drainAbort.signal);
       if (!renewGitSweepLease(db, projectIdentity, holderId))
         leaseLost = true;
       if (leaseLost || embedded === 0)
@@ -2792,6 +2834,7 @@ async function drainCompartmentChunkBacklogForProject(db, projectIdentity, deadl
         break;
     }
   } finally {
+    clearTimeout(deadlineTimer);
     clearInterval(renewal);
     releaseGitSweepLease(db, projectIdentity, holderId);
   }
@@ -2805,11 +2848,28 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
   if (!snapshot?.historyEnabled || snapshot.chunkModelId === "off") {
     return { status: "disabled", embedded: 0, total: 0 };
   }
-  recordSessionProjectIdentity(db, sessionId, projectIdentity);
+  if (options?.automatic && !options.databaseWorker) {
+    const worker = createChunkEmbeddingWriter(db);
+    if (worker) {
+      try {
+        return await embedSessionCompartmentChunks2(db, projectIdentity, sessionId, {
+          ...options,
+          databaseWorker: worker
+        });
+      } finally {
+        await worker.close();
+      }
+    }
+  }
+  const writer = options?.databaseWorker ?? null;
+  if (writer)
+    await writer.project(projectIdentity, sessionId);
+  else
+    recordSessionProjectIdentity(db, sessionId, projectIdentity);
   const maxInputTokens = getProjectEmbeddingMaxInputTokens2(projectIdentity);
-  const total = await countUnembeddedSessionCompartmentsPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens);
+  const total = writer ? await writer.count(projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens) : await countUnembeddedSessionCompartmentsPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens);
   const holderId = `session-embed-${randomUUID()}`;
-  const lease = acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
+  const lease = writer ? await writer.acquire(projectIdentity, holderId) : acquireGitSweepLease(db, projectIdentity, holderId, { ignoreCooldown: true });
   if (!lease.acquired)
     return { status: "busy", embedded: 0, total };
   let leaseLost = false;
@@ -2819,9 +2879,9 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
     drainAbort.abort();
   else
     options?.signal?.addEventListener("abort", forwardCallerAbort, { once: true });
-  const renewal = inRootAsyncContext2(() => setInterval(() => {
+  const renewal = inRootAsyncContext2(() => setInterval(async () => {
     try {
-      if (!renewGitSweepLease(db, projectIdentity, holderId)) {
+      if (!(writer ? await writer.renew(projectIdentity, holderId) : renewGitSweepLease(db, projectIdentity, holderId))) {
         leaseLost = true;
         drainAbort.abort();
       }
@@ -2839,11 +2899,18 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
   try {
     options?.onProgress?.({ embedded, total });
     for (;; ) {
-      if (leaseLost || drainAbort.signal.aborted || isEmbeddingHostBusy2()) {
+      if (leaseLost || drainAbort.signal.aborted || !options?.automatic && isEmbeddingHostBusy2() || getProjectEmbeddingSnapshot2(projectIdentity)?.generation !== snapshot.generation) {
         aborted = true;
         break;
       }
-      const candidates = await loadUnembeddedSessionChunkCandidatesPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds], maxInputTokens, true);
+      if (options?.automatic && isEmbeddingHostBusy2()) {
+        await new Promise((resolve) => setTimeout(resolve, 100));
+        if (drainAbort.signal.aborted) {
+          aborted = true;
+          break;
+        }
+      }
+      const candidates = writer ? await writer.candidates(projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds], maxInputTokens) : await loadUnembeddedSessionChunkCandidatesPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, batchSize, [...skipIds, ...failedIds], maxInputTokens, true);
       if (candidates.length === 0)
         break;
       const {
@@ -2851,8 +2918,8 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
         noWork,
         failed,
         failureReasons: batchFailureReasons
-      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, drainAbort.signal);
-      if (leaseLost || !renewGitSweepLease(db, projectIdentity, holderId)) {
+      } = await embedCandidateChunkBatch(db, projectIdentity, snapshot.chunkModelId, candidates, drainAbort.signal, writer);
+      if (leaseLost || !(writer ? await writer.renew(projectIdentity, holderId) : renewGitSweepLease(db, projectIdentity, holderId))) {
         leaseLost = true;
         drainAbort.abort();
         aborted = true;
@@ -2880,7 +2947,10 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
     clearInterval(renewal);
     options?.signal?.removeEventListener("abort", forwardCallerAbort);
     try {
-      releaseGitSweepLease(db, projectIdentity, holderId);
+      if (writer)
+        await writer.release(projectIdentity, holderId);
+      else
+        releaseGitSweepLease(db, projectIdentity, holderId);
     } catch (error) {
       log2("[magic-context] embed drain: lease release failed (will TTL-expire):", error);
     }
@@ -2890,7 +2960,7 @@ async function embedSessionCompartmentChunks2(db, projectIdentity, sessionId, op
   if (aborted)
     return { status: "aborted", embedded, total, failed: failedIds.length };
   if (providerDown || failedIds.length > 0) {
-    const remaining = Math.max(failedIds.length, await countUnembeddedSessionCompartmentsPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens) - skipIds.length);
+    const remaining = Math.max(failedIds.length, (writer ? await writer.count(projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens) : await countUnembeddedSessionCompartmentsPolite(db, projectIdentity, sessionId, snapshot.chunkModelId, maxInputTokens)) - skipIds.length);
     if (remaining > 0) {
       return {
         status: "stalled",
@@ -3025,4 +3095,4 @@ function _resetProjectEmbeddingRegistryForTests2() {
   setBootQuietPeriodForTests(null);
 }
 
-export { recordSessionProjectIdentity, drainBackgroundBatches, recordEmbeddingMeasurement, OpenAICompatibleEmbeddingProvider, saveCommitEmbedding, loadProjectCommitEmbeddings, loadUnembeddedCommits, countEmbeddedCommits, upsertCommits, getLatestIndexedCommitSha, enforceProjectCap, GIT_SWEEP_LEASE_RENEWAL_MS, acquireGitSweepLease, renewGitSweepLease, markGitSweepSuccessAndRelease, parkGitSweepNonIndexable, releaseGitSweepLease, describeShadowBackfillWriteRefusal2, listShadowBackfillStalls2, getShadowBackfillStopReason2, markProjectLoadUntrusted2, contentSha2562, drainProjectEmbeddingIdentityMaintenance2, drainStaleEmbeddingIdentitiesForProject2, registerProjectEmbedding2, registerProjectShadowEmbedding2, getShadowEmbeddingMeasurementCohort2, getPrimaryEmbeddingMeasurementCohort2, embedShadowTextForProject2, enqueueShadowEmbeddingItems2, getShadowBackfillRemaining2, flushShadowEmbeddingBacklog2, registerProjectInObservationMode2, unregisterProjectShadowEmbedding2, unregisterProjectEmbedding2, getProjectEmbeddingSnapshot2, installProjectEmbeddingSearchBridge2, getProjectChunkEmbeddingModelId2, getProjectEmbeddingMaxInputTokens2, embedTextForProject2, embedBatchForProject2, embedItemsForProject2, embedUnembeddedMemoriesForProject2, drainCommitBacklogForProject2, embedUnembeddedCompartmentChunksForProject2, embedSessionCompartmentChunks2, getEmbeddingCoverageStatus2, getAutoEmbeddingSessionCoverage2, sweepAllRegisteredProjects2, _setTestProviderFactoryForProject2, _resetProjectEmbeddingRegistryForTests2 };
+export { embedPauseBySession, embedRunStateBySession, activeEmbeddingSessions, autoEmbedAttemptedBySession, autoEmbedIdentityBySession, autoEmbedRetryAfterBySession, invalidateAutoEmbedSession, getEmbedDrainUiStatus, drainBackgroundBatches, recordEmbeddingMeasurement, OpenAICompatibleEmbeddingProvider, saveCommitEmbedding, loadProjectCommitEmbeddings, loadUnembeddedCommits, countEmbeddedCommits, upsertCommits, getLatestIndexedCommitSha, enforceProjectCap, describeShadowBackfillWriteRefusal2, listShadowBackfillStalls2, getShadowBackfillStopReason2, markProjectLoadUntrusted2, contentSha2562, drainProjectEmbeddingIdentityMaintenance2, drainStaleEmbeddingIdentitiesForProject2, registerProjectEmbedding2, registerProjectShadowEmbedding2, getShadowEmbeddingMeasurementCohort2, getPrimaryEmbeddingMeasurementCohort2, embedShadowTextForProject2, enqueueShadowEmbeddingItems2, getShadowBackfillRemaining2, flushShadowEmbeddingBacklog2, registerProjectInObservationMode2, unregisterProjectShadowEmbedding2, unregisterProjectEmbedding2, getProjectEmbeddingSnapshot2, installProjectEmbeddingSearchBridge2, getProjectChunkEmbeddingModelId2, getProjectEmbeddingMaxInputTokens2, embedTextForProject2, embedBatchForProject2, embedItemsForProject2, embedUnembeddedMemoriesForProject2, drainCommitBacklogForProject2, embedUnembeddedCompartmentChunksForProject2, embedSessionCompartmentChunks2, getEmbeddingCoverageStatus2, getAutoEmbeddingSessionCoverage2, sweepAllRegisteredProjects2, _setTestProviderFactoryForProject2, _resetProjectEmbeddingRegistryForTests2 };