@cortexkit/pi-magic-context 0.49.11 → 0.49.13

package/dist/{index-gqxsds3q.js → index-6ex901g3.js}

@@ -1,13 +1,13 @@
 import {
   getMagicContextStorageDir,
   log2
-} from "./index-gycf3sp7.js";
+} from "./index-7bqrfyny.js";
 import {
   inRootAsyncContext2
 } from "./index-asrxgdt4.js";
 import {
   projectDirectoryKey
-} from "./index-fdxzpnbj.js";
+} from "./index-djxc8w8c.js";
 import {
   writeStorageFileAtomicSync
 } from "./index-81nthk8j.js";
@@ -15,9 +15,9 @@ import {
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execFileSync } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync, realpathSync, statSync } from "node:fs";
+import { existsSync, realpathSync as realpathSync2, statSync as statSync2 } from "node:fs";
 import { homedir } from "node:os";
-import path2 from "node:path";
+import path3 from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity-cache.ts
 import { createHash } from "node:crypto";
@@ -42,6 +42,162 @@ function readRememberedGitIdentity(directory, storageDir) {
   return;
 }
 
+// ../plugin/src/features/magic-context/memory/unborn-head.ts
+import { readFileSync as readFileSync2, realpathSync, statSync } from "node:fs";
+import path2 from "node:path";
+var GIT_LOCATION_ENV_VARS = [
+  "GIT_DIR",
+  "GIT_COMMON_DIR",
+  "GIT_WORK_TREE",
+  "GIT_CEILING_DIRECTORIES"
+];
+function errorCode(error) {
+  if (error === null || typeof error !== "object" || !("code" in error))
+    return;
+  const code = error.code;
+  return typeof code === "string" ? code : undefined;
+}
+function readText(file) {
+  try {
+    return { ok: true, text: readFileSync2(file, "utf8") };
+  } catch (error) {
+    return { ok: false, missing: errorCode(error) === "ENOENT" };
+  }
+}
+function entryKind(entry) {
+  try {
+    const stat = statSync(entry);
+    if (stat.isFile())
+      return "file";
+    if (stat.isDirectory())
+      return "directory";
+    return "other";
+  } catch (error) {
+    return errorCode(error) === "ENOENT" ? "missing" : "error";
+  }
+}
+function stripLineEnding(text) {
+  return text.replace(/\r?\n$/u, "");
+}
+function resolveMetadataPath(baseDirectory, value) {
+  return path2.resolve(baseDirectory, value);
+}
+function isPlainBranchName(name) {
+  if (name.length === 0 || name.endsWith("/") || name.endsWith("."))
+    return false;
+  if (name.includes("..") || name.includes("//") || name.includes("@{"))
+    return false;
+  for (const character of name) {
+    const code = character.charCodeAt(0);
+    if (code <= 32 || code === 127 || "~^:?*[\\".includes(character))
+      return false;
+  }
+  return name.split("/").every((component) => !component.startsWith(".") && !component.endsWith(".lock"));
+}
+function findGitDirectory(start) {
+  let current = start;
+  while (true) {
+    const dotGit = path2.join(current, ".git");
+    const kind = entryKind(dotGit);
+    if (kind === "directory")
+      return dotGit;
+    if (kind === "file") {
+      const read = readText(dotGit);
+      if (!read.ok)
+        return;
+      const match = /^gitdir: (.+)$/u.exec(stripLineEnding(read.text));
+      if (!match?.[1] || match[1].includes(`
+`))
+        return;
+      return resolveMetadataPath(current, match[1]);
+    }
+    if (kind !== "missing")
+      return;
+    const parent = path2.dirname(current);
+    if (parent === current)
+      return;
+    current = parent;
+  }
+}
+function packedRefsList(text, ref) {
+  for (const rawLine of text.split(`
+`)) {
+    const line = rawLine.replace(/\r$/u, "");
+    if (line === "" || line.startsWith("#") || line.startsWith("^"))
+      continue;
+    const match = /^[0-9a-f]{40,64} (\S+)$/u.exec(line);
+    if (!match)
+      return;
+    if (match[1] === ref)
+      return true;
+  }
+  return false;
+}
+function isUnbornHeadInLayout(directory) {
+  const gitDirectory = findGitDirectory(directory);
+  if (gitDirectory === undefined)
+    return false;
+  let commonDirectory = gitDirectory;
+  const commondir = readText(path2.join(gitDirectory, "commondir"));
+  if (commondir.ok) {
+    const value = stripLineEnding(commondir.text);
+    if (value === "" || value.includes(`
+`))
+      return false;
+    commonDirectory = resolveMetadataPath(gitDirectory, value);
+  } else if (!commondir.missing) {
+    return false;
+  }
+  if (entryKind(path2.join(gitDirectory, "HEAD")) !== "file")
+    return false;
+  if (entryKind(path2.join(commonDirectory, "objects")) !== "directory")
+    return false;
+  if (entryKind(path2.join(commonDirectory, "refs")) !== "directory")
+    return false;
+  if (entryKind(path2.join(commonDirectory, "reftable")) !== "missing")
+    return false;
+  const config = readText(path2.join(commonDirectory, "config"));
+  if (config.ok) {
+    if (/refstorage/iu.test(config.text))
+      return false;
+  } else if (!config.missing) {
+    return false;
+  }
+  const head = readText(path2.join(gitDirectory, "HEAD"));
+  if (!head.ok)
+    return false;
+  const headMatch = /^ref: (refs\/heads\/(.+))$/u.exec(head.text.replace(/\s+$/u, ""));
+  const ref = headMatch?.[1];
+  const branch = headMatch?.[2];
+  if (!ref || branch === undefined || !isPlainBranchName(branch))
+    return false;
+  const refSegments = ref.split("/");
+  for (const base of new Set([commonDirectory, gitDirectory])) {
+    if (entryKind(path2.join(base, ...refSegments)) !== "missing")
+      return false;
+  }
+  const packed = readText(path2.join(commonDirectory, "packed-refs"));
+  if (packed.ok) {
+    if (packedRefsList(packed.text, ref) !== false)
+      return false;
+  } else if (!packed.missing) {
+    return false;
+  }
+  return true;
+}
+function isUnbornHeadOnDisk(directory, env = process.env) {
+  if (GIT_LOCATION_ENV_VARS.some((name) => env[name] !== undefined && env[name] !== "")) {
+    return false;
+  }
+  let realDirectory;
+  try {
+    realDirectory = realpathSync.native(path2.resolve(directory));
+  } catch {
+    return false;
+  }
+  return isUnbornHeadInLayout(realDirectory);
+}
+
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 var GIT_TIMEOUT_MS = 5000;
 var TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
@@ -62,6 +218,7 @@ function setHomeProjectPermission(allowed) {
   homeProjectPermission = allowed;
 }
 var execFileSyncForIdentity = execFileSync;
+var gitTimeoutMs = GIT_TIMEOUT_MS;
 var userHomeDirectoryForIdentity = () => homedir();
 var nowMs = () => Date.now();
 var filesystemProbeObserverForTests;
@@ -116,7 +273,7 @@ function getErrorStderr(error) {
   return "";
 }
 function directoryFallback(directory) {
-  const canonical = path2.resolve(directory);
+  const canonical = path3.resolve(directory);
   const hash = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
@@ -125,7 +282,7 @@ function rememberedIdentityOrDirectoryFallback(canonical) {
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
   try {
-    const stat = statSync(canonicalDirectory);
+    const stat = statSync2(canonicalDirectory);
     if (!stat.isDirectory()) {
       throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
     }
@@ -151,7 +308,7 @@ function hasUnbornHead(directory) {
     encoding: "utf8",
     env: { ...process.env, LC_ALL: "C", LANG: "C" },
     stdio: ["ignore", "pipe", "pipe"],
-    timeout: GIT_TIMEOUT_MS,
+    timeout: gitTimeoutMs,
     windowsHide: true
   };
   try {
@@ -168,7 +325,7 @@ function hasUnbornHead(directory) {
 }
 function classifyGitError(error, rawDirectory) {
   if (isGitTimeoutError(error)) {
-    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
+    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${gitTimeoutMs}ms`, asError(error));
   }
   const code = getErrorCode(error);
   if (code === "ENOENT") {
@@ -188,7 +345,7 @@ function classifyGitError(error, rawDirectory) {
 }
 function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission, options = {}) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path2.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cached = options.cache === false ? undefined : identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
@@ -197,6 +354,9 @@ function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectP
   if (!hasGitDir(canonical)) {
     throw new ProjectIdentityError("not_git_repo", directory, "Directory has no git metadata; caller may use directory fallback");
   }
+  if (isUnbornHeadOnDisk(canonical)) {
+    throw new ProjectIdentityError("no_commits", directory, "Git repository has no commits yet");
+  }
   let output;
   try {
     output = execFileSyncForIdentity("git", ["rev-list", "--max-parents=0", "HEAD"], {
@@ -204,7 +364,7 @@ function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectP
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C", LANG: "C" },
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS,
+      timeout: gitTimeoutMs,
       windowsHide: true
     });
   } catch (error) {
@@ -257,9 +417,9 @@ function nearestLastKnownGitIdentity(canonical) {
       const cached = lastKnownGitIdentity(current);
       if (cached !== undefined)
         return { identity: cached, source: current };
-      if (existsSync(path2.join(current, ".git")))
+      if (existsSync(path3.join(current, ".git")))
         break;
-      const parent = path2.dirname(current);
+      const parent = path3.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -270,7 +430,7 @@ function nearestLastKnownGitIdentity(canonical) {
   if (exactOrAncestor)
     return exactOrAncestor;
   try {
-    const realCanonical = realpathSync.native(canonical);
+    const realCanonical = realpathSync2.native(canonical);
     if (realCanonical !== canonical)
       return walk(realCanonical);
   } catch {}
@@ -300,7 +460,7 @@ function recordDubiousOwnershipFallback(canonical) {
 function canonicalUserHomeDirectory() {
   const homeDirectory = userHomeDirectoryForIdentity();
   try {
-    return realpathSync.native(homeDirectory);
+    return realpathSync2.native(homeDirectory);
   } catch {
     return homeDirectory;
   }
@@ -309,20 +469,20 @@ function isUserHomeDirectory(directory) {
   if (projectDirectoryKey(directory) === projectDirectoryKey(userHomeDirectoryForIdentity()))
     return true;
   try {
-    return projectDirectoryKey(realpathSync.native(path2.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
+    return projectDirectoryKey(realpathSync2.native(path3.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
   } catch {
     return false;
   }
 }
 function assertProjectAllowed(directory, allowHomeProject) {
-  const canonical = path2.resolve(directory);
+  const canonical = path3.resolve(directory);
   if (!allowHomeProject && (isUserHomeDirectory(directory) || isUserHomeDirectory(gitRootDirectory(canonical) ?? canonical))) {
     throw new ProjectIdentityError("home_project_disabled", directory, "Home project memory is disabled; set allow_home_project to opt in");
   }
 }
 function resolveProjectIdentity(directory, allowHomeProject = homeProjectPermission) {
   assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path2.resolve(directory);
+  const canonical = path3.resolve(directory);
   const cachedFallback = directoryFallbackCache.get(canonical);
   if (cachedFallback !== undefined) {
     if (!hasGitDir(canonical)) {
@@ -370,7 +530,7 @@ function resolveProjectIdentityOrFallback(directory, allowHomeProject = homeProj
   try {
     return resolveProjectIdentity(directory, allowHomeProject);
   } catch (error) {
-    const canonical = path2.resolve(directory);
+    const canonical = path3.resolve(directory);
     if (hasGitDir(canonical) || error instanceof ProjectIdentityError && error.errorClass === "home_project_disabled")
       throw error;
     const fallback = rememberedIdentityOrDirectoryFallback(canonical);
@@ -384,7 +544,7 @@ function hasGitDir(canonical) {
     return true;
   }
   try {
-    const realCanonical = realpathSync.native(canonical);
+    const realCanonical = realpathSync2.native(canonical);
     return realCanonical !== canonical && hasGitDirInAncestorChain(realCanonical);
   } catch {
     return false;
@@ -393,14 +553,14 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync(path2.join(current, ".git"))) {
+    if (existsSync(path3.join(current, ".git"))) {
       try {
-        return realpathSync.native(current);
+        return realpathSync2.native(current);
       } catch {
-        return path2.resolve(current);
+        return path3.resolve(current);
       }
     }
-    const parent = path2.dirname(current);
+    const parent = path3.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -415,20 +575,20 @@ function gitRootDirectory(canonical) {
   if (direct)
     return direct;
   try {
-    const realCanonical = realpathSync.native(canonical);
+    const realCanonical = realpathSync2.native(canonical);
     return realCanonical === canonical ? null : gitRootInAncestorChain(realCanonical);
   } catch {
     return null;
   }
 }
 function directoryHasGitMetadata(directory) {
-  return gitRootDirectory(path2.resolve(directory)) !== null;
+  return gitRootDirectory(path3.resolve(directory)) !== null;
 }
 function isUsableProjectIdentity(identity) {
   return typeof identity === "string" && identity.trim().length > 0;
 }
 function resolveProjectIdentityForSession(directory, allowHomeProject = homeProjectPermission) {
-  const resolvedDirectory = path2.resolve(directory);
+  const resolvedDirectory = path3.resolve(directory);
   const cacheKey = `${allowHomeProject ? "1" : "0"}\x00${resolvedDirectory}`;
   const cached = sessionIdentityCache.get(cacheKey);
   if (cached && (cached.revalidateAt === null || nowMs() < cached.revalidateAt) && !(cached.identity?.startsWith("dir:") && hasGitDir(resolvedDirectory))) {
@@ -439,7 +599,7 @@ function resolveProjectIdentityForSession(directory, allowHomeProject = homeProj
   const canonicalDirectory = (() => {
     try {
       filesystemProbeObserverForTests?.();
-      return realpathSync.native(resolvedDirectory);
+      return realpathSync2.native(resolvedDirectory);
     } catch {
       return resolvedDirectory;
     }

package/dist/{index-gycf3sp7.js → index-7bqrfyny.js}

@@ -7,7 +7,15 @@ import * as fs from "node:fs";
 import * as path2 from "node:path";
 
 // ../plugin/src/shared/data-path.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import {
+  existsSync,
+  lstatSync,
+  mkdirSync,
+  readFileSync,
+  readlinkSync,
+  realpathSync,
+  writeFileSync
+} from "node:fs";
 import * as os from "node:os";
 import * as path from "node:path";
 
@@ -99,6 +107,42 @@ function getMagicContextStorageResolution() {
 function getMagicContextStorageDir() {
   return getMagicContextStorageResolution().path;
 }
+function canonicalizeStoragePath(value, seen = new Set) {
+  const absolute = path.resolve(value);
+  if (seen.has(absolute))
+    return absolute;
+  seen.add(absolute);
+  try {
+    return realpathSync.native(absolute);
+  } catch {
+    try {
+      if (lstatSync(absolute).isSymbolicLink()) {
+        const target = readlinkSync(absolute);
+        const resolvedTarget = path.isAbsolute(target) ? target : path.resolve(path.dirname(absolute), target);
+        return canonicalizeStoragePath(resolvedTarget, seen);
+      }
+    } catch {}
+    const parent = path.dirname(absolute);
+    if (parent === absolute)
+      return absolute;
+    const resolvedParent = canonicalizeStoragePath(parent, seen);
+    return path.resolve(resolvedParent, path.basename(absolute));
+  }
+}
+function isMagicContextStorageOutsideEngram(storageDir = getMagicContextStorageDir(), backupDir = path.join(os.homedir(), ".local", "share", "cortexkit", "magic-context")) {
+  const resolvedStorageDir = canonicalizeStoragePath(storageDir);
+  const resolvedBackupDir = canonicalizeStoragePath(backupDir);
+  const relative2 = path.relative(resolvedBackupDir, resolvedStorageDir);
+  return path.isAbsolute(relative2) || relative2 === ".." || relative2.startsWith(`..${path.sep}`);
+}
+var STORAGE_BACKUP_WARNING_CHECKED = Symbol.for("magic-context.storage-backup-warning-checked");
+function claimStorageBackupWarningCheck() {
+  const processState = globalThis;
+  if (processState[STORAGE_BACKUP_WARNING_CHECKED])
+    return false;
+  processState[STORAGE_BACKUP_WARNING_CHECKED] = true;
+  return true;
+}
 function getLegacyOpenCodeMagicContextStorageDir() {
   return path.join(getOpenCodeStorageDir(), "plugin", "magic-context");
 }
@@ -655,4 +699,4 @@ if (!isTestEnv) {
   process.on("exit", flush);
 }
 
-export { getDataDir, ensureCortexKitArtifactGitignore, getProjectMagicContextHistorianDir, getMagicContextStorageDir, getLegacyOpenCodeMagicContextStorageDir, sanitizeDiagnosticText, hasShareabilitySensitiveText, registerStalePluginBuildHost, classifyStalePluginBuild, importPluginModule, setLogLineForwarder2, writeForwardedLogLine2, log2, sessionLog2, getLoggerDiagnostics2, flushLogger2, getLogFilePath2 };
+export { getDataDir, ensureCortexKitArtifactGitignore, getProjectMagicContextHistorianDir, getMagicContextStorageDir, isMagicContextStorageOutsideEngram, claimStorageBackupWarningCheck, getLegacyOpenCodeMagicContextStorageDir, sanitizeDiagnosticText, hasShareabilitySensitiveText, registerStalePluginBuildHost, classifyStalePluginBuild, importPluginModule, setLogLineForwarder2, writeForwardedLogLine2, log2, sessionLog2, getLoggerDiagnostics2, flushLogger2, getLogFilePath2 };

package/dist/{index-drah07tf.js → index-7qc73yk5.js}

@@ -1,19 +1,19 @@
 import {
   getTokenEstimatorFingerprint,
   estimateTokens
-} from "./index-4pxydwvg.js";
+} from "./index-g4jf772p.js";
 import {
   getHarness2
 } from "./index-0h2mkab2.js";
 import {
   log2
-} from "./index-gycf3sp7.js";
+} from "./index-7bqrfyny.js";
 import {
   isSynapseEmbeddingTruncated
-} from "./index-szh001qb.js";
+} from "./index-6dz2ed1v.js";
 import {
   messageFtsOrdinalRangeIsMapped
-} from "./index-fdxzpnbj.js";
+} from "./index-djxc8w8c.js";
 
 // ../plugin/src/features/magic-context/compartment-chunk-embedding.ts
 import { createHash } from "node:crypto";
@@ -858,13 +858,17 @@ function loadUnembeddedShadowChunkCandidates(db, projectPath, primaryModelId, sh
   const rows = getShadowBackfillCandidateStatement(db).all(projectPath, projectPath, primaryModelId);
   return selectHashIncompleteChunkCandidates(db, projectPath, shadowModelId, mapBackfillCandidateRows(rows), Math.max(1, limit), shadowMaxInputTokens);
 }
-async function loadUnembeddedCompartmentChunkCandidatesPolite(db, projectPath, modelId, limit, maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS, leaseHeldRenumber = false) {
+async function loadUnembeddedCompartmentChunkCandidatesPolite(db, projectPath, modelId, limit, maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS, leaseHeldRenumber = false, isEligible) {
   const rows = getBackfillCandidateStatement(db).all(projectPath);
   const candidates = mapBackfillCandidateRows(rows);
   const missing = [];
   const stale = [];
   let sliceStarted = performance.now();
   for (const candidate of candidates) {
+    if (isEligible && !isEligible(candidate)) {
+      sliceStarted = await yieldCoverageSlice(sliceStarted);
+      continue;
+    }
     const classification = classifyChunkCoverageDefect(db, projectPath, modelId, candidate, maxInputTokens);
     if (classification.defect === "missing")
       missing.push(candidate);
@@ -1019,7 +1023,7 @@ function memoizedCoverageWindows(candidate, canonicalText, sourceKey, modelId, m
   return windows;
 }
 async function yieldCoverageSlice(started) {
-  if (performance.now() - started < 35)
+  if (performance.now() - started < 8)
     return started;
   await new Promise((resolve) => setTimeout(resolve, 0));
   return performance.now();
@@ -1093,6 +1097,47 @@ function selectHashIncompleteChunkCandidates(db, projectPath, modelId, candidate
   return [...missing, ...stale].slice(0, limit);
 }
 var sessionBackfillCandidateStatements = new WeakMap;
+function loadUnembeddedSessionChunkCandidates(db, projectPath, sessionId, modelId, limit, excludeIds, maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS, leaseHeldRenumber = false) {
+  const exclusions = excludeIds && excludeIds.length > 0 ? excludeIds : [];
+  const exclusionSql = exclusions.length > 0 ? `AND c.id NOT IN (${exclusions.map(() => "?").join(", ")})` : "";
+  const stmt = exclusions.length > 0 ? db.prepare(`SELECT c.id AS id,
+                          c.session_id AS sessionId,
+                          c.start_message AS startMessage,
+                          c.end_message AS endMessage,
+                          c.title AS title
+                   FROM compartments c
+                   JOIN session_projects sp
+                     ON sp.session_id = c.session_id
+                    AND sp.harness = c.harness
+                    AND sp.project_path = ?
+                   WHERE c.session_id = ?
+                     AND c.start_message IS NOT NULL
+                     AND c.end_message IS NOT NULL
+                     ${exclusionSql}
+                   ORDER BY c.start_message ASC, c.id ASC`) : (() => {
+    let cached = sessionBackfillCandidateStatements.get(db);
+    if (!cached) {
+      cached = db.prepare(`SELECT c.id AS id,
+                                  c.session_id AS sessionId,
+                                  c.start_message AS startMessage,
+                                  c.end_message AS endMessage,
+                                  c.title AS title
+                           FROM compartments c
+                           JOIN session_projects sp
+                             ON sp.session_id = c.session_id
+                            AND sp.harness = c.harness
+                            AND sp.project_path = ?
+                           WHERE c.session_id = ?
+                             AND c.start_message IS NOT NULL
+                             AND c.end_message IS NOT NULL
+                           ORDER BY c.start_message ASC, c.id ASC`);
+      sessionBackfillCandidateStatements.set(db, cached);
+    }
+    return cached;
+  })();
+  const rows = stmt.all(projectPath, sessionId, ...exclusions);
+  return selectHashIncompleteChunkCandidates(db, projectPath, modelId, mapBackfillCandidateRows(rows), Math.max(1, limit), maxInputTokens, leaseHeldRenumber);
+}
 async function loadUnembeddedSessionChunkCandidatesPolite(db, projectPath, sessionId, modelId, limit, excludeIds = [], maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS, leaseHeldRenumber = false) {
   const excluded = new Set(excludeIds);
   const missing = [];
@@ -1109,10 +1154,22 @@ async function loadUnembeddedSessionChunkCandidatesPolite(db, projectPath, sessi
     else if (leaseHeldRenumber) {
       applyLeaseHeldCoverageRepair(db, candidate, projectPath, modelId, classification);
     }
+    if (missing.length >= Math.max(1, limit))
+      return missing;
     started = await yieldCoverageSlice(started);
   }
   return [...missing, ...stale].slice(0, Math.max(1, limit));
 }
+function countUnembeddedSessionCompartments(db, projectPath, sessionId, modelId, maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS) {
+  const rows = getSessionBackfillRows(db, projectPath, sessionId);
+  let count = 0;
+  for (const candidate of rows) {
+    const { defect } = classifyChunkCoverageDefect(db, projectPath, modelId, candidate, maxInputTokens);
+    if (defect === "missing" || defect === "stale")
+      count++;
+  }
+  return count;
+}
 function countSessionCompartmentEmbedCoverage(db, projectPath, sessionId, modelId, maxInputTokens = DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS) {
   const candidates = getSessionBackfillRows(db, projectPath, sessionId);
   let embedded = 0;
@@ -1165,4 +1222,4 @@ async function countUnembeddedSessionCompartmentsPolite(db, projectPath, session
   return count;
 }
 
-export { CHUNK_WINDOW_SAFETY_RATIO, normalizeCompartmentChunkMaxInputTokens, buildCanonicalChunkTextFromFts, buildCompartmentSummaryFallbackText, canonicalizeInMemoryChunkTextForEmbedding, chunkCanonicalText, chunkEmbeddingWindowsAreCurrent, replaceCompartmentChunkEmbeddings, loadCompartmentChunkEmbeddingsForSearch, loadUnembeddedShadowChunkCandidates, loadUnembeddedCompartmentChunkCandidatesPolite, deleteChunkEmbedBackoffForSession, recordChunkEmbedBackoff, chunkWindowSourceKey, loadUnembeddedSessionChunkCandidatesPolite, countSessionCompartmentEmbedCoverage, countSessionCompartmentEmbedCoveragePolite, countUnembeddedSessionCompartmentsPolite };
+export { DEFAULT_COMPARTMENT_CHUNK_MAX_INPUT_TOKENS, CHUNK_WINDOW_SAFETY_RATIO, normalizeCompartmentChunkMaxInputTokens, buildCanonicalChunkTextFromFts, buildCompartmentSummaryFallbackText, canonicalizeInMemoryChunkTextForEmbedding, chunkCanonicalText, chunkEmbeddingWindowsAreCurrent, replaceCompartmentChunkEmbeddings, loadCompartmentChunkEmbeddingsForSearch, loadUnembeddedShadowChunkCandidates, loadUnembeddedCompartmentChunkCandidatesPolite, deleteChunkEmbedBackoffForSession, recordChunkEmbedBackoff, chunkWindowSourceKey, loadUnembeddedSessionChunkCandidates, loadUnembeddedSessionChunkCandidatesPolite, countUnembeddedSessionCompartments, countSessionCompartmentEmbedCoverage, countSessionCompartmentEmbedCoveragePolite, countUnembeddedSessionCompartmentsPolite };

package/dist/{index-s9kwv5pp.js → index-7wagp5jp.js}

@@ -1,21 +1,21 @@
 import {
   DEFAULT_LOCAL_EMBEDDING_MODEL
-} from "./index-ta0ed2nc.js";
+} from "./index-1k729e4f.js";
 import {
   log2
-} from "./index-gycf3sp7.js";
+} from "./index-7bqrfyny.js";
 import {
   isSynapseEmbeddingTruncated,
   SynapseEmbeddingProvider
-} from "./index-szh001qb.js";
+} from "./index-6dz2ed1v.js";
 import {
   LocalEmbeddingProvider
-} from "./index-8yjhda46.js";
+} from "./index-9jvktm7k.js";
 import {
   OpenAICompatibleEmbeddingProvider,
   getProjectEmbeddingSnapshot2,
   embedBatchForProject2
-} from "./index-78c864c8.js";
+} from "./index-nwbhe6qv.js";
 import {
   isEmbeddingHostBusy2
 } from "./index-9p40dgkm.js";

package/dist/{index-8yjhda46.js → index-9jvktm7k.js}

@@ -1,9 +1,9 @@
 import {
   DEFAULT_LOCAL_EMBEDDING_MODEL
-} from "./index-ta0ed2nc.js";
+} from "./index-1k729e4f.js";
 import {
   getSynapseLaneIdentity
-} from "./index-szh001qb.js";
+} from "./index-6dz2ed1v.js";
 import {
   getHarness2
 } from "./index-0h2mkab2.js";
@@ -11,7 +11,7 @@ import {
   getMagicContextStorageDir,
   importPluginModule,
   log2
-} from "./index-gycf3sp7.js";
+} from "./index-7bqrfyny.js";
 import {
   inRootAsyncContext2
 } from "./index-asrxgdt4.js";

package/dist/{index-3veejgp8.js → index-apgwdby5.js}

@@ -1,6 +1,6 @@
 import {
   log2
-} from "./index-gycf3sp7.js";
+} from "./index-7bqrfyny.js";
 
 // ../plugin/src/shared/rpc-utils.ts
 import { execFile, execFileSync } from "node:child_process";