@cortexkit/magic-context 0.44.1 → 0.44.2

package/dist/index.js

@@ -1647,6 +1647,7 @@ var init_prompts = __esm(() => {
 });
 
 // ../plugin/src/shared/sqlite.ts
+import { AsyncLocalStorage } from "node:async_hooks";
 function registerSlowWriteReporter(reporter) {
   reportSlowPrivilegedWrite = reporter;
 }
@@ -1680,6 +1681,62 @@ async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = impo
     throw error;
   }
 }
+function installTransactionRouting(db, readonly) {
+  const nativeExec = db.exec.bind(db);
+  Object.defineProperty(db, "exec", {
+    configurable: true,
+    writable: true,
+    value: (sql) => {
+      if (/^\s*BEGIN\s+(?:IMMEDIATE|EXCLUSIVE)(?:\s+TRANSACTION)?\s*;?\s*$/i.test(sql)) {
+        retryAcquisition(() => nativeExec(sql), sql.trim());
+        return db;
+      }
+      return nativeExec(sql);
+    }
+  });
+  Object.defineProperty(db, "transaction", {
+    configurable: true,
+    writable: true,
+    value: (fn) => {
+      const make = (mode) => function(...args) {
+        const nested = isInTransaction(db);
+        const savepoint = "mc_tx_sp";
+        db.exec(nested ? `SAVEPOINT ${savepoint}` : `BEGIN ${mode}`);
+        try {
+          const result = fn.apply(this, args);
+          db.exec(nested ? `RELEASE ${savepoint}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (isInTransaction(db)) {
+            if (nested) {
+              db.exec(`ROLLBACK TO ${savepoint}`);
+              db.exec(`RELEASE ${savepoint}`);
+            } else
+              db.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const defaultTransaction = make(readonly ? "DEFERRED" : "IMMEDIATE");
+      const variants = {
+        default: defaultTransaction,
+        deferred: make("DEFERRED"),
+        immediate: make("IMMEDIATE"),
+        exclusive: make("EXCLUSIVE"),
+        database: db
+      };
+      for (const transaction of [
+        variants.default,
+        variants.deferred,
+        variants.immediate,
+        variants.exclusive
+      ]) {
+        Object.assign(transaction, variants);
+      }
+      return defaultTransaction;
+    }
+  });
+}
 function trackSqliteConnection(db, filename, options) {
   const originalClose = db.close.bind(db);
   const sequence = nextSqliteConnectionSequence++;
@@ -1688,6 +1745,7 @@ function trackSqliteConnection(db, filename, options) {
     filename: typeof filename === "string" ? filename : Buffer.isBuffer(filename) ? "<buffer>" : ":memory:",
     readonly: Boolean(options) && typeof options === "object" && (options.readonly === true || options.readOnly === true)
   };
+  installTransactionRouting(db, metadata.readonly);
   Object.defineProperty(db, "close", {
     configurable: true,
     value: (...args) => {
@@ -1705,7 +1763,6 @@ function trackSqliteConnection(db, filename, options) {
   return db;
 }
 function buildNodeSqliteDatabaseClass(DatabaseSync) {
-  const SAVEPOINT = "mc_tx_sp";
 
   class NodeSqliteDatabase extends DatabaseSync {
     constructor(filename, options) {
@@ -1724,45 +1781,34 @@ function buildNodeSqliteDatabaseClass(DatabaseSync) {
       }
       return stmt;
     }
-    transaction(fn) {
-      const self = this;
-      const execute = (mode, receiver, args) => {
-        const nested = self.isTransaction === true;
-        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
-        try {
-          const result = fn.apply(receiver, args);
-          self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
-          return result;
-        } catch (error) {
-          if (nested) {
-            self.exec(`ROLLBACK TO ${SAVEPOINT}`);
-            self.exec(`RELEASE ${SAVEPOINT}`);
-          } else {
-            self.exec("ROLLBACK");
-          }
-          throw error;
-        }
-      };
-      const wrapped = function(...args) {
-        return execute("", this, args);
-      };
-      wrapped.default = function(...args) {
-        return execute("", this, args);
-      };
-      wrapped.deferred = function(...args) {
-        return execute("DEFERRED", this, args);
-      };
-      wrapped.immediate = function(...args) {
-        return execute("IMMEDIATE", this, args);
-      };
-      wrapped.exclusive = function(...args) {
-        return execute("EXCLUSIVE", this, args);
-      };
-      return wrapped;
-    }
   }
   return NodeSqliteDatabase;
 }
+function isTransientSqliteError(error) {
+  if (!error || typeof error !== "object")
+    return false;
+  const value = error;
+  return typeof value.code === "string" && /^(SQLITE_BUSY|SQLITE_LOCKED)(_|$)/.test(value.code) || typeof value.errcode === "number" && [5, 6].includes(value.errcode & 255);
+}
+function retryAcquisition(acquire, stage) {
+  if (!transformPassScope.getStore()?.active) {
+    acquire();
+    return;
+  }
+  const delays = [500, 1000];
+  for (let attempt = 0;; attempt++) {
+    try {
+      acquire();
+      return;
+    } catch (error) {
+      if (error instanceof SqliteAcquisitionBusyError || !isTransientSqliteError(error))
+        throw error;
+      if (attempt === delays.length)
+        throw new SqliteAcquisitionBusyError(error, stage);
+      Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, delays[attempt]);
+    }
+  }
+}
 function isInTransaction(db) {
   const candidate = db;
   return candidate.inTransaction === true || candidate.isTransaction === true;
@@ -1775,7 +1821,7 @@ function withPrivilegedWriter(db, operation) {
   if (nested) {
     db.exec(`SAVEPOINT ${savepoint}`);
   } else {
-    db.exec("BEGIN IMMEDIATE");
+    retryAcquisition(() => db.exec("BEGIN IMMEDIATE"), "BEGIN IMMEDIATE");
   }
   privilegeDepth.set(db, previousDepth + 1);
   try {
@@ -1814,7 +1860,7 @@ function withPrivilegedWriter(db, operation) {
     throw error;
   }
 }
-var reportSlowPrivilegedWrite, bunSpec, nodeSpec, SqliteRuntimeUnavailableError, detectedRuntime, isBun, sqliteModule, DatabaseImpl, trackedSqliteConnections, nextSqliteConnectionSequence = 1, TrackedDatabase, Database, privilegeDepth;
+var reportSlowPrivilegedWrite, bunSpec, nodeSpec, SqliteRuntimeUnavailableError, detectedRuntime, isBun, sqliteModule, DatabaseImpl, trackedSqliteConnections, nextSqliteConnectionSequence = 1, TrackedDatabase, Database, privilegeDepth, transformPassScope, SqliteAcquisitionBusyError;
 var init_sqlite = __esm(async () => {
   bunSpec = "bun:" + "sqlite";
   nodeSpec = "node:" + "sqlite";
@@ -1842,6 +1888,16 @@ var init_sqlite = __esm(async () => {
   });
   Database = TrackedDatabase;
   privilegeDepth = new WeakMap;
+  transformPassScope = new AsyncLocalStorage;
+  SqliteAcquisitionBusyError = class SqliteAcquisitionBusyError extends Error {
+    code = "SQLITE_BUSY";
+    stage;
+    constructor(cause, stage = "BEGIN IMMEDIATE") {
+      super("SQLite writer acquisition remained busy after 3 attempts", { cause });
+      this.name = "SqliteAcquisitionBusyError";
+      this.stage = stage;
+    }
+  };
 });
 
 // src/lib/docs-proposal-gitignore.ts
@@ -4270,6 +4326,7 @@ function getPiVersion(piPath) {
   try {
     const invocation = getPiCommandInvocation(piPath, ["--version"]);
     const result = spawnSync(invocation.command, invocation.args, {
+      windowsHide: true,
       encoding: "utf-8",
       timeout: 1e4
     });
@@ -4288,6 +4345,7 @@ function runPiCommand(piPath, args, timeout = 20000) {
   try {
     const invocation = getPiCommandInvocation(piPath, args);
     return execFileSync(invocation.command, invocation.args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout
@@ -4403,6 +4461,7 @@ function runOmpCommand(ompPath, args, timeout = 30000, overrides = {}) {
   try {
     const invocation = deps.getInvocation(ompPath, args);
     const result = deps.spawnSync(invocation.command, invocation.args, {
+      windowsHide: true,
       encoding: "utf-8",
       timeout,
       maxBuffer: 10 * 1024 * 1024,
@@ -12794,7 +12853,7 @@ var init_opencode_plugin_cache = __esm(() => {
 import { spawnSync as spawnSync3 } from "node:child_process";
 import { existsSync as existsSync8, rmSync as rmSync2 } from "node:fs";
 function runLsof(args, spawn) {
-  const result = spawn("lsof", args, { encoding: "utf-8", timeout: 15000 });
+  const result = spawn("lsof", args, { encoding: "utf-8", timeout: 15000, windowsHide: true });
   if (result.error)
     return { error: result.error.message };
   if (result.status !== 0 && result.status !== 1) {
@@ -13160,7 +13219,11 @@ function getOpenCodeCommandInvocation(binary, args) {
 }
 function runOpenCode(args, binary, timeoutMs) {
   try {
-    const options = { stdio: "pipe", ...timeoutMs ? { timeout: timeoutMs } : {} };
+    const options = {
+      stdio: "pipe",
+      windowsHide: true,
+      ...timeoutMs ? { timeout: timeoutMs } : {}
+    };
     if (binary) {
       const invocation = getOpenCodeCommandInvocation(binary, args);
       return execFileSync2(invocation.command, invocation.args, {
@@ -14676,6 +14739,49 @@ function parseCron(expression) {
 function isValidCron(expression) {
   return parseCron(expression).ok;
 }
+function matchesDay(cron, date) {
+  const dom = cron.dom.has(date.getDate());
+  const dow = cron.dow.has(date.getDay());
+  if (cron.domRestricted && cron.dowRestricted)
+    return dom || dow;
+  if (cron.domRestricted)
+    return dom;
+  if (cron.dowRestricted)
+    return dow;
+  return true;
+}
+function matchesCron(cron, date) {
+  return cron.minute.has(date.getMinutes()) && cron.hour.has(date.getHours()) && cron.month.has(date.getMonth() + 1) && matchesDay(cron, date);
+}
+function civilMinuteKey(date) {
+  const p = (n, w = 2) => String(n).padStart(w, "0");
+  return `${p(date.getFullYear(), 4)}-${p(date.getMonth() + 1)}-${p(date.getDate())} ${p(date.getHours())}:${p(date.getMinutes())}`;
+}
+function nextOccurrence(cron, after, excludeCivilMinute, maxSearchMs = MAX_SEARCH_MS) {
+  const afterMs = after.getTime();
+  let cursorMs = Math.floor(afterMs / MINUTE_MS) * MINUTE_MS + MINUTE_MS;
+  const capMs = afterMs + Math.max(0, Math.min(MAX_SEARCH_MS, maxSearchMs));
+  while (cursorMs <= capMs) {
+    const candidate = new Date(cursorMs);
+    if (matchesCron(cron, candidate)) {
+      if (!excludeCivilMinute || civilMinuteKey(candidate) !== excludeCivilMinute) {
+        return candidate;
+      }
+    }
+    cursorMs += MINUTE_MS;
+  }
+  return null;
+}
+function nextDueAtMs(expression, afterMs, consumedScheduledAtMs, maxSearchMs = MAX_SEARCH_MS) {
+  if (expression.trim().length === 0)
+    return null;
+  const parsed = parseCron(expression);
+  if (!parsed.ok)
+    return null;
+  const exclude = consumedScheduledAtMs !== undefined ? civilMinuteKey(new Date(consumedScheduledAtMs)) : undefined;
+  const next = nextOccurrence(parsed.cron, new Date(afterMs), exclude, maxSearchMs);
+  return next ? next.getTime() : null;
+}
 var FIELDS, MINUTE_MS = 60000, MAX_SEARCH_MS;
 var init_cron = __esm(() => {
   FIELDS = [
@@ -21156,9 +21262,9 @@ import { homedir as homedir9 } from "node:os";
 function defaultTaskConfig(task) {
   const base = { schedule: DEFAULT_TASK_SCHEDULES2[task] };
   if (task === "review-user-memories")
-    base.promotion_threshold = 3;
+    base.promotion_threshold = DREAM_TASK_PROMOTION_DEFAULTS["review-user-memories"];
   if (task === "promote-primers")
-    base.promotion_threshold = 2;
+    base.promotion_threshold = DREAM_TASK_PROMOTION_DEFAULTS["promote-primers"];
   return base;
 }
 function expandConfigPath(value) {
@@ -21169,7 +21275,7 @@ function expandConfigPath(value) {
     return `${homedir9()}/${trimmed.slice(2)}`;
   return trimmed;
 }
-var DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE = 65, EXECUTE_THRESHOLD_CAP_MESSAGE = "execute_threshold is capped at 90% for cache safety: output capacity is reserved from the usable context window, and the remaining 10% absorbs mid-turn growth before the absolute 95% emergency wall. Use a value between 20 and 90.", DEFAULT_HISTORIAN_TIMEOUT_MS = 600000, DEFAULT_HISTORY_BUDGET_PERCENTAGE = 0.15, PROTECTED_TOKENS_MIN = 4000, DEFAULT_LOCAL_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2", PiThinkingLevelSchema, OmpThinkingLevelSchema, PiConfigSchema, PromptSurfacePresetSchema, PromptSurfaceModelKeySchema, PromptSurfaceToolKeySchema, PromptSurfaceConfigSchema, PER_HARNESS_MIGRATION_INVENTORY, PER_HARNESS_MODEL_KEYS, OcEntryObjectSchema, OcEntrySchema, PiEntryObjectSchema, PiEntrySchema, OmpEntryObjectSchema, OmpEntrySchema, OpenCodeHarnessBlockSchema, PiHarnessBlockSchema, OmpHarnessBlockSchema, OpenCodeTaskExecutionSchema, PiTaskExecutionSchema, OmpTaskExecutionSchema, DreamerOpenCodeHarnessBlockSchema, DreamerPiHarnessBlockSchema, DreamerOmpHarnessBlockSchema, ProfileOpenCodeModelBlockSchema, ProfilePiModelBlockSchema, ProfileOmpModelBlockSchema, ProfileHistorianSchema, ProfileDreamerSchema, ConfigProfileSchema, ConfigProfilesSchema, CronScheduleSchema, DreamTaskBaseConfigSchema, PromotionThresholdSchema, PrimerPromotionThresholdSchema, DreamTaskConfigSchema, ReviewUserMemoriesTaskConfigSchema, PromotePrimersTaskConfigSchema, RetrospectiveTaskConfigSchema, DEFAULT_TASK_SCHEDULES2, DreamTasksSchema, AgentMetadataSchema, DreamerConfigSchema, HistorianConfigSchema, EmbeddingFallbackProviderSchema, BaseEmbeddingConfigSchema, EmbeddingConfigSchema, MagicContextConfigSchema, LIVE_RELOAD_CONFIG_PATHS;
+var DEFAULT_EXECUTE_THRESHOLD_PERCENTAGE = 65, EXECUTE_THRESHOLD_CAP_MESSAGE = "execute_threshold is capped at 90% for cache safety: output capacity is reserved from the usable context window, and the remaining 10% absorbs mid-turn growth before the absolute 95% emergency wall. Use a value between 20 and 90.", DEFAULT_HISTORIAN_TIMEOUT_MS = 600000, DEFAULT_HISTORY_BUDGET_PERCENTAGE = 0.15, PROTECTED_TOKENS_MIN = 4000, DEFAULT_LOCAL_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2", PiThinkingLevelSchema, OmpThinkingLevelSchema, PiConfigSchema, PromptSurfacePresetSchema, PromptSurfaceModelKeySchema, PromptSurfaceToolKeySchema, PromptSurfaceConfigSchema, PER_HARNESS_MIGRATION_INVENTORY, PER_HARNESS_MODEL_KEYS, OcEntryObjectSchema, OcEntrySchema, PiEntryObjectSchema, PiEntrySchema, OmpEntryObjectSchema, OmpEntrySchema, OpenCodeHarnessBlockSchema, PiHarnessBlockSchema, OmpHarnessBlockSchema, OpenCodeTaskExecutionSchema, PiTaskExecutionSchema, OmpTaskExecutionSchema, DreamerOpenCodeHarnessBlockSchema, DreamerPiHarnessBlockSchema, DreamerOmpHarnessBlockSchema, ProfileOpenCodeModelBlockSchema, ProfilePiModelBlockSchema, ProfileOmpModelBlockSchema, ProfileHistorianSchema, ProfileDreamerSchema, ConfigProfileSchema, ConfigProfilesSchema, CronScheduleSchema, DreamTaskBaseConfigSchema, DREAM_TASK_PROMOTION_DEFAULTS, PromotionThresholdSchema, PrimerPromotionThresholdSchema, DreamTaskConfigSchema, ReviewUserMemoriesTaskConfigSchema, PromotePrimersTaskConfigSchema, RetrospectiveTaskConfigSchema, DEFAULT_TASK_SCHEDULES2, DreamTasksSchema, AgentMetadataSchema, DreamerConfigSchema, HistorianConfigSchema, EmbeddingFallbackProviderSchema, BaseEmbeddingConfigSchema, EmbeddingConfigSchema, MagicContextConfigSchema, LIVE_RELOAD_CONFIG_PATHS;
 var init_magic_context = __esm(() => {
   init_zod();
   init_language_directive();
@@ -21346,10 +21452,15 @@ var init_magic_context = __esm(() => {
     message: 'Invalid schedule: use a 5-field cron expression (e.g. "0 3 * * *" for 3am daily, "0 3 * * 0" for Sunday 3am, "0 */6 * * *" every 6h) or "" to disable.'
   }).describe('5-field cron schedule (e.g. "0 3 * * *"), or "" to disable this task.');
   DreamTaskBaseConfigSchema = object({
-    schedule: CronScheduleSchema.default("")
+    schedule: CronScheduleSchema.default(""),
+    token_budget: number2().int().positive().optional().describe("Maximum cumulative prompt tokens (input + cache read + cache write) for one tool-loop child. Defaults vary by task.")
   }).strict();
-  PromotionThresholdSchema = number2().min(2).max(20).optional().describe("review-user-memories: min candidate observations before promotion is considered (default: 3)");
-  PrimerPromotionThresholdSchema = number2().min(2).max(20).optional().describe("promote-primers: min recurring source days before promotion is considered (default: 2)");
+  DREAM_TASK_PROMOTION_DEFAULTS = {
+    "review-user-memories": 3,
+    "promote-primers": 2
+  };
+  PromotionThresholdSchema = number2().min(2).max(20).default(DREAM_TASK_PROMOTION_DEFAULTS["review-user-memories"]).describe("review-user-memories: min candidate observations before promotion is considered (default: 3)");
+  PrimerPromotionThresholdSchema = number2().min(2).max(20).default(DREAM_TASK_PROMOTION_DEFAULTS["promote-primers"]).describe("promote-primers: min recurring source days before promotion is considered (default: 2)");
   DreamTaskConfigSchema = DreamTaskBaseConfigSchema.extend({
     promotion_threshold: PromotionThresholdSchema
   });
@@ -21526,7 +21637,7 @@ var init_magic_context = __esm(() => {
   });
   MagicContextConfigSchema = object({
     enabled: boolean2().default(true).describe("Enable magic context (default: true)"),
-    allow_home_project: boolean2().default(false).describe("Allow Magic Context sessions launched from the exact canonical home directory. The home session uses its deterministic dir: identity so pre-gate memories reconnect. USER-LEVEL ONLY: project config is ignored. The home identity is excluded from registry seed exports, never resolves descendants by containment, and cannot join a workspace."),
+    allow_home_project: boolean2().default(false).describe("Allow Magic Context sessions launched from the exact canonical home directory. A non-git home uses its deterministic dir: identity; a home repository uses its git: identity. USER-LEVEL ONLY: project config is ignored. The home identity is excluded from registry seed exports, never resolves descendants by containment, and cannot join a workspace."),
     mural: object({
       enabled: boolean2().default(false),
       model: string2().trim().min(1).optional().describe("Model for the compress-cues task that compresses each memory into a mural cue. The mural image itself is rendered deterministically (no author model).")
@@ -24905,11 +25016,48 @@ var init_context_authority = __esm(async () => {
   mirrorFlights = new WeakMap;
 });
 
+// ../plugin/src/features/magic-context/memory/project-identity-cache.ts
+import { createHash as createHash2, randomUUID as randomUUID2 } from "node:crypto";
+import { mkdirSync as mkdirSync6, readFileSync as readFileSync14, renameSync as renameSync4, writeFileSync as writeFileSync5 } from "node:fs";
+import path3 from "node:path";
+function projectDirectoryKey(directory) {
+  const slashed = directory.replaceAll("\\", "/").replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
+  if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
+    return path3.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
+  }
+  return path3.resolve(directory);
+}
+function cachePath(directory) {
+  const hash = createHash2("sha256").update(projectDirectoryKey(directory)).digest("hex");
+  return path3.join(getMagicContextStorageDir(), "project-identities", `${hash}.json`);
+}
+function rememberGitIdentity(directory, identity) {
+  try {
+    const destination = cachePath(directory);
+    mkdirSync6(path3.dirname(destination), { recursive: true });
+    const temporary = `${destination}.${randomUUID2()}.tmp`;
+    writeFileSync5(temporary, JSON.stringify({ directory: projectDirectoryKey(directory), identity }), { mode: 384 });
+    renameSync4(temporary, destination);
+  } catch {}
+}
+function readRememberedGitIdentity(directory) {
+  try {
+    const record = JSON.parse(readFileSync14(cachePath(directory), "utf8"));
+    if (record.directory === projectDirectoryKey(directory) && /^git:[0-9a-f]{7,64}$/.test(record.identity))
+      return record.identity;
+  } catch {}
+  return;
+}
+var init_project_identity_cache = __esm(() => {
+  init_data_path();
+});
+
 // ../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 { createHash as createHash3 } from "node:crypto";
 import { existsSync as existsSync21, realpathSync as realpathSync2, statSync as statSync9 } from "node:fs";
-import path3 from "node:path";
+import { homedir as homedir14 } from "node:os";
+import path4 from "node:path";
 function asError(error) {
   return error instanceof Error ? error : undefined;
 }
@@ -24947,8 +25095,8 @@ function getErrorStderr(error) {
   return "";
 }
 function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
-  const hash = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
+  const canonical = path4.resolve(directory);
+  const hash = createHash3("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
   return `dir:${hash}`;
 }
 function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
@@ -24993,8 +25141,9 @@ function classifyGitError(error, rawDirectory) {
   }
   return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
 }
-function resolveProjectIdentityStrict(directory) {
-  const canonical = path3.resolve(directory);
+function resolveProjectIdentityStrict(directory, allowHomeProject = false) {
+  assertProjectAllowed(directory, allowHomeProject);
+  const canonical = path4.resolve(directory);
   const cached = identityCache.get(canonical);
   if (cached !== undefined) {
     return cached;
@@ -25010,7 +25159,8 @@ function resolveProjectIdentityStrict(directory) {
       encoding: "utf8",
       env: { ...process.env, LC_ALL: "C", LANG: "C" },
       stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS
+      timeout: GIT_TIMEOUT_MS,
+      windowsHide: true
     });
   } catch (error) {
     throw classifyGitError(error, directory);
@@ -25023,13 +25173,17 @@ function resolveProjectIdentityStrict(directory) {
   const identity = `git:${rootCommit}`;
   identityCache.set(canonical, identity);
   lastKnownGitIdentityCache.set(canonical, identity);
+  rememberGitIdentity(canonical, identity);
+  const root = gitRootDirectory(canonical);
+  if (root && root !== canonical)
+    rememberGitIdentity(root, identity);
   transientFailureCooldown.delete(canonical);
   dubiousOwnershipFallbackDirectories.delete(canonical);
   transientGitIdentityReuseLoggedDirectories.delete(canonical);
   return identity;
 }
 function shouldUseDirectoryFallback(error) {
-  return error.errorClass !== "permission_denied";
+  return error.errorClass !== "home_project_disabled";
 }
 function getActiveCooldown(canonical) {
   const until = transientFailureCooldown.get(canonical);
@@ -25041,7 +25195,7 @@ function getActiveCooldown(canonical) {
   return;
 }
 function lastKnownGitIdentity(canonical) {
-  return lastKnownGitIdentityCache.get(canonical) ?? identityCache.get(canonical);
+  return lastKnownGitIdentityCache.get(canonical) ?? identityCache.get(canonical) ?? readRememberedGitIdentity(canonical);
 }
 function nearestLastKnownGitIdentity(canonical) {
   const visited = new Set;
@@ -25052,7 +25206,9 @@ function nearestLastKnownGitIdentity(canonical) {
       const cached = lastKnownGitIdentity(current);
       if (cached !== undefined)
         return { identity: cached, source: current };
-      const parent = path3.dirname(current);
+      if (existsSync21(path4.join(current, ".git")))
+        break;
+      const parent = path4.dirname(current);
       if (parent === current)
         break;
       current = parent;
@@ -25081,7 +25237,7 @@ function reuseLastKnownGitIdentity(canonical) {
   return cached.identity;
 }
 function formatDubiousOwnershipWarning(canonical) {
-  return `Magic Context: git refused to read ${canonical} (dubious ownership — the repo is owned by a different user). Using a directory-based project identity for now, which keeps memory separate from this repo's normal identity. Fix: git config --global --add safe.directory ${canonical}`;
+  return `Magic Context: git refused to read ${canonical} (dubious ownership — the repo is owned by a different user). Memory features are paused unless a previous git identity is available. Fix: git config --global --add safe.directory ${canonical}`;
 }
 function recordDubiousOwnershipFallback(canonical) {
   dubiousOwnershipFallbackDirectories.add(canonical);
@@ -25090,8 +25246,32 @@ function recordDubiousOwnershipFallback(canonical) {
   dubiousOwnershipLoggedDirectories.add(canonical);
   log3(`[magic-context] ${formatDubiousOwnershipWarning(canonical)}`);
 }
-function resolveProjectIdentity(directory) {
-  const canonical = path3.resolve(directory);
+function canonicalUserHomeDirectory() {
+  const homeDirectory = userHomeDirectoryForIdentity();
+  try {
+    return realpathSync2.native(homeDirectory);
+  } catch {
+    return homeDirectory;
+  }
+}
+function isUserHomeDirectory(directory) {
+  if (projectDirectoryKey(directory) === projectDirectoryKey(userHomeDirectoryForIdentity()))
+    return true;
+  try {
+    return projectDirectoryKey(realpathSync2.native(path4.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
+  } catch {
+    return false;
+  }
+}
+function assertProjectAllowed(directory, allowHomeProject) {
+  const canonical = path4.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 = false) {
+  assertProjectAllowed(directory, allowHomeProject);
+  const canonical = path4.resolve(directory);
   const cachedFallback = directoryFallbackCache.get(canonical);
   if (cachedFallback !== undefined) {
     if (!hasGitDir(canonical)) {
@@ -25105,27 +25285,30 @@ function resolveProjectIdentity(directory) {
       if (cachedGitIdentity !== undefined) {
         return cachedGitIdentity;
       }
+      throw new ProjectIdentityError("git_identity_unavailable", directory, "Git identity unavailable; memory features paused until the retry cooldown expires");
     }
     return directoryFallback(canonical);
   }
   try {
-    return resolveProjectIdentityStrict(directory);
+    return resolveProjectIdentityStrict(directory, allowHomeProject);
   } catch (error) {
     if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
       const fallback = directoryFallback(canonical);
       const hasGitMetadata = hasGitDir(canonical);
       if (!hasGitMetadata) {
+        if (error.errorClass === "permission_denied")
+          throw error;
         directoryFallbackCache.set(canonical, fallback);
         transientFailureCooldown.delete(canonical);
       } else {
         transientFailureCooldown.set(canonical, nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS);
         const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
+        if (error.errorClass === "dubious_ownership")
+          recordDubiousOwnershipFallback(canonical);
         if (cachedGitIdentity !== undefined) {
           return cachedGitIdentity;
         }
-      }
-      if (error.errorClass === "dubious_ownership") {
-        recordDubiousOwnershipFallback(canonical);
+        throw error;
       }
       return fallback;
     }
@@ -25146,14 +25329,14 @@ function hasGitDir(canonical) {
 function gitRootInAncestorChain(startDirectory) {
   let current = startDirectory;
   while (true) {
-    if (existsSync21(path3.join(current, ".git"))) {
+    if (existsSync21(path4.join(current, ".git"))) {
       try {
         return realpathSync2.native(current);
       } catch {
-        return path3.resolve(current);
+        return path4.resolve(current);
       }
     }
-    const parent = path3.dirname(current);
+    const parent = path4.dirname(current);
     if (parent === current) {
       return null;
     }
@@ -25163,9 +25346,21 @@ function gitRootInAncestorChain(startDirectory) {
 function hasGitDirInAncestorChain(startDirectory) {
   return gitRootInAncestorChain(startDirectory) !== null;
 }
-var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, execFileSyncForIdentity, nowMs = () => Date.now(), ProjectIdentityError;
+function gitRootDirectory(canonical) {
+  const direct = gitRootInAncestorChain(canonical);
+  if (direct)
+    return direct;
+  try {
+    const realCanonical = realpathSync2.native(canonical);
+    return realCanonical === canonical ? null : gitRootInAncestorChain(realCanonical);
+  } catch {
+    return null;
+  }
+}
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, sessionIdentityCache, execFileSyncForIdentity, userHomeDirectoryForIdentity = () => homedir14(), nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
   init_logger();
+  init_project_identity_cache();
   TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
   identityCache = new Map;
   linkedGitWorktreeCache = new Map;
@@ -26865,6 +27060,11 @@ var init_user_facing_codes = __esm(() => {
       sentence: "Memory maintenance stopped at its hidden agent step limit.",
       action: "This task needs less work per run; changing the model connection will not help."
     },
+    dream_token_budget: {
+      code: "MC-D11",
+      sentence: "Memory maintenance reached its prompt-token budget.",
+      action: "The unfinished items will be retried on the next run."
+    },
     dream_empty_completion: {
       code: "MC-D03",
       sentence: "Memory maintenance received no usable response.",
@@ -27776,8 +27976,8 @@ var init_pi_executable = __esm(() => {
 });
 
 // ../plugin/src/shared/rpc-utils.ts
-import { execFileSync as execFileSync4 } from "node:child_process";
-import { readFileSync as readFileSync14 } from "node:fs";
+import { execFile, execFileSync as execFileSync4 } from "node:child_process";
+import { readFileSync as readFileSync15 } from "node:fs";
 function isOwnRpcServerRecord(record) {
   return record.pid === process.pid && record.instance_id !== undefined && ownRpcServerInstanceIds.has(record.instance_id);
 }
@@ -27820,7 +28020,8 @@ function readPsProcessStartTime(pid) {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
       timeout: PS_PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     const processStartTime = Date.parse(String(output).trim());
     return Number.isFinite(processStartTime) ? processStartTime : null;
@@ -27895,7 +28096,8 @@ function readWindowsProcess(pid) {
     const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
       encoding: "utf8",
       timeout: PS_PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     const entries = parseTasklistOutput(String(output));
     if (entries === null)
@@ -27928,7 +28130,8 @@ function readPsProcessCommand(pid) {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
       encoding: "utf8",
       timeout: PS_PROBE_TIMEOUT_MS,
-      stdio: ["ignore", "pipe", "pipe"]
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true
     });
     return String(output);
   } catch {
@@ -28039,7 +28242,8 @@ function execProcessList(exec, file, args, timeout = PS_PROBE_TIMEOUT_MS) {
   return String(exec(file, [...args], {
     encoding: "utf8",
     timeout,
-    stdio: ["ignore", "pipe", "pipe"]
+    stdio: ["ignore", "pipe", "pipe"],
+    windowsHide: true
   }));
 }
 function parseWindowsCreationDate(value) {
@@ -28101,7 +28305,7 @@ function parseWindowsCimOutput(output) {
       pid,
       parentPid: Number.isInteger(parentPid) && parentPid > 0 ? parentPid : null,
       commandLine,
-      imageName: commandLine ? executableName(commandTokens(commandLine)[0]) : null,
+      imageName: typeof record.Name === "string" ? record.Name : commandLine ? executableName(commandTokens(commandLine)[0]) : null,
       startTime: parseWindowsCreationDate(record.CreationDate)
     });
   }
@@ -28179,14 +28383,14 @@ function readPosixParentPid(pid) {
     return null;
   }
 }
-function collectAncestorPids(selfPid, parentByPid) {
+function collectAncestorPids(selfPid, parentByPid, probeParents = true) {
   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") {
+    } else if (rpcIdentityPlatform !== "win32" && probeParents) {
       ppid = readPosixParentPid(current);
       if (ppid == null && current === process.pid && process.ppid > 0) {
         ppid = process.ppid;
@@ -28203,8 +28407,8 @@ function collectAncestorPids(selfPid, parentByPid) {
   }
   return ancestors;
 }
-function classifyLivePiSnapshot(snapshot) {
-  const ancestors = collectAncestorPids(process.pid, snapshot.parentByPid);
+function classifyLivePiSnapshot(snapshot, probeParents = true) {
+  const ancestors = collectAncestorPids(process.pid, snapshot.parentByPid, probeParents);
   const processIds = new Set;
   const inconclusivePids = new Set;
   const skippedAncestorPids = [];
@@ -28249,8 +28453,9 @@ function inspectLivePiProcesses() {
   if (false) {}
   try {
     if (rpcIdentityPlatform === "win32") {
-      const cim = tryReadWindowsCimSnapshot(rpcProcessListExecFileSync);
-      const snapshot = cim ?? tryReadWindowsTasklistSnapshot();
+      const now = rpcIdentityNowMs();
+      const cached = windowsProcessSnapshotCache;
+      const snapshot = cached && now >= cached.at && now - cached.at < WINDOWS_PROCESS_SNAPSHOT_TTL_MS ? cached.snapshot : tryReadWindowsCimSnapshot(rpcProcessListExecFileSync) ?? tryReadWindowsTasklistSnapshot();
       if (!snapshot) {
         return {
           state: "unreadable",
@@ -28258,6 +28463,8 @@ function inspectLivePiProcesses() {
           error: "process list unavailable"
         };
       }
+      if (snapshot !== cached?.snapshot)
+        windowsProcessSnapshotCache = { snapshot, at: now };
       rememberWindowsProcessFacts(snapshot.facts);
       return classifyLivePiSnapshot(snapshot);
     }
@@ -28303,7 +28510,81 @@ function parseRpcPortFile(content, fallbackPid = 0) {
 function isValidPort(port) {
   return Number.isInteger(port) && port > 0 && port <= 65535;
 }
-var ownRpcServerInstanceIds, 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, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null;
+function execProcessListAsync(file, args, timeout) {
+  return new Promise((resolve, reject) => {
+    execFile(file, args, { encoding: "utf8", timeout, windowsHide: true, maxBuffer: 8 * 1024 * 1024 }, (error, stdout) => {
+      if (error)
+        reject(error);
+      else
+        resolve(stdout);
+    });
+  });
+}
+function inspectProcessesAsync(forceFresh = false) {
+  if (!forceFresh && asyncInspection && rpcIdentityNowMs() < asyncInspectionExpires)
+    return asyncInspection;
+  asyncInspectionExpires = Number.POSITIVE_INFINITY;
+  asyncInspection = (async () => {
+    let snapshot = null;
+    try {
+      if (rpcIdentityPlatform === "win32") {
+        try {
+          const output = await asyncProcessExec("powershell", ["-NoProfile", "-Command", WINDOWS_CIM_COMMAND], WINDOWS_CIM_PROBE_TIMEOUT_MS);
+          const facts = parseWindowsCimOutput(output);
+          if (facts)
+            snapshot = snapshotFromFacts(facts, "cim");
+        } catch {}
+        if (!snapshot) {
+          const entries = parseTasklistOutput(await asyncProcessExec("tasklist", ["/FO", "CSV"], PS_PROBE_TIMEOUT_MS));
+          if (entries)
+            snapshot = snapshotFromFacts(entries.map(({ pid, command }) => ({
+              pid,
+              parentPid: null,
+              commandLine: null,
+              imageName: command,
+              startTime: null
+            })), "tasklist");
+        }
+      } else {
+        const output = await asyncProcessExec("ps", ["-axo", "pid=,ppid=,lstart=,command="], PS_PROBE_TIMEOUT_MS);
+        const facts = [];
+        for (const line of output.split(/\r?\n/)) {
+          const match = /^\s*(\d+)\s+(\d+)\s+(\S+\s+\S+\s+\d+\s+\d+:\d+:\d+\s+\d+)\s+(.+)$/.exec(line);
+          if (!match)
+            continue;
+          const startTime = Date.parse(match[3]);
+          facts.push({
+            pid: Number(match[1]),
+            parentPid: Number(match[2]),
+            commandLine: match[4],
+            imageName: null,
+            startTime: Number.isFinite(startTime) ? startTime : null
+          });
+        }
+        snapshot = facts.length > 0 ? snapshotFromFacts(facts, "ps") : null;
+      }
+    } catch {}
+    const fresh = snapshot !== null;
+    if (snapshot)
+      lastAsyncSnapshot = snapshot;
+    else
+      snapshot = lastAsyncSnapshot;
+    const byPid = new Map(snapshot?.facts.map((fact) => [fact.pid, fact]));
+    return {
+      pi: snapshot ? classifyLivePiSnapshot(snapshot, false) : { state: "unreadable", processIds: [] },
+      ...fresh && snapshot ? { processSnapshot: { source: snapshot.source, facts: snapshot.facts } } : {},
+      evidence: (pid) => ({
+        startTime: byPid.get(pid)?.startTime ?? null,
+        commandLine: byPid.get(pid)?.commandLine ?? byPid.get(pid)?.imageName ?? null
+      }),
+      liveness: (pid) => byPid.has(pid) ? "alive" : fresh ? "dead" : "inconclusive"
+    };
+  })().finally(() => {
+    asyncInspectionExpires = rpcIdentityNowMs() + WINDOWS_PROCESS_SNAPSHOT_TTL_MS;
+  });
+  return asyncInspection;
+}
+var ownRpcServerInstanceIds, RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, WINDOWS_CIM_PROBE_TIMEOUT_MS = 5000, WINDOWS_PROCESS_SNAPSHOT_TTL_MS = 2000, MAX_ANCESTOR_WALK_DEPTH = 16, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, WINDOWS_CIM_COMMAND = "Get-CimInstance Win32_Process | Select-Object ProcessId,ParentProcessId,Name,CommandLine,CreationDate | ConvertTo-Json -Compress", PI_HARNESS_ARC_MARKERS, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now(), windowsProcessFactsCache = null, windowsProcessSnapshotCache = null, asyncProcessExec, asyncInspection, asyncInspectionExpires = 0, lastAsyncSnapshot = null;
 var init_rpc_utils = __esm(() => {
   init_logger();
   init_pi_executable();
@@ -28317,11 +28598,12 @@ var init_rpc_utils = __esm(() => {
     "cljs/dist",
     "dist/bundle/cli"
   ];
-  rpcIdentityReadFileSync = readFileSync14;
+  rpcIdentityReadFileSync = readFileSync15;
   rpcIdentityExecFileSync = execFileSync4;
   rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync4;
   rpcIdentityPlatform = process.platform;
+  asyncProcessExec = execProcessListAsync;
 });
 // ../plugin/src/features/magic-context/fail-closed-block.ts
 function attachFailClosedBlockingProcessEvidence(process2, evidence) {
@@ -28463,11 +28745,11 @@ var init_fail_closed_block = __esm(() => {
 });
 
 // ../plugin/src/features/magic-context/message-fts-rowid-map.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 var EMPTY_INDEX_CONTENT_HASH, upsertMapStatements, rangeReadyStatements, updateTimeStatements, activeBackfills;
 var init_message_fts_rowid_map = __esm(() => {
   init_write_transaction_timing();
-  EMPTY_INDEX_CONTENT_HASH = createHash3("sha256").update("").digest("hex");
+  EMPTY_INDEX_CONTENT_HASH = createHash4("sha256").update("").digest("hex");
   upsertMapStatements = new WeakMap;
   rangeReadyStatements = new WeakMap;
   updateTimeStatements = new WeakMap;
@@ -31651,9 +31933,9 @@ import {
   copyFileSync,
   cpSync,
   existsSync as existsSync22,
-  mkdirSync as mkdirSync6,
+  mkdirSync as mkdirSync7,
   readdirSync as readdirSync4,
-  readFileSync as readFileSync15,
+  readFileSync as readFileSync16,
   statSync as statSync10,
   unlinkSync as unlinkSync3
 } from "node:fs";
@@ -31736,7 +32018,7 @@ function classifyJunkDiscovery(portFile, raw, staleFiles) {
   log3(`[magic-context] removing stale RPC discovery file ${portFile}: ${reason} record older than 10 minutes`);
   return null;
 }
-function inspectRpcServerDiscovery(storageDir) {
+function inspectRpcServerDiscovery(storageDir, processes) {
   const rpcRoot = join18(storageDir, "rpc");
   let projectEntries;
   try {
@@ -31794,12 +32076,12 @@ function inspectRpcServerDiscovery(storageDir) {
     }
     if (isOwnRpcServerRecord(record))
       continue;
-    const liveness = isPidAlive(record.pid);
+    const liveness = processes ? processes.liveness(record.pid) : isPidAlive(record.pid);
     if (liveness === "dead") {
       staleFiles.push(portFile);
       continue;
     }
-    const evidence = readProcessProbeEvidence(record.pid);
+    const evidence = processes ? processes.evidence(record.pid) : readProcessProbeEvidence(record.pid);
     const identity = isPidIdentityPlausible(record, evidence);
     if (identity === "plausible") {
       pids.add(record.pid);
@@ -33108,7 +33390,7 @@ var init_storage_db = __esm(async () => {
   RPC_DISCOVERY_PARSE_GRACE_MS = 10 * 60 * 1000;
   defaultRpcDiscoveryFs = {
     readdirSync: (path, options) => options?.withFileTypes ? readdirSync4(path, { withFileTypes: true }) : readdirSync4(path),
-    readFileSync: (path, encoding) => String(readFileSync15(path, encoding)),
+    readFileSync: (path, encoding) => String(readFileSync16(path, encoding)),
     statSync: (path) => ({ mtimeMs: statSync10(path).mtimeMs }),
     unlinkSync: (path) => unlinkSync3(path)
   };
@@ -33121,7 +33403,7 @@ var init_storage_db = __esm(async () => {
 });
 
 // src/lib/database-access.ts
-import { existsSync as existsSync23, writeFileSync as writeFileSync5 } from "node:fs";
+import { existsSync as existsSync23, writeFileSync as writeFileSync6 } from "node:fs";
 import { pathToFileURL } from "node:url";
 function getPersistedSchemaVersion2(db) {
   return getPersistedSchemaVersion(db);
@@ -33175,7 +33457,7 @@ function openExistingContextDatabaseForMutation(path) {
 async function backupDatabaseSnapshot(db, destination) {
   const serializable = db;
   if (typeof serializable.serialize === "function") {
-    writeFileSync5(destination, serializable.serialize(), { flag: "wx" });
+    writeFileSync6(destination, serializable.serialize(), { flag: "wx" });
     return;
   }
   const moduleName = "node:" + "sqlite";
@@ -33457,7 +33739,10 @@ function logRow(db, fromIdentity, toIdentity, tableName, rowId, action, targetRo
             (from_identity, to_identity, table_name, row_id, action, target_row_id, merged_at)
          VALUES (?, ?, ?, ?, ?, ?, ?)`).run(fromIdentity, toIdentity, tableName, rowId, action, targetRowId, mergedAt);
 }
-function mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt) {
+function normalizedContent(value) {
+  return String(value).toLowerCase().replace(/\s+/g, " ").trim();
+}
+function mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt, review) {
   const sourceId = row.id;
   if (typeof sourceId !== "number")
     return false;
@@ -33465,10 +33750,13 @@ function mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt) {
                FROM memories
               WHERE project_path = ? AND category = ? AND normalized_hash = ? AND id <> ?
               LIMIT 1`).get(toIdentity, row.category, row.normalized_hash, sourceId);
-  if (collision && typeof collision.id === "number") {
+  if (collision && normalizedContent(collision.content) !== normalizedContent(row.content)) {
+    db.prepare("UPDATE memories SET normalized_hash = ?, metadata_json = json_set(CASE WHEN json_valid(metadata_json) THEN metadata_json ELSE '{}' END, '$.identity_merge_original_hash', ?, '$.identity_merge_review', ?) WHERE id = ?").run(`${row.normalized_hash}:identity-conflict:${sourceId}`, row.normalized_hash, fromIdentity, sourceId);
+    review = true;
+  } else if (collision && typeof collision.id === "number") {
     const targetId = collision.id;
     const targetSeen = Number(collision.seen_count ?? 1);
-    const mergedSeen = Math.max(targetSeen, Number(row.seen_count ?? 1));
+    const mergedSeen = targetSeen + Number(row.seen_count ?? 1);
     const sourceClassifiedAt = Number(row.classified_at ?? 0);
     const targetClassifiedAt = Number(collision.classified_at ?? 0);
     if (sourceClassifiedAt > targetClassifiedAt) {
@@ -33501,8 +33789,9 @@ function mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt) {
                  END`).run(targetId, sourceId);
     db.prepare("DELETE FROM memory_verifications WHERE memory_id = ?").run(sourceId);
     if (mergedSeen !== targetSeen || collision.status === null || collision.status === undefined) {
-      db.prepare("UPDATE memories SET seen_count = ?, status = COALESCE(status, 'active'), updated_at = ? WHERE id = ?").run(mergedSeen, mergedAt, targetId);
+      db.prepare("UPDATE memories SET seen_count = ?, status = CASE WHEN ? = 'active' THEN 'active' ELSE COALESCE(status, 'active') END, updated_at = ? WHERE id = ?").run(mergedSeen, row.status, mergedAt, targetId);
     }
+    db.prepare(`UPDATE memories SET first_seen_at = MIN(first_seen_at, ?), last_seen_at = MAX(last_seen_at, ?), retrieval_count = COALESCE(retrieval_count, 0) + ?, merged_from = CASE WHEN merged_from IS NULL OR merged_from = '' THEN ? ELSE merged_from || ',' || ? END WHERE id = ?`).run(row.first_seen_at, row.last_seen_at, Number(row.retrieval_count ?? 0), String(sourceId), String(sourceId), targetId);
     db.prepare(`UPDATE memories
                 SET status = 'archived',
                     superseded_by_memory_id = ?,
@@ -33518,6 +33807,9 @@ function mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt) {
     logRow(db, fromIdentity, toIdentity, "memories", String(sourceId), "superseded", String(targetId), mergedAt);
     return true;
   }
+  if (review) {
+    db.prepare("UPDATE memories SET metadata_json = json_set(CASE WHEN json_valid(metadata_json) THEN metadata_json ELSE '{}' END, '$.identity_merge_review', ?) WHERE id = ?").run(fromIdentity, sourceId);
+  }
   const result = db.prepare("UPDATE memories SET project_path = ?, updated_at = ? WHERE id = ? AND project_path = ?").run(toIdentity, mergedAt, sourceId, fromIdentity);
   if ((result.changes ?? 0) === 0)
     return false;
@@ -33532,21 +33824,33 @@ function oldestOpenCycleStart(left, right) {
   const values = [left, right].filter((value) => typeof value === "number" && value > 0);
   return values.length > 0 ? Math.min(...values) : null;
 }
-function reconcileTaskScheduleCollision(db, source, target) {
-  const sourceIsNewer = typeof source.last_run_at === "number" && (typeof target.last_run_at !== "number" || source.last_run_at > target.last_run_at);
+function reconcileTaskScheduleCollision(db, source, target, mergedAt) {
+  const sourceIsNewer = source.last_status === "completed" && (target.last_status !== "completed" || typeof source.last_run_at === "number" && (typeof target.last_run_at !== "number" || source.last_run_at > target.last_run_at));
   const latest = sourceIsNewer ? source : target;
   db.prepare(`UPDATE task_schedule_state
             SET last_run_at = ?, next_due_at = ?, schedule = ?, last_status = ?,
                 last_error = ?, retry_count = ?, last_checked_commit = ?,
                 last_broad_run_at = ?, retrospective_watermark_ms = ?
-          WHERE project_path = ? AND task = ?`).run(nullableMaximum(source.last_run_at, target.last_run_at), latest.next_due_at, latest.schedule, latest.last_status, latest.last_error, latest.retry_count, latest.last_checked_commit, oldestOpenCycleStart(source.last_broad_run_at, target.last_broad_run_at), nullableMaximum(source.retrospective_watermark_ms, target.retrospective_watermark_ms), target.project_path, target.task);
+          WHERE project_path = ? AND task = ?`).run(latest.last_run_at, nextDueAtMs(String(target.schedule ?? ""), Math.max(mergedAt, Number(source.last_run_at ?? 0), Number(target.last_run_at ?? 0))), target.schedule, latest.last_status, latest.last_error, latest.retry_count, latest.last_checked_commit, oldestOpenCycleStart(source.last_broad_run_at, target.last_broad_run_at), nullableMaximum(source.retrospective_watermark_ms, target.retrospective_watermark_ms), target.project_path, target.task);
 }
 function rekeyGenericRow(db, table, row, fromIdentity, toIdentity, mergedAt) {
   const rowId = rowKey(db, table.name, row);
   const collision = findUniqueCollision(db, table, row, fromIdentity, toIdentity);
   if (collision) {
     if (table.name === "task_schedule_state") {
-      reconcileTaskScheduleCollision(db, row, collision);
+      reconcileTaskScheduleCollision(db, row, collision, mergedAt);
+    }
+    const maximumColumns = {
+      retrospective_processed_windows: ["processed_at"],
+      embedding_identity_active: ["last_active_at"],
+      memory_embedding_watermarks: ["written_memory_id", "embedded_memory_id", "updated_at"],
+      project_state: ["project_memory_epoch", "project_user_profile_version", "updated_at"],
+      project_key_files_version: ["version"]
+    };
+    const columns = maximumColumns[table.name];
+    if (columns) {
+      const targetPredicate = rowPredicate(db, table.name, collision);
+      db.prepare(`UPDATE ${quoteIdentifier(table.name)} SET ${columns.map((column) => `${quoteIdentifier(column)} = ?`).join(", ")} WHERE ${targetPredicate.sql}`).run(...columns.map((column) => nullableMaximum(row[column], collision[column])), ...targetPredicate.values);
     }
     const sourcePredicate = rowPredicate(db, table.name, row);
     const result = db.prepare(`DELETE FROM ${quoteIdentifier(table.name)} WHERE ${sourcePredicate.sql}`).run(...sourcePredicate.values);
@@ -33555,6 +33859,9 @@ function rekeyGenericRow(db, table, row, fromIdentity, toIdentity, mergedAt) {
     logRow(db, fromIdentity, toIdentity, table.name, rowId, "collision_deleted", rowKey(db, table.name, collision), mergedAt);
     return true;
   }
+  if (table.name === "task_schedule_state") {
+    db.prepare("UPDATE task_schedule_state SET next_due_at = ? WHERE project_path = ? AND task = ?").run(nextDueAtMs(String(row.schedule ?? ""), Math.max(mergedAt, Number(row.last_run_at ?? 0))), fromIdentity, row.task);
+  }
   const predicate = rowPredicate(db, table.name, row);
   const result = db.prepare(`UPDATE ${quoteIdentifier(table.name)}
                 SET ${quoteIdentifier(table.identityColumn)} = ?
@@ -33566,21 +33873,37 @@ function rekeyGenericRow(db, table, row, fromIdentity, toIdentity, mergedAt) {
   return true;
 }
 function tableSourceRows(db, table, fromIdentity) {
-  return db.prepare(`SELECT rowid, * FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.identityColumn)} = ?`).all(fromIdentity);
+  return db.prepare(`SELECT rowid, * FROM ${quoteIdentifier(table.name)} WHERE ${quoteIdentifier(table.identityColumn)} = ?${table.name === "memories" ? " AND NOT (status = 'archived' AND superseded_by_memory_id IS NOT NULL AND EXISTS (SELECT 1 FROM identity_merge_log l WHERE l.table_name = 'memories' AND l.row_id = CAST(memories.id AS TEXT) AND l.from_identity = memories.project_path AND l.action = 'superseded'))" : ""}`).all(fromIdentity);
 }
 function assertMergeAllowed(db, fromIdentity, toIdentity) {
+  const memberships = db.prepare(`SELECT m.project_path, w.id, w.name FROM workspace_members m JOIN workspaces w ON w.id = m.workspace_id WHERE m.project_path IN (?, ?)`).all(fromIdentity, toIdentity);
+  if (memberships.length === 2 && memberships[0].id !== memberships[1].id) {
+    throw new Error(`Refusing identity merge: different workspaces ${memberships[0].name} and ${memberships[1].name}. Choose membership before merging.`);
+  }
   if (!tableExists3(db, "authority_managed"))
     return;
   const source = db.prepare("SELECT 1 FROM authority_managed WHERE project_path = ? LIMIT 1").get(fromIdentity);
   if (source) {
-    throw new Error(`Refusing identity merge: ${fromIdentity} is managed by the Rust module. Drain module authority before re-keying; module-store re-keying is not in scope.`);
+    throw new Error(`Refusing identity merge: ${fromIdentity} is managed by the Rust module: this project runs in Rust mode and its data lives in the module store. Merging will be possible once the single-store migration lands.`);
   }
   const target = db.prepare("SELECT 1 FROM authority_managed WHERE project_path = ? LIMIT 1").get(toIdentity);
   if (target) {
-    throw new Error(`Refusing identity merge: ${toIdentity} is managed by the Rust module. Module-owned target pools cannot be re-keyed by this command.`);
+    throw new Error(`Refusing identity merge: ${toIdentity} is managed by the Rust module: this project runs in Rust mode and its data lives in the module store. Merging will be possible once the single-store migration lands.`);
   }
 }
-function auditIdentityMerge(db, fromIdentity, toIdentity) {
+function memoryDisposition(db, from, to) {
+  const duplicateMemoryIds = [];
+  const reviewMemoryIds = [];
+  for (const row of tableSourceRows(db, { name: "memories", identityColumn: "project_path", derived: false }, from)) {
+    const collision = db.prepare("SELECT content FROM memories WHERE project_path = ? AND category = ? AND normalized_hash = ?").get(to, row.category, row.normalized_hash);
+    if (collision && normalizedContent(collision.content) === normalizedContent(row.content))
+      duplicateMemoryIds.push(Number(row.id));
+    else if (db.prepare("SELECT 1 FROM memories WHERE project_path = ? AND category = ? LIMIT 1").get(to, row.category))
+      reviewMemoryIds.push(Number(row.id));
+  }
+  return { duplicateMemoryIds, reviewMemoryIds };
+}
+function auditIdentityMerge(db, fromIdentity, toIdentity, now = Date.now()) {
   const auditedTables = discoverIdentityTables(db).map((table) => ({
     tableName: table.name,
     identityColumn: table.identityColumn,
@@ -33588,12 +33911,31 @@ function auditIdentityMerge(db, fromIdentity, toIdentity) {
     sourceRows: table.derived ? 0 : tableSourceRows(db, table, fromIdentity).length,
     changedRows: 0
   }));
+  const changes = [];
+  for (const table of discoverIdentityTables(db).filter((table) => !table.derived && table.name !== "memories")) {
+    for (const row of tableSourceRows(db, table, fromIdentity)) {
+      const collision = findUniqueCollision(db, table, row, fromIdentity, toIdentity);
+      if (collision)
+        changes.push(`${table.name} ${rowKey(db, table.name, row)}: collapse into ${rowKey(db, table.name, collision)} (target content/configuration retained; progress counters reconciled)`);
+      if (table.name === "workspace_members")
+        changes.push(`workspace ${row.workspace_id}: ${collision ? "collapse aliases" : "transfer source membership"}`);
+      if (table.name === "task_schedule_state") {
+        const schedule = String((collision ?? row).schedule ?? "");
+        changes.push(`task ${row.task}: schedule ${JSON.stringify(row.schedule)} → ${JSON.stringify(schedule)}; next_due_at → ${nextDueAtMs(schedule, Math.max(now, Number(row.last_run_at ?? 0), Number(collision?.last_run_at ?? 0)))}`);
+      }
+    }
+  }
+  const queues = db.prepare("SELECT reason, COUNT(*) AS n FROM dream_queue WHERE project_path IN (?, ?) GROUP BY reason HAVING COUNT(*) > 1").all(fromIdentity, toIdentity);
+  for (const queue of queues)
+    changes.push(`dream_queue ${JSON.stringify(queue.reason)}: ${queue.n} → 1 queued row`);
   return {
     fromIdentity,
     toIdentity,
+    changes,
     auditedTables,
     changedRows: auditedTables.reduce((total, table) => total + table.sourceRows, 0),
-    dryRun: true
+    dryRun: true,
+    ...memoryDisposition(db, fromIdentity, toIdentity)
   };
 }
 function mergeProjectIdentities(db, fromIdentity, toIdentity, options = {}) {
@@ -33605,11 +33947,14 @@ function mergeProjectIdentities(db, fromIdentity, toIdentity, options = {}) {
   }
   assertMergeAllowed(db, fromIdentity, toIdentity);
   const tables = discoverIdentityTables(db);
-  const report = auditIdentityMerge(db, fromIdentity, toIdentity);
+  const report = auditIdentityMerge(db, fromIdentity, toIdentity, options.now);
   if (options.dryRun)
     return report;
+  if (report.changedRows === 0)
+    return { ...report, dryRun: false };
   const mergedAt = options.now ?? Date.now();
   const run = db.transaction(() => {
+    assertMergeAllowed(db, fromIdentity, toIdentity);
     if (tableExists3(db, "v22_identity_rekey_map")) {
       db.prepare(`INSERT INTO v22_identity_rekey_map (old_project_path, new_project_path, rekeyed_at)
                  VALUES (?, ?, ?)
@@ -33624,11 +33969,15 @@ function mergeProjectIdentities(db, fromIdentity, toIdentity, options = {}) {
       const rows = tableSourceRows(db, table, fromIdentity);
       tableReport.sourceRows = rows.length;
       for (const row of rows) {
-        const changed = table.name === "memories" ? mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt) : rekeyGenericRow(db, table, row, fromIdentity, toIdentity, mergedAt);
+        const changed = table.name === "memories" ? mergeMemoryRow(db, row, fromIdentity, toIdentity, mergedAt, report.reviewMemoryIds.includes(Number(row.id))) : rekeyGenericRow(db, table, row, fromIdentity, toIdentity, mergedAt);
         if (changed)
           tableReport.changedRows += 1;
       }
     }
+    db.prepare(`DELETE FROM dream_queue WHERE project_path = ? AND id NOT IN (SELECT MIN(id) FROM dream_queue WHERE project_path = ? GROUP BY reason)`).run(toIdentity, toIdentity);
+    db.prepare(`UPDATE dream_queue SET started_at = NULL WHERE project_path = ?`).run(toIdentity);
+    db.prepare(`UPDATE git_sweep_coordinator SET lease_holder = NULL, lease_expires_at = NULL, last_swept_at = NULL WHERE project_path = ?`).run(toIdentity);
+    db.prepare(`UPDATE session_meta SET cached_m0_bytes = NULL, cached_m0_project_identity = NULL WHERE cached_m0_project_identity IN (?, ?)`).run(fromIdentity, toIdentity);
     db.prepare(`INSERT INTO project_state
                 (project_path, project_memory_epoch, project_user_profile_version, updated_at)
              VALUES (?, 1, 0, ?)
@@ -33645,6 +33994,7 @@ function mergeProjectIdentities(db, fromIdentity, toIdentity, options = {}) {
 }
 var IDENTITY_COLUMNS, DERIVED_TABLE_SUFFIXES;
 var init_storage_identity_merge = __esm(() => {
+  init_cron();
   IDENTITY_COLUMNS = new Set(["project_path", "project_identity"]);
   DERIVED_TABLE_SUFFIXES = [
     "_fts",
@@ -33656,84 +34006,88 @@ var init_storage_identity_merge = __esm(() => {
   ];
 });
 
-// src/commands/doctor-merge-identity.ts
+// src/commands/doctor-identity-splits.ts
+import { realpathSync as realpathSync4 } from "node:fs";
 import { join as join19 } from "node:path";
-function valueAfter(args, flag) {
-  const index = args.indexOf(flag);
-  if (index < 0)
-    return null;
-  const value = args[index + 1];
-  if (!value || value.startsWith("--")) {
-    throw new Error(`${flag} requires a value`);
-  }
-  return value;
+function tableExists4(db, table) {
+  return !!db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ?").get(table);
 }
-function parseMergeIdentityArgs(args) {
-  const from = valueAfter(args, "--from");
-  const to = valueAfter(args, "--to");
-  if (!from || !to)
-    throw new Error("doctor merge-identity requires --from and --to");
-  const dbPath = valueAfter(args, "--db");
-  const knownFlags = new Set(["--from", "--to", "--db"]);
-  for (let index = 0;index < args.length; index += 1) {
-    const arg = args[index];
-    if (knownFlags.has(arg)) {
-      index += 1;
+function findIdentitySplits(db, host, includeSingles = false) {
+  if (!tableExists4(db, "session_projects"))
+    return [];
+  const directories = new Map;
+  for (const table of ["session", "session_v2"]) {
+    if (!tableExists4(host, table))
       continue;
+    const rows = host.prepare(`SELECT id, directory FROM ${table} WHERE directory IS NOT NULL`).all();
+    for (const row of rows) {
+      if (!row.directory)
+        continue;
+      let canonical = row.directory;
+      try {
+        canonical = realpathSync4.native(canonical);
+      } catch {}
+      const key = `${table === "session" ? "opencode" : "opencode2"}\x00${row.id}`;
+      const roots = directories.get(key) ?? new Set;
+      roots.add(projectDirectoryKey(canonical));
+      directories.set(key, roots);
     }
-    if (arg === "--dry-run" || arg === "--yes")
+  }
+  const byDirectory = new Map;
+  const bindings = db.prepare("SELECT session_id, harness, project_path FROM session_projects WHERE harness IN ('opencode', 'opencode2')").all();
+  for (const row of bindings) {
+    if (!/^(git|dir):/.test(row.project_path))
       continue;
-    throw new Error(`Unknown doctor merge-identity option: ${arg}`);
+    for (const directory of directories.get(`${row.harness}\x00${row.session_id}`) ?? []) {
+      const identities = byDirectory.get(directory) ?? new Set;
+      identities.add(row.project_path);
+      byDirectory.set(directory, identities);
+    }
   }
-  return {
-    from,
-    to,
-    dryRun: args.includes("--dry-run"),
-    yes: args.includes("--yes"),
-    ...dbPath ? { dbPath } : {}
-  };
+  const count = (table, identity) => tableExists4(db, table) ? db.prepare(`SELECT COUNT(*) AS n FROM ${table} WHERE project_path = ?`).get(identity).n : 0;
+  return [...byDirectory].filter(([, identities]) => includeSingles || identities.size > 1).sort(([a], [b]) => a.localeCompare(b)).map(([directory, identities]) => ({
+    directory,
+    identities: [...identities].sort().map((identity) => ({
+      identity,
+      sessions: count("session_projects", identity),
+      memories: count("memories", identity),
+      notes: count("notes", identity),
+      dreamer: [
+        "dream_queue",
+        "dream_runs",
+        "task_schedule_state",
+        "retrospective_processed_windows"
+      ].reduce((n, table) => n + count(table, identity), 0)
+    }))
+  }));
 }
-function printReport(report) {
-  console.log(`Identity merge ${report.dryRun ? "preview" : "complete"}:`);
-  console.log(`  from: ${report.fromIdentity}`);
-  console.log(`  to:   ${report.toIdentity}`);
-  console.log("  audited project-scoped tables:");
-  for (const table of report.auditedTables) {
-    const suffix = table.derived ? " (derived; updated by source triggers)" : "";
-    console.log(`    ${table.tableName} [${table.identityColumn}]${suffix}: ${report.dryRun ? table.sourceRows : table.changedRows} row(s)`);
-  }
-  console.log(`  rows changed: ${report.changedRows}`);
-  if (report.dryRun) {
-    console.log("  no database writes performed");
-  }
+function formatIdentitySplits(splits) {
+  return splits.flatMap((split) => [
+    `Project identity split: ${split.directory} (read-only; no merge performed)`,
+    ...split.identities.map((row) => `  ${row.identity}: ${row.sessions} sessions, ${row.memories} memories, ${row.notes} notes, ${row.dreamer} dreamer rows (identity-wide counts)`)
+  ]);
 }
-function openMergeDatabase(path, mutate) {
-  const db = mutate ? openExistingContextDatabaseForMutation(path) : openExistingContextDatabase(path, { readonly: true });
+function diagnoseIdentitySplits() {
+  const db = openExistingContextDatabase(join19(getMagicContextStorageDir(), "context.db"), {
+    readonly: true
+  });
   if (!db)
-    throw new Error(`Context database does not exist: ${path}`);
-  return db;
-}
-function runMergeIdentityCli(args) {
-  const options = parseMergeIdentityArgs(args);
-  if (!options.dryRun && !options.yes) {
-    console.error("Refusing to mutate context.db without explicit --yes. Re-run with --yes, or use --dry-run to preview.");
-    return 2;
-  }
-  const dbPath = options.dbPath ?? join19(getMagicContextStorageDir(), "context.db");
-  const db = openMergeDatabase(dbPath, !options.dryRun);
+    return [];
+  let host = null;
   try {
-    const report = mergeProjectIdentities(db, options.from, options.to, {
-      dryRun: options.dryRun
-    });
-    printReport(report);
-    return 0;
+    host = openExistingDatabase(resolveOpenCodeDbPath().path, { readonly: true });
+    if (!host)
+      return ["Identity split check skipped: OpenCode session directories unavailable."];
+    return formatIdentitySplits(findIdentitySplits(db, host));
   } finally {
+    host?.close();
     db.close();
   }
 }
-var init_doctor_merge_identity = __esm(async () => {
-  init_storage_identity_merge();
+var init_doctor_identity_splits = __esm(async () => {
+  init_project_identity_cache();
   init_data_path();
+  init_opencode_db_path();
   await init_database_access();
 });
 
@@ -33746,7 +34100,7 @@ import {
   copyFileSync as copyFileSync2,
   existsSync as existsSync24,
   openSync as openSync4,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   rmSync as rmSync3,
   statSync as statSync11
 } from "node:fs";
@@ -34001,15 +34355,15 @@ function activateReplacement(dbPath, replacementPath, originalAsidePath) {
       if (!existsSync24(from))
         continue;
       const to = `${originalAsidePath}${suffix}`;
-      renameSync4(from, to);
+      renameSync5(from, to);
       movedOriginals.push({ from, to });
     }
-    renameSync4(replacementPath, dbPath);
+    renameSync5(replacementPath, dbPath);
     return movedOriginals.map(({ to }) => to);
   } catch (error) {
     for (const moved of movedOriginals.reverse()) {
       if (existsSync24(moved.to) && !existsSync24(moved.from))
-        renameSync4(moved.to, moved.from);
+        renameSync5(moved.to, moved.from);
     }
     throw error;
   }
@@ -34240,6 +34594,232 @@ var init_doctor_repair_db = __esm(async () => {
   ];
 });
 
+// src/commands/doctor-merge-identity.ts
+import { execFileSync as execFileSync5 } from "node:child_process";
+import { createHash as createHash5 } from "node:crypto";
+import {
+  cpSync as cpSync2,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync8,
+  mkdtempSync,
+  readdirSync as readdirSync5,
+  readFileSync as readFileSync17,
+  renameSync as renameSync6,
+  writeFileSync as writeFileSync7
+} from "node:fs";
+import { dirname as dirname13, join as join21 } from "node:path";
+function parseMergeIdentityArgs(args) {
+  const values = {};
+  const switches = new Set(["--apply", "--force", "--dry-run", "--yes"]);
+  for (let i = 0;i < args.length; i++) {
+    const flag = args[i];
+    if (["--from", "--to", "--db", "--host-db"].includes(flag)) {
+      const value = args[++i];
+      if (!value || value.startsWith("--"))
+        throw new Error(`${flag} requires a value`);
+      if (values[flag])
+        throw new Error(`Repeated option: ${flag}`);
+      values[flag] = value;
+    } else if (!switches.has(flag))
+      throw new Error(`Unknown doctor merge-identities option: ${flag}`);
+  }
+  if (Boolean(values["--from"]) !== Boolean(values["--to"]))
+    throw new Error("Supply both --from and --to");
+  const apply = args.includes("--apply") || args.includes("--yes");
+  if (apply && (!values["--from"] || args.includes("--dry-run")))
+    throw new Error("--apply requires --from/--to and cannot be combined with --dry-run");
+  return {
+    from: values["--from"],
+    to: values["--to"],
+    dbPath: values["--db"],
+    hostPath: values["--host-db"],
+    dryRun: !apply,
+    yes: apply,
+    force: args.includes("--force")
+  };
+}
+function printReport(report) {
+  console.log(`Identity merge ${report.dryRun ? "preview" : "complete"}: ${report.fromIdentity} → ${report.toIdentity}`);
+  for (const table of report.auditedTables) {
+    console.log(`  ${table.tableName}: ${report.dryRun ? table.sourceRows : table.changedRows} row(s)${table.derived ? " (derived; maintained by triggers)" : ""}`);
+  }
+  for (const change of report.changes)
+    console.log(`  ${change}`);
+  console.log(`  identical memories collapsed: ${report.duplicateMemoryIds.join(", ") || "none"}`);
+  console.log(`  potential content conflicts kept for review (same category): ${report.reviewMemoryIds.join(", ") || "none"}`);
+  console.log("  Workspace aliases collapse; source-only membership transfers. Target schedules win; next_due_at is recomputed. Queued reasons deduplicate; run history and processed windows remain.");
+  console.log("  Git indexes move; sweep leases reset for rebuilding. Existing memory embeddings remain valid (content unchanged); FTS triggers rekey indexes.");
+  if (!report.changedRows)
+    console.log("  No-op: no source rows remain to move.");
+  if (report.dryRun)
+    console.log("  No writes. Review this preview, then repeat with --apply to confirm.");
+}
+function resolveReadOnly(directory) {
+  if (!existsSync25(directory))
+    return;
+  try {
+    const roots = execFileSync5("git", ["rev-list", "--max-parents=0", "HEAD"], {
+      cwd: directory,
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"]
+    }).trim().split(/\s+/).filter((root) => /^[0-9a-f]{40,64}$/.test(root)).sort();
+    if (roots[0])
+      return `git:${roots[0]}`;
+  } catch {}
+  try {
+    const result = execFileSync5("git", ["rev-parse", "--is-inside-work-tree"], {
+      cwd: directory,
+      windowsHide: true,
+      encoding: "utf8",
+      timeout: 5000,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    if (result.trim() === "true")
+      return;
+  } catch (error) {
+    if (String(error.stderr).includes("not a git repository"))
+      return `dir:${createHash5("md5").update(projectDirectoryKey(directory)).digest("hex").slice(0, 12)}`;
+  }
+  return;
+}
+function observations(db, hostPath, storageDir) {
+  const host = openExistingDatabase(hostPath, { readonly: true });
+  let rows = [];
+  try {
+    rows = host ? findIdentitySplits(db, host, true) : [];
+  } finally {
+    host?.close();
+  }
+  const add = (directory, identity) => {
+    if (!/^(git|dir):/.test(identity))
+      return;
+    directory = projectDirectoryKey(directory);
+    let row = rows.find((item) => item.directory === directory);
+    if (!row) {
+      row = { directory, identities: [] };
+      rows.push(row);
+    }
+    if (!row.identities.some((item) => item.identity === identity))
+      row.identities.push({ identity, sessions: 0, memories: 0, notes: 0, dreamer: 0 });
+  };
+  const sidecars = join21(storageDir, "project-identities");
+  if (existsSync25(sidecars))
+    for (const file of readdirSync5(sidecars)) {
+      if (!file.endsWith(".json"))
+        continue;
+      try {
+        const record = JSON.parse(readFileSync17(join21(sidecars, file), "utf8"));
+        if (typeof record.directory === "string" && typeof record.identity === "string")
+          add(record.directory, record.identity);
+      } catch {}
+    }
+  for (const row of db.prepare("SELECT project_path, display_path FROM workspace_members").all())
+    add(row.display_path, row.project_path);
+  return rows;
+}
+function runMergeIdentityCli(args, deps = {}) {
+  const options = parseMergeIdentityArgs(args);
+  const dbPath = options.dbPath ?? join21(getMagicContextStorageDir(), "context.db");
+  const storageDir = dirname13(dbPath);
+  const hostPath = options.hostPath ?? (options.dbPath ? join21(storageDir, "host.db") : resolveOpenCodeDbPath().path);
+  let db = openExistingContextDatabase(dbPath, {
+    readonly: true,
+    minimumSupportedVersion: CLI_SCHEMA_FLOOR_VERSION
+  });
+  if (!db)
+    throw new Error(`Context database does not exist: ${dbPath}`);
+  let directories = [];
+  try {
+    const observed = observations(db, hostPath, storageDir);
+    if (!options.from || !options.to) {
+      for (const split of observed.filter((row) => row.identities.length > 1)) {
+        const target = resolveReadOnly(split.directory) ?? split.identities.map((row) => row.identity).filter((id) => id.startsWith("git:")).sort()[0];
+        console.log(`Project identity split: ${split.directory}`);
+        for (const row of split.identities)
+          if (row.identity !== target)
+            console.log(`  ${row.identity} → ${target ?? "unresolved target"}`);
+      }
+      if (!observed.some((row) => row.identities.length > 1))
+        console.log("No detected identity splits.");
+      return 0;
+    }
+    if (options.from === options.to)
+      throw new Error(`Source and target identities must differ: ${options.from}`);
+    for (const identity of [options.from, options.to]) {
+      const known = auditIdentityMerge(db, identity, options.to).changedRows > 0 || db.prepare("SELECT 1 FROM v22_identity_rekey_map WHERE old_project_path = ? OR new_project_path = ?").get(identity, identity);
+      if (!known)
+        throw new Error(`Unknown identity: ${identity}`);
+    }
+    const sourceDirs = observed.filter((row) => row.identities.some((item) => item.identity === options.from)).map((row) => row.directory);
+    const targetDirs = observed.filter((row) => row.identities.some((item) => item.identity === options.to)).map((row) => row.directory);
+    directories = [...new Set([...sourceDirs, ...targetDirs])];
+    const alreadyMerged = auditIdentityMerge(db, options.from, options.to).changedRows === 0 && db.prepare("SELECT 1 FROM v22_identity_rekey_map WHERE old_project_path = ? AND new_project_path = ?").get(options.from, options.to);
+    if (!alreadyMerged && options.from.startsWith("git:") && options.to.startsWith("git:") && (!sourceDirs.length || !targetDirs.length || sourceDirs.some((dir) => !targetDirs.includes(dir)) || targetDirs.some((dir) => !sourceDirs.includes(dir))))
+      throw new Error(`Refusing different directories for ${options.from} (${sourceDirs.join(", ") || "unknown"}) and ${options.to} (${targetDirs.join(", ") || "unknown"})`);
+    if (!options.force && !directories.some((directory) => resolveReadOnly(directory) === options.to))
+      throw new Error(`Target ${options.to} does not resolve for any observed directory on this machine; use --force only after reviewing the identity.`);
+    const preview = mergeProjectIdentities(db, options.from, options.to, { dryRun: true });
+    printReport(preview);
+    if (options.dryRun)
+      return 0;
+  } finally {
+    db.close();
+  }
+  const { from, to } = options;
+  if (!from || !to)
+    return 0;
+  const holders = (deps.inspectHolders ?? defaultInspectHolders)(storageDir);
+  const probe = (deps.probe ?? probeHostProcessesUsing)({
+    files: [dbPath, `${dbPath}-wal`, `${dbPath}-shm`],
+    directories: []
+  });
+  if (!holders.safe || probe.status !== "free")
+    throw new Error(`Refusing merge: close OpenCode, Pi, OpenCode 2 and ck-mc. ${holders.blockers.join(", ")} ${holders.uncertainty ?? ""} ${probe.status === "in_use" ? `context.db holders: ${probe.pids.join(", ")}` : probe.status === "unknown" ? probe.reason : ""}`);
+  const backup = mkdtempSync(join21(storageDir, "identity-merge-backup-"));
+  const quote = (value) => `'${value.replaceAll("'", "'\\''")}'`;
+  console.log(`Backup directory: ${backup}`);
+  console.log(`Restore with hosts closed: rm -f ${quote(`${dbPath}-wal`)} ${quote(`${dbPath}-shm`)}; cp ${quote(join21(backup, "context.db"))} ${quote(dbPath)}; if test -f ${quote(join21(backup, "context.db-wal"))}; then cp ${quote(join21(backup, "context.db-wal"))} ${quote(`${dbPath}-wal`)}; fi`);
+  const sidecarRoot = join21(storageDir, "project-identities");
+  const sidecarBackup = join21(backup, "project-identities");
+  mkdirSync8(sidecarBackup);
+  if (existsSync25(sidecarRoot))
+    cpSync2(sidecarRoot, sidecarBackup, { recursive: true });
+  console.log(`Restore identity sidecars too: rm -rf ${quote(sidecarRoot)}; cp -R ${quote(sidecarBackup)} ${quote(sidecarRoot)}`);
+  copyDatabaseBundle(dbPath, join21(backup, "context.db"));
+  db = openExistingDatabase(dbPath, { readonly: false });
+  if (!db)
+    throw new Error(`Context database disappeared: ${dbPath}`);
+  try {
+    printReport(mergeProjectIdentities(db, from, to));
+  } finally {
+    db.close();
+  }
+  if (to.startsWith("git:"))
+    for (const directory of directories) {
+      const root = join21(storageDir, "project-identities");
+      mkdirSync8(root, { recursive: true });
+      const path = join21(root, `${createHash5("sha256").update(projectDirectoryKey(directory)).digest("hex")}.json`);
+      const temporary = `${path}.merge.tmp`;
+      writeFileSync7(temporary, JSON.stringify({ directory: projectDirectoryKey(directory), identity: options.to }), { mode: 384 });
+      renameSync6(temporary, path);
+    }
+  return 0;
+}
+var init_doctor_merge_identity = __esm(async () => {
+  init_project_identity_cache();
+  init_storage_identity_merge();
+  init_data_path();
+  init_opencode_db_path();
+  init_doctor_opencode2_cache();
+  await __promiseAll([
+    init_database_access(),
+    init_doctor_identity_splits(),
+    init_doctor_repair_db()
+  ]);
+});
+
 // src/commands/doctor-hidden-sessions.ts
 function parseMetadata(value) {
   if (value && typeof value === "object" && !Array.isArray(value)) {
@@ -34330,20 +34910,20 @@ var init_migration_paths = __esm(() => {
 });
 
 // src/commands/migrate.ts
-import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
-import { existsSync as existsSync25, mkdirSync as mkdirSync7, renameSync as renameSync5, unlinkSync as unlinkSync4 } from "node:fs";
-import { dirname as dirname13, join as join21 } from "node:path";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync26, mkdirSync as mkdirSync9, renameSync as renameSync7, unlinkSync as unlinkSync4 } from "node:fs";
+import { dirname as dirname14, join as join22 } from "node:path";
 function defaultOpenCodeDbPath() {
   return getOpenCodeDatabasePath();
 }
 function defaultCortexkitDbPath() {
-  return join21(getMagicContextStorageDir(), "context.db");
+  return join22(getMagicContextStorageDir(), "context.db");
 }
 function defaultPiSessionsRoot() {
   return getPiSessionsRoot();
 }
 function defaultFs() {
-  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync25, renameSync: renameSync5, mkdirSync: mkdirSync7 };
+  return { writeFileAtomic, unlinkSync: unlinkSync4, existsSync: existsSync26, renameSync: renameSync7, mkdirSync: mkdirSync9 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -34370,7 +34950,7 @@ function shortId() {
   return randomBytes2(4).toString("hex");
 }
 function migrationKeyFor(sourceSessionId, targetHarness) {
-  return createHash4("sha256").update(`${sourceSessionId}
+  return createHash6("sha256").update(`${sourceSessionId}
 ${targetHarness}`).digest("hex");
 }
 function moduleManagedProjectForSession(db, sessionId) {
@@ -34409,7 +34989,7 @@ function sweepPendingMigrations(db, fs = defaultFs()) {
     }
     if (row.phase === "db_committed") {
       if (fs.existsSync(row.stage_path)) {
-        fs.mkdirSync(dirname13(row.final_path), { recursive: true });
+        fs.mkdirSync(dirname14(row.final_path), { recursive: true });
         fs.renameSync(row.stage_path, row.final_path);
         stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
         report.rolledForward += 1;
@@ -34439,7 +35019,7 @@ function claimJournalIdentity(args) {
              migration_key, source_session_id, target_harness, pi_session_id,
              final_path, stage_path, content_sha256, phase, created_at
          ) VALUES (?, ?, ?, ?, ?, ?, '', 'staged', ?)
-         ON CONFLICT(migration_key) DO NOTHING`).run(args.migrationKey, args.sourceSessionId, args.targetHarness, piSessionId, args.finalPathFor(piSessionId), join21(args.stageDir, `${args.migrationKey}.jsonl`), args.now);
+         ON CONFLICT(migration_key) DO NOTHING`).run(args.migrationKey, args.sourceSessionId, args.targetHarness, piSessionId, args.finalPathFor(piSessionId), join22(args.stageDir, `${args.migrationKey}.jsonl`), args.now);
   const row = readPendingMigration(args.db, args.migrationKey);
   if (!row) {
     throw new Error("migration journal row disappeared during insert; aborting migration");
@@ -34944,7 +35524,7 @@ function migrateOpenCodeSessionToPi(opts) {
     const provider = opts.provider ?? model.provider;
     const modelId = opts.modelId ?? model.modelId;
     const cwd = session.directory ?? session.path ?? process.cwd();
-    const outputDir = join21(piSessionsRoot, projectPathToPiDirSlug(cwd));
+    const outputDir = join22(piSessionsRoot, projectPathToPiDirSlug(cwd));
     const targetHarness = opts.targetHarness ?? "pi";
     const moduleManagedProject = cortexkitDb === null ? null : moduleManagedProjectForSession(cortexkitDb, session.id);
     if (moduleManagedProject) {
@@ -34968,8 +35548,8 @@ function migrateOpenCodeSessionToPi(opts) {
         migrationKey,
         sourceSessionId: session.id,
         targetHarness,
-        finalPathFor: (id) => join21(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
-        stageDir: join21(dirname13(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
+        finalPathFor: (id) => join22(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
+        stageDir: join22(dirname14(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
         now: now.getTime()
       });
       piSessionId = claimed.row.pi_session_id;
@@ -34978,7 +35558,7 @@ function migrateOpenCodeSessionToPi(opts) {
       journalResumed = claimed.resumed;
     } else {
       piSessionId = generateUuidV7(now);
-      finalPath = join21(outputDir, `${formatPiFilenameTimestamp(now)}_${piSessionId}.jsonl`);
+      finalPath = join22(outputDir, `${formatPiFilenameTimestamp(now)}_${piSessionId}.jsonl`);
       stagePath = "";
     }
     const buildResult = buildPiEntries({
@@ -35017,11 +35597,11 @@ function migrateOpenCodeSessionToPi(opts) {
 `;
     if (!opts.dryRun) {
       if (journalActive && cortexkitDb !== null && migrationKey !== undefined && plan) {
-        const contentSha256 = createHash4("sha256").update(jsonl, "utf8").digest("hex");
+        const contentSha256 = createHash6("sha256").update(jsonl, "utf8").digest("hex");
         commitStagedChecksum(cortexkitDb, migrationKey, contentSha256);
         fs.writeFileAtomic(stagePath, jsonl);
         plan.commit(migrationKey);
-        fs.mkdirSync(dirname13(finalPath), { recursive: true });
+        fs.mkdirSync(dirname14(finalPath), { recursive: true });
         fs.renameSync(stagePath, finalPath);
         stmt(cortexkitDb, "DELETE FROM migration_pending WHERE migration_key = ?").run(migrationKey);
       } else {
@@ -35291,9 +35871,9 @@ var init_relocate_memory = __esm(() => {
 });
 
 // src/commands/migrate-session.ts
-import { existsSync as existsSync26, realpathSync as realpathSync4 } from "node:fs";
-import { homedir as homedir14 } from "node:os";
-import path4, { join as join22 } from "node:path";
+import { existsSync as existsSync27, realpathSync as realpathSync5 } from "node:fs";
+import { homedir as homedir15 } from "node:os";
+import path5, { join as join23 } from "node:path";
 function existingSessionColumns(db) {
   const rows = db.prepare("PRAGMA table_info(session)").all();
   return new Set(rows.map((r) => r.name).filter((n) => typeof n === "string"));
@@ -35377,7 +35957,7 @@ function planMigrateSession(sessionId, rawTargetDirectory, deps) {
     ocProjectId = "global";
     ocWorktree = globalRow.worktree || "/";
   }
-  const sessionPath = path4.relative(ocWorktree, targetDirectory);
+  const sessionPath = path5.relative(ocWorktree, targetDirectory);
   const ownershipRow = deps.contextDb.prepare("SELECT project_path FROM session_projects WHERE session_id = ? AND harness = 'opencode'").get(sessionId);
   const fromMcIdentity = ownershipRow?.project_path ?? (sessionRow.directory ? deps.resolveIdentity(sessionRow.directory) : "");
   const toMcIdentity = deps.resolveIdentity(targetDirectory);
@@ -35503,18 +36083,18 @@ function defaultOpenCodeDbPath2() {
   return getOpenCodeDatabasePath();
 }
 function defaultContextDbPath() {
-  return join22(getMagicContextStorageDir(), "context.db");
+  return join23(getMagicContextStorageDir(), "context.db");
 }
 function realDeps(opencodeDb, contextDb) {
   return {
     opencodeDb,
     contextDb,
     resolveIdentity: resolveProjectIdentity,
-    hasGitDir: (dir) => existsSync26(join22(dir, ".git")),
-    realpath: (p) => realpathSync4(p)
+    hasGitDir: (dir) => existsSync27(join23(dir, ".git")),
+    realpath: (p) => realpathSync5(p)
   };
 }
-function valueAfter2(args, flag) {
+function valueAfter(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
     return null;
@@ -35568,11 +36148,11 @@ async function runMigrateSessionCli(args) {
     printMigrateSessionHelp();
     return 0;
   }
-  const sessionId = valueAfter2(args, "--session");
-  const toDir = valueAfter2(args, "--to");
+  const sessionId = valueAfter(args, "--session");
+  const toDir = valueAfter(args, "--to");
   const dryRun = args.includes("--dry-run");
   const skipConfirm = args.includes("--yes");
-  const memoriesFlag = valueAfter2(args, "--memories");
+  const memoriesFlag = valueAfter(args, "--memories");
   if (!sessionId) {
     console.error("Missing required flag: --session <id>");
     printMigrateSessionHelp();
@@ -35588,8 +36168,8 @@ async function runMigrateSessionCli(args) {
     printMigrateSessionHelp();
     return 1;
   }
-  const expandedTo = toDir.startsWith("~") ? join22(homedir14(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
-  if (!existsSync26(expandedTo)) {
+  const expandedTo = toDir.startsWith("~") ? join23(homedir15(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
+  if (!existsSync27(expandedTo)) {
     console.error(`Target directory does not exist: ${expandedTo}`);
     return 1;
   }
@@ -35741,9 +36321,9 @@ var init_migrate_session = __esm(async () => {
 });
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
-import { createHash as createHash5 } from "node:crypto";
-import { realpathSync as realpathSync5 } from "node:fs";
-import path5 from "node:path";
+import { createHash as createHash7 } from "node:crypto";
+import { realpathSync as realpathSync6 } from "node:fs";
+import path6 from "node:path";
 function readMeta(db, key) {
   const row = db.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(key);
   return row?.value ?? null;
@@ -35764,7 +36344,7 @@ function countFailures(db) {
 function classifyBackfillError(error) {
   if (error instanceof ProjectIdentityError) {
     return {
-      errorClass: error.errorClass === "dubious_ownership" ? "unknown" : error.errorClass,
+      errorClass: error.errorClass === "dubious_ownership" || error.errorClass === "home_project_disabled" || error.errorClass === "git_identity_unavailable" ? "unknown" : error.errorClass,
       errorMessage: error.message
     };
   }
@@ -35786,11 +36366,11 @@ function resolveBackfillIdentity(rawProjectPath) {
 function computeLegacyRustDirIdentity(rawProjectPath) {
   let canonical;
   try {
-    canonical = realpathSync5(rawProjectPath);
+    canonical = realpathSync6(rawProjectPath);
   } catch {
-    canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
+    canonical = path6.isAbsolute(rawProjectPath) ? rawProjectPath : path6.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash5("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash7("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)
@@ -36011,7 +36591,7 @@ var init_tick_failure = __esm(() => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync27 } from "node:fs";
+import { existsSync as existsSync28 } from "node:fs";
 function getProjectConfigPaths(cwd) {
   const basePath = cortexKitProjectConfigBasePath(cwd);
   return [`${basePath}.jsonc`, `${basePath}.json`];
@@ -36021,10 +36601,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path) => existsSync27(path));
+  return paths.find((path) => existsSync28(path));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync27(source.path)) ?? null;
+  return sources.find((source) => existsSync28(source.path)) ?? null;
 }
 function loadConfigFile(path, scope) {
   let raw;
@@ -36319,7 +36899,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync27(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync28(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -36328,7 +36908,7 @@ function loadPiConfigDetailed(opts = {}, applyRuntimeGlobals = true) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync27(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync28(source.path));
   if (userLegacyFallback) {
     warnings.push(`[user config] reading legacy config from ${userLegacyFallback.path} until migration completes; run \`npx @cortexkit/magic-context doctor\` to consolidate into the shared CortexKit location.`);
   } else if (legacyUserUnmigrated) {
@@ -36450,10 +37030,11 @@ var DATABASE_REPAIR_COMMAND = "bunx @cortexkit/magic-context@latest doctor repai
 
 // src/lib/github-issue.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { readFileSync as readFileSync16 } from "node:fs";
+import { readFileSync as readFileSync18 } from "node:fs";
 function runGhCommand(args) {
   try {
     const result = spawnSync5("gh", args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -36476,7 +37057,7 @@ function failed(result) {
 function submitGithubIssue(title, bodyPath, runner = runGhCommand) {
   let body;
   try {
-    body = readFileSync16(bodyPath, "utf-8");
+    body = readFileSync18(bodyPath, "utf-8");
   } catch (error) {
     return {
       ok: false,
@@ -36534,9 +37115,9 @@ var MAX_GITHUB_ISSUE_BODY_CHARS = 65536;
 var init_github_issue = () => {};
 
 // src/lib/log-lines.ts
-import { existsSync as existsSync28, readFileSync as readFileSync17, statSync as statSync12 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync19, statSync as statSync12 } from "node:fs";
 import { tmpdir as tmpdir2 } from "node:os";
-import { join as join23 } from "node:path";
+import { join as join24 } from "node:path";
 function tokenize(input, limit = Number.POSITIVE_INFINITY) {
   const tokens = [];
   let index = 0;
@@ -36822,20 +37403,20 @@ function parseLogLine(line) {
 }
 function getMagicContextLogPaths(harness, options = {}) {
   const override = options.override === undefined ? process.env.MAGIC_CONTEXT_LOG_PATH?.trim() : options.override?.trim();
-  const storageLogs = join23(options.storageDir ?? getMagicContextStorageDir(), "logs");
+  const storageLogs = join24(options.storageDir ?? getMagicContextStorageDir(), "logs");
   return [
     ...override ? [override] : [],
-    join23(options.tempDir ?? tmpdir2(), harness, "magic-context", "magic-context.log"),
-    join23(storageLogs, `magic-context.${harness}.log`),
-    join23(storageLogs, "magic-context.log")
+    join24(options.tempDir ?? tmpdir2(), harness, "magic-context", "magic-context.log"),
+    join24(storageLogs, `magic-context.${harness}.log`),
+    join24(storageLogs, "magic-context.log")
   ].filter((path, index, paths) => paths.indexOf(path) === index);
 }
 function inspectLogFile(path) {
-  if (!existsSync28(path)) {
+  if (!existsSync29(path)) {
     return { path, exists: false, sizeKb: 0, lineCount: 0, grammar: "unknown" };
   }
   try {
-    const content = readFileSync17(path, "utf8");
+    const content = readFileSync19(path, "utf8");
     const lines = content.split(/\r?\n/).filter((line) => line.length > 0);
     const grammars = new Set(lines.flatMap((line) => {
       const parsed = parseLogLine(line);
@@ -36862,7 +37443,7 @@ function readLogLines(files) {
       return [];
     try {
       let precedingTimestamp = "";
-      return readFileSync17(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
+      return readFileSync19(file.path, "utf8").split(/\r?\n/).filter((line) => line.length > 0).map((line, lineIndex) => {
         precedingTimestamp = parseLogLine(line)?.ts ?? precedingTimestamp;
         return { line, timestamp: precedingTimestamp, fileIndex, lineIndex };
       });
@@ -36911,10 +37492,10 @@ var init_redaction2 = __esm(() => {
 });
 
 // src/commands/doctor-omp.ts
-import { execFileSync as execFileSync5, spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync29, mkdirSync as mkdirSync8, readFileSync as readFileSync18 } from "node:fs";
+import { execFileSync as execFileSync6, spawnSync as spawnSync6 } from "node:child_process";
+import { existsSync as existsSync30, mkdirSync as mkdirSync10, readFileSync as readFileSync20 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
-import { dirname as dirname14, join as join24, resolve as resolve8 } from "node:path";
+import { dirname as dirname15, join as join25, resolve as resolve8 } from "node:path";
 function parseSemver(value) {
   const match = value?.match(/(\d+)\.(\d+)\.(\d+)/);
   return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
@@ -36956,10 +37537,10 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path) {
-  if (!existsSync29(path))
+  if (!existsSync30(path))
     return {};
   try {
-    const parsed = import_comment_json7.parse(readFileSync18(path, "utf-8"));
+    const parsed = import_comment_json7.parse(readFileSync20(path, "utf-8"));
     return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? {} : { error: "top level is not an object" };
   } catch (error) {
     return { error: error instanceof Error ? error.message : String(error) };
@@ -36969,7 +37550,7 @@ function pluginDeclaresOmp(path) {
   if (!path)
     return null;
   try {
-    const pkg = JSON.parse(readFileSync18(join24(path, "package.json"), "utf-8"));
+    const pkg = JSON.parse(readFileSync20(join25(path, "package.json"), "utf-8"));
     return Array.isArray(pkg.omp?.extensions) || Array.isArray(pkg.pi?.extensions);
   } catch {
     return null;
@@ -37050,7 +37631,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync29(userConfigPath)) {
+  if (!existsSync30(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -37067,9 +37648,9 @@ async function runHealthChecks(options) {
     for (const warning of loaded.warnings.slice(0, 5))
       add(results, "warn", warning);
   const storage = getMagicContextStorageResolution();
-  const dbPath = join24(storage.path, "context.db");
+  const dbPath = join25(storage.path, "context.db");
   add(results, "info", `Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync29(dbPath))
+  if (!existsSync30(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -37123,7 +37704,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   };
 }
 function writeDefaultConfig(path) {
-  mkdirSync8(dirname14(path), { recursive: true });
+  mkdirSync10(dirname15(path), { recursive: true });
   const config = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
@@ -37133,7 +37714,7 @@ function writeDefaultConfig(path) {
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync29(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync30(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -37175,6 +37756,7 @@ function timestamp2(date) {
 function runGhCommandWithDeps(deps, args) {
   if (args[0] === "issue") {
     const result = deps.spawnSync("gh", args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -37186,6 +37768,7 @@ function runGhCommandWithDeps(deps, args) {
   }
   try {
     const output = deps.execFileSync("gh", args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -37218,7 +37801,7 @@ async function runIssueFlow(options) {
     ...report.results.map((result) => `- ${result.status.toUpperCase()}: ${sanitizeDiagnosticText(result.message)}`)
   ].join(`
 `);
-  const path = join24(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
+  const path = join25(options.cwd, `magic-context-omp-issue-${timestamp2(options.deps.now())}.md`);
   writeFileAtomic(path, `${body}
 `);
   options.prompts.log.success(`Sanitized report written to ${path}`);
@@ -37289,7 +37872,7 @@ var init_doctor_omp = __esm(async () => {
     openExistingContextDatabase,
     now: () => new Date,
     inspectMagicContextLogs,
-    execFileSync: execFileSync5,
+    execFileSync: execFileSync6,
     spawnSync: spawnSync6
   };
 });
@@ -37406,7 +37989,7 @@ function truncate(text) {
 var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 
 // ../plugin/src/features/magic-context/memory/embedding-synapse.ts
-import { createHash as createHash6 } from "node:crypto";
+import { createHash as createHash8 } from "node:crypto";
 function toSynapseLaneDescriptor(metadata) {
   const tokenBudget = metadata.recommended_token_budget;
   return {
@@ -37546,7 +38129,7 @@ function wait(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 function sha256(value) {
-  return createHash6("sha256").update(value).digest("hex");
+  return createHash8("sha256").update(value).digest("hex");
 }
 function stableJson2(value) {
   if (Array.isArray(value))
@@ -38190,12 +38773,12 @@ function listShadowBackfillStalls(db, projectIdentity) {
 var SHADOW_BACKFILL_PROVENANCE_KEY = "_magicContextShadowBackfill";
 
 // ../plugin/src/shared/auto-update-provenance.ts
-import { existsSync as existsSync30, readFileSync as readFileSync19 } from "node:fs";
+import { existsSync as existsSync31, readFileSync as readFileSync21 } from "node:fs";
 function readAutoUpdateCheckState(path) {
-  if (!existsSync30(path))
+  if (!existsSync31(path))
     return null;
   try {
-    const value = JSON.parse(readFileSync19(path, "utf-8"));
+    const value = JSON.parse(readFileSync21(path, "utf-8"));
     if (!value || typeof value !== "object" || Array.isArray(value))
       return null;
     const raw = value;
@@ -38223,14 +38806,14 @@ var init_auto_update_provenance = () => {};
 // ../plugin/src/shared/tui-config.ts
 import {
   chmodSync as chmodSync5,
-  existsSync as existsSync31,
-  mkdirSync as mkdirSync9,
-  readFileSync as readFileSync20,
-  renameSync as renameSync6,
+  existsSync as existsSync32,
+  mkdirSync as mkdirSync11,
+  readFileSync as readFileSync22,
+  renameSync as renameSync8,
   statSync as statSync13,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync8
 } from "node:fs";
-import { dirname as dirname15, join as join25 } from "node:path";
+import { dirname as dirname16, join as join26 } from "node:path";
 function pluginEntryId(entry) {
   if (typeof entry === "string")
     return entry;
@@ -38261,21 +38844,21 @@ function writeTuiConfigAtomic(configPath, config) {
   const body = `${import_comment_json8.stringify(config, null, 2)}
 `;
   const tmpPath = `${configPath}.tmp`;
-  writeFileSync6(tmpPath, body);
+  writeFileSync8(tmpPath, body);
   try {
     if (statSync13(configPath, { throwIfNoEntry: false })?.isFile()) {
       chmodSync5(tmpPath, statSync13(configPath).mode & 511);
     }
   } catch {}
-  renameSync6(tmpPath, configPath);
+  renameSync8(tmpPath, configPath);
 }
 function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
-  const jsoncPath = join25(configDir, "tui.jsonc");
-  const jsonPath = join25(configDir, "tui.json");
-  if (existsSync31(jsoncPath))
+  const jsoncPath = join26(configDir, "tui.jsonc");
+  const jsonPath = join26(configDir, "tui.json");
+  if (existsSync32(jsoncPath))
     return jsoncPath;
-  if (existsSync31(jsonPath))
+  if (existsSync32(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -38283,8 +38866,8 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config = {};
-    if (existsSync31(configPath)) {
-      const raw = readFileSync20(configPath, "utf-8");
+    if (existsSync32(configPath)) {
+      const raw = readFileSync22(configPath, "utf-8");
       config = import_comment_json8.parse(raw) ?? {};
     }
     const plugins = Array.isArray(config.plugin) ? [...config.plugin] : [];
@@ -38318,7 +38901,7 @@ function ensureTuiPluginEntry(options = {}) {
       }
     }
     config.plugin = plugins;
-    mkdirSync9(dirname15(configPath), { recursive: true });
+    mkdirSync11(dirname16(configPath), { recursive: true });
     writeTuiConfigAtomic(configPath, config);
     log3(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -38336,9 +38919,9 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync32, readdirSync as readdirSync5, readFileSync as readFileSync21, statSync as statSync14 } from "node:fs";
+import { existsSync as existsSync33, readdirSync as readdirSync6, readFileSync as readFileSync23, statSync as statSync14 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { join as join26 } from "node:path";
+import { join as join27 } from "node:path";
 function getSelfVersion() {
   const require2 = createRequire4(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -38353,7 +38936,7 @@ function getSelfVersion() {
 }
 function readLegacyCachedVersion(root) {
   try {
-    const pkg = JSON.parse(readFileSync21(getOpenCodePluginPackageJsonPath(root), "utf-8"));
+    const pkg = JSON.parse(readFileSync23(getOpenCodePluginPackageJsonPath(root), "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -38362,7 +38945,7 @@ function readLegacyCachedVersion(root) {
 function collectOpenCodePluginCacheReport(hostGeneration, opencodeConfig) {
   const installs = [];
   for (const root of getOpenCodePluginCacheRoots()) {
-    if (!existsSync32(root))
+    if (!existsSync33(root))
       continue;
     const spec = root.endsWith("@latest") ? "latest" : "(bare)";
     installs.push({
@@ -38396,7 +38979,7 @@ function getStorageResolution() {
 }
 function fileSize(path) {
   try {
-    return existsSync32(path) ? statSync14(path).size : 0;
+    return existsSync33(path) ? statSync14(path).size : 0;
   } catch {
     return 0;
   }
@@ -38408,10 +38991,10 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path) {
-  if (!existsSync32(path))
+  if (!existsSync33(path))
     return { value: null };
   try {
-    const raw = readFileSync21(path, "utf-8");
+    const raw = readFileSync23(path, "utf-8");
     const value = import_comment_json9.parse(raw);
     return { value };
   } catch (error) {
@@ -38436,7 +39019,7 @@ function configHasPluginEntry(config) {
 }
 function parseHistorianDumpMeta(path) {
   try {
-    const xml = readFileSync21(path, "utf-8");
+    const xml = readFileSync23(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -38469,11 +39052,11 @@ function parseHistorianDumpMeta(path) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync32(dir))
+  if (!existsSync33(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync5(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync14(join26(dir, name));
+    const entries = readdirSync6(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+      const stat = statSync14(join27(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -38482,7 +39065,7 @@ function listDumpsInDir(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta(join26(dir, entry.name));
+      const meta = parseHistorianDumpMeta(join27(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -38620,8 +39203,8 @@ async function collectRecentSessions(resolution, hostGeneration) {
   }
 }
 async function collectHistorianFailures(storageDirPath) {
-  const contextDbPath = join26(storageDirPath, "context.db");
-  if (!existsSync32(contextDbPath))
+  const contextDbPath = join27(storageDirPath, "context.db");
+  if (!existsSync33(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -38654,8 +39237,8 @@ async function collectHistorianFailures(storageDirPath) {
   }
 }
 async function collectHistorianRuns(storageDirPath) {
-  const contextDbPath = join26(storageDirPath, "context.db");
-  if (!existsSync32(contextDbPath))
+  const contextDbPath = join27(storageDirPath, "context.db");
+  if (!existsSync33(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined")
     return [];
@@ -38728,7 +39311,7 @@ async function collectDiagnostics() {
   const magicContextConfig = readConfig3(configPaths.magicContextConfig);
   const storageResolution = getStorageResolution();
   const storageDirPath = storageResolution.path;
-  const contextDbPath = join26(storageDirPath, "context.db");
+  const contextDbPath = join27(storageDirPath, "context.db");
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -38760,7 +39343,7 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync32(configPaths.magicContextConfig),
+      exists: existsSync33(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
@@ -38768,7 +39351,7 @@ async function collectDiagnostics() {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync32(storageDirPath),
+      exists: existsSync33(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     openCodeDatabase: {
@@ -39001,9 +39584,9 @@ var init_embedding_local = __esm(() => {
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync33, readFileSync as readFileSync22 } from "node:fs";
+import { existsSync as existsSync34, readFileSync as readFileSync24 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
-import { dirname as dirname16, join as join27, sep } from "node:path";
+import { dirname as dirname17, join as join28, sep } from "node:path";
 function describeError(error) {
   const message = error instanceof Error ? error.message : String(error ?? "unknown error");
   const code = error?.code;
@@ -39011,6 +39594,7 @@ function describeError(error) {
 }
 function runOnnxRuntimeNodeLoadProbeChild(packageDir) {
   return spawnSync7(process.execPath, ["-e", ONNX_RUNTIME_NODE_LOAD_PROBE_SCRIPT], {
+    windowsHide: true,
     encoding: "utf8",
     env: { ...process.env, [ONNX_LOAD_PROBE_PACKAGE_DIR_ENV]: packageDir },
     stdio: ["ignore", "pipe", "pipe"],
@@ -39144,11 +39728,11 @@ function expectedBinaryRelPath(platform, arch) {
   const supportedArch = arch === "x64" || arch === "arm64";
   if (!supportedPlatform || !supportedArch)
     return null;
-  return join27("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
+  return join28("bin", "napi-v6", platform, arch, "onnxruntime_binding.node");
 }
 function onnxRuntimeNodeVersion(packageDir) {
   try {
-    const parsed = JSON.parse(readFileSync22(join27(packageDir, "package.json"), "utf8"));
+    const parsed = JSON.parse(readFileSync24(join28(packageDir, "package.json"), "utf8"));
     return typeof parsed.version === "string" ? parsed.version : undefined;
   } catch {
     return;
@@ -39197,7 +39781,7 @@ function formatLocalEmbeddingRuntimeWasmSelected(status) {
 function requireNodeWasmBundle(probe, candidates) {
   if (probe.state === "failed")
     return probe;
-  const bundlePath = candidates.find((candidate) => existsSync33(candidate));
+  const bundlePath = candidates.find((candidate) => existsSync34(candidate));
   return bundlePath ? probe : {
     state: "failed",
     reason: `functional Node WASM Transformers bundle is missing (checked ${candidates.join(", ")})`
@@ -39205,13 +39789,13 @@ function requireNodeWasmBundle(probe, candidates) {
 }
 function nodeWasmBundleCandidates(installRoot) {
   return [
-    join27(installRoot, "dist", "transformers-node-wasm.js"),
-    join27(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
-    join27(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
+    join28(installRoot, "dist", "transformers-node-wasm.js"),
+    join28(installRoot, "node_modules", "@cortexkit", "opencode-magic-context", "dist", "transformers-node-wasm.js"),
+    join28(installRoot, "node_modules", "@cortexkit", "pi-magic-context", "dist", "transformers-node-wasm.js")
   ];
 }
 function probeWasmRuntimeAt(installRoot) {
-  const requireFn = createRequire5(join27(installRoot, "package.json"));
+  const requireFn = createRequire5(join28(installRoot, "package.json"));
   return requireNodeWasmBundle(probeWasmRuntimeFromRequire(requireFn), nodeWasmBundleCandidates(installRoot));
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
@@ -39220,9 +39804,9 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
     const wasm = probeWasmRuntimeAt(installRoot);
     return wasm.state === "ok" ? { state: "wasm-selected", wasmPath: wasm.wasmPath } : { state: "wasm-broken", wasmReason: wasm.reason };
   }
-  const packageDir = join27(installRoot, "node_modules", "onnxruntime-node");
+  const packageDir = join28(installRoot, "node_modules", "onnxruntime-node");
   let native;
-  if (!existsSync33(join27(packageDir, "package.json"))) {
+  if (!existsSync34(join28(packageDir, "package.json"))) {
     native = { state: "package-missing", packageDir };
   } else {
     const rel = expectedBinaryRelPath(platform, arch);
@@ -39232,8 +39816,8 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
         binaryPath: packageDir
       };
     } else {
-      const binaryPath = join27(packageDir, rel);
-      native = existsSync33(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
+      const binaryPath = join28(packageDir, rel);
+      native = existsSync34(binaryPath) ? probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath } : {
         state: "binary-missing",
         packageDir,
         expectedBinary: binaryPath,
@@ -39244,7 +39828,7 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
   return withWasmFallback(native, () => probeWasmRuntimeAt(installRoot));
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  const existing = installRoots.filter((root) => existsSync33(root));
+  const existing = installRoots.filter((root) => existsSync34(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -39270,19 +39854,19 @@ function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, a
 function packageDirFromResolved(resolvedPath, packageName) {
   const marker = `node_modules${sep}${packageName.split("/").join(sep)}`;
   const idx = resolvedPath.indexOf(marker);
-  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname16(resolvedPath);
+  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname17(resolvedPath);
 }
 function probeWasmRuntimeByResolution(pluginDir) {
   try {
-    const reqPlugin = createRequire5(join27(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join28(pluginDir, "package.json"));
     const direct = probeWasmRuntimeFromRequire(reqPlugin);
     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(createRequire5(join27(tfDir, "package.json")));
+      probe = probeWasmRuntimeFromRequire(createRequire5(join28(tfDir, "package.json")));
     }
-    return requireNodeWasmBundle(probe, [join27(pluginDir, "dist", "transformers-node-wasm.js")]);
+    return requireNodeWasmBundle(probe, [join28(pluginDir, "dist", "transformers-node-wasm.js")]);
   } catch (error) {
     return {
       state: "failed",
@@ -39291,7 +39875,7 @@ function probeWasmRuntimeByResolution(pluginDir) {
   }
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch, runtimePreference = "auto", host) {
-  if (!existsSync33(join27(pluginDir, "package.json"))) {
+  if (!existsSync34(join28(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   const selectedRuntime = resolveLocalEmbeddingRuntime(runtimePreference, host);
@@ -39302,13 +39886,13 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   let onnxDir = null;
   let resolveError;
   try {
-    const reqPlugin = createRequire5(join27(pluginDir, "package.json"));
+    const reqPlugin = createRequire5(join28(pluginDir, "package.json"));
     try {
       onnxDir = packageDirFromResolved(reqPlugin.resolve("onnxruntime-node"), "onnxruntime-node");
     } catch {
       const tfResolved = reqPlugin.resolve("@huggingface/transformers");
       const tfDir = packageDirFromResolved(tfResolved, "@huggingface/transformers");
-      const reqTf = createRequire5(join27(tfDir, "package.json"));
+      const reqTf = createRequire5(join28(tfDir, "package.json"));
       onnxDir = packageDirFromResolved(reqTf.resolve("onnxruntime-node"), "onnxruntime-node");
     }
   } catch (error) {
@@ -39316,7 +39900,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     if (resolveError === "ERR_MODULE_NOT_FOUND" || resolveError === "MODULE_NOT_FOUND") {
       return withWasmFallback({
         state: "package-missing",
-        packageDir: join27(pluginDir, "node_modules", "onnxruntime-node")
+        packageDir: join28(pluginDir, "node_modules", "onnxruntime-node")
       }, () => probeWasmRuntimeByResolution(pluginDir));
     }
     return {
@@ -39332,8 +39916,8 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
   if (rel === null) {
     native = probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   } else {
-    const binaryPath = join27(onnxDir, rel);
-    native = existsSync33(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
+    const binaryPath = join28(onnxDir, rel);
+    native = existsSync34(binaryPath) ? probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath } : {
       state: "binary-missing",
       packageDir: onnxDir,
       expectedBinary: binaryPath,
@@ -39475,8 +40059,8 @@ var init_issue_body = __esm(() => {
 });
 
 // src/lib/logs-opencode.ts
-import { writeFileSync as writeFileSync7 } from "node:fs";
-import { join as join28 } from "node:path";
+import { writeFileSync as writeFileSync9 } from "node:fs";
+import { join as join29 } from "node:path";
 function sanitizeLogContent(content) {
   return sanitizeDiagnosticText(content);
 }
@@ -39583,12 +40167,12 @@ async function bundleIssueReport(report, description, title, sessionFilter = nul
   const bodyMarkdown = capBodyToGithubLimit(rawBodyMarkdown);
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const timestamp = formatTimestamp(new Date);
-  const path = join28(process.cwd(), `magic-context-issue-${timestamp}.md`);
-  writeFileSync7(path, `${bodyMarkdown}
+  const path = join29(process.cwd(), `magic-context-issue-${timestamp}.md`);
+  writeFileSync9(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? join28(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? join29(process.cwd(), `magic-context-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync7(fullPath, `${rawBodyMarkdown}
+    writeFileSync9(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -39852,25 +40436,25 @@ function migrateExperimentalPinKeyFilesForDoctor(mcConfig) {
 }
 
 // ../plugin/src/hooks/auto-update-checker/constants.ts
-import { homedir as homedir15, platform } from "node:os";
-import { join as join29 } from "node:path";
+import { homedir as homedir16, platform } from "node:os";
+import { join as join30 } from "node:path";
 function getOpenCodeCacheRoot() {
   if (platform() === "win32") {
-    return join29(process.env.LOCALAPPDATA ?? homedir15(), "opencode");
+    return join30(process.env.LOCALAPPDATA ?? homedir16(), "opencode");
   }
-  return join29(homedir15(), ".cache", "opencode");
+  return join30(homedir16(), ".cache", "opencode");
 }
 function getOpenCodeConfigRoot() {
   if (platform() === "win32") {
-    return join29(process.env.APPDATA ?? join29(homedir15(), "AppData", "Roaming"), "opencode");
+    return join30(process.env.APPDATA ?? join30(homedir16(), "AppData", "Roaming"), "opencode");
   }
-  return join29(process.env.XDG_CONFIG_HOME ?? join29(homedir15(), ".config"), "opencode");
+  return join30(process.env.XDG_CONFIG_HOME ?? join30(homedir16(), ".config"), "opencode");
 }
 var PACKAGE_NAME = "@cortexkit/opencode-magic-context", CACHE_DIR, USER_OPENCODE_CONFIG, USER_OPENCODE_CONFIG_JSONC;
 var init_constants2 = __esm(() => {
-  CACHE_DIR = join29(getOpenCodeCacheRoot(), "packages");
-  USER_OPENCODE_CONFIG = join29(getOpenCodeConfigRoot(), "opencode.json");
-  USER_OPENCODE_CONFIG_JSONC = join29(getOpenCodeConfigRoot(), "opencode.jsonc");
+  CACHE_DIR = join30(getOpenCodeCacheRoot(), "packages");
+  USER_OPENCODE_CONFIG = join30(getOpenCodeConfigRoot(), "opencode.json");
+  USER_OPENCODE_CONFIG_JSONC = join30(getOpenCodeConfigRoot(), "opencode.jsonc");
 });
 
 // ../plugin/src/hooks/auto-update-checker/types.ts
@@ -39894,14 +40478,14 @@ var init_types = __esm(() => {
 // ../plugin/src/hooks/auto-update-checker/checker.ts
 import {
   accessSync as accessSync2,
-  existsSync as existsSync34,
+  existsSync as existsSync35,
   constants as fsConstants,
-  readFileSync as readFileSync23,
-  renameSync as renameSync7,
+  readFileSync as readFileSync25,
+  renameSync as renameSync9,
   statSync as statSync15,
-  writeFileSync as writeFileSync8
+  writeFileSync as writeFileSync10
 } from "node:fs";
-import { dirname as dirname17, isAbsolute as isAbsolute7, join as join30, resolve as resolve9 } from "node:path";
+import { dirname as dirname18, isAbsolute as isAbsolute7, join as join31, resolve as resolve9 } from "node:path";
 function warn(message) {
   log3(`WARN: ${message}`);
 }
@@ -39927,17 +40511,17 @@ function parseJsonConfig(content) {
 }
 function getSurfaceConfigPaths(directory, surface) {
   const name = surface === "server" ? "opencode" : "tui";
-  const globalDir = dirname17(USER_OPENCODE_CONFIG);
+  const globalDir = dirname18(USER_OPENCODE_CONFIG);
   const dirs = [
     globalDir,
     directory,
-    join30(directory, ".opencode"),
+    join31(directory, ".opencode"),
     process.env.OPENCODE_CONFIG_DIR
   ].filter((value) => Boolean(value));
   const paths = [];
   for (const dir of dirs) {
     for (const extension of ["json", "jsonc"]) {
-      const path = join30(dir, `${name}.${extension}`);
+      const path = join31(dir, `${name}.${extension}`);
       if (!paths.includes(path))
         paths.push(path);
     }
@@ -39948,9 +40532,9 @@ function getWinningConfig(directory, surface) {
   let winner = null;
   for (const path of getSurfaceConfigPaths(directory, surface)) {
     try {
-      if (!existsSync34(path))
+      if (!existsSync35(path))
         continue;
-      const parsed = parseJsonConfig(readFileSync23(path, "utf-8"));
+      const parsed = parseJsonConfig(readFileSync25(path, "utf-8"));
       const entries = getPluginEntries(parsed);
       if (entries.some((entry) => entry === PACKAGE_NAME || entry.startsWith(`${PACKAGE_NAME}@`))) {
         if (winner) {
@@ -39986,14 +40570,14 @@ var init_checker = __esm(() => {
 });
 
 // src/lib/opencode-plugin-schema-fence.ts
-import { existsSync as existsSync35, readdirSync as readdirSync6, readFileSync as readFileSync24 } from "node:fs";
-import { join as join31 } from "node:path";
+import { existsSync as existsSync36, readdirSync as readdirSync7, readFileSync as readFileSync26 } from "node:fs";
+import { join as join32 } from "node:path";
 import { gunzipSync } from "node:zlib";
 function readPackageVersion(packageJsonPath) {
   try {
-    if (!existsSync35(packageJsonPath))
+    if (!existsSync36(packageJsonPath))
       return null;
-    const packageJson = JSON.parse(readFileSync24(packageJsonPath, "utf-8"));
+    const packageJson = JSON.parse(readFileSync26(packageJsonPath, "utf-8"));
     if (packageJson.name !== OPENCODE_PLUGIN_NAME || typeof packageJson.version !== "string") {
       return null;
     }
@@ -40012,8 +40596,8 @@ function readFenceValue(text) {
   return values.size === 1 ? [...values][0] ?? null : null;
 }
 function readFenceFromDist(packageDirectory) {
-  const distDirectory = join31(packageDirectory, "dist");
-  if (!existsSync35(distDirectory))
+  const distDirectory = join32(packageDirectory, "dist");
+  if (!existsSync36(distDirectory))
     return null;
   const pending = [distDirectory];
   const fenceValues = new Set;
@@ -40022,15 +40606,15 @@ function readFenceFromDist(packageDirectory) {
     if (!directory)
       continue;
     try {
-      for (const entry of readdirSync6(directory, { withFileTypes: true })) {
-        const path = join31(directory, entry.name);
+      for (const entry of readdirSync7(directory, { withFileTypes: true })) {
+        const path = join32(directory, entry.name);
         if (entry.isDirectory()) {
           pending.push(path);
           continue;
         }
         if (!entry.isFile() || !/\.(?:[cm]?js|ts)$/.test(entry.name))
           continue;
-        const fence = readFenceValue(readFileSync24(path, "utf-8"));
+        const fence = readFenceValue(readFileSync26(path, "utf-8"));
         if (fence !== null)
           fenceValues.add(fence);
       }
@@ -40041,20 +40625,20 @@ function readFenceFromDist(packageDirectory) {
   return fenceValues.size === 1 ? [...fenceValues][0] ?? null : null;
 }
 function findInstalledPluginPackage(cacheDirectory, specifier, requestedVersion) {
-  const directCacheRoot = join31(cacheDirectory, specifier);
+  const directCacheRoot = join32(cacheDirectory, specifier);
   const candidates = [directCacheRoot];
   try {
-    for (const entry of readdirSync6(cacheDirectory, { withFileTypes: true })) {
+    for (const entry of readdirSync7(cacheDirectory, { withFileTypes: true })) {
       if (!entry.isDirectory())
         continue;
-      const candidate = join31(cacheDirectory, entry.name);
+      const candidate = join32(cacheDirectory, entry.name);
       if (!candidates.includes(candidate))
         candidates.push(candidate);
     }
   } catch {}
   for (const cacheRoot of candidates) {
-    const directory = join31(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
-    const version = readPackageVersion(join31(directory, "package.json"));
+    const directory = join32(cacheRoot, "node_modules", ...PACKAGE_PATH_SEGMENTS);
+    const version = readPackageVersion(join32(directory, "package.json"));
     if (!version)
       continue;
     if (cacheRoot === directCacheRoot || EXACT_VERSION_PATTERN.test(requestedVersion) && version === requestedVersion) {
@@ -40248,13 +40832,13 @@ var init_storage_versions = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync36, readFileSync as readFileSync25, rmSync as rmSync4 } from "node:fs";
+import { existsSync as existsSync37, readFileSync as readFileSync27, rmSync as rmSync4 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync36(installedPkgPath))
+    if (!existsSync37(installedPkgPath))
       return;
-    const pkg = JSON.parse(readFileSync25(installedPkgPath, "utf-8"));
+    const pkg = JSON.parse(readFileSync27(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
   } catch {
     return;
@@ -40263,7 +40847,7 @@ function readCachedPluginVersion(pluginCacheDir) {
 async function clearPluginCache(options = {}, deps = {}) {
   const remove = deps.remove ?? ((path) => rmSync4(path, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync36(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync37(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -40330,19 +40914,19 @@ var init_doctor_opencode_cache = __esm(() => {
 });
 
 // src/commands/doctor-cached-plugin-fence.ts
-import { existsSync as existsSync37 } from "node:fs";
-import { dirname as dirname18 } from "node:path";
+import { existsSync as existsSync38 } from "node:fs";
+import { dirname as dirname19 } from "node:path";
 function listCachedOpenCodePluginFences(sources = {}) {
   const fences = [];
   for (const root of sources.openCodeV1Roots ?? getOpenCodePluginCacheRoots()) {
     const packageJson = getOpenCodePluginPackageJsonPath(root);
-    if (!existsSync37(packageJson))
+    if (!existsSync38(packageJson))
       continue;
     fences.push({
       host: "opencode1",
       directory: root,
       version: readCachedPluginVersion(root),
-      supportedVersion: readFenceFromDist(dirname18(packageJson))
+      supportedVersion: readFenceFromDist(dirname19(packageJson))
     });
   }
   for (const slot of listOpenCodeV2PluginCacheSlots(sources.openCodeV2NpmCacheDir)) {
@@ -40356,7 +40940,7 @@ function listCachedOpenCodePluginFences(sources = {}) {
       directory: slot.slot,
       spec: slot.spec,
       version: slot.version,
-      supportedVersion: readFenceFromDist(dirname18(getOpenCodePluginPackageJsonPath(generation)))
+      supportedVersion: readFenceFromDist(dirname19(getOpenCodePluginPackageJsonPath(generation)))
     });
   }
   return fences;
@@ -40431,11 +41015,11 @@ function mcMarkerPredicate(column = "data") {
         AND json_extract(${data}, '$.summary') = 1
         AND json_extract(${data}, '$.providerID') = 'magic-context'`;
 }
-function tableExists4(db, table) {
+function tableExists5(db, table) {
   return db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = ? LIMIT 1").get(table) != null;
 }
 function countMissingCompleted(db) {
-  if (!tableExists4(db, "message"))
+  if (!tableExists5(db, "message"))
     return 0;
   const row = db.prepare(`SELECT COUNT(*) AS count
                FROM message
@@ -40444,7 +41028,7 @@ function countMissingCompleted(db) {
   return Number(row?.count ?? 0);
 }
 function migrationV1ToV2Completed(db) {
-  if (!tableExists4(db, "kv"))
+  if (!tableExists5(db, "kv"))
     return false;
   const columns = db.prepare("PRAGMA table_info(kv)").all();
   const names = new Set(columns.flatMap((column) => typeof column.name === "string" ? [column.name] : []));
@@ -40461,7 +41045,7 @@ function migrationV1ToV2Completed(db) {
   }
 }
 function countUnmatchedConvertedMarkers(db, migratedV2Schema) {
-  if (!migratedV2Schema || !tableExists4(db, "message"))
+  if (!migratedV2Schema || !tableExists5(db, "message"))
     return 0;
   const row = db.prepare(`SELECT COUNT(DISTINCT json_extract(${safeData("marker.data")}, '$.parentID')) AS count
                FROM message marker
@@ -40476,7 +41060,7 @@ function countUnmatchedConvertedMarkers(db, migratedV2Schema) {
   return Number(row?.count ?? 0);
 }
 function countPostConversionMessages(db, migratedV2Schema) {
-  if (!migratedV2Schema || !tableExists4(db, "message") || !tableExists4(db, "session")) {
+  if (!migratedV2Schema || !tableExists5(db, "message") || !tableExists5(db, "session")) {
     return { messages: 0, sessions: 0 };
   }
   const row = db.prepare(`SELECT COUNT(*) AS messages, COUNT(DISTINCT converted.session_id) AS sessions
@@ -40493,7 +41077,7 @@ function countPostConversionMessages(db, migratedV2Schema) {
 function checkOpenCodeCompactionMarkerConversion(db, options = {}) {
   const missingBefore = countMissingCompleted(db);
   let repaired = 0;
-  if (options.fix && missingBefore > 0 && tableExists4(db, "message")) {
+  if (options.fix && missingBefore > 0 && tableExists5(db, "message")) {
     repaired = db.transaction(() => {
       const result = db.prepare(`UPDATE message
                         SET data = json_set(
@@ -40507,7 +41091,7 @@ function checkOpenCodeCompactionMarkerConversion(db, options = {}) {
     })();
   }
   const missingAfter = countMissingCompleted(db);
-  const migratedV2Schema = tableExists4(db, "session_v2") && tableExists4(db, "session_message");
+  const migratedV2Schema = tableExists5(db, "session_v2") && tableExists5(db, "session_message");
   const migrationCompleted = migrationV1ToV2Completed(db);
   const unmatchedConvertedMarkers = countUnmatchedConvertedMarkers(db, migratedV2Schema);
   const postConversion = countPostConversionMessages(db, migratedV2Schema);
@@ -40618,6 +41202,182 @@ var init_doctor_harness_relabel = __esm(async () => {
   await init_opencode2_relabel();
 });
 
+// src/commands/doctor-hidden-children.ts
+import { spawnSync as spawnSync8 } from "node:child_process";
+import { existsSync as existsSync39, realpathSync as realpathSync7 } from "node:fs";
+import { dirname as dirname20 } from "node:path";
+async function assertHiddenChildStoresClosed(contextDbPath, hostDbPath, platform = process.platform, processProbe = () => inspectProcessesAsync(true)) {
+  if (platform === "win32") {
+    const processes = await processProbe();
+    if (processes.pi.state !== "known" || processes.pi.processIds.length > 0 || (processes.pi.inconclusivePids?.length ?? 0) > 0 || processes.processSnapshot?.source !== "cim") {
+      throw new Error("Windows process probe could not rule out OpenCode, Pi or ck-mc holders");
+    }
+    const unknown = processes.processSnapshot.facts.filter(({ pid, imageName, commandLine }) => pid !== process.pid && (!imageName && !commandLine || /^(?:bun|node|deno)(?:\.exe)?$/i.test(imageName ?? "") && !commandLine));
+    if (unknown.length)
+      throw new Error(`Windows process identity is unavailable (PID ${unknown.map(({ pid }) => pid).join(", ")})`);
+    const blockers = processes.processSnapshot.facts.filter(({ pid, imageName, commandLine }) => {
+      if (pid === process.pid)
+        return false;
+      const image = (imageName ?? "").toLowerCase().replaceAll("\\", "/").split("/").at(-1) ?? "";
+      return /^(?:opencode|opencode2|pi|omp|ck-mc)(?:\.exe)?$/.test(image) || /(?:^|[\\/\s"'])(?:ck-mc|opencode2?)(?:\.exe|\.js|\.mjs)?(?:$|[\s"'])/i.test(commandLine ?? "");
+    });
+    if (blockers.length)
+      throw new Error(`OpenCode, Pi or ck-mc process is running (PID ${blockers.map(({ pid }) => pid).join(", ")})`);
+    return;
+  }
+  const inspection = defaultInspectHolders(dirname20(contextDbPath));
+  if (!inspection.safe) {
+    throw new Error(`database holders cannot be ruled out: ${[...inspection.blockers, inspection.uncertainty].filter(Boolean).join("; ")}`);
+  }
+  const paths = [contextDbPath, hostDbPath].flatMap((path) => [path, `${path}-wal`, `${path}-shm`].filter(existsSync39).map((file) => realpathSync7(file)));
+  const result = spawnSync8("lsof", ["-Fn", "--", ...paths], {
+    encoding: "utf8",
+    timeout: 30000,
+    maxBuffer: 32 * 1024 * 1024,
+    windowsHide: true
+  });
+  if (result.error || result.stderr?.trim() || result.status !== 0 && !(result.status === 1 && !result.stdout?.trim())) {
+    throw new Error(`lsof could not inspect database holders: ${result.error?.message ?? result.stderr ?? result.status}`);
+  }
+  const opened = result.stdout.split(`
+`).filter((line) => line.startsWith("n"));
+  if (opened.length)
+    throw new Error(`database holder is present: ${opened.map((line) => line.slice(1)).join(", ")}`);
+  if (result.status === 0)
+    throw new Error("lsof returned success without any file evidence");
+}
+function assertVerifiedV2Schema(db) {
+  const table = db.prepare("SELECT name FROM sqlite_master WHERE type = 'table'").all();
+  const names = new Set(table.map((row) => row.name));
+  if (!names.has("session_v2") || !names.has("session_message") || names.has("message") || names.has("part")) {
+    throw new Error("OpenCode store is not the verified OpenCode 2 session_v2 schema");
+  }
+  const fields = db.prepare("PRAGMA table_info('session_v2')").all();
+  if (!fields.some((field) => field.name === "id" && field.pk === 1) || !fields.some((field) => field.name === "metadata") || !fields.some((field) => field.name === "directory")) {
+    throw new Error("OpenCode session_v2 columns differ from the verified schema");
+  }
+  const dependents = table.flatMap(({ name }) => {
+    const foreignKeys = db.prepare(`PRAGMA foreign_key_list('${name.replaceAll("'", "''")}')`).all();
+    return foreignKeys.filter((key) => key.table === "session_v2").map((key) => ({ name, ...key }));
+  });
+  if (dependents.length !== CASCADE_TABLES.length || dependents.some((key) => !CASCADE_TABLES.includes(key.name) || key.from !== "session_id" || key.to !== "id" || key.on_delete !== "CASCADE")) {
+    throw new Error("OpenCode session_v2 cascade schema differs from the verified 2.0.18 host");
+  }
+}
+async function cleanupRetiredHiddenChildren(options) {
+  const { contextDbPath, hostDbPath, fix = false } = options;
+  if (!existsSync39(contextDbPath) || !existsSync39(hostDbPath))
+    return { waiting: 0, deleted: 0 };
+  const context = new Database(contextDbPath, { readonly: true, fileMustExist: true });
+  const host = new Database(hostDbPath, { readonly: true, fileMustExist: true });
+  let states;
+  let candidates;
+  let waiting;
+  try {
+    assertVerifiedV2Schema(host);
+    const rows = context.prepare("SELECT key, value FROM schema_migrations_meta WHERE substr(key, 1, ?) = ?").all(PREFIX.length, PREFIX);
+    states = rows.map(({ key, value }) => {
+      const state = JSON.parse(value);
+      if (state.version !== 1 || !Array.isArray(state.retired_children) || state.retired_children.some((child) => typeof child.id !== "string")) {
+        throw new Error(`Invalid hidden-child state at ${key}`);
+      }
+      return { key, state };
+    });
+    const ids = [
+      ...new Set(states.flatMap(({ state }) => state.retired_children.map((child) => child.id)))
+    ];
+    waiting = ids.length;
+    candidates = ids.filter((id) => {
+      const row = host.prepare("SELECT metadata FROM session_v2 WHERE id = ?").get(id);
+      if (!row)
+        return false;
+      let marker;
+      try {
+        marker = JSON.parse(row.metadata ?? "null");
+      } catch {
+        return false;
+      }
+      return marker?.magic_context === "hidden-run";
+    });
+  } finally {
+    context.close();
+    host.close();
+  }
+  options.report?.(`${waiting} retired hidden sessions are waiting for deletion${fix ? "" : "; run `doctor --fix` with OpenCode closed"}`);
+  if (!fix || candidates.length === 0)
+    return { waiting, deleted: 0 };
+  const inspect = options.inspectHolders ?? ((context, host) => assertHiddenChildStoresClosed(context, host, options.platform, options.processProbe));
+  await inspect(contextDbPath, hostDbPath);
+  const backup = `${hostDbPath}.hidden-child-backup-${new Date().toISOString().replace(/[:.]/g, "-")}-${process.pid}`;
+  copyDatabaseBundle(hostDbPath, backup);
+  options.report?.(`OpenCode store backup: ${backup}`);
+  await inspect(contextDbPath, hostDbPath);
+  const writableHost = new Database(hostDbPath);
+  let writableContext;
+  const deletedIds = [];
+  let hostLocked = false;
+  let contextLocked = false;
+  try {
+    writableHost.exec("PRAGMA busy_timeout = 250");
+    writableHost.exec("PRAGMA foreign_keys = ON");
+    writableContext = new Database(contextDbPath);
+    writableContext.exec("PRAGMA busy_timeout = 250");
+    try {
+      writableHost.exec("BEGIN EXCLUSIVE");
+      hostLocked = true;
+      writableContext.exec("BEGIN EXCLUSIVE");
+      contextLocked = true;
+    } catch (error) {
+      throw new Error(`Cannot acquire exclusive locks on ${hostDbPath} and ${contextDbPath}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+    assertVerifiedV2Schema(writableHost);
+    for (const id of candidates) {
+      const result = writableHost.prepare("DELETE FROM session_v2 WHERE id = ? AND json_valid(metadata) AND json_extract(metadata, '$.magic_context') = 'hidden-run'").run(id);
+      if (result.changes > 0)
+        deletedIds.push(id);
+    }
+    for (const { key } of states) {
+      const current = writableContext.prepare("SELECT value FROM schema_migrations_meta WHERE key = ?").get(key);
+      if (!current)
+        throw new Error(`Hidden-child state ${key} disappeared during repair`);
+      const state = JSON.parse(current.value);
+      if (state.version !== 1 || !Array.isArray(state.retired_children)) {
+        throw new Error(`Hidden-child state ${key} changed during repair`);
+      }
+      state.retired_children = state.retired_children.filter((child) => !deletedIds.includes(child.id));
+      writableContext.prepare("UPDATE schema_migrations_meta SET value = ? WHERE key = ?").run(JSON.stringify(state), key);
+    }
+    writableHost.exec("COMMIT");
+    hostLocked = false;
+    writableContext.exec("COMMIT");
+    contextLocked = false;
+  } finally {
+    if (contextLocked)
+      writableContext?.exec("ROLLBACK");
+    if (hostLocked)
+      writableHost.exec("ROLLBACK");
+    writableContext?.close();
+    writableHost.close();
+  }
+  options.report?.(`Deleted ${deletedIds.length} marked, recorded hidden sessions`);
+  return { waiting, deleted: deletedIds.length, backup };
+}
+var PREFIX = "opencode2_hidden_children:", CASCADE_TABLES;
+var init_doctor_hidden_children = __esm(async () => {
+  init_rpc_utils();
+  await __promiseAll([
+    init_sqlite(),
+    init_doctor_repair_db()
+  ]);
+  CASCADE_TABLES = [
+    "instruction_entry",
+    "instruction_state",
+    "session_inbox",
+    "session_message",
+    "session_pending"
+  ];
+});
+
 // src/commands/doctor-opencode-plugin-duplicates.ts
 import { isDeepStrictEqual } from "node:util";
 function entryOptions(entry) {
@@ -40844,11 +41604,11 @@ function formatUnresolvedCompartmentSession(session) {
 }
 
 // src/commands/doctor-opencode.ts
-import { spawnSync as spawnSync8 } from "node:child_process";
-import { existsSync as existsSync38, mkdtempSync, readFileSync as readFileSync26, rmSync as rmSync5 } from "node:fs";
+import { spawnSync as spawnSync9 } from "node:child_process";
+import { existsSync as existsSync40, mkdtempSync as mkdtempSync2, readFileSync as readFileSync28, rmSync as rmSync5 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
-import { homedir as homedir16, tmpdir as tmpdir3 } from "node:os";
-import { join as join32 } from "node:path";
+import { homedir as homedir17, tmpdir as tmpdir3 } from "node:os";
+import { join as join33 } from "node:path";
 function formatSharedDbRowCounts(db) {
   return SHARED_DB_ROW_COUNT_TABLES.map((table) => {
     try {
@@ -40879,7 +41639,8 @@ function findUnknownConfiguredModels(configured, catalog) {
     return [];
   });
 }
-function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args, cwd) => spawnSync8("opencode", args, {
+function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args, cwd) => spawnSync9("opencode", args, {
+  windowsHide: true,
   cwd,
   encoding: "utf8",
   timeout: hostGeneration === "v2" ? 90000 : 45000,
@@ -40916,7 +41677,7 @@ function checkConfiguredVariantCatalog(config, hostGeneration, warn, run = (args
   }
   if (models.length === 0)
     return;
-  const tempRoot = mkdtempSync(join32(tmpdir3(), "magic-context-opencode-catalog-"));
+  const tempRoot = mkdtempSync2(join33(tmpdir3(), "magic-context-opencode-catalog-"));
   try {
     const command = hostGeneration === "v2" ? ["api", "model.list", "--param", `directory=${projectDir}`] : ["models", "--verbose"];
     const guidance = `opencode ${command.join(" ")}`;
@@ -41092,7 +41853,7 @@ function getSelfVersion2() {
 function describeAutoUpdateStall(specifier, autoUpdateEnabled, storageDir = getMagicContextStorageDir()) {
   if (!autoUpdateEnabled || !isPinnedOpenCodePluginSpecifier(specifier))
     return null;
-  const state = readAutoUpdateCheckState(join32(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
+  const state = readAutoUpdateCheckState(join33(storageDir, AUTO_UPDATE_CHECK_STATE_FILENAME));
   const owner = isUpdaterPinnedSpec(state, specifier) ? "updater" : "you";
   return `auto-update: stalled — config pinned to ${specifier} (by ${owner})`;
 }
@@ -41101,15 +41862,15 @@ function getUserNpmrcPath() {
   if (custom)
     return custom;
   const home = process.env.HOME?.trim();
-  return join32(home || homedir16(), ".npmrc");
+  return join33(home || homedir17(), ".npmrc");
 }
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync38(npmrcPath))
+  if (!existsSync40(npmrcPath))
     return ageWarnings;
   try {
-    const npmrc = readFileSync26(npmrcPath, "utf-8");
+    const npmrc = readFileSync28(npmrcPath, "utf-8");
     for (const line of npmrc.split(`
 `)) {
       const trimmed = line.trim();
@@ -41142,15 +41903,18 @@ function compareVersions(a, b) {
 function openBrowser(url) {
   try {
     if (process.platform === "darwin") {
-      const child = spawnSync8("open", [url], { stdio: "ignore" });
+      const child = spawnSync9("open", [url], { windowsHide: true, stdio: "ignore" });
       if (child.status === 0)
         return;
     } else if (process.platform === "linux") {
-      const child = spawnSync8("xdg-open", [url], { stdio: "ignore" });
+      const child = spawnSync9("xdg-open", [url], { windowsHide: true, stdio: "ignore" });
       if (child.status === 0)
         return;
     } else if (process.platform === "win32") {
-      const child = spawnSync8("cmd", ["/c", "start", "", url], { stdio: "ignore" });
+      const child = spawnSync9("cmd", ["/c", "start", "", url], {
+        windowsHide: true,
+        stdio: "ignore"
+      });
       if (child.status === 0)
         return;
     }
@@ -41243,7 +42007,7 @@ function checkLocalEmbeddingRuntimeForDoctor(runtimePreference = "auto") {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync38(magicContextConfigPath)) {
+  if (!existsSync40(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -41400,7 +42164,7 @@ async function runDoctor2(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "OpenCode",
     openDatabase: (readonly = true) => {
-      const dbPath = join32(getMagicContextStorageDir(), "context.db");
+      const dbPath = join33(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -41432,7 +42196,7 @@ async function runDoctor2(options = {}) {
     failCount++;
     issues++;
   };
-  const authorityDbPath = join32(getMagicContextStorageDir(), "context.db");
+  const authorityDbPath = join33(getMagicContextStorageDir(), "context.db");
   let authorityDb = null;
   try {
     authorityDb = openExistingContextDatabase(authorityDbPath, { readonly: true });
@@ -41486,6 +42250,19 @@ async function runDoctor2(options = {}) {
   else
     fail(openCodeDbCheck.message);
   if (openCodeDbCheck.ok) {
+    if (storeGeneration === "v2") {
+      try {
+        const cleanup = await cleanupRetiredHiddenChildren({
+          contextDbPath: authorityDbPath,
+          hostDbPath: openCodeDbResolution.path,
+          fix: options.fix,
+          report: (line) => log2.info(line)
+        });
+        fixed += cleanup.deleted;
+      } catch (error) {
+        fail(`Retired hidden-child cleanup refused: ${error instanceof Error ? error.message : String(error)}`);
+      }
+    }
     let markerDb = null;
     try {
       markerDb = new Database(openCodeDbResolution.path, {
@@ -41593,7 +42370,7 @@ async function runDoctor2(options = {}) {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
   let autoUpdateEnabled = true;
-  if (existsSync38(paths.magicContextConfig)) {
+  if (existsSync40(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
@@ -41629,7 +42406,7 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log2.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync38(paths.magicContextConfig)) {
+  if (existsSync40(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -41759,7 +42536,7 @@ async function runDoctor2(options = {}) {
   };
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      const raw = readFileSync26(paths.opencodeConfig, "utf-8");
+      const raw = readFileSync28(paths.opencodeConfig, "utf-8");
       const config = import_comment_json11.parse(raw);
       const configName = paths.opencodeConfigFormat === "jsonc" ? "opencode.jsonc" : "opencode.json";
       if (checkPluginDuplicates(config, configName, options, {
@@ -41828,9 +42605,9 @@ async function runDoctor2(options = {}) {
       pass("Added TUI sidebar plugin to tui.json");
       warn("Restart OpenCode to see the sidebar");
       fixed++;
-    } else if (existsSync38(paths.tuiConfig)) {
+    } else if (existsSync40(paths.tuiConfig)) {
       try {
-        const tuiRaw = readFileSync26(paths.tuiConfig, "utf-8");
+        const tuiRaw = readFileSync28(paths.tuiConfig, "utf-8");
         const tuiConfig = import_comment_json11.parse(tuiRaw);
         const tuiRawPlugins = Array.isArray(tuiConfig?.plugin) ? tuiConfig.plugin : [];
         const tuiIdx = tuiRawPlugins.findIndex((entry) => matchesPluginEntry(entry, OPENCODE_PLUGIN_NAME) || isDevPathPluginEntry(entry));
@@ -41868,7 +42645,7 @@ async function runDoctor2(options = {}) {
       fail("Could not create or verify the TUI sidebar config");
     }
   }
-  if (existsSync38(paths.magicContextConfig)) {
+  if (existsSync40(paths.magicContextConfig)) {
     try {
       const raw = loadRawConfigFile({ configPath: paths.magicContextConfig, tier: "user" });
       if (!raw)
@@ -41890,9 +42667,9 @@ async function runDoctor2(options = {}) {
   else
     passCount++;
   const storage = getMagicContextStorageResolution();
-  const dbPath = join32(storage.path, "context.db");
+  const dbPath = join33(storage.path, "context.db");
   log2.info(`Shared storage: ${storage.path} (source: ${storage.source})`);
-  if (!existsSync38(dbPath)) {
+  if (!existsSync40(dbPath)) {
     log2.info(`Shared context DB not yet created at ${dbPath} (will be created on first run)`);
   } else {
     log2.info(`Shared context DB exists at ${dbPath}`);
@@ -41994,7 +42771,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   let v2DistTag;
   if (paths.opencodeConfigFormat !== "none") {
     try {
-      v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync26(paths.opencodeConfig, "utf-8")));
+      v2DistTag = configuredOpenCodeV2DistTag(import_comment_json11.parse(readFileSync28(paths.opencodeConfig, "utf-8")));
     } catch {}
   }
   const v2Cache = reportOpenCodeV2PluginCache(checkOpenCodeV2PluginCache({
@@ -42121,16 +42898,17 @@ var init_doctor_opencode = __esm(async () => {
     init_v22_backfill_commands(),
     init_doctor_authority(),
     init_doctor_cached_plugin_fence(),
-    init_doctor_harness_relabel()
+    init_doctor_harness_relabel(),
+    init_doctor_hidden_children()
   ]);
   import_comment_json11 = __toESM(require_src3(), 1);
   SHARED_DB_ROW_COUNT_TABLES = ["tags", "compartments", "memories", "notes", "dream_runs"];
 });
 
 // src/lib/diagnostics-pi.ts
-import { existsSync as existsSync39, readdirSync as readdirSync7, readFileSync as readFileSync27, statSync as statSync16 } from "node:fs";
+import { existsSync as existsSync41, readdirSync as readdirSync8, readFileSync as readFileSync29, statSync as statSync16 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
-import { join as join33 } from "node:path";
+import { join as join34 } from "node:path";
 function getSelfVersion3() {
   const req = createRequire7(import.meta.url);
   for (const relPath of ["../../package.json", "../package.json"]) {
@@ -42145,7 +42923,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path) {
   try {
-    return existsSync39(path) ? statSync16(path).size : 0;
+    return existsSync41(path) ? statSync16(path).size : 0;
   } catch {
     return 0;
   }
@@ -42157,11 +42935,11 @@ function sanitizeValue2(value) {
   return sanitizeConfigValue(value);
 }
 function readJsonc(path) {
-  if (!existsSync39(path))
+  if (!existsSync41(path))
     return { value: {} };
   try {
     return {
-      value: import_comment_json12.parse(readFileSync27(path, "utf-8"))
+      value: import_comment_json12.parse(readFileSync29(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -42177,7 +42955,7 @@ function readConfigDiagnostic(path) {
   const parsed = readJsonc(path);
   return {
     path,
-    exists: existsSync39(path),
+    exists: existsSync41(path),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -42195,25 +42973,25 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync39(sessionsRoot))
+  if (!existsSync41(sessionsRoot))
     return [];
   try {
-    const slugs = readdirSync7(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
+    const slugs = readdirSync8(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
     const candidates = [];
     for (const slug of slugs) {
       const directory = reverseSlugToDirectory(slug);
       if (!directory)
         continue;
-      const slugDir = join33(sessionsRoot, slug);
+      const slugDir = join34(sessionsRoot, slug);
       let files;
       try {
-        files = readdirSync7(slugDir).filter((name) => name.endsWith(".jsonl"));
+        files = readdirSync8(slugDir).filter((name) => name.endsWith(".jsonl"));
       } catch {
         continue;
       }
       for (const file of files) {
         try {
-          const mtime = statSync16(join33(slugDir, file)).mtimeMs;
+          const mtime = statSync16(join34(slugDir, file)).mtimeMs;
           const sessionId = file.replace(/\.jsonl$/, "");
           candidates.push({ sessionId, directory, mtime });
         } catch {}
@@ -42231,7 +43009,7 @@ function collectPiRecentSessions() {
 }
 function parseHistorianDumpMeta2(path) {
   try {
-    const xml = readFileSync27(path, "utf-8");
+    const xml = readFileSync29(path, "utf-8");
     const parsed = parseCompartmentOutput(xml);
     const factCountByCategory = {};
     for (const fact of parsed.facts) {
@@ -42264,11 +43042,11 @@ function parseHistorianDumpMeta2(path) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync39(dir))
+  if (!existsSync41(dir))
     return { count: 0, recent: [] };
   try {
-    const entries = readdirSync7(dir).filter((name) => name.endsWith(".xml")).map((name) => {
-      const stat = statSync16(join33(dir, name));
+    const entries = readdirSync8(dir).filter((name) => name.endsWith(".xml")).map((name) => {
+      const stat = statSync16(join34(dir, name));
       return {
         name,
         mtime: stat.mtimeMs,
@@ -42277,7 +43055,7 @@ function listDumpsInDir2(dir, limit) {
     }).sort((a, b) => b.mtime - a.mtime);
     const now = Date.now();
     const recent = entries.slice(0, limit).map((entry) => {
-      const meta = parseHistorianDumpMeta2(join33(dir, entry.name));
+      const meta = parseHistorianDumpMeta2(join34(dir, entry.name));
       const summary = {
         name: entry.name,
         ageMinutes: Math.round((now - entry.mtime) / 60000),
@@ -42341,7 +43119,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const loaded = loadPiConfig({ cwd });
   const storageResolution = getMagicContextStorageResolution();
   const storageDirPath = storageResolution.path;
-  const dbPath = join33(storageDirPath, "context.db");
+  const dbPath = join34(storageDirPath, "context.db");
   const logFiles = inspectMagicContextLogs("pi");
   const primaryLog = logFiles.find((file) => file.exists) ?? logFiles[0];
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
@@ -42358,7 +43136,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync39(settingsPath),
+      exists: existsSync41(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -42375,7 +43153,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     storageDir: {
       path: storageDirPath,
       source: storageResolution.source,
-      exists: existsSync39(storageDirPath),
+      exists: existsSync41(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -42480,8 +43258,8 @@ var init_diagnostics_pi = __esm(() => {
 });
 
 // src/lib/logs-pi.ts
-import { mkdirSync as mkdirSync10, writeFileSync as writeFileSync9 } from "node:fs";
-import { dirname as dirname19, join as join34 } from "node:path";
+import { mkdirSync as mkdirSync12, writeFileSync as writeFileSync11 } from "node:fs";
+import { dirname as dirname21, join as join35 } from "node:path";
 function sanitizeLogContent2(content) {
   return sanitizeString2(content);
 }
@@ -42551,13 +43329,13 @@ async function bundleIssueReport2(report, description, title, options = {}) {
   const truncated = bodyMarkdown !== rawBodyMarkdown;
   const cwd = options.cwd ?? process.cwd();
   const timestamp = formatTimestamp2(options.now ?? new Date);
-  const path = options.outputPath ?? join34(cwd, `magic-context-pi-issue-${timestamp}.md`);
-  mkdirSync10(dirname19(path), { recursive: true });
-  writeFileSync9(path, `${bodyMarkdown}
+  const path = options.outputPath ?? join35(cwd, `magic-context-pi-issue-${timestamp}.md`);
+  mkdirSync12(dirname21(path), { recursive: true });
+  writeFileSync11(path, `${bodyMarkdown}
 `);
-  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join34(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
+  const fullPath = truncated ? options.outputPath ? `${options.outputPath}.full.md` : join35(cwd, `magic-context-pi-issue-${timestamp}-full.md`) : undefined;
   if (fullPath)
-    writeFileSync9(fullPath, `${rawBodyMarkdown}
+    writeFileSync11(fullPath, `${rawBodyMarkdown}
 `);
   return { path, bodyMarkdown, ...fullPath ? { fullPath } : {}, truncated };
 }
@@ -42568,11 +43346,11 @@ var init_logs_pi = __esm(() => {
 });
 
 // src/commands/doctor-pi.ts
-import { execFileSync as execFileSync6, spawnSync as spawnSync9 } from "node:child_process";
-import { existsSync as existsSync40, mkdirSync as mkdirSync11, readdirSync as readdirSync8, readFileSync as readFileSync28, rmSync as rmSync6, statSync as statSync17 } from "node:fs";
+import { execFileSync as execFileSync7, spawnSync as spawnSync10 } from "node:child_process";
+import { existsSync as existsSync42, mkdirSync as mkdirSync13, readdirSync as readdirSync9, readFileSync as readFileSync30, rmSync as rmSync6, statSync as statSync17 } from "node:fs";
 import { createRequire as createRequire8 } from "node:module";
-import { homedir as homedir17 } from "node:os";
-import { dirname as dirname20, isAbsolute as isAbsolute8, join as join35 } from "node:path";
+import { homedir as homedir18 } from "node:os";
+import { dirname as dirname22, isAbsolute as isAbsolute8, join as join36 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS5,
@@ -42609,7 +43387,8 @@ function selfVersion2() {
 }
 function getLatestNpmVersion(packageName) {
   try {
-    return execFileSync6("npm", ["view", packageName, "version"], {
+    return execFileSync7("npm", ["view", packageName, "version"], {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "ignore"],
       timeout: 1e4
@@ -42663,7 +43442,7 @@ function summarize(results) {
 function readJsonc2(path) {
   try {
     return {
-      value: import_comment_json13.parse(readFileSync28(path, "utf-8"))
+      value: import_comment_json13.parse(readFileSync30(path, "utf-8"))
     };
   } catch (error) {
     return {
@@ -42713,15 +43492,15 @@ function piPluginDirCandidates(packages, cwd) {
     if (resolved)
       dirs.push(resolved);
   }
-  dirs.push(join35(agentDir, "npm", "node_modules", PACKAGE_NAME2));
-  dirs.push(join35(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
-  return dirs.filter((dir) => existsSync40(join35(dir, "package.json")));
+  dirs.push(join36(agentDir, "npm", "node_modules", PACKAGE_NAME2));
+  dirs.push(join36(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2));
+  return dirs.filter((dir) => existsSync42(join36(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path, isProjectConfig) {
-  if (!existsSync40(path))
+  if (!existsSync42(path))
     return null;
   try {
     const raw = loadRawConfigFile({
@@ -42807,22 +43586,22 @@ function pinnedVersionFromPackageSpecifier(specifier) {
 }
 function cacheRoots(cwd) {
   const home = process.env.HOME?.trim();
-  const cacheHome = process.env.XDG_CACHE_HOME || join35(home || homedir17(), ".cache");
+  const cacheHome = process.env.XDG_CACHE_HOME || join36(home || homedir18(), ".cache");
   const piCacheRoot = getPiCacheRoot();
   return [
-    join35(piCacheRoot, "extensions"),
-    join35(piCacheRoot, "packages"),
-    join35(cacheHome, "pi", "extensions"),
-    join35(cacheHome, "pi", "packages"),
-    join35(getPiAgentConfigDir(), "cache", "extensions"),
-    join35(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
-    join35(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
+    join36(piCacheRoot, "extensions"),
+    join36(piCacheRoot, "packages"),
+    join36(cacheHome, "pi", "extensions"),
+    join36(cacheHome, "pi", "packages"),
+    join36(getPiAgentConfigDir(), "cache", "extensions"),
+    join36(getPiAgentConfigDir(), "npm", "node_modules", PACKAGE_NAME2),
+    join36(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME2)
   ];
 }
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path, depth) => {
-    if (depth < 0 || !existsSync40(path))
+    if (depth < 0 || !existsSync42(path))
       return;
     let stat;
     try {
@@ -42832,10 +43611,10 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     if (!stat.isDirectory())
       return;
-    const packageJson = join35(path, "package.json");
-    if (existsSync40(packageJson)) {
+    const packageJson = join36(path, "package.json");
+    if (existsSync42(packageJson)) {
       try {
-        const pkg = JSON.parse(readFileSync28(packageJson, "utf-8"));
+        const pkg = JSON.parse(readFileSync30(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
         const version = typeof pkg.version === "string" ? pkg.version : undefined;
         if (name === PACKAGE_NAME2) {
@@ -42850,12 +43629,12 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     }
     let entries = [];
     try {
-      entries = readdirSync8(path);
+      entries = readdirSync9(path);
     } catch {
       return;
     }
     for (const entry of entries)
-      visit(join35(path, entry), depth - 1);
+      visit(join36(path, entry), depth - 1);
   };
   for (const root of cacheRoots(cwd))
     visit(root, 5);
@@ -42900,7 +43679,7 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync40(settingsPath)) {
+  if (!existsSync42(settingsPath)) {
     add2(results, "fail", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -42924,7 +43703,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync40(path)) {
+    if (!existsSync42(path)) {
       if (required) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path}`);
         if (userConfigMigrationRefused) {
@@ -42964,9 +43743,9 @@ async function runHealthChecks2(options) {
   }
   const storage = getMagicContextStorageResolution();
   const storageDir = storage.path;
-  const dbPath = join35(storageDir, "context.db");
+  const dbPath = join36(storageDir, "context.db");
   add2(results, "info", `Shared storage: ${storageDir} (source: ${storage.source})`);
-  const existedBeforeOpen = existsSync40(dbPath);
+  const existedBeforeOpen = existsSync42(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -43184,7 +43963,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   return { results, repairPlan, ...summarize(results) };
 }
 function writeDefaultMagicContextConfig(path) {
-  mkdirSync11(dirname20(path), { recursive: true });
+  mkdirSync13(dirname22(path), { recursive: true });
   const config = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
@@ -43206,7 +43985,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync40(configPath)) {
+    if (!existsSync42(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -43230,6 +44009,7 @@ function repair2(plan, prompts) {
 function runGhCommandWithDeps2(deps, args) {
   if (args[0] === "issue") {
     const result = deps.spawnSync("gh", args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -43241,6 +44021,7 @@ function runGhCommandWithDeps2(deps, args) {
   }
   try {
     const output = deps.execFileSync("gh", args, {
+      windowsHide: true,
       encoding: "utf-8",
       stdio: ["ignore", "pipe", "pipe"]
     });
@@ -43258,7 +44039,7 @@ async function runIssueFlow3(options) {
   if (options.reportPath) {
     try {
       const report = await options.deps.collectDiagnostics(options.cwd);
-      const outputPath = isAbsolute8(options.reportPath) ? options.reportPath : join35(options.cwd, options.reportPath);
+      const outputPath = isAbsolute8(options.reportPath) ? options.reportPath : join36(options.cwd, options.reportPath);
       const bundled = await bundleIssueReport2(report, "Generated non-interactively by `doctor --issue --report`.", "Magic Context diagnostic report", { cwd: options.cwd, now: options.deps.now(), outputPath });
       options.prompts.log.info(`Report written to ${bundled.path}`);
       return 0;
@@ -43342,7 +44123,7 @@ async function runDoctor3(options = {}) {
   const v22Result = await runV22BackfillCommands({
     name: "Pi",
     openDatabase: (readonly = true) => {
-      const dbPath = join35(getMagicContextStorageDir(), "context.db");
+      const dbPath = join36(getMagicContextStorageDir(), "context.db");
       v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
       return v22Db;
     },
@@ -43384,7 +44165,7 @@ async function runDoctor3(options = {}) {
   prompts.outro(first.fail > 0 ? "Doctor found failures" : "Doctor complete");
   return first.fail > 0 ? 1 : 0;
 }
-function valueAfter3(args, flag) {
+function valueAfter2(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
     return null;
@@ -43394,8 +44175,8 @@ function valueAfter3(args, flag) {
   return next;
 }
 function parseDoctorArgs(args) {
-  const rekeyV22DirIdentity = valueAfter3(args, "--rekey-v22-dir-identity");
-  const report = valueAfter3(args, "--report");
+  const rekeyV22DirIdentity = valueAfter2(args, "--rekey-v22-dir-identity");
+  const report = valueAfter2(args, "--report");
   return {
     force: args.includes("--force"),
     issue: args.includes("--issue") || report !== null,
@@ -43452,14 +44233,14 @@ var init_doctor_pi = __esm(async () => {
     probeEmbeddingEndpoint,
     openExistingContextDatabase,
     now: () => new Date,
-    execFileSync: execFileSync6,
-    spawnSync: spawnSync9
+    execFileSync: execFileSync7,
+    spawnSync: spawnSync10
   };
 });
 
 // src/commands/doctor.ts
-import { existsSync as existsSync41, rmSync as rmSync7 } from "node:fs";
-import { join as join36 } from "node:path";
+import { existsSync as existsSync43, rmSync as rmSync7 } from "node:fs";
+import { join as join37 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
     return runClear();
@@ -43477,7 +44258,7 @@ async function runDoctor4(options) {
     const result = await runV22BackfillCommands({
       name: "Magic Context",
       openDatabase: (readonly = true) => {
-        const dbPath = join36(getMagicContextStorageDir(), "context.db");
+        const dbPath = join37(getMagicContextStorageDir(), "context.db");
         v22Db = readonly ? openExistingContextDatabase(dbPath, { readonly: true }) : openExistingContextDatabaseForMutation(dbPath);
         return v22Db;
       },
@@ -43490,8 +44271,14 @@ async function runDoctor4(options) {
     if (result.handled)
       return result.exitCode;
   }
+  try {
+    for (const line of diagnoseIdentitySplits())
+      log2.warn(line);
+  } catch (error) {
+    log2.warn(`Identity split check unavailable: ${error instanceof Error ? error.message : String(error)}`);
+  }
   await init_migrate();
-  const sweepDbPath = join36(getMagicContextStorageDir(), "context.db");
+  const sweepDbPath = join37(getMagicContextStorageDir(), "context.db");
   let sweepDb = null;
   try {
     sweepDb = openExistingContextDatabaseForMutation(sweepDbPath);
@@ -43605,7 +44392,7 @@ async function runClear() {
           failed += 1;
           continue;
         }
-      } else if (existsSync41(item.path)) {
+      } else if (existsSync43(item.path)) {
         rmSync7(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
@@ -43635,6 +44422,7 @@ var init_doctor = __esm(async () => {
   await __promiseAll([
     init_database_access(),
     init_v22_backfill_commands(),
+    init_doctor_identity_splits(),
     init_doctor_omp(),
     init_doctor_opencode(),
     init_doctor_pi()
@@ -43696,7 +44484,7 @@ var DOCTOR_HELP = [
   "    drain-authority <project>   Drain module memory/note authority back to TypeScript",
   "    migrate                     Migrate an OpenCode session to Pi or OMP JSONL",
   "    migrate-session             Re-home an OpenCode session to another directory",
-  "    merge-identity              Merge project rows between identities",
+  "    merge-identities            Preview or explicitly merge split identities",
   "    repair-db                   Back up and salvage a corrupted shared database",
   "    list-hidden-sessions        List Magic Context OpenCode 2 roots",
   ""
@@ -43712,16 +44500,19 @@ var DRAIN_AUTHORITY_HELP = [
 `);
 var MERGE_IDENTITY_HELP = [
   "",
-  "  Usage: magic-context doctor merge-identity --from <identity> --to <identity> [--dry-run] [--yes] [--db <path>]",
+  "  Usage: magic-context doctor merge-identities [--from <identity> --to <identity>] [--apply] [--force] [--db <path>]",
   "",
   "  Merge every project-scoped row from one project identity into another.",
   "",
   "  Options:",
   "    --from <identity>   Identity whose rows are moved",
   "    --to <identity>     Identity that receives them",
-  "    --dry-run           Report what would change without writing",
-  "    --yes               Confirm the write (required unless --dry-run)",
+  "    (no flags)          List splits; --from/--to previews without writing",
+  "    --apply             Confirm the reviewed preview; hosts must be closed",
+  "    --force             Permit a target not resolving on this machine",
   "    --db <path>         Use this context.db instead of the shared one",
+  "    --host-db <path>    Read session directories from this host database",
+  "    Legacy alias: doctor merge-identity; --dry-run previews, --yes applies",
   ""
 ].join(`
 `);
@@ -43745,7 +44536,7 @@ function subcommandHelp(argv) {
   const subcommand = rest[0];
   if (subcommand === "drain-authority")
     return DRAIN_AUTHORITY_HELP;
-  if (subcommand === "merge-identity")
+  if (subcommand === "merge-identity" || subcommand === "merge-identities")
     return MERGE_IDENTITY_HELP;
   if (subcommand === "list-hidden-sessions")
     return LIST_HIDDEN_SESSIONS_HELP;
@@ -43794,7 +44585,7 @@ function getVersion() {
   }
   return "0.0.0";
 }
-function valueAfter4(args, flag) {
+function valueAfter3(args, flag) {
   const index = args.indexOf(flag);
   if (index === -1)
     return null;
@@ -43879,7 +44670,7 @@ async function main(argv = process.argv.slice(2)) {
         ]);
         return runDoctorDrainAuthority(projectRoot, join(getMagicContextStorageDir(), "context.db"));
       }
-      if (rest[0] === "merge-identity") {
+      if (rest[0] === "merge-identities" || rest[0] === "merge-identity") {
         await init_doctor_merge_identity();
         return runMergeIdentityCli(rest.slice(1));
       }
@@ -43900,8 +44691,8 @@ async function main(argv = process.argv.slice(2)) {
         return runMigrateSessionCli(rest.slice(1));
       }
       await init_doctor();
-      const rekeyV22DirIdentity = valueAfter4(rest, "--rekey-v22-dir-identity");
-      const report = valueAfter4(rest, "--report");
+      const rekeyV22DirIdentity = valueAfter3(rest, "--rekey-v22-dir-identity");
+      const report = valueAfter3(rest, "--report");
       return runDoctor4({
         force: rest.includes("--force"),
         fix: rest.includes("--fix"),