@cortexkit/magic-context 0.41.0 → 0.41.2

package/dist/index.js

@@ -14708,6 +14708,73 @@ function recordSwallowedWrite(error) {
 function ensureDir4(filePath) {
   fs.mkdirSync(path2.dirname(filePath), { recursive: true });
 }
+function isMissingFile(error) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT";
+}
+function getCurrentLogSize(logFile) {
+  if (activeLogFile === logFile && activeLogSize !== null && flushesSinceSizeCheck < SIZE_CHECK_INTERVAL_FLUSHES) {
+    return activeLogSize;
+  }
+  try {
+    const stat = fs.statSync(logFile);
+    if (!stat.isFile()) {
+      throw new Error(`Magic Context log path is not a regular file: ${logFile}`);
+    }
+    fs.chmodSync(logFile, 384);
+    activeLogFile = logFile;
+    activeLogSize = stat.size;
+    flushesSinceSizeCheck = 0;
+    return stat.size;
+  } catch (error) {
+    if (!isMissingFile(error))
+      throw error;
+    activeLogFile = logFile;
+    activeLogSize = 0;
+    flushesSinceSizeCheck = 0;
+    return 0;
+  }
+}
+function capLogData(data) {
+  if (Buffer.byteLength(data) <= MAX_LOG_FILE_BYTES)
+    return data;
+  let bounded = Buffer.from(data).subarray(0, MAX_LOG_FILE_BYTES).toString("utf8");
+  while (Buffer.byteLength(bounded) > MAX_LOG_FILE_BYTES) {
+    bounded = bounded.slice(0, -1);
+  }
+  return bounded;
+}
+function writeBoundedPredecessor(logFile, predecessorPath, size) {
+  const predecessorFd = fs.openSync(predecessorPath, "w", 384);
+  try {
+    fs.fchmodSync(predecessorFd, 384);
+    const bytesToCopy = Math.min(size, MAX_LOG_FILE_BYTES);
+    const sourceFd = fs.openSync(logFile, "r");
+    try {
+      const chunk = Buffer.allocUnsafe(Math.min(64 * 1024, bytesToCopy));
+      let remaining = bytesToCopy;
+      let position = Math.max(0, size - bytesToCopy);
+      while (remaining > 0) {
+        const bytesRead = fs.readSync(sourceFd, chunk, 0, Math.min(chunk.length, remaining), position);
+        if (bytesRead === 0)
+          break;
+        fs.writeSync(predecessorFd, chunk, 0, bytesRead);
+        remaining -= bytesRead;
+        position += bytesRead;
+      }
+    } finally {
+      fs.closeSync(sourceFd);
+    }
+  } finally {
+    fs.closeSync(predecessorFd);
+  }
+}
+function rotateLogFile(logFile, size) {
+  const predecessorPath = `${logFile}.1`;
+  writeBoundedPredecessor(logFile, predecessorPath, size);
+  fs.truncateSync(logFile, 0);
+  activeLogSize = 0;
+  flushesSinceSizeCheck = 0;
+}
 function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -14715,13 +14782,26 @@ function flush() {
   }
   if (buffer.length === 0)
     return;
-  const data = buffer.join("");
+  const bufferedData = buffer.join("");
   buffer = [];
   try {
+    const data = capLogData(bufferedData);
     const logFile = getMagicContextLogPath();
     ensureDir4(logFile);
-    fs.appendFileSync(logFile, data);
+    let currentSize = getCurrentLogSize(logFile);
+    const dataSize = Buffer.byteLength(data);
+    if (currentSize > 0 && currentSize + dataSize > MAX_LOG_FILE_BYTES) {
+      rotateLogFile(logFile, currentSize);
+      currentSize = 0;
+    }
+    fs.appendFileSync(logFile, data, { encoding: "utf8", mode: 384 });
+    activeLogFile = logFile;
+    activeLogSize = currentSize + dataSize;
+    flushesSinceSizeCheck++;
   } catch (error) {
+    activeLogFile = null;
+    activeLogSize = null;
+    flushesSinceSizeCheck = 0;
     recordSwallowedWrite(error);
   }
 }
@@ -14749,17 +14829,23 @@ ${data.stack}` : ""}`)}` : ` ${JSON.stringify(sanitizeConfigValue(data))}`;
     }
   } catch {}
 }
-var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, MAX_LOG_FILE_BYTES, SIZE_CHECK_INTERVAL_FLUSHES = 64, activeLogFile = null, activeLogSize = null, flushesSinceSizeCheck = 0, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
 var init_logger = __esm(() => {
   init_data_path();
   init_redaction();
   buffer = [];
+  MAX_LOG_FILE_BYTES = 32 * 1024 * 1024;
   if (!isTestEnv) {
     process.on("exit", flush);
   }
 });
 // ../plugin/src/shared/window-geometry.ts
 function setWindowOverlayPath(path3) {
+  if (configuredOverlayPath === path3)
+    return;
+  reloadWindowOverlay(path3);
+}
+function reloadWindowOverlay(path3) {
   configuredOverlayPath = path3;
   loadedOverlayPath = undefined;
   loadedOverlay = undefined;
@@ -30132,6 +30218,7 @@ var init_magic_context = __esm(() => {
     query_input_type: exports_external.string().optional().describe("Optional input_type for query (search) embeddings on asymmetric models (e.g. NVIDIA NIM 'query'). When unset, query embeddings use embedding.input_type. Passage/stored content always uses embedding.input_type."),
     truncate: exports_external.string().optional().describe("Optional truncate mode sent in the embedding request body (e.g. NVIDIA NIM accepts 'NONE' | 'START' | 'END'). Omitted from the request when unset."),
     max_input_tokens: exports_external.number().int().positive().optional().describe("Optional maximum input tokens for chunk embeddings. Defaults conservatively to 512 when omitted."),
+    local_runtime: exports_external.enum(["auto", "native", "wasm"]).default("auto").describe("Local provider only: ONNX runtime selection. 'auto' uses native under Node and uses WASM under Bun versions before 1.4.0, where Bun's NAPI teardown race can panic on quit; native is restored automatically on Bun 1.4.0+. Set 'native' only to prefer speed while accepting that pre-1.4.0 Bun crash risk, or 'wasm' to avoid loading the native addon."),
     local_dtype: exports_external.enum([
       "auto",
       "fp32",
@@ -30188,6 +30275,7 @@ var init_magic_context = __esm(() => {
       return {
         provider: "local",
         model: data.model?.trim() || DEFAULT_LOCAL_EMBEDDING_MODEL,
+        local_runtime: data.local_runtime,
         ...data.max_input_tokens ? { max_input_tokens: data.max_input_tokens } : {},
         ...data.local_dtype ? { local_dtype: data.local_dtype } : {}
       };
@@ -30268,7 +30356,8 @@ var init_magic_context = __esm(() => {
     }).default({ enforce_private_permissions: true }).describe("Storage permission policy. The default keeps session content and memories owner-private. Disabling enforcement is for trusted shared-group storage managed externally; every group member able to read the storage can read all stored session content and memories."),
     embedding: EmbeddingConfigSchema.default({
       provider: "local",
-      model: DEFAULT_LOCAL_EMBEDDING_MODEL
+      model: DEFAULT_LOCAL_EMBEDDING_MODEL,
+      local_runtime: "auto"
     }).describe("Embedding provider configuration"),
     subc: exports_external.object({
       connection_file: exports_external.string().trim().min(1).transform(expandConfigPath).describe("Path to the owner-only subc connection file.")
@@ -31820,8 +31909,8 @@ function runOpenCode(args, binary, timeoutMs) {
     return null;
   }
 }
-function getOpenCodeVersion(binary) {
-  return runOpenCode(["--version"], binary, OPENCODE_VERSION_PROBE_TIMEOUT_MS);
+function getOpenCodeVersion(binary, timeoutMs = OPENCODE_VERSION_PROBE_TIMEOUT_MS) {
+  return runOpenCode(["--version"], binary, timeoutMs);
 }
 function describeOpenCodeInstallations(installations, deps = {}) {
   const getVersion = deps.getVersion ?? getOpenCodeVersion;
@@ -32872,11 +32961,16 @@ function prepareMirrorPageStatements(db) {
 function mirrorIdentity(db, domain2, moduleProject, moduleRowId, statements) {
   return (statements?.identityByModule ?? db.prepare("SELECT context_row_id FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?")).get(domain2, moduleProject, moduleRowId) ?? null;
 }
-function rememberIdentity(db, domain2, moduleProject, moduleRowId, contextRowId, statements) {
+function rememberIdentity(db, domain2, moduleProject, moduleRowId, contextRowId, statements, replaceContextIdentity = domain2 === "notes") {
   const existing = mirrorIdentity(db, domain2, moduleProject, moduleRowId, statements);
-  if (existing)
+  if (existing?.context_row_id === contextRowId)
     return;
-  if (domain2 === "notes") {
+  if (existing) {
+    if (!replaceContextIdentity)
+      return;
+    (statements?.deleteIdentity ?? db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?")).run(domain2, moduleProject, moduleRowId);
+  }
+  if (replaceContextIdentity) {
     (statements?.deleteIdentityByContext ?? db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND context_row_id = ?")).run(domain2, contextRowId);
   }
   (statements?.insertIdentity ?? db.prepare("INSERT OR IGNORE INTO mirror_identity(domain, module_project, module_row_id, context_row_id) VALUES (?, ?, ?, ?)")).run(domain2, moduleProject, moduleRowId, contextRowId);
@@ -32891,7 +32985,7 @@ function contextMemoryId(db, domain2, moduleProject, row, moduleRowId, statement
   if (sourceUuid && sourceUuid === localStoreUuid && sourceId >= 0) {
     const existing = (statements?.memoryIdByStoreId ?? db.prepare("SELECT id FROM memories WHERE id = ? AND project_path = ?")).get(sourceId, moduleProject);
     if (existing?.id !== undefined) {
-      rememberIdentity(db, domain2, moduleProject, moduleRowId, existing.id, statements);
+      rememberIdentity(db, domain2, moduleProject, moduleRowId, existing.id, statements, true);
       return existing.id;
     }
   }
@@ -33120,6 +33214,24 @@ function applyMirrorPage(args) {
       if (page.domain === "memories" && resnapshotStatus !== "complete" && page.rows.some((feed) => feed.op === "tombstone")) {
         throw new Error("memory mirror resnapshot must complete before tombstones");
       }
+      if (page.domain === "memories") {
+        for (const feed of page.rows) {
+          if (feed.domain !== "memories" || feed.op === "tombstone" || feed.feed_seq <= durableCursor) {
+            continue;
+          }
+          const row = feed.full_row_snapshot;
+          const moduleProject = rowString(row, "project_path");
+          const sourceUuid = rowNullableString(row, "context_store_uuid");
+          const sourceId = rowNumber(row, "context_row_id", -1);
+          if (!moduleProject || !sourceUuid || sourceUuid !== statements.contextStoreUuid || sourceId < 0) {
+            continue;
+          }
+          const existing = statements.memoryIdByStoreId.get(sourceId, moduleProject);
+          if (existing?.id === undefined)
+            continue;
+          rememberIdentity(db, "memories", moduleProject, feed.module_row_id, existing.id, statements, true);
+        }
+      }
       const touchedProjects = new Set;
       for (const feed of page.rows) {
         if (feed.domain !== page.domain || feed.feed_seq <= nextCursor)
@@ -33314,7 +33426,7 @@ var init_context_authority = __esm(async () => {
 // ../plugin/src/features/magic-context/memory/project-identity.ts
 import { execFileSync as execFileSync3 } from "node:child_process";
 import { createHash as createHash2 } from "node:crypto";
-import { existsSync as existsSync18, realpathSync as realpathSync2, statSync as statSync7 } from "node:fs";
+import { existsSync as existsSync18, realpathSync as realpathSync2, statSync as statSync8 } from "node:fs";
 import path3 from "node:path";
 function asError(error51) {
   return error51 instanceof Error ? error51 : undefined;
@@ -33359,7 +33471,7 @@ function directoryFallback(directory) {
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
   try {
-    const stat = statSync7(canonicalDirectory);
+    const stat = statSync8(canonicalDirectory);
     if (!stat.isDirectory()) {
       throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
     }
@@ -35613,7 +35725,7 @@ function readPsProcessStartTime(pid) {
 function readProcessStartTime(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return null;
-  return rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(pid) : rpcIdentityPlatform === "win32" ? null : readPsProcessStartTime(pid);
+  return rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(pid) : rpcIdentityPlatform === "win32" ? readWindowsProcessStartTime(pid) : readPsProcessStartTime(pid);
 }
 function readProcessProbeEvidence(pid) {
   return {
@@ -35621,6 +35733,9 @@ function readProcessProbeEvidence(pid) {
     commandLine: readProcessCommand(pid)
   };
 }
+function rememberWindowsProcessFacts(facts) {
+  windowsProcessFactsCache = new Map(facts.map((fact) => [fact.pid, fact]));
+}
 function parseCsvLine(line) {
   const fields = [];
   let field = "";
@@ -35685,6 +35800,16 @@ function readWindowsProcess(pid) {
     return { state: "inconclusive" };
   }
 }
+function readWindowsProcessStartTime(pid) {
+  const cached2 = windowsProcessFactsCache?.get(pid);
+  if (cached2)
+    return cached2.startTime;
+  const snapshot = tryReadWindowsCimSnapshot(rpcIdentityExecFileSync);
+  if (!snapshot)
+    return null;
+  rememberWindowsProcessFacts(snapshot.facts);
+  return windowsProcessFactsCache?.get(pid)?.startTime ?? null;
+}
 function readLinuxProcessCommand(pid) {
   try {
     return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
@@ -35707,7 +35832,15 @@ function readPsProcessCommand(pid) {
 function readProcessCommand(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
     return null;
-  return rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(pid) : rpcIdentityPlatform === "win32" ? readWindowsProcess(pid).command ?? null : readPsProcessCommand(pid);
+  if (rpcIdentityPlatform === "linux")
+    return readLinuxProcessCommand(pid);
+  if (rpcIdentityPlatform === "win32") {
+    const cached2 = windowsProcessFactsCache?.get(pid);
+    if (cached2?.commandLine)
+      return cached2.commandLine;
+    return readWindowsProcess(pid).command ?? null;
+  }
+  return readPsProcessCommand(pid);
 }
 function executableName(token) {
   return (token ?? "").replace(/^['"]|['"]$/g, "").split("/").at(-1) ?? "";
@@ -35767,57 +35900,262 @@ function isPidIdentityPlausible(record2, evidence) {
     return "inconclusive";
   return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }
-function commandLooksLikePi(command) {
-  const normalized = command.trim().toLowerCase().replaceAll("\\", "/");
-  const tokens = normalized.split(/\s+/).filter(Boolean);
-  const executableName2 = (token) => (token ?? "").split("/").at(-1) ?? "";
-  const first = executableName2(tokens[0]).replace(/\.exe$/, "");
-  if (["pi", "pi.cmd", "omp", "oh-my-pi"].includes(first))
+function commandLooksLikePiImage(command) {
+  const tokens = commandTokens(command);
+  const first = executableName(tokens[0]).replace(/\.(?:exe|cmd)$/, "");
+  return PI_IMAGE_NAMES.has(first);
+}
+function commandHasPiHarnessArc(command) {
+  const normalized = command.trim().toLowerCase().replaceAll("\\", "/").replaceAll("\x00", " ");
+  if (!normalized)
+    return false;
+  const tokens = commandTokens(command);
+  if (tokens.length === 0)
+    return false;
+  const hasArc = PI_HARNESS_ARC_MARKERS.some((marker) => normalized.includes(marker));
+  const first = executableName(tokens[0]).replace(/\.(?:exe|cmd)$/, "");
+  if (hasArc && ["pi", "omp", "oh-my-pi", "node", "bun", "deno", "cmd"].includes(first)) {
+    return true;
+  }
+  if (hasArc && PI_HARNESS_ARC_MARKERS.some((marker) => tokens[0].includes(marker))) {
     return true;
+  }
   if (["node", "bun", "deno"].includes(first)) {
-    const script = executableName2(tokens[1]);
-    return ["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script) || normalized.includes("pi-coding-agent");
+    const script = executableName(tokens[1]).replace(/\.(?:exe|cmd)$/, "");
+    if (["pi", "pi.js", "pi.mjs", "pi.cjs"].includes(script))
+      return true;
+    if (hasArc)
+      return true;
   }
   return false;
 }
+function execProcessList(exec2, file2, args, timeout = PS_PROBE_TIMEOUT_MS) {
+  return String(exec2(file2, [...args], {
+    encoding: "utf8",
+    timeout,
+    stdio: ["ignore", "pipe", "pipe"]
+  }));
+}
+function parseWindowsCreationDate(value) {
+  if (typeof value === "number" && Number.isFinite(value)) {
+    return value > 1000000000000 ? value : value * 1000;
+  }
+  if (typeof value !== "string")
+    return null;
+  const trimmed = value.trim();
+  if (!trimmed)
+    return null;
+  const wmi = /^(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})\.(\d{6})([+-])(\d{3})$/.exec(trimmed);
+  if (wmi) {
+    const utcMs = Date.UTC(Number(wmi[1]), Number(wmi[2]) - 1, Number(wmi[3]), Number(wmi[4]), Number(wmi[5]), Number(wmi[6]), Number(wmi[7]) / 1000);
+    if (!Number.isFinite(utcMs))
+      return null;
+    const offsetMinutes = Number(wmi[9]);
+    const sign = wmi[8] === "+" ? 1 : -1;
+    return utcMs - sign * offsetMinutes * 60000;
+  }
+  const dotNet = /^\/Date\((-?\d+)\)\/$/.exec(trimmed);
+  if (dotNet) {
+    const milliseconds = Number(dotNet[1]);
+    return Number.isFinite(milliseconds) ? milliseconds : null;
+  }
+  const parsed = Date.parse(trimmed);
+  return Number.isFinite(parsed) ? parsed : null;
+}
+function parseWindowsCimOutput(output) {
+  const trimmed = output.trim();
+  if (!trimmed)
+    return null;
+  const bracket = trimmed.indexOf("[");
+  const brace = trimmed.indexOf("{");
+  const start = Math.min(bracket === -1 ? Number.POSITIVE_INFINITY : bracket, brace === -1 ? Number.POSITIVE_INFINITY : brace);
+  if (!Number.isFinite(start))
+    return null;
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed.slice(start));
+  } catch {
+    return null;
+  }
+  if (parsed == null)
+    return null;
+  const rows = Array.isArray(parsed) ? parsed : [parsed];
+  const facts = [];
+  for (const row of rows) {
+    if (!row || typeof row !== "object")
+      continue;
+    const record2 = row;
+    const pid = Number(record2.ProcessId);
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    const parentRaw = record2.ParentProcessId;
+    const parentPid = parentRaw == null || parentRaw === "" ? Number.NaN : Number(parentRaw);
+    const commandLine = typeof record2.CommandLine === "string" ? record2.CommandLine : null;
+    facts.push({
+      pid,
+      parentPid: Number.isInteger(parentPid) && parentPid > 0 ? parentPid : null,
+      commandLine,
+      imageName: commandLine ? executableName(commandTokens(commandLine)[0]) : null,
+      startTime: parseWindowsCreationDate(record2.CreationDate)
+    });
+  }
+  return facts.length > 0 ? facts : null;
+}
+function snapshotFromFacts(facts, source) {
+  const parentByPid = new Map;
+  for (const fact of facts) {
+    if (fact.parentPid != null)
+      parentByPid.set(fact.pid, fact.parentPid);
+  }
+  return { facts, parentByPid, source };
+}
+function tryReadWindowsCimSnapshot(exec2) {
+  try {
+    const output = execProcessList(exec2, "powershell", ["-NoProfile", "-Command", WINDOWS_CIM_COMMAND], WINDOWS_CIM_PROBE_TIMEOUT_MS);
+    const facts = parseWindowsCimOutput(output);
+    return facts ? snapshotFromFacts(facts, "cim") : null;
+  } catch {
+    return null;
+  }
+}
+function tryReadWindowsTasklistSnapshot() {
+  try {
+    const output = execProcessList(rpcProcessListExecFileSync, "tasklist", ["/FO", "CSV"]);
+    const entries = parseTasklistOutput(output);
+    if (entries === null)
+      return null;
+    const facts = entries.map((entry) => ({
+      pid: entry.pid,
+      parentPid: null,
+      commandLine: null,
+      imageName: entry.command,
+      startTime: null
+    }));
+    return snapshotFromFacts(facts, "tasklist");
+  } catch {
+    return null;
+  }
+}
+function readPosixProcessSnapshot() {
+  const output = execProcessList(rpcProcessListExecFileSync, "ps", ["-axo", "pid=,command="]);
+  const facts = [];
+  for (const line of output.split(/\r?\n/)) {
+    const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+    if (!match)
+      continue;
+    const pid = Number(match[1]);
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    facts.push({
+      pid,
+      parentPid: null,
+      commandLine: match[2],
+      imageName: executableName(commandTokens(match[2])[0]),
+      startTime: null
+    });
+  }
+  return snapshotFromFacts(facts, "ps");
+}
+function readPosixParentPid(pid) {
+  try {
+    const output = execProcessList(rpcProcessListExecFileSync, "ps", [
+      "-o",
+      "ppid=",
+      "-p",
+      String(pid)
+    ]);
+    const match = /^\s*(\d+)\s*$/.exec(output);
+    if (!match)
+      return null;
+    const ppid = Number(match[1]);
+    return Number.isInteger(ppid) && ppid > 0 ? ppid : null;
+  } catch {
+    return null;
+  }
+}
+function collectAncestorPids(selfPid, parentByPid) {
+  const ancestors = new Set;
+  let current = selfPid;
+  for (let depth = 0;depth < MAX_ANCESTOR_WALK_DEPTH; depth += 1) {
+    let ppid = null;
+    if (parentByPid.has(current)) {
+      ppid = parentByPid.get(current) ?? null;
+    } else if (rpcIdentityPlatform !== "win32") {
+      ppid = readPosixParentPid(current);
+      if (ppid == null && current === process.pid && process.ppid > 0) {
+        ppid = process.ppid;
+      }
+    } else if (current === process.pid && process.ppid > 0) {
+      ppid = process.ppid;
+    } else {
+      break;
+    }
+    if (ppid == null || ppid <= 0 || ppid === current || ancestors.has(ppid))
+      break;
+    ancestors.add(ppid);
+    current = ppid;
+  }
+  return ancestors;
+}
+function classifyLivePiSnapshot(snapshot) {
+  const ancestors = collectAncestorPids(process.pid, snapshot.parentByPid);
+  const processIds = new Set;
+  const inconclusivePids = new Set;
+  const skippedAncestorPids = [];
+  for (const fact of snapshot.facts) {
+    if (fact.pid === process.pid)
+      continue;
+    const command = fact.commandLine ?? fact.imageName ?? "";
+    const looksLikeHarness = commandHasPiHarnessArc(command) || commandLooksLikePiImage(command);
+    if (!looksLikeHarness)
+      continue;
+    if (ancestors.has(fact.pid)) {
+      skippedAncestorPids.push(fact.pid);
+      log3(`[magic-context] Pi process scan: skipping ancestor PID ${fact.pid} (session launcher shim)`);
+      continue;
+    }
+    if (commandHasPiHarnessArc(command)) {
+      processIds.add(fact.pid);
+      continue;
+    }
+    inconclusivePids.add(fact.pid);
+    log3(`[magic-context] Pi process scan: PID ${fact.pid} command line is ambiguous (image-name or missing Pi/OMP arc); treating as inconclusive`);
+  }
+  skippedAncestorPids.sort((left, right) => left - right);
+  const verified = [...processIds].sort((left, right) => left - right);
+  const inconclusive = [...inconclusivePids].sort((left, right) => left - right);
+  if (verified.length === 0 && inconclusive.length > 0) {
+    return {
+      state: "inconclusive",
+      processIds: [],
+      inconclusivePids: inconclusive,
+      ...skippedAncestorPids.length > 0 ? { skippedAncestorPids } : {}
+    };
+  }
+  return {
+    state: "known",
+    processIds: verified,
+    ...inconclusive.length > 0 ? { inconclusivePids: inconclusive } : {},
+    ...skippedAncestorPids.length > 0 ? { skippedAncestorPids } : {}
+  };
+}
 function inspectLivePiProcesses() {
   if (false) {}
   try {
-    const isWindows = rpcIdentityPlatform === "win32";
-    const output = String(rpcProcessListExecFileSync(isWindows ? "tasklist" : "ps", isWindows ? ["/FO", "CSV"] : ["-axo", "pid=,command="], {
-      encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "pipe"]
-    }));
-    const pids = new Set;
-    if (isWindows) {
-      const entries = parseTasklistOutput(output);
-      if (entries === null) {
+    if (rpcIdentityPlatform === "win32") {
+      const cim = tryReadWindowsCimSnapshot(rpcProcessListExecFileSync);
+      const snapshot = cim ?? tryReadWindowsTasklistSnapshot();
+      if (!snapshot) {
         return {
           state: "unreadable",
           processIds: [],
-          error: "tasklist output unavailable"
+          error: "process list unavailable"
         };
       }
-      for (const entry of entries) {
-        if (entry.pid === process.pid)
-          continue;
-        if (commandLooksLikePi(entry.command))
-          pids.add(entry.pid);
-      }
-    } else {
-      for (const line of output.split(/\r?\n/)) {
-        const match = /^\s*(\d+)\s+(.+)$/.exec(line);
-        if (!match)
-          continue;
-        const pid = Number(match[1]);
-        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
-          continue;
-        if (commandLooksLikePi(match[2]))
-          pids.add(pid);
-      }
+      rememberWindowsProcessFacts(snapshot.facts);
+      return classifyLivePiSnapshot(snapshot);
     }
-    return { state: "known", processIds: [...pids].sort((left, right) => left - right) };
+    return classifyLivePiSnapshot(readPosixProcessSnapshot());
   } catch (error51) {
     return {
       state: "unreadable",
@@ -35859,10 +36197,19 @@ function parseRpcPortFile(content, fallbackPid = 0) {
 function isValidPort(port) {
   return Number.isInteger(port) && port > 0 && port <= 65535;
 }
-var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now();
+var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, PI_IMAGE_NAMES, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
 var init_rpc_utils = __esm(() => {
+  init_logger();
   OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
   TASKLIST_NO_TASKS_PATTERN = /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
+  PI_HARNESS_ARC_MARKERS = [
+    "pi-coding-agent",
+    "oh-my-pi",
+    "@oh-my-pi",
+    "cljs/dist",
+    "dist/bundle/cli"
+  ];
+  PI_IMAGE_NAMES = new Set(["pi", "pi.cmd", "omp", "oh-my-pi"]);
   rpcIdentityReadFileSync = readFileSync12;
   rpcIdentityExecFileSync = execFileSync4;
   rpcIdentityProcessKill = process.kill;
@@ -35982,8 +36329,8 @@ function formatFailClosedBlockingMessage(reason) {
       ].join(" ");
     }
     return [
-      `Magic Context cannot migrate the shared database because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
-      "Restart the blocking process (it will pick up the new build and migrate on start), or shut it down and retry.",
+      `Magic Context cannot migrate the shared database (one database serves every project on this machine) because ${formatFailClosedBlockingProcesses(reason.blockingProcesses)} may be running an older Magic Context build that would fail against the migrated database.`,
+      "Restart the blocking process — even one from a different project — and it will pick up the new build and migrate on start; or shut it down and retry.",
       `Recovery: ${FAIL_CLOSED_DOCTOR_COMMAND}`
     ].join(" ");
   }
@@ -36006,6 +36353,16 @@ var init_fail_closed_block = __esm(() => {
   OPENCODE_INTERNAL_AGENT_NAMES = new Set(["title", "summary", "compaction"]);
 });
 
+// ../plugin/src/features/magic-context/message-fts-rowid-map.ts
+import { createHash as createHash3 } from "node:crypto";
+var EMPTY_INDEX_CONTENT_HASH, upsertMapStatements, rangeReadyStatements, activeBackfills;
+var init_message_fts_rowid_map = __esm(() => {
+  EMPTY_INDEX_CONTENT_HASH = createHash3("sha256").update("").digest("hex");
+  upsertMapStatements = new WeakMap;
+  rangeReadyStatements = new WeakMap;
+  activeBackfills = new WeakMap;
+});
+
 // ../plugin/src/hooks/magic-context/compartment-parser.ts
 function makeTierOpenRegex(n2) {
   return new RegExp(`<p${n2}\\s*(/?)>`);
@@ -36244,6 +36601,7 @@ function healAllNullColumns(db) {
     ["stale_reduce_stripped_ids", ""],
     ["processed_image_stripped_ids", ""],
     ["merged_reasoning_stripped_ids", ""],
+    ["thinking_binding_recovery_target", ""],
     ["trailing_blank_decisions", ""],
     ["memory_block_cache", ""],
     ["memory_block_ids", ""],
@@ -38623,6 +38981,30 @@ var init_migrations = __esm(() => {
           return;
         ensureColumn(db, "memory_verifications", "mapping_origin", "TEXT NOT NULL DEFAULT 'mapper'");
       }
+    },
+    {
+      version: 83,
+      description: "add indexed rowid access for message FTS content",
+      up(db) {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS message_fts_rowid_map (
+                    session_id TEXT NOT NULL,
+                    message_ordinal INTEGER NOT NULL,
+                    fts_rowid INTEGER NOT NULL,
+                    PRIMARY KEY(session_id, message_ordinal)
+                );
+
+                CREATE TABLE IF NOT EXISTS message_fts_rowid_map_backfill_state (
+                    id INTEGER PRIMARY KEY CHECK(id = 1),
+                    watermark_rowid INTEGER NOT NULL DEFAULT 0,
+                    completed INTEGER NOT NULL DEFAULT 0 CHECK(completed IN (0, 1)),
+                    updated_at INTEGER NOT NULL DEFAULT 0
+                );
+                INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
+                    (id, watermark_rowid, completed, updated_at)
+                VALUES (1, 0, 0, 0);
+            `);
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m3) => Math.max(max, m3.version), 0);
@@ -38656,14 +39038,14 @@ var init_tool_owner_backfill = __esm(() => {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 import {
-  chmodSync as chmodSync2,
+  chmodSync as chmodSync3,
   copyFileSync,
   cpSync,
   existsSync as existsSync19,
   mkdirSync as mkdirSync7,
   readdirSync as readdirSync2,
   readFileSync as readFileSync13,
-  statSync as statSync8,
+  statSync as statSync9,
   unlinkSync as unlinkSync3
 } from "node:fs";
 import { basename as basename4, dirname as dirname11, join as join15, resolve as resolve6 } from "node:path";
@@ -39385,6 +39767,23 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       tokenize='porter unicode61'
     );
 
+    CREATE TABLE IF NOT EXISTS message_fts_rowid_map (
+      session_id TEXT NOT NULL,
+      message_ordinal INTEGER NOT NULL,
+      fts_rowid INTEGER NOT NULL,
+      PRIMARY KEY(session_id, message_ordinal)
+    );
+
+    CREATE TABLE IF NOT EXISTS message_fts_rowid_map_backfill_state (
+      id INTEGER PRIMARY KEY CHECK(id = 1),
+      watermark_rowid INTEGER NOT NULL DEFAULT 0,
+      completed INTEGER NOT NULL DEFAULT 0 CHECK(completed IN (0, 1)),
+      updated_at INTEGER NOT NULL DEFAULT 0
+    );
+    INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
+      (id, watermark_rowid, completed, updated_at)
+    VALUES (1, 0, 0, 0);
+
     CREATE TABLE IF NOT EXISTS message_history_index (
       session_id TEXT PRIMARY KEY,
       last_indexed_ordinal INTEGER NOT NULL DEFAULT 0,
@@ -39528,8 +39927,9 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       cached_m0_system_hash TEXT,
       cached_m0_tool_set_hash TEXT,
       cached_m0_model_key TEXT,
-      cached_m0_project_identity TEXT,
-      cached_m0_last_baseline_end_message_id TEXT,
+       cached_m0_project_identity TEXT,
+       cached_m0_last_baseline_end_message_id TEXT,
+       thinking_binding_recovery_target TEXT NOT NULL DEFAULT '',
        upgrade_reminded_at INTEGER,
        pi_stable_id_scheme INTEGER
     );
@@ -39751,6 +40151,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "processed_image_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "merged_reasoning_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "thinking_binding_recovery_target", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "trailing_blank_decisions", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "start_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "end_message_id", "TEXT DEFAULT ''");
@@ -39984,12 +40385,13 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
     `);
   ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
 }
-var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 82, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS;
+var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 83, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig, CHANNEL2_CLAIM_TTL_MS;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
   init_rpc_utils();
   init_fail_closed_block();
+  init_message_fts_rowid_map();
   init_migrations();
   init_tool_definition_tokens();
   init_tool_owner_backfill();
@@ -40007,7 +40409,7 @@ var init_storage_db = __esm(async () => {
   defaultRpcDiscoveryFs = {
     readdirSync: (path4, options) => options?.withFileTypes ? readdirSync2(path4, { withFileTypes: true }) : readdirSync2(path4),
     readFileSync: (path4, encoding) => String(readFileSync13(path4, encoding)),
-    statSync: (path4) => ({ mtimeMs: statSync8(path4).mtimeMs }),
+    statSync: (path4) => ({ mtimeMs: statSync9(path4).mtimeMs }),
     unlinkSync: (path4) => unlinkSync3(path4)
   };
   rpcDiscoveryFs = defaultRpcDiscoveryFs;
@@ -40647,15 +41049,15 @@ __export(exports_doctor_repair_db, {
 });
 import { spawnSync as spawnSync3 } from "node:child_process";
 import {
-  chmodSync as chmodSync3,
-  closeSync as closeSync3,
+  chmodSync as chmodSync4,
+  closeSync as closeSync4,
   constants as constants2,
   copyFileSync as copyFileSync2,
   existsSync as existsSync21,
-  openSync as openSync3,
+  openSync as openSync4,
   renameSync as renameSync4,
   rmSync as rmSync2,
-  statSync as statSync9
+  statSync as statSync10
 } from "node:fs";
 import { dirname as dirname12, join as join17 } from "node:path";
 function defaultInspectHolders(storageDir) {
@@ -40670,11 +41072,11 @@ function defaultInspectHolders(storageDir) {
   }
   const blockers = rpc.state === "live" ? rpc.serverPids.map((pid) => `OpenCode server (PID ${pid})`) : [];
   const pi = inspectLivePiProcesses();
-  if (pi.state === "unreadable") {
+  if (pi.state === "unreadable" || pi.state === "inconclusive") {
     return {
       safe: false,
       blockers,
-      uncertainty: `Pi/OMP process liveness could not be determined: ${pi.error ?? "process list unavailable"}`
+      uncertainty: pi.state === "inconclusive" ? `Pi/OMP process image or command line was ambiguous (PID ${(pi.inconclusivePids ?? []).join(", ")})` : `Pi/OMP process liveness could not be determined: ${pi.error ?? "process list unavailable"}`
     };
   }
   blockers.push(...pi.processIds.map((pid) => `Pi/OMP harness (PID ${pid})`));
@@ -40772,13 +41174,13 @@ function isRecoverCapabilityMissing(errorDetail) {
 function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath) {
   let dumpWriteFd = null;
   try {
-    dumpWriteFd = openSync3(dumpPath, "wx", 384);
+    dumpWriteFd = openSync4(dumpPath, "wx", 384);
     const recovered = spawnSync3(sqliteExecutable, [sourcePath, ".recover"], {
       stdio: ["ignore", dumpWriteFd, "pipe"],
       encoding: "utf8",
       windowsHide: true
     });
-    closeSync3(dumpWriteFd);
+    closeSync4(dumpWriteFd);
     dumpWriteFd = null;
     if (recovered.error || recovered.status !== 0) {
       const errorDetail = sqliteError(recovered);
@@ -40790,7 +41192,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
         unavailable: attempted && isRecoverCapabilityMissing(errorDetail)
       };
     }
-    const dumpReadFd = openSync3(dumpPath, "r");
+    const dumpReadFd = openSync4(dumpPath, "r");
     try {
       const replayed = spawnSync3(sqliteExecutable, [recoveredPath], {
         stdio: [dumpReadFd, "ignore", "pipe"],
@@ -40806,7 +41208,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
         };
       }
     } finally {
-      closeSync3(dumpReadFd);
+      closeSync4(dumpReadFd);
     }
     return { ok: true };
   } catch (error51) {
@@ -40818,7 +41220,7 @@ function runRecoverShell(sqliteExecutable, sourcePath, recoveredPath, dumpPath)
     };
   } finally {
     if (dumpWriteFd !== null)
-      closeSync3(dumpWriteFd);
+      closeSync4(dumpWriteFd);
     rmSync2(dumpPath, { force: true });
   }
 }
@@ -41039,8 +41441,8 @@ async function runRepairDb(options = {}) {
       return reportSafetyRefusal(prompts, dbPath, finalInspection, backup.basePath);
     }
     try {
-      const originalMode = statSync9(dbPath).mode & 511;
-      chmodSync3(recoveredPath, originalMode);
+      const originalMode = statSync10(dbPath).mode & 511;
+      chmodSync4(recoveredPath, originalMode);
       const originalAsidePath = uniqueBase(`${dbPath}.corrupt-original-${stamp}`);
       const moved = activateReplacement(dbPath, recoveredPath, originalAsidePath);
       reportSchemaTransition(prompts, salvageResult);
@@ -41087,8 +41489,8 @@ async function runRepairDb(options = {}) {
     return REPAIR_DB_EXIT.failed;
   }
   try {
-    const originalMode = statSync9(dbPath).mode & 511;
-    chmodSync3(freshPath, originalMode);
+    const originalMode = statSync10(dbPath).mode & 511;
+    chmodSync4(freshPath, originalMode);
     const originalAsidePath = uniqueBase(`${dbPath}.corrupt-original-${stamp}`);
     const moved = activateReplacement(dbPath, freshPath, originalAsidePath);
     reportSchemaTransition(prompts, fresh);
@@ -41176,7 +41578,7 @@ __export(exports_migrate, {
   runMigrateCli: () => runMigrateCli,
   sweepPendingMigrations: () => sweepPendingMigrations
 });
-import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
 import { existsSync as existsSync22, mkdirSync as mkdirSync8, renameSync as renameSync5, unlinkSync as unlinkSync4 } from "node:fs";
 import { dirname as dirname13, join as join19 } from "node:path";
 function defaultOpenCodeDbPath() {
@@ -41216,7 +41618,7 @@ function shortId() {
   return randomBytes2(4).toString("hex");
 }
 function migrationKeyFor(sourceSessionId, targetHarness) {
-  return createHash3("sha256").update(`${sourceSessionId}
+  return createHash4("sha256").update(`${sourceSessionId}
 ${targetHarness}`).digest("hex");
 }
 function moduleManagedProjectForSession(db, sessionId) {
@@ -41862,7 +42264,7 @@ function migrateOpenCodeSessionToPi(opts) {
 `;
     if (!opts.dryRun) {
       if (journalActive && cortexkitDb !== null && migrationKey !== undefined && plan) {
-        const contentSha256 = createHash3("sha256").update(jsonl, "utf8").digest("hex");
+        const contentSha256 = createHash4("sha256").update(jsonl, "utf8").digest("hex");
         commitStagedChecksum(cortexkitDb, migrationKey, contentSha256);
         fs3.writeFileAtomic(stagePath, jsonl);
         plan.commit(migrationKey);
@@ -42588,7 +42990,7 @@ var init_migrate_session = __esm(async () => {
 });
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import { realpathSync as realpathSync5 } from "node:fs";
 import path5 from "node:path";
 function readMeta(db, key) {
@@ -42637,7 +43039,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash4("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash5("sha256").update(canonical, "utf8").digest("hex")}`;
 }
 function upsertRekeyMap(db, oldProjectPath, newProjectPath, rekeyedAt) {
   db.prepare(`INSERT INTO v22_identity_rekey_map (old_project_path, new_project_path, rekeyed_at)
@@ -43686,12 +44088,12 @@ var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
 // ../plugin/src/shared/tui-config.ts
 import {
-  chmodSync as chmodSync4,
+  chmodSync as chmodSync5,
   existsSync as existsSync26,
   mkdirSync as mkdirSync10,
   readFileSync as readFileSync16,
   renameSync as renameSync6,
-  statSync as statSync10,
+  statSync as statSync11,
   writeFileSync as writeFileSync7
 } from "node:fs";
 import { dirname as dirname15, join as join22 } from "node:path";
@@ -43727,8 +44129,8 @@ function writeTuiConfigAtomic(configPath, config2) {
   const tmpPath = `${configPath}.tmp`;
   writeFileSync7(tmpPath, body);
   try {
-    if (statSync10(configPath, { throwIfNoEntry: false })?.isFile()) {
-      chmodSync4(tmpPath, statSync10(configPath).mode & 511);
+    if (statSync11(configPath, { throwIfNoEntry: false })?.isFile()) {
+      chmodSync5(tmpPath, statSync11(configPath).mode & 511);
     }
   } catch {}
   renameSync6(tmpPath, configPath);
@@ -43800,7 +44202,7 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync27, readdirSync as readdirSync3, readFileSync as readFileSync17, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync27, readdirSync as readdirSync3, readFileSync as readFileSync17, statSync as statSync12 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir15 } from "node:os";
 import { join as join23 } from "node:path";
@@ -43838,7 +44240,7 @@ function getStorageResolution() {
 }
 function fileSize(path6) {
   try {
-    return existsSync27(path6) ? statSync11(path6).size : 0;
+    return existsSync27(path6) ? statSync12(path6).size : 0;
   } catch {
     return 0;
   }
@@ -43915,7 +44317,7 @@ function listDumpsInDir(dir, limit) {
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync3(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync11(join23(dir, name));
+      const stat = statSync12(join23(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -44169,7 +44571,7 @@ async function collectDiagnostics() {
   const storageDirPath = storageResolution.path;
   const contextDbPath = join23(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("opencode");
-  const logFileSize = existsSync27(logPath) ? statSync11(logPath).size : 0;
+  const logFileSize = existsSync27(logPath) ? statSync12(logPath).size : 0;
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -44368,10 +44770,71 @@ var init_diagnostics_opencode = __esm(() => {
   init_redaction2();
   import_comment_json10 = __toESM(require_src3(), 1);
 });
+// ../plugin/src/features/magic-context/memory/embedding-synapse.ts
+var SYNAPSE_CERTIFICATION_REFUSAL_REASONS, factoryClients;
+var init_embedding_synapse = __esm(() => {
+  init_dist5();
+  init_logger();
+  SYNAPSE_CERTIFICATION_REFUSAL_REASONS = new Set([
+    "not_certified",
+    "probe_required",
+    "migration_required"
+  ]);
+  factoryClients = new WeakMap;
+});
+
+// ../plugin/src/features/magic-context/memory/normalize-hash.ts
+var init_normalize_hash = () => {};
+
+// ../plugin/src/features/magic-context/memory/embedding-identity.ts
+var init_embedding_identity = __esm(() => {
+  init_magic_context();
+  init_embedding_synapse();
+  init_normalize_hash();
+});
+
+// ../plugin/src/features/magic-context/memory/embedding-local.ts
+function currentLocalEmbeddingHost() {
+  const bun = globalThis.Bun;
+  const hasProcess = typeof process !== "undefined";
+  const bunVersion = hasProcess && typeof process.versions?.bun === "string" ? process.versions.bun : undefined;
+  return {
+    isElectron: hasProcess && Boolean(process.versions?.electron),
+    isBun: Boolean(bun) || Boolean(bunVersion),
+    bunVersion,
+    hasNodeFilesystem: hasProcess && (typeof process.versions?.node === "string" || typeof bunVersion === "string")
+  };
+}
+function bunHasNapiTeardownFix(version2) {
+  const match = version2?.match(/^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?(?:\+[0-9A-Za-z.-]+)?$/);
+  if (!match || match[4])
+    return false;
+  const parsed = [Number(match[1]), Number(match[2]), Number(match[3])];
+  return parsed.some((part) => !Number.isSafeInteger(part)) ? false : parsed[0] > BUN_NAPI_TEARDOWN_FIX_VERSION[0] || parsed[0] === BUN_NAPI_TEARDOWN_FIX_VERSION[0] && (parsed[1] > BUN_NAPI_TEARDOWN_FIX_VERSION[1] || parsed[1] === BUN_NAPI_TEARDOWN_FIX_VERSION[1] && parsed[2] >= BUN_NAPI_TEARDOWN_FIX_VERSION[2]);
+}
+function resolveLocalEmbeddingRuntime(preference = "auto", host = currentLocalEmbeddingHost()) {
+  if (preference === "native" || preference === "wasm")
+    return preference;
+  if (host.isElectron)
+    return "electron";
+  if (host.isBun && !bunHasNapiTeardownFix(host.bunVersion))
+    return "wasm";
+  return "native";
+}
+var BUN_NAPI_TEARDOWN_FIX_VERSION, STALE_LOCK_MS, MAX_LOCK_WAIT_MS;
+var init_embedding_local = __esm(() => {
+  init_magic_context();
+  init_data_path();
+  init_logger();
+  init_embedding_identity();
+  BUN_NAPI_TEARDOWN_FIX_VERSION = [1, 4, 0];
+  STALE_LOCK_MS = 3 * 60000;
+  MAX_LOCK_WAIT_MS = 5 * 60000;
+});
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync28 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync18 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
 import { dirname as dirname16, join as join24, sep } from "node:path";
 function describeError(error51) {
@@ -44474,19 +44937,40 @@ function isNativeLocalEmbeddingRuntimeFailure(status) {
   return status.state === "package-missing" || status.state === "binary-missing" || status.state === "load-failed";
 }
 function describeNativeFailure(status) {
-  return status.state === "package-missing" ? "package is not installed" : status.state === "binary-missing" ? "expected platform binding file is absent" : `binding failed to load: ${status.reason}`;
+  return status.state === "package-missing" ? "package is not installed" : status.state === "binary-missing" ? status.knownUnavailable ? `onnxruntime-node ${status.knownUnavailable.packageVersion} does not ship a darwin/x64 native binding` : "expected platform binding file is absent" : `binding failed to load: ${status.reason}`;
+}
+function knownUnavailableNativeBinding(status) {
+  return status.state === "binary-missing" ? status.knownUnavailable : undefined;
+}
+function intelMacNativeGuidance(version2) {
+  return `onnxruntime-node ${version2} has no native binding for darwin/x64; reinstalling the same package ` + "(including doctor --force) cannot restore native inference. The supported fallback is WASM. " + "For optional native speed, manually pin onnxruntime-node@1.23.0.";
 }
 function isLocalEmbeddingRuntimeBroken(status) {
-  return status.state === "both-broken" || isNativeLocalEmbeddingRuntimeFailure(status);
+  return status.state === "both-broken" || status.state === "wasm-broken" || isNativeLocalEmbeddingRuntimeFailure(status);
 }
 function formatLocalEmbeddingRuntimeDoctorWarning(status) {
+  if (status.state === "wasm-broken") {
+    return "Embedding provider: local — configured/selected onnxruntime-web (WASM) is unavailable — " + `${status.wasmReason}. Reinstall the plugin package or select embedding.local_runtime: native ` + "only on a host where its native runtime is safe.";
+  }
   if (status.state !== "both-broken") {
+    const knownUnavailable2 = knownUnavailableNativeBinding(status);
+    if (knownUnavailable2) {
+      return `Embedding provider: local — ${intelMacNativeGuidance(knownUnavailable2.packageVersion)} WASM fallback is unavailable, so embeddings will not work.`;
+    }
     return "Embedding provider: local — onnxruntime-node native binding missing — " + `${describeNativeFailure(status)}; its postinstall likely failed. Embeddings will not work. ` + "Reinstall with network access to the npm registry and GitHub releases, " + "or switch `embedding.provider` to an HTTP endpoint (`openai-compatible`).";
   }
+  const knownUnavailable = knownUnavailableNativeBinding(status.nativeFailure);
+  if (knownUnavailable) {
+    return `Embedding provider: local — ${intelMacNativeGuidance(knownUnavailable.packageVersion)} ` + `The WASM fallback is also unavailable: ${status.wasmReason}. Reinstall may repair the WASM package only; ` + "otherwise switch `embedding.provider` to an HTTP endpoint (`openai-compatible`).";
+  }
   return "Embedding provider: local — native runtime and WASM fallback both unavailable — " + `native: ${describeNativeFailure(status.nativeFailure)}; WASM: ${status.wasmReason}; ` + "their install or postinstall likely failed. Reinstall with network access to the npm registry and GitHub releases, " + "or switch `embedding.provider` to an HTTP endpoint (`openai-compatible`).";
 }
 function formatLocalEmbeddingRuntimeWasmFallback(status) {
-  return "Embedding provider: local — onnxruntime-node native binding failed " + `(${describeNativeFailure(status.nativeFailure)}); using onnxruntime-web (WASM) at ${status.wasmPath}. ` + "WASM inference is slower than native; a remote `openai-compatible` provider may be faster.";
+  const knownUnavailable = knownUnavailableNativeBinding(status.nativeFailure);
+  if (knownUnavailable) {
+    return "Embedding provider: local — " + `onnxruntime-node ${knownUnavailable.packageVersion} has no native binding for darwin/x64; ` + `WASM fallback active at ${status.wasmPath}. Reinstalling the same package (including doctor --force) ` + "cannot restore native inference. WASM is slower; for optional native speed, manually pin onnxruntime-node@1.23.0.";
+  }
+  return "Embedding provider: local — onnxruntime-node native binding failed " + `(${describeNativeFailure(status.nativeFailure)}); WASM fallback active at ${status.wasmPath}. ` + "WASM inference is slower than native; a remote `openai-compatible` provider may be faster.";
 }
 function expectedBinaryRelPath(platform, arch) {
   const supportedPlatform = platform === "linux" || platform === "darwin" || platform === "win32";
@@ -44495,6 +44979,27 @@ function expectedBinaryRelPath(platform, arch) {
     return null;
   return join24("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
+function onnxRuntimeNodeVersion(packageDir) {
+  try {
+    const parsed = JSON.parse(readFileSync18(join24(packageDir, "package.json"), "utf8"));
+    return typeof parsed.version === "string" ? parsed.version : undefined;
+  } catch {
+    return;
+  }
+}
+function darwinX64BindingDropped(packageDir, platform, arch) {
+  if (platform !== "darwin" || arch !== "x64")
+    return;
+  const packageVersion = onnxRuntimeNodeVersion(packageDir);
+  const match = packageVersion?.match(/^(\d+)\.(\d+)(?:\.|$)/);
+  if (!match)
+    return;
+  const major = Number(match[1]);
+  const minor = Number(match[2]);
+  if (major < 1 || major === 1 && minor < 24)
+    return;
+  return { kind: "darwin-x64-dropped", packageVersion };
+}
 function probeWasmRuntimeFromRequire(requireFn) {
   try {
     const resolved = requireFn.resolve("onnxruntime-web");
@@ -44519,11 +45024,35 @@ function withWasmFallback(native, probeWasm) {
   }
   return { state: "both-broken", nativeFailure: native, wasmReason: wasm.reason };
 }
+function formatLocalEmbeddingRuntimeWasmSelected(status) {
+  return "Embedding provider: local — onnxruntime-web (WASM) selected by embedding.local_runtime/host at " + `${status.wasmPath}. The native addon was not probed or loaded. WASM inference is slower than native.`;
+}
+function requireNodeWasmBundle(probe, candidates) {
+  if (probe.state === "failed")
+    return probe;
+  const bundlePath = candidates.find((candidate) => existsSync28(candidate));
+  return bundlePath ? probe : {
+    state: "failed",
+    reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
+  };
+}
+function nodeWasmBundleCandidates(installRoot) {
+  return [
+    join24(installRoot, "dist", "transformers-node-wasm.js"),
+    join24(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
+    join24(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
+  ];
+}
 function probeWasmRuntimeAt(installRoot) {
   const requireFn = createRequire4(join24(installRoot, "package.json"));
-  return probeWasmRuntimeFromRequire(requireFn);
+  return requireNodeWasmBundle(probeWasmRuntimeFromRequire(requireFn), nodeWasmBundleCandidates(installRoot));
 }
-function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch) {
+function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
+  const selectedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, host);
+  if (selectedRuntime !== "native") {
+    const wasm = probeWasmRuntimeAt(installRoot);
+    return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
+  }
   const packageDir = join24(installRoot, "node_modules", "onnxruntime-node");
   let native;
   if (!existsSync28(join24(packageDir, "package.json"))) {
@@ -44537,12 +45066,17 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
       };
     } else {
       const binaryPath = join24(packageDir, rel);
-      native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : { state: "binary-missing", packageDir, expectedBinary: binaryPath };
+      native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+        state: "binary-missing",
+        packageDir,
+        expectedBinary: binaryPath,
+        knownUnavailable: darwinX64BindingDropped(packageDir, platform, arch)
+      };
     }
   }
   return withWasmFallback(native, () => probeWasmRuntimeAt(installRoot));
 }
-function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch) {
+function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
   const existing = installRoots.filter((root) => existsSync28(root));
   if (existing.length === 0) {
     return {
@@ -44553,7 +45087,7 @@ function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, a
   let firstFallback = null;
   let firstFailure = null;
   for (const root of existing) {
-    const status = checkLocalEmbeddingRuntimeAt(root, platform, arch);
+    const status = checkLocalEmbeddingRuntimeAt(root, platform, arch, runtimePreference, host);
     if (status.state === "ok")
       return status;
     if (status.state === "wasm-fallback") {
@@ -44575,12 +45109,13 @@ function probeWasmRuntimeByResolution(pluginDir) {
   try {
     const reqPlugin = createRequire4(join24(pluginDir, "package.json"));
     const direct = probeWasmRuntimeFromRequire(reqPlugin);
-    if (direct.state === "ok" || !direct.reason.startsWith("onnxruntime-web is not resolvable")) {
-      return direct;
+    let probe = direct;
+    if (direct.state === "failed" && direct.reason.startsWith("onnxruntime-web is not resolvable")) {
+      const tfResolved = reqPlugin.resolve("@huggingface/transformers");
+      const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
+      probe = probeWasmRuntimeFromRequire(createRequire4(join24(tfDir, "package.json")));
     }
-    const tfResolved = reqPlugin.resolve("@huggingface/transformers");
-    const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-    return probeWasmRuntimeFromRequire(createRequire4(join24(tfDir, "package.json")));
+    return requireNodeWasmBundle(probe, [join24(pluginDir, "dist", "transformers-node-wasm.js")]);
   } catch (error51) {
     return {
       state: "failed",
@@ -44588,10 +45123,15 @@ function probeWasmRuntimeByResolution(pluginDir) {
     };
   }
 }
-function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch) {
+function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
   if (!existsSync28(join24(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
+  const selectedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, host);
+  if (selectedRuntime !== "native") {
+    const wasm = probeWasmRuntimeByResolution(pluginDir);
+    return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
+  }
   let onnxDir = null;
   let resolveError;
   try {
@@ -44626,12 +45166,18 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
     const binaryPath = join24(onnxDir, rel);
-    native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : { state: "binary-missing", packageDir: onnxDir, expectedBinary: binaryPath };
+    native = existsSync28(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+      state: "binary-missing",
+      packageDir: onnxDir,
+      expectedBinary: binaryPath,
+      knownUnavailable: darwinX64BindingDropped(onnxDir, platform, arch)
+    };
   }
   return withWasmFallback(native, () => probeWasmRuntimeByResolution(pluginDir));
 }
 var ONNX_LOAD_PROBE_TIMEOUT_MS = 1e4, ONNX_LOAD_PROBE_OUTPUT_LIMIT = 800, ONNX_LOAD_PROBE_PACKAGE_DIR_ENV = "MAGIC_CONTEXT_ONNX_RUNTIME_NODE_PACKAGE_DIR", ONNX_RUNTIME_NODE_LOAD_PROBE_SCRIPT, runOnnxRuntimeNodeLoadProbeChildForRuntime;
 var init_embedding_runtime = __esm(() => {
+  init_embedding_local();
   ONNX_RUNTIME_NODE_LOAD_PROBE_SCRIPT = [
     'const { createRequire } = require("node:module");',
     'const { join } = require("node:path");',
@@ -44754,7 +45300,7 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/logs-opencode.ts
-import { readFileSync as readFileSync18, writeFileSync as writeFileSync8 } from "node:fs";
+import { readFileSync as readFileSync19, writeFileSync as writeFileSync8 } from "node:fs";
 import { join as join25 } from "node:path";
 function sanitizeLogContent(content) {
   return sanitizeDiagnosticText(content);
@@ -44797,7 +45343,7 @@ function filterLogLinesBySession(lines, sessionId) {
 }
 async function bundleIssueReport(report, description, title, sessionFilter = null) {
   const LOG_TAIL_LINES = 400;
-  const allLogLines = report.logFile.exists ? readFileSync18(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = report.logFile.exists ? readFileSync19(report.logFile.path, "utf-8").split(/\r?\n/) : [];
   const logLines = filterLogLinesBySession(allLogLines, sessionFilter);
   const recentLog = sanitizeLogContent(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
@@ -45169,9 +45715,9 @@ import {
   accessSync as accessSync2,
   existsSync as existsSync29,
   constants as fsConstants,
-  readFileSync as readFileSync19,
+  readFileSync as readFileSync20,
   renameSync as renameSync7,
-  statSync as statSync12,
+  statSync as statSync13,
   writeFileSync as writeFileSync9
 } from "node:fs";
 import { dirname as dirname17, isAbsolute as isAbsolute5, join as join27, resolve as resolve8 } from "node:path";
@@ -45223,7 +45769,7 @@ function getWinningConfig(directory, surface) {
     try {
       if (!existsSync29(path6))
         continue;
-      const parsed = parseJsonConfig(readFileSync19(path6, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync20(path6, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -45259,14 +45805,14 @@ var init_checker = __esm(() => {
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync30, readdirSync as readdirSync4, readFileSync as readFileSync20 } from "node:fs";
+import { existsSync as existsSync30, readdirSync as readdirSync4, readFileSync as readFileSync21 } from "node:fs";
 import { join as join28 } from "node:path";
 import { gunzipSync } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
     if (!existsSync30(packageJsonPath))
       return null;
-    const packageJson = JSON.parse(readFileSync20(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync21(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
       return null;
     }
@@ -45303,7 +45849,7 @@ function readFenceFromDist(packageDirectory) {
         }
         if (!entry.isFile() || !/\.(?:[cm]?js|ts)$/.test(entry.name))
           continue;
-        const fence = readFenceValue(readFileSync20(path6, "utf-8"));
+        const fence = readFenceValue(readFileSync21(path6, "utf-8"));
         if (fence !== null)
           fenceValues.add(fence);
       }
@@ -45521,13 +46067,13 @@ var init_storage_versions = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync31, readFileSync as readFileSync21, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync22, rmSync as rmSync3 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
     if (!existsSync31(installedPkgPath))
       return;
-    const pkg = JSON.parse(readFileSync21(installedPkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync22(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -45604,7 +46150,7 @@ var init_doctor_opencode_cache = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync32, readFileSync as readFileSync22, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync32, readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir17 } from "node:os";
 import { join as join29 } from "node:path";
@@ -45714,7 +46260,7 @@ function collectNpmReleaseAgeWarnings() {
   if (!existsSync32(npmrcPath))
     return ageWarnings;
   try {
-    const npmrc = readFileSync22(npmrcPath, "utf-8");
+    const npmrc = readFileSync23(npmrcPath, "utf-8");
     for (const line of npmrc.split(`
 `)) {
       const trimmed = line.trim();
@@ -45826,8 +46372,12 @@ async function runIssueFlow2() {
     return 1;
   }
 }
-function checkLocalEmbeddingRuntimeForDoctor() {
-  const runtime = checkLocalEmbeddingRuntime(getOpenCodePluginCacheRoots());
+function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
+  const runtime = checkLocalEmbeddingRuntime(getOpenCodePluginCacheRoots(), process.platform, process.arch, runtimePreference);
+  if (runtime.state === "wasm-selected") {
+    log2.info(formatLocalEmbeddingRuntimeWasmSelected(runtime));
+    return { issues: 0 };
+  }
   if (runtime.state === "wasm-fallback") {
     log2.warn(formatLocalEmbeddingRuntimeWasmFallback(runtime));
     return { issues: 0 };
@@ -45840,7 +46390,7 @@ function checkLocalEmbeddingRuntimeForDoctor() {
     log2.warn(`Local embedding runtime unverified: ${runtime.reason}`);
     return { issues: 0, unverified: true };
   }
-  log2.success("Embedding provider: local (native runtime OK; Xenova/all-MiniLM-L6-v2 bundled)");
+  log2.success("Embedding provider: local (native runtime selected and OK; Xenova/all-MiniLM-L6-v2 bundled)");
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
@@ -45875,7 +46425,8 @@ async function checkEmbeddingConfig(magicContextConfigPath) {
     return { issues: 0 };
   }
   if (provider === undefined || provider === "local") {
-    return checkLocalEmbeddingRuntimeForDoctor();
+    const runtimePreference = embedding?.local_runtime === "native" || embedding?.local_runtime === "wasm" ? embedding.local_runtime : "auto";
+    return checkLocalEmbeddingRuntimeForDoctor(runtimePreference);
   }
   if (provider !== "openai-compatible") {
     log2.warn(`Unknown embedding provider: ${String(provider)} (expected local | openai-compatible | off)`);
@@ -46210,7 +46761,7 @@ async function runDoctor2(options = {}) {
   }
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync22(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync23(paths.opencodeConfig, "utf-8");
       const config2 = import_comment_json12.parse(raw);
       const rawPlugins = Array.isArray(config2?.plugin) ? config2.plugin : [];
       const existingIdx = rawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
@@ -46297,7 +46848,7 @@ async function runDoctor2(options = {}) {
     fixed++;
   } else if (existsSync32(paths.tuiConfig)) {
     try {
-      const tuiRaw = readFileSync22(paths.tuiConfig, "utf-8");
+      const tuiRaw = readFileSync23(paths.tuiConfig, "utf-8");
       const tuiConfig = import_comment_json12.parse(tuiRaw);
       const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
       const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
@@ -46493,7 +47044,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   }
   const logPath = getMagicContextLogPath2("opencode");
   if (existsSync32(logPath)) {
-    const logStat = statSync13(logPath);
+    const logStat = statSync14(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     log2.info(`Log file: ${logPath} (${sizeKb} KB)`);
   } else {
@@ -46575,7 +47126,7 @@ var init_doctor_opencode = __esm(async () => {
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync33, readdirSync as readdirSync5, readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync33, readdirSync as readdirSync5, readFileSync as readFileSync24, statSync as statSync15 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { join as join30 } from "node:path";
 function getSelfVersion3() {
@@ -46592,7 +47143,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path6) {
   try {
-    return existsSync33(path6) ? statSync14(path6).size : 0;
+    return existsSync33(path6) ? statSync15(path6).size : 0;
   } catch {
     return 0;
   }
@@ -46608,7 +47159,7 @@ function readJsonc(path6) {
     return { value: {} };
   try {
     return {
-      value: import_comment_json13.parse(readFileSync23(path6, "utf-8"))
+      value: import_comment_json13.parse(readFileSync24(path6, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -46660,7 +47211,7 @@ function collectPiRecentSessions() {
       }
       for (const file2 of files) {
         try {
-          const mtime = statSync14(join30(slugDir, file2)).mtimeMs;
+          const mtime = statSync15(join30(slugDir, file2)).mtimeMs;
           const sessionId = file2.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -46678,7 +47229,7 @@ function collectPiRecentSessions() {
 }
 function parseHistorianDumpMeta2(path6) {
   try {
-    const xml = readFileSync23(path6, "utf-8");
+    const xml = readFileSync24(path6, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -46715,7 +47266,7 @@ function listDumpsInDir2(dir, limit) {
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync5(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync14(join30(dir, name));
+      const stat = statSync15(join30(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -46790,7 +47341,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const storageDirPath = storageResolution.path;
   const dbPath = join30(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("pi");
-  const logFileSize = existsSync33(logPath) ? statSync14(logPath).size : 0;
+  const logFileSize = existsSync33(logPath) ? statSync15(logPath).size : 0;
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
   const recentSessions = collectPiRecentSessions();
   const historianDumps = collectPiHistorianDumps(recentSessions);
@@ -46926,7 +47477,7 @@ var init_diagnostics_pi = __esm(() => {
 });
 
 // src/lib/logs-pi.ts
-import { readFileSync as readFileSync24, writeFileSync as writeFileSync10 } from "node:fs";
+import { readFileSync as readFileSync25, writeFileSync as writeFileSync10 } from "node:fs";
 import { join as join31 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
@@ -46956,7 +47507,7 @@ function filterLogLinesBySession2(lines, sessionId) {
 }
 async function bundleIssueReport2(report, description, title, options = {}) {
   const LOG_TAIL_LINES = 400;
-  const allLogLines = report.logFile.exists ? readFileSync24(report.logFile.path, "utf-8").split(/\r?\n/) : [];
+  const allLogLines = report.logFile.exists ? readFileSync25(report.logFile.path, "utf-8").split(/\r?\n/) : [];
   const logLines = filterLogLinesBySession2(allLogLines, options.sessionFilter ?? null);
   const recentLog = sanitizeLogContent2(logLines.slice(-LOG_TAIL_LINES).join(`
 `)).trim();
@@ -47010,7 +47561,7 @@ var init_logs_pi = __esm(() => {
 
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync6, spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync34, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync25, rmSync as rmSync4, statSync as statSync15 } from "node:fs";
+import { existsSync as existsSync34, mkdirSync as mkdirSync11, readdirSync as readdirSync6, readFileSync as readFileSync26, rmSync as rmSync4, statSync as statSync16 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { homedir as homedir18 } from "node:os";
 import { dirname as dirname18, isAbsolute as isAbsolute6, join as join32 } from "node:path";
@@ -47103,7 +47654,7 @@ function summarize(results) {
 function readJsonc2(path6) {
   try {
     return {
-      value: import_comment_json14.parse(readFileSync25(path6, "utf-8"))
+      value: import_comment_json14.parse(readFileSync26(path6, "utf-8"))
     };
   } catch (error51) {
     return {
@@ -47251,7 +47802,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
       return;
     let stat;
     try {
-      stat = statSync15(path6);
+      stat = statSync16(path6);
     } catch {
       return;
     }
@@ -47260,7 +47811,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     const packageJson = join32(path6, "package.json");
     if (existsSync34(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync25(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync26(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version2 = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -47487,9 +48038,14 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     let runtimeReported = false;
     let runtimeUnverifiedReason = "no installed plugin tree found to inspect";
     for (const pluginDir of piPluginDirCandidates(packages, options.cwd)) {
-      const runtime = checkLocalEmbeddingRuntimeByResolution(pluginDir);
+      const runtime = checkLocalEmbeddingRuntimeByResolution(pluginDir, process.platform, process.arch, loadedConfig.config.embedding.provider === "local" ? loadedConfig.config.embedding.local_runtime : "auto", { isBun: false, isElectron: false });
+      if (runtime.state === "wasm-selected") {
+        add2(results, "info", formatLocalEmbeddingRuntimeWasmSelected(runtime));
+        runtimeReported = true;
+        break;
+      }
       if (runtime.state === "ok") {
-        add2(results, "pass", `Embedding provider: ${loadedConfig.config.embedding.provider} (native runtime OK)`);
+        add2(results, "pass", `Embedding provider: ${loadedConfig.config.embedding.provider} (native runtime selected and OK)`);
         runtimeReported = true;
         break;
       }
@@ -47507,7 +48063,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
         runtimeUnverifiedReason = runtime.reason;
     }
     if (!runtimeReported) {
-      add2(results, "warn", `Embedding provider ${loadedConfig.config.embedding.provider}: native runtime unverified (${runtimeUnverifiedReason})`);
+      add2(results, "warn", `Embedding provider ${loadedConfig.config.embedding.provider}: selected runtime unverified (${runtimeUnverifiedReason})`);
     }
   }
   const piEntries = packages.filter(isPiMagicContextPackageEntry).map(describePiPackageEntry);
@@ -47534,9 +48090,9 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   }
   const logPath = getMagicContextLogPath2("pi");
   if (existsSync34(logPath)) {
-    const stat = statSync15(logPath);
+    const stat = statSync16(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
-    const lines = readFileSync25(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+    const lines = readFileSync26(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
     add2(results, "info", `Log file: ${logPath} (${sizeKb} KB)`);
     const lastLine = lines.at(-1);
     add2(results, "info", `Last plugin log line: ${lastLine ? sanitizeDiagnosticText(lastLine) : "<empty log>"}`);