@cortexkit/magic-context 0.36.1 → 0.37.0

package/dist/index.js

@@ -12847,15 +12847,16 @@ Edit those files directly, then rerun setup.`);
 // ../plugin/src/shared/logger.ts
 import * as fs from "node:fs";
 import * as path2 from "node:path";
-function ensureDir4(filePath) {
-  const dir = path2.dirname(filePath);
-  if (dir === lastEnsuredDir)
-    return;
+function recordSwallowedWrite(error) {
   try {
-    fs.mkdirSync(dir, { recursive: true });
-    lastEnsuredDir = dir;
+    swallowedWriteCount++;
+    lastErrorMessage = error instanceof Error ? error.message : String(error);
+    lastErrorTime = new Date().toISOString();
   } catch {}
 }
+function ensureDir4(filePath) {
+  fs.mkdirSync(path2.dirname(filePath), { recursive: true });
+}
 function flush() {
   if (flushTimer) {
     clearTimeout(flushTimer);
@@ -12869,7 +12870,9 @@ function flush() {
     const logFile = getMagicContextLogPath();
     ensureDir4(logFile);
     fs.appendFileSync(logFile, data);
-  } catch {}
+  } catch (error) {
+    recordSwallowedWrite(error);
+  }
 }
 function scheduleFlush() {
   if (flushTimer)
@@ -12895,7 +12898,7 @@ ${data.stack}` : ""}` : ` ${JSON.stringify(data)}`;
     }
   } catch {}
 }
-var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, lastEnsuredDir = null;
+var isTestEnv = false, buffer, flushTimer = null, FLUSH_INTERVAL_MS = 500, BUFFER_SIZE_LIMIT = 50, swallowedWriteCount = 0, lastErrorMessage = null, lastErrorTime = null;
 var init_logger = __esm(() => {
   init_data_path();
   buffer = [];
@@ -12903,6 +12906,43 @@ var init_logger = __esm(() => {
     process.on("exit", flush);
   }
 });
+// ../plugin/src/shared/window-geometry.ts
+function setWindowOverlayPath(path3) {
+  configuredOverlayPath = path3;
+  loadedOverlayPath = undefined;
+  loadedOverlay = undefined;
+}
+var GRADES, UNITS, BOUNDARIES, UNKNOWN_REASONS, NUMERIC_FACT_KEYS, configuredOverlayPath, loadedOverlayPath, loadedOverlay, geometryClampLogSeen;
+var init_window_geometry = __esm(() => {
+  init_data_path();
+  init_harness_provider_map();
+  init_logger();
+  GRADES = new Set([
+    "provider_asserted_runtime",
+    "measured",
+    "provider_asserted_doc",
+    "catalog",
+    "unknown"
+  ]);
+  UNITS = new Set(["provider", "estimate"]);
+  BOUNDARIES = new Set(["Observed", "Asserted", "Corrected"]);
+  UNKNOWN_REASONS = new Set([
+    "placeholder_output_equals_context",
+    "placeholder_zero",
+    "never_measured",
+    "not_single_valued_at_key",
+    "retracted"
+  ]);
+  NUMERIC_FACT_KEYS = new Set([
+    "window.advertised",
+    "window.enforced",
+    "output.advertised",
+    "output.enforced",
+    "output.default"
+  ]);
+  geometryClampLogSeen = new Set;
+});
+
 // ../plugin/src/shared/models-dev-cache.ts
 function setOutputReserveConfig(config) {
   outputReserveConfig = config;
@@ -12912,6 +12952,7 @@ var init_models_dev_cache = __esm(() => {
   init_data_path();
   init_harness_provider_map();
   init_logger();
+  init_window_geometry();
   SEPARATE_OUTPUT_QUOTA_PROVIDERS = new Set(["google", "google-antigravity"]);
   reserveClampLogSeen = new Set;
 });
@@ -27951,6 +27992,9 @@ function isValidPromptSurfaceModelKey(key) {
     return true;
   return modelID.length > 0 && !modelID.startsWith("/") && !modelID.endsWith("/") && !modelID.includes("//");
 }
+var init_prompt_surface = __esm(() => {
+  init_harness_provider_map();
+});
 
 // ../plugin/src/config/schema/agent-overrides.ts
 var PermissionValueSchema, PermissionSchema, AgentOverrideConfigSchema;
@@ -28005,6 +28049,7 @@ var init_magic_context = __esm(() => {
   init_zod();
   init_language_directive();
   init_cron();
+  init_prompt_surface();
   init_agent_overrides();
   PiThinkingLevelSchema = exports_external.enum(["off", "minimal", "low", "medium", "high", "xhigh", "max"]).optional();
   PiConfigSchema = exports_external.object({
@@ -28201,6 +28246,9 @@ var init_magic_context = __esm(() => {
       exports_external.number().min(0),
       exports_external.object({ default: exports_external.number().min(0) }).catchall(exports_external.number().min(0))
     ]).optional().describe('User-only output-token reservation override. Number or per-model object ({ default: 16384, "provider/model": 8192 }); 0 disables reservation. When unset, Magic Context reserves the catalog output limit (capped at 25% of context) for shared-window providers and keeps proven separate-quota Google/Gemini windows unchanged.'),
+    models: exports_external.object({
+      window_overlay_path: exports_external.string().trim().min(1).optional()
+    }).optional().describe("User-only Fusiform window-overlay settings. The path defaults to <dataDir>/fusiform/window-overlay.json."),
     toast_duration_ms: exports_external.number().min(0).max(60000).default(5000).describe("TUI toast lifetime in milliseconds for Magic Context notifications. Set to 0 to disable Magic Context toasts entirely (min: 0, max: 60000, default: 5000)"),
     execute_threshold_percentage: exports_external.union([
       exports_external.number().min(20).max(90, EXECUTE_THRESHOLD_CAP_MESSAGE),
@@ -28407,6 +28455,11 @@ function stripUnsafeProjectConfigFields(projectRaw) {
     delete projectRaw.output_reserve;
     warnings.push("Ignoring output_reserve from project config (security: output-token reservation only honors user-level config).");
   }
+  const models = projectRaw.models;
+  if (isPlainObject2(models) && "window_overlay_path" in models) {
+    delete models.window_overlay_path;
+    warnings.push("Ignoring models.window_overlay_path from project config (security: only user-level config may select model geometry metadata).");
+  }
   if ("language" in projectRaw) {
     delete projectRaw.language;
     warnings.push("Ignoring language from project config (security: output language is a user-level setting).");
@@ -29085,6 +29138,7 @@ function loadPluginConfigDetailed(directory) {
   const recoveredTopLevelKeys = [];
   const config2 = parsePluginConfig(mergedRaw, recoveredTopLevelKeys);
   setOutputReserveConfig(config2.output_reserve);
+  setWindowOverlayPath(config2.models?.window_overlay_path);
   if (config2.configWarnings?.length) {
     allWarnings.push(...config2.configWarnings.map((w) => {
       if (userLoaded && projectLoaded)
@@ -29126,6 +29180,7 @@ function loadPluginConfigDetailed(directory) {
 var init_config = __esm(() => {
   init_jsonc_parser();
   init_models_dev_cache();
+  init_window_geometry();
   init_agent_disable();
   init_migrate_config_location();
   init_migrate_dreamer_v2();
@@ -29176,14 +29231,17 @@ function detectConflicts(directory, options) {
     omoAnthropicRecovery: false
   };
   const reasons = [];
-  const compactionResult = checkCompaction(directory);
+  let compactionResult = options?.resolvedCompaction ?? checkCompaction(directory);
+  if (process.env.OPENCODE_DISABLE_AUTOCOMPACT) {
+    compactionResult = { auto: false, prune: false };
+  }
   if (compactionEnabled && compactionResult.auto) {
     conflicts.compactionAuto = true;
-    reasons.push("OpenCode auto-compaction is enabled (compaction.auto=true)");
+    reasons.push(options?.resolvedCompaction ? "OpenCode auto-compaction is enabled (compaction.auto=true) (resolved config)" : "OpenCode auto-compaction is enabled (compaction.auto=true)");
   }
   if (compactionEnabled && compactionResult.prune) {
     conflicts.compactionPrune = true;
-    reasons.push("OpenCode prune is enabled (compaction.prune=true)");
+    reasons.push(options?.resolvedCompaction ? "OpenCode prune is enabled (compaction.prune=true) (resolved config)" : "OpenCode prune is enabled (compaction.prune=true)");
   }
   const dcpFound = checkDcpPlugin(directory);
   if (dcpFound) {
@@ -29371,6 +29429,7 @@ function readOmoDisabledHooks(directory) {
 var DCP_PACKAGE_NAMES, OMO_PACKAGE_NAMES;
 var init_conflict_detector = __esm(() => {
   init_jsonc_parser();
+  init_logger();
   init_opencode_config_dir();
   DCP_PACKAGE_NAMES = new Set(["@tarquinen/opencode-dcp"]);
   OMO_PACKAGE_NAMES = new Set(["oh-my-opencode", "oh-my-openagent"]);
@@ -30671,6 +30730,7 @@ function prepareMirrorPageStatements(db) {
   return {
     identityByModule: db.prepare("SELECT context_row_id FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?"),
     insertIdentity: db.prepare("INSERT OR IGNORE INTO mirror_identity(domain, module_project, module_row_id, context_row_id) VALUES (?, ?, ?, ?)"),
+    deleteIdentityByContext: db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND context_row_id = ?"),
     deleteLiveMemory: db.prepare("DELETE FROM mirror_live_memory_rows WHERE module_project = ? AND module_row_id = ?"),
     deletePendingReferencesForMemory: db.prepare("DELETE FROM mirror_pending_references WHERE domain = ? AND module_project = ? AND (module_row_id = ? OR target_module_row_id = ?)"),
     deleteIdentity: db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND module_project = ? AND module_row_id = ?"),
@@ -30722,7 +30782,7 @@ function prepareMirrorPageStatements(db) {
              check_quarantined_until = ?, check_next_due_at = ?, check_compiled_at = ?, check_false_since_at = ?,
              check_last_liveness_at = ?, last_checked_at = ?, check_status = ?, check_version = ?,
              policy_version = ?, anchor_block_id = ?, anchor_ordinal = ?, created_at = ?, updated_at = ? WHERE id = ?`),
-    upsertNoteRevision: db.prepare("INSERT INTO mirror_note_revisions(module_project, module_row_id, context_row_id, status_version) VALUES (?, ?, ?, ?) ON CONFLICT(module_project, module_row_id) DO UPDATE SET context_row_id = excluded.context_row_id, status_version = excluded.status_version"),
+    upsertNoteRevision: db.prepare("INSERT OR REPLACE INTO mirror_note_revisions(module_project, module_row_id, context_row_id, status_version) VALUES (?, ?, ?, ?)"),
     translateMemoryReferences: db.prepare(`UPDATE memories
                 SET superseded_by_memory_id = (
                     SELECT target.context_row_id
@@ -30795,6 +30855,9 @@ function rememberIdentity(db, domain2, moduleProject, moduleRowId, contextRowId,
   const existing = mirrorIdentity(db, domain2, moduleProject, moduleRowId, statements);
   if (existing)
     return;
+  if (domain2 === "notes") {
+    (statements?.deleteIdentityByContext ?? db.prepare("DELETE FROM mirror_identity WHERE domain = ? AND context_row_id = ?")).run(domain2, contextRowId);
+  }
   (statements?.insertIdentity ?? db.prepare("INSERT OR IGNORE INTO mirror_identity(domain, module_project, module_row_id, context_row_id) VALUES (?, ?, ?, ?)")).run(domain2, moduleProject, moduleRowId, contextRowId);
 }
 function contextMemoryId(db, domain2, moduleProject, row, moduleRowId, statements) {
@@ -31427,11 +31490,12 @@ function gitRootInAncestorChain(startDirectory) {
 function hasGitDirInAncestorChain(startDirectory) {
   return gitRootInAncestorChain(startDirectory) !== null;
 }
-var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, execFileSyncForIdentity, nowMs = () => Date.now(), ProjectIdentityError;
+var GIT_TIMEOUT_MS = 5000, TRANSIENT_FAILURE_COOLDOWN_MS, identityCache, linkedGitWorktreeCache, lastKnownGitIdentityCache, directoryFallbackCache, transientFailureCooldown, dubiousOwnershipFallbackDirectories, dubiousOwnershipLoggedDirectories, dubiousOwnershipWarnedDirectories, transientGitIdentityReuseLoggedDirectories, execFileSyncForIdentity, nowMs = () => Date.now(), ProjectIdentityError;
 var init_project_identity = __esm(() => {
   init_logger();
   TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
   identityCache = new Map;
+  linkedGitWorktreeCache = new Map;
   lastKnownGitIdentityCache = new Map;
   directoryFallbackCache = new Map;
   transientFailureCooldown = new Map;
@@ -33731,6 +33795,7 @@ class SubcModuleTransport {
     return error51;
   }
   async beforeDeadline(operation, deadlineMs, detail) {
+    operation.catch(() => {});
     const remainingMs = deadlineMs - Date.now();
     if (remainingMs <= 0)
       throw this.deadlineError(detail);
@@ -34145,12 +34210,14 @@ import { execFileSync as execFileSync4 } from "node:child_process";
 import { readFileSync as readFileSync12 } from "node:fs";
 function isPidAlive(pid) {
   if (!Number.isInteger(pid) || pid <= 0)
-    return false;
+    return "dead";
+  if (rpcIdentityPlatform === "win32")
+    return readWindowsProcess(pid).state;
   try {
-    process.kill(pid, 0);
-    return true;
-  } catch (err) {
-    return err.code === "EPERM";
+    rpcIdentityProcessKill(pid, 0);
+    return "alive";
+  } catch (error51) {
+    return error51.code === "ESRCH" ? "dead" : "inconclusive";
   }
 }
 function parseLinuxProcessStartTime(statContent, uptimeContent) {
@@ -34179,7 +34246,8 @@ function readPsProcessStartTime(pid) {
   try {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "lstart="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     });
     const processStartTime = Date.parse(String(output).trim());
     return Number.isFinite(processStartTime) ? processStartTime : null;
@@ -34187,6 +34255,70 @@ function readPsProcessStartTime(pid) {
     return null;
   }
 }
+function parseCsvLine(line) {
+  const fields = [];
+  let field = "";
+  let quoted = false;
+  for (let index = 0;index < line.length; index += 1) {
+    const character = line[index];
+    if (character === '"') {
+      if (quoted && line[index + 1] === '"') {
+        field += '"';
+        index += 1;
+      } else {
+        quoted = !quoted;
+      }
+    } else if (character === "," && !quoted) {
+      fields.push(field);
+      field = "";
+    } else {
+      field += character;
+    }
+  }
+  if (quoted)
+    return null;
+  fields.push(field);
+  return fields;
+}
+function parseTasklistOutput(output) {
+  const entries = [];
+  let sawHeader = false;
+  for (const rawLine of output.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (!line)
+      continue;
+    if (TASKLIST_NO_TASKS_PATTERN.test(line))
+      return [];
+    const fields = parseCsvLine(line);
+    if (!fields)
+      continue;
+    if (fields[1]?.trim().toLowerCase() === "pid") {
+      sawHeader = true;
+      continue;
+    }
+    const pid = Number(fields[1]);
+    if (!Number.isInteger(pid) || pid <= 0 || !fields[0])
+      continue;
+    entries.push({ pid, command: fields[0] });
+  }
+  return entries.length > 0 || sawHeader ? entries : null;
+}
+function readWindowsProcess(pid) {
+  try {
+    const output = rpcIdentityExecFileSync("tasklist", ["/FO", "CSV", "/FI", `PID eq ${pid}`], {
+      encoding: "utf8",
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
+    });
+    const entries = parseTasklistOutput(String(output));
+    if (entries === null)
+      return { state: "inconclusive" };
+    const process3 = entries.find((entry) => entry.pid === pid);
+    return process3 ? { state: "alive", command: process3.command } : { state: "dead" };
+  } catch {
+    return { state: "inconclusive" };
+  }
+}
 function readLinuxProcessCommand(pid) {
   try {
     return String(rpcIdentityReadFileSync(`/proc/${pid}/cmdline`, "utf8"));
@@ -34198,7 +34330,8 @@ function readPsProcessCommand(pid) {
   try {
     const output = rpcIdentityExecFileSync("ps", ["-p", String(pid), "-o", "command="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     });
     return String(output);
   } catch {
@@ -34211,17 +34344,17 @@ function commandLooksLikeOpenCode(command) {
 }
 function isPidIdentityPlausible(record2) {
   if (!Number.isInteger(record2.pid) || record2.pid <= 0)
-    return false;
+    return "implausible";
   if (Number.isFinite(record2.started_at) && record2.started_at > 0) {
-    const processStartTime = rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(record2.pid) : readPsProcessStartTime(record2.pid);
+    const processStartTime = rpcIdentityPlatform === "linux" ? readLinuxProcessStartTime(record2.pid) : rpcIdentityPlatform === "win32" ? null : readPsProcessStartTime(record2.pid);
     if (processStartTime === null)
-      return true;
-    return processStartTime <= record2.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS;
+      return "inconclusive";
+    return processStartTime <= record2.started_at + RPC_IDENTITY_SKEW_TOLERANCE_MS ? "plausible" : "implausible";
   }
-  const command = rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(record2.pid) : readPsProcessCommand(record2.pid);
+  const command = rpcIdentityPlatform === "linux" ? readLinuxProcessCommand(record2.pid) : rpcIdentityPlatform === "win32" ? readWindowsProcess(record2.pid).command ?? null : readPsProcessCommand(record2.pid);
   if (command === null)
-    return true;
-  return commandLooksLikeOpenCode(command);
+    return "inconclusive";
+  return commandLooksLikeOpenCode(command) ? "plausible" : "implausible";
 }
 function commandLooksLikePi(command) {
   const normalized = command.trim().toLowerCase().replaceAll("\\", "/");
@@ -34239,20 +34372,39 @@ function commandLooksLikePi(command) {
 function inspectLivePiProcesses() {
   if (false) {}
   try {
-    const output = String(rpcProcessListExecFileSync("ps", ["-axo", "pid=,command="], {
+    const isWindows = rpcIdentityPlatform === "win32";
+    const output = String(rpcProcessListExecFileSync(isWindows ? "tasklist" : "ps", isWindows ? ["/FO", "CSV"] : ["-axo", "pid=,command="], {
       encoding: "utf8",
-      timeout: PS_PROBE_TIMEOUT_MS
+      timeout: PS_PROBE_TIMEOUT_MS,
+      stdio: ["ignore", "pipe", "pipe"]
     }));
     const pids = new Set;
-    for (const line of output.split(/\r?\n/)) {
-      const match = /^\s*(\d+)\s+(.+)$/.exec(line);
-      if (!match)
-        continue;
-      const pid = Number(match[1]);
-      if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
-        continue;
-      if (commandLooksLikePi(match[2]))
-        pids.add(pid);
+    if (isWindows) {
+      const entries = parseTasklistOutput(output);
+      if (entries === null) {
+        return {
+          state: "unreadable",
+          processIds: [],
+          error: "tasklist output unavailable"
+        };
+      }
+      for (const entry of entries) {
+        if (entry.pid === process.pid)
+          continue;
+        if (commandLooksLikePi(entry.command))
+          pids.add(entry.pid);
+      }
+    } else {
+      for (const line of output.split(/\r?\n/)) {
+        const match = /^\s*(\d+)\s+(.+)$/.exec(line);
+        if (!match)
+          continue;
+        const pid = Number(match[1]);
+        if (!Number.isInteger(pid) || pid <= 0 || pid === process.pid)
+          continue;
+        if (commandLooksLikePi(match[2]))
+          pids.add(pid);
+      }
     }
     return { state: "known", processIds: [...pids].sort((left, right) => left - right) };
   } catch (error51) {
@@ -34297,11 +34449,13 @@ function parseRpcPortFile(content, fallbackPid = 0) {
 function isValidPort(port) {
   return Number.isInteger(port) && port > 0 && port <= 65535;
 }
-var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, OPEN_CODE_COMMAND_MARKERS, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now();
+var RPC_IDENTITY_SKEW_TOLERANCE_MS = 120000, LINUX_CLOCK_TICKS_PER_SECOND = 100, PS_PROBE_TIMEOUT_MS = 1000, OPEN_CODE_COMMAND_MARKERS, TASKLIST_NO_TASKS_PATTERN, rpcIdentityReadFileSync, rpcIdentityExecFileSync, rpcIdentityProcessKill, rpcProcessListExecFileSync, rpcIdentityPlatform, rpcIdentityNowMs = () => Date.now();
 var init_rpc_utils = __esm(() => {
   OPEN_CODE_COMMAND_MARKERS = ["opencode", "node", "bun", "electron"];
+  TASKLIST_NO_TASKS_PATTERN = /^INFO:\s+No tasks are running which match the specified criteria\.?$/im;
   rpcIdentityReadFileSync = readFileSync12;
   rpcIdentityExecFileSync = execFileSync4;
+  rpcIdentityProcessKill = process.kill;
   rpcProcessListExecFileSync = execFileSync4;
   rpcIdentityPlatform = process.platform;
 });
@@ -34528,6 +34682,8 @@ function healAllNullColumns(db) {
     ["stripped_placeholder_ids", ""],
     ["stale_reduce_stripped_ids", ""],
     ["processed_image_stripped_ids", ""],
+    ["merged_reasoning_stripped_ids", ""],
+    ["trailing_blank_decisions", ""],
     ["memory_block_cache", ""],
     ["memory_block_ids", ""],
     ["compaction_marker_state", ""],
@@ -34981,6 +35137,7 @@ var init_migrations = __esm(() => {
                     status TEXT NOT NULL DEFAULT 'active',
                     promoted_at INTEGER NOT NULL,
                     source_candidate_ids TEXT DEFAULT '[]',
+                    source_candidate_provenance TEXT,
                     created_at INTEGER NOT NULL,
                     updated_at INTEGER NOT NULL
                 );
@@ -36007,6 +36164,7 @@ var init_migrations = __esm(() => {
                     last_observed_at INTEGER,
                     answer_refreshed_at INTEGER,
                     source_candidate_ids TEXT NOT NULL DEFAULT '[]',
+                    source_candidate_provenance TEXT,
                     created_at INTEGER NOT NULL,
                     updated_at INTEGER NOT NULL
                 );
@@ -36816,6 +36974,37 @@ var init_migrations = __esm(() => {
         ensureColumn(db, "notes", "compiled_at", "INTEGER");
         ensureColumn(db, "notes", "compile_status", "TEXT CHECK(compile_status IN ('compiled', 'plain', 'refused'))");
       }
+    },
+    {
+      version: 77,
+      description: "persist scoped provenance for promoted user memories and primers",
+      up(db) {
+        if (tableExists(db, "user_memories")) {
+          ensureColumn(db, "user_memories", "source_candidate_provenance", "TEXT");
+        }
+        if (tableExists(db, "primers")) {
+          ensureColumn(db, "primers", "source_candidate_provenance", "TEXT");
+        }
+      }
+    },
+    {
+      version: 78,
+      description: "add migration_pending journal for crash-safe cross-harness session migration",
+      up(db) {
+        db.exec(`
+                CREATE TABLE IF NOT EXISTS migration_pending (
+                    migration_key TEXT PRIMARY KEY,
+                    source_session_id TEXT NOT NULL,
+                    target_harness TEXT NOT NULL,
+                    pi_session_id TEXT NOT NULL,
+                    final_path TEXT NOT NULL,
+                    stage_path TEXT NOT NULL,
+                    content_sha256 TEXT NOT NULL,
+                    phase TEXT NOT NULL CHECK (phase IN ('staged', 'db_committed')),
+                    created_at INTEGER NOT NULL
+                );
+            `);
+      }
     }
   ];
   LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m3) => Math.max(max, m3.version), 0);
@@ -36944,6 +37133,7 @@ function inspectRpcServerDiscovery(storageDir) {
   }
   const pids = new Set;
   const staleFiles = [];
+  const inconclusivePids = new Set;
   for (const portFile of portFiles) {
     let raw;
     try {
@@ -36963,10 +37153,15 @@ function inspectRpcServerDiscovery(storageDir) {
         return junk;
       continue;
     }
-    if (isPidAlive(record2.pid) && isPidIdentityPlausible(record2))
+    const liveness = isPidAlive(record2.pid);
+    const identity = liveness === "dead" ? "implausible" : isPidIdentityPlausible(record2);
+    if (liveness === "alive" && identity === "plausible") {
       pids.add(record2.pid);
-    else
+    } else if (liveness === "dead" || identity === "implausible") {
       staleFiles.push(portFile);
+    } else {
+      inconclusivePids.add(record2.pid);
+    }
   }
   for (const staleFile of staleFiles) {
     try {
@@ -36979,6 +37174,15 @@ function inspectRpcServerDiscovery(storageDir) {
   if (serverPids.length > 0) {
     return { state: "live", serverPids, staleFiles };
   }
+  const uncertainPids = [...inconclusivePids].sort((a3, b2) => a3 - b2);
+  if (uncertainPids.length > 0) {
+    return {
+      state: "inconclusive",
+      serverPids: [],
+      staleFiles,
+      inconclusivePids: uncertainPids
+    };
+  }
   return { state: "stale", serverPids: [], staleFiles };
 }
 function getLiveMigrationBlockingProcesses(storageDir) {
@@ -37163,6 +37367,7 @@ function initializeDatabase(db) {
       last_observed_at INTEGER,
       answer_refreshed_at INTEGER,
       source_candidate_ids TEXT NOT NULL DEFAULT '[]',
+      source_candidate_provenance TEXT,
       created_at INTEGER NOT NULL,
       updated_at INTEGER NOT NULL
     );
@@ -37798,6 +38003,11 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "primer_candidates", "question_embedding", "BLOB");
   ensureColumn(db, "primer_candidates", "question_embedding_model_id", "TEXT");
   ensureColumn(db, "primers", "question_embedding_model_id", "TEXT");
+  ensureColumn(db, "primers", "source_candidate_provenance", "TEXT");
+  const hasUserMemoriesTable = db.prepare("SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'user_memories'").get();
+  if (hasUserMemoriesTable) {
+    ensureColumn(db, "user_memories", "source_candidate_provenance", "TEXT");
+  }
   db.exec(`
       CREATE UNIQUE INDEX IF NOT EXISTS idx_primer_candidates_occurrence
         ON primer_candidates(project_path, harness, session_id, source_start_message_id, source_end_message_id);
@@ -37871,6 +38081,8 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "session_meta", "stripped_placeholder_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "stale_reduce_stripped_ids", "TEXT DEFAULT ''");
   ensureColumn(db, "session_meta", "processed_image_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "merged_reasoning_stripped_ids", "TEXT DEFAULT ''");
+  ensureColumn(db, "session_meta", "trailing_blank_decisions", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "start_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "compartments", "end_message_id", "TEXT DEFAULT ''");
   ensureColumn(db, "memory_embeddings", "model_id", "TEXT");
@@ -38089,7 +38301,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
   ensureColumn(db, "message_history_index", "harness", "TEXT NOT NULL DEFAULT 'opencode'");
   ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
 }
-var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 76, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig;
+var databases, pendingAsyncOpens, persistenceByDatabase, persistenceErrorByDatabase, pathByDatabase, LATEST_SUPPORTED_VERSION = 78, PERMISSIONS_ENFORCEABLE, RPC_DISCOVERY_PARSE_GRACE_MS, defaultRpcDiscoveryFs, rpcDiscoveryFs, sqlitePragmaConfig;
 var init_storage_db = __esm(async () => {
   init_data_path();
   init_logger();
@@ -38224,8 +38436,44 @@ var init_database_access = __esm(async () => {
 var exports_doctor_authority = {};
 __export(exports_doctor_authority, {
   runDoctorDrainAuthority: () => runDoctorDrainAuthority,
-  reportAuthorityMarkers: () => reportAuthorityMarkers
+  reportAuthorityMarkers: () => reportAuthorityMarkers,
+  authorityDrainCommand: () => authorityDrainCommand,
+  assertProjectsUseTsAuthority: () => assertProjectsUseTsAuthority
 });
+function authorityDrainCommand(project) {
+  return `magic-context doctor drain-authority ${project.projectRoot ?? `<${project.role} project root>`}`;
+}
+async function assertProjectsUseTsAuthority(args) {
+  const markers = listAuthorityManagedMarkers(args.db);
+  const markerByProject = new Map(markers.map((marker) => [marker.project_path, marker]));
+  for (const project of args.projects) {
+    const marker = markerByProject.get(project.projectPath);
+    if (!marker)
+      continue;
+    const projectRoot = project.projectRoot;
+    if (!projectRoot) {
+      throw new Error(`Migration refused: durable module authority for ${project.role} project ${project.projectPath} cannot be checked because its project directory is unavailable. ` + `Writes remain fenced. Drain it first: ${authorityDrainCommand(project)}`);
+    }
+    let statuses;
+    try {
+      statuses = await Promise.all(AUTHORITY_DOMAINS.map((domain2) => args.module.authorityStatus({
+        context_store_uuid: marker.context_store_uuid,
+        project: project.projectPath,
+        projectRoot,
+        domain: domain2
+      })));
+    } catch (error51) {
+      throw new Error(`Migration refused: module unreachable while checking ${project.role} project ${project.projectPath}; writes remain fenced. ` + `Drain it first: ${authorityDrainCommand(project)}. ` + `Module error: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    }
+    for (const [index, status] of statuses.entries()) {
+      const state = status.authority?.state ?? "TS";
+      if (state === "TS")
+        continue;
+      throw new Error(`Migration refused: ${project.role} project ${project.projectPath} has ${AUTHORITY_DOMAINS[index]} authority in ${state} mode; writes remain fenced. ` + `Drain it first: ${authorityDrainCommand(project)}`);
+    }
+  }
+  return { markers };
+}
 function authorityClient(transport, projectRoot) {
   return {
     authorityStatus: (request) => transport.authorityStatus({ ...request, projectRoot }),
@@ -38258,12 +38506,12 @@ async function reportAuthorityMarkers(args) {
     }
     try {
       const module = authorityClient(transport, process.cwd());
-      const statuses = await Promise.all(DOMAINS.map((domain2) => module.authorityStatus({
+      const statuses = await Promise.all(AUTHORITY_DOMAINS.map((domain2) => module.authorityStatus({
         context_store_uuid: ensureContextStoreUuid(args.db),
         project: marker.project_path,
         domain: domain2
       })));
-      args.info(`  ${marker.project_path}: ${statuses.map((status, index) => `${DOMAINS[index]}=${status.authority?.state ?? "TS"}`).join(", ")}`);
+      args.info(`  ${marker.project_path}: ${statuses.map((status, index) => `${AUTHORITY_DOMAINS[index]}=${status.authority?.state ?? "TS"}`).join(", ")}`);
     } catch {
       args.warn(`  ${marker.project_path}: module unreachable — writes fenced; run with rust mode or restore subc connectivity`);
     }
@@ -38283,7 +38531,7 @@ async function runDoctorDrainAuthority(projectRoot, dbPath) {
     }
     const module = authorityClient(new SubcModuleTransport, projectRoot);
     let drainedAny = false;
-    for (const domain2 of DOMAINS) {
+    for (const domain2 of AUTHORITY_DOMAINS) {
       const status = await module.authorityStatus({
         context_store_uuid: ensureContextStoreUuid(db),
         project: projectPath,
@@ -38327,7 +38575,6 @@ async function runDoctorDrainAuthority(projectRoot, dbPath) {
     db.close();
   }
 }
-var DOMAINS;
 var init_doctor_authority = __esm(async () => {
   init_project_identity();
   init_storage_project_state();
@@ -38336,7 +38583,6 @@ var init_doctor_authority = __esm(async () => {
     init_context_authority(),
     init_database_access()
   ]);
-  DOMAINS = ["memories", "notes"];
 });
 
 // ../plugin/src/features/magic-context/storage-identity-merge.ts
@@ -39225,17 +39471,20 @@ var init_migration_paths = () => {};
 // src/commands/migrate.ts
 var exports_migrate = {};
 __export(exports_migrate, {
+  sweepPendingMigrations: () => sweepPendingMigrations,
   runMigrateCli: () => runMigrateCli,
   projectPathToPiDirSlug: () => projectPathToPiDirSlug,
   printMigrateHelp: () => printMigrateHelp,
   parseMigrateArgs: () => parseMigrateArgs,
+  migrationKeyFor: () => migrationKeyFor,
   migrateOpenCodeSessionToPi: () => migrateOpenCodeSessionToPi,
   generateUuidV7: () => generateUuidV7,
-  formatPiFilenameTimestamp: () => formatPiFilenameTimestamp
+  formatPiFilenameTimestamp: () => formatPiFilenameTimestamp,
+  formatMigrationSweepLines: () => formatMigrationSweepLines
 });
-import { randomBytes as randomBytes2 } from "node:crypto";
-import { unlinkSync as unlinkSync3 } from "node:fs";
-import { join as join18 } from "node:path";
+import { createHash as createHash3, randomBytes as randomBytes2 } from "node:crypto";
+import { existsSync as existsSync21, mkdirSync as mkdirSync8, renameSync as renameSync4, unlinkSync as unlinkSync3 } from "node:fs";
+import { dirname as dirname12, join as join18 } from "node:path";
 function defaultOpenCodeDbPath() {
   return getOpenCodeDatabasePath();
 }
@@ -39246,7 +39495,7 @@ function defaultPiSessionsRoot() {
   return getPiSessionsRoot();
 }
 function defaultFs() {
-  return { writeFileAtomic, unlinkSync: unlinkSync3 };
+  return { writeFileAtomic, unlinkSync: unlinkSync3, existsSync: existsSync21, renameSync: renameSync4, mkdirSync: mkdirSync8 };
 }
 function stmt(db, sql) {
   return db.prepare(sql);
@@ -39272,6 +39521,74 @@ function generateUuidV7(date5 = new Date) {
 function shortId() {
   return randomBytes2(4).toString("hex");
 }
+function migrationKeyFor(sourceSessionId, targetHarness) {
+  return createHash3("sha256").update(`${sourceSessionId}
+${targetHarness}`).digest("hex");
+}
+function hasMigrationJournal(db) {
+  return Boolean(stmt(db, "SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'migration_pending'").get());
+}
+function sweepPendingMigrations(db, fs3 = defaultFs()) {
+  const report = {
+    completed: 0,
+    rolledForward: 0,
+    rolledBack: 0,
+    lost: []
+  };
+  if (!hasMigrationJournal(db))
+    return report;
+  const rows = stmt(db, `SELECT migration_key, source_session_id, target_harness, pi_session_id,
+               final_path, stage_path, content_sha256, phase, created_at
+          FROM migration_pending
+      ORDER BY created_at ASC`).all();
+  for (const row of rows) {
+    if (fs3.existsSync(row.final_path)) {
+      stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
+      report.completed += 1;
+      continue;
+    }
+    if (row.phase === "db_committed") {
+      if (fs3.existsSync(row.stage_path)) {
+        fs3.mkdirSync(dirname12(row.final_path), { recursive: true });
+        fs3.renameSync(row.stage_path, row.final_path);
+        stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
+        report.rolledForward += 1;
+      } else {
+        report.lost.push(row);
+      }
+      continue;
+    }
+    try {
+      fs3.unlinkSync(row.stage_path);
+    } catch {}
+    stmt(db, "DELETE FROM migration_pending WHERE migration_key = ?").run(row.migration_key);
+    report.rolledBack += 1;
+  }
+  return report;
+}
+function readPendingMigration(db, migrationKey) {
+  return stmt(db, JOURNAL_SELECT_SQL).get(migrationKey);
+}
+function claimJournalIdentity(args) {
+  const existing = readPendingMigration(args.db, args.migrationKey);
+  if (existing) {
+    return { row: existing, resumed: true };
+  }
+  const piSessionId = generateUuidV7(new Date(args.now));
+  stmt(args.db, `INSERT INTO migration_pending (
+             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), join18(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");
+  }
+  return { row, resumed: row.pi_session_id !== piSessionId };
+}
+function commitStagedChecksum(db, migrationKey, contentSha256) {
+  stmt(db, "UPDATE migration_pending SET content_sha256 = ? WHERE migration_key = ?").run(contentSha256, migrationKey);
+}
 function parseJsonObject(text3) {
   const parsed = JSON.parse(text3);
   if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) {
@@ -39431,7 +39748,7 @@ function convertPartToEntries(ctx) {
   }
 }
 function buildPiEntries(params) {
-  const sessionUuid = generateUuidV7(params.now);
+  const sessionUuid = params.piSessionId;
   const nowIso = params.now.toISOString();
   const entries = [
     {
@@ -39467,6 +39784,7 @@ The following conversation was migrated from a different harness. Reasoning cont
     list.push(part);
     partsByMessage.set(part.message_id, list);
   }
+  const messageIdToFirstPiEntryId = new Map;
   const messageIdToLastPiEntryId = new Map;
   const orderedSourceMessageIds = [];
   let parentId = boundary.id;
@@ -39477,6 +39795,7 @@ The following conversation was migrated from a different harness. Reasoning cont
     const timestamp2 = isoFromMs(message.time_created, params.now);
     const tokens = tokensFromMessage(message);
     const usage = tokensToPiUsage(tokens);
+    let firstEntryIdForMessage = null;
     let lastEntryIdForMessage = null;
     for (const part of partsByMessage.get(message.id) ?? []) {
       const newEntries = convertPartToEntries({
@@ -39491,10 +39810,13 @@ The following conversation was migrated from a different harness. Reasoning cont
           entry.parentId = parentId;
         entries.push(entry);
         parentId = entry.id;
+        if (firstEntryIdForMessage === null)
+          firstEntryIdForMessage = parentId;
         lastEntryIdForMessage = parentId;
       }
     }
-    if (lastEntryIdForMessage !== null) {
+    if (lastEntryIdForMessage !== null && firstEntryIdForMessage !== null) {
+      messageIdToFirstPiEntryId.set(message.id, firstEntryIdForMessage);
       messageIdToLastPiEntryId.set(message.id, lastEntryIdForMessage);
       orderedSourceMessageIds.push(message.id);
     }
@@ -39502,6 +39824,7 @@ The following conversation was migrated from a different harness. Reasoning cont
   return {
     entries,
     piSessionId: sessionUuid,
+    messageIdToFirstPiEntryId,
     messageIdToLastPiEntryId,
     orderedSourceMessageIds
   };
@@ -39539,8 +39862,9 @@ function fetchRows(db, sessionId, maxMessages) {
     throw error51;
   }
 }
-function remapBoundaryId(openCodeMessageId, messageIdToLastPiEntryId, orderedSourceMessageIds) {
-  const direct = messageIdToLastPiEntryId.get(openCodeMessageId);
+function remapBoundaryId(openCodeMessageId, edge, messageIdToFirstPiEntryId, messageIdToLastPiEntryId, orderedSourceMessageIds) {
+  const directMap = edge === "start" ? messageIdToFirstPiEntryId : messageIdToLastPiEntryId;
+  const direct = directMap.get(openCodeMessageId);
   if (direct !== undefined)
     return { piEntryId: direct, exact: true };
   let nearestAtOrBefore;
@@ -39601,8 +39925,8 @@ function copyMagicContextState(args) {
   let boundariesApproximated = 0;
   const remappedCompartments = [];
   for (const c3 of sourceCompartments) {
-    const startRemap = remapBoundaryId(c3.start_message_id, args.messageIdToLastPiEntryId, args.orderedSourceMessageIds);
-    const endRemap = remapBoundaryId(c3.end_message_id, args.messageIdToLastPiEntryId, args.orderedSourceMessageIds);
+    const startRemap = remapBoundaryId(c3.start_message_id, "start", args.messageIdToFirstPiEntryId, args.messageIdToLastPiEntryId, args.orderedSourceMessageIds);
+    const endRemap = remapBoundaryId(c3.end_message_id, "end", args.messageIdToFirstPiEntryId, args.messageIdToLastPiEntryId, args.orderedSourceMessageIds);
     if (!startRemap || !endRemap)
       continue;
     if (!startRemap.exact || !endRemap.exact)
@@ -39631,9 +39955,9 @@ function copyMagicContextState(args) {
     lastCompartmentEndPiEntryId: remappedCompartments.at(-1)?.end_message_id
   };
   if (args.dryRun) {
-    return { ...result, commit: () => {} };
+    return { ...result, remappedCompartments, commit: () => {} };
   }
-  const commit = () => {
+  const commit = (journalKey) => {
     const insertCompartment = stmt(args.cortexkitDb, `INSERT INTO compartments (
        session_id, sequence, start_message, end_message,
        start_message_id, end_message_id, title, content,
@@ -39645,19 +39969,72 @@ function copyMagicContextState(args) {
      ) VALUES (?, ?, ?, ?, ?, 'pi')`);
     args.cortexkitDb.exec("BEGIN IMMEDIATE");
     try {
+      stmt(args.cortexkitDb, "DELETE FROM compartments WHERE session_id = ? AND harness = 'pi'").run(args.piSessionId);
+      stmt(args.cortexkitDb, "DELETE FROM session_facts WHERE session_id = ? AND harness = 'pi'").run(args.piSessionId);
       for (const c3 of remappedCompartments) {
         insertCompartment.run(args.piSessionId, c3.sequence, c3.start_message, c3.end_message, c3.start_message_id, c3.end_message_id, c3.title, c3.content, c3.p1, c3.p2, c3.p3, c3.p4, typeof c3.importance === "number" ? c3.importance : 50, c3.episode_type, c3.legacy, args.now);
       }
       for (const f2 of sourceFacts) {
         insertFact.run(args.piSessionId, f2.category, f2.content, f2.created_at, f2.updated_at);
       }
+      if (journalKey !== undefined) {
+        stmt(args.cortexkitDb, "UPDATE migration_pending SET phase = 'db_committed' WHERE migration_key = ?").run(journalKey);
+      }
       args.cortexkitDb.exec("COMMIT");
     } catch (error51) {
       args.cortexkitDb.exec("ROLLBACK");
       throw error51;
     }
   };
-  return { ...result, commit };
+  return { ...result, remappedCompartments, commit };
+}
+function derivePiRuntimeOrdinals(entries) {
+  const ordinalByEntryId = new Map;
+  let nextOrdinal = 1;
+  const pendingToolResultIds = [];
+  const foldPendingInto = (ordinal) => {
+    for (const id of pendingToolResultIds)
+      ordinalByEntryId.set(id, ordinal);
+    pendingToolResultIds.length = 0;
+  };
+  for (const entry of entries) {
+    const message = entry.message;
+    if (entry.type !== "message" || typeof entry.id !== "string" || message === null || typeof message !== "object") {
+      continue;
+    }
+    const role = message.role;
+    if (role === "toolResult") {
+      pendingToolResultIds.push(entry.id);
+      continue;
+    }
+    if (role === "assistant" && pendingToolResultIds.length > 0) {
+      foldPendingInto(nextOrdinal);
+      nextOrdinal += 1;
+    }
+    const ordinal = nextOrdinal;
+    nextOrdinal += 1;
+    if (role === "user" && pendingToolResultIds.length > 0) {
+      foldPendingInto(ordinal);
+    }
+    ordinalByEntryId.set(entry.id, ordinal);
+  }
+  if (pendingToolResultIds.length > 0) {
+    foldPendingInto(nextOrdinal);
+  }
+  return ordinalByEntryId;
+}
+function applyRuntimeOrdinals(remappedCompartments, entries) {
+  const ordinals = derivePiRuntimeOrdinals(entries);
+  for (const compartment of remappedCompartments) {
+    const startOrdinal = ordinals.get(compartment.start_message_id);
+    const endOrdinal = ordinals.get(compartment.end_message_id);
+    if (startOrdinal === undefined || endOrdinal === undefined) {
+      const missing = startOrdinal === undefined ? compartment.start_message_id : compartment.end_message_id;
+      throw new Error(`Migration boundary entry ${missing} has no runtime ordinal; migrator invariant violated`);
+    }
+    compartment.start_message = startOrdinal;
+    compartment.end_message = endOrdinal;
+  }
 }
 function ensureValidOptions(opts) {
   if (!opts.from)
@@ -39707,52 +40084,88 @@ function migrateOpenCodeSessionToPi(opts) {
     const modelId = opts.modelId ?? model.modelId;
     const cwd = session.directory ?? session.path ?? process.cwd();
     const outputDir = join18(piSessionsRoot, projectPathToPiDirSlug(cwd));
+    const targetHarness = opts.targetHarness ?? "pi";
+    const journalActive = cortexkitDb !== null && !opts.dryRun;
+    let recovery;
+    let migrationKey;
+    let journalResumed = false;
+    let piSessionId;
+    let finalPath;
+    let stagePath;
+    if (journalActive && cortexkitDb !== null) {
+      if (!hasMigrationJournal(cortexkitDb)) {
+        throw new Error("context.db has no migration_pending journal (shared schema older than v78). Run a harness session once so the plugin can upgrade the schema, then retry doctor migrate.");
+      }
+      recovery = sweepPendingMigrations(cortexkitDb, fs3);
+      migrationKey = migrationKeyFor(session.id, targetHarness);
+      const claimed = claimJournalIdentity({
+        db: cortexkitDb,
+        migrationKey,
+        sourceSessionId: session.id,
+        targetHarness,
+        finalPathFor: (id) => join18(outputDir, `${formatPiFilenameTimestamp(now)}_${id}.jsonl`),
+        stageDir: join18(dirname12(piSessionsRoot), MIGRATION_STAGE_DIRNAME),
+        now: now.getTime()
+      });
+      piSessionId = claimed.row.pi_session_id;
+      finalPath = claimed.row.final_path;
+      stagePath = claimed.row.stage_path;
+      journalResumed = claimed.resumed;
+    } else {
+      piSessionId = generateUuidV7(now);
+      finalPath = join18(outputDir, `${formatPiFilenameTimestamp(now)}_${piSessionId}.jsonl`);
+      stagePath = "";
+    }
     const buildResult = buildPiEntries({
       session,
       messages,
       parts,
       now,
       provider,
-      modelId
+      modelId,
+      piSessionId
     });
     let copyResult = {
       compartmentsCopied: 0,
       factsCopied: 0,
       boundariesApproximated: 0
     };
-    let commitMagicContextState = null;
+    let plan = null;
     if (cortexkitDb !== null) {
-      const plan = copyMagicContextState({
+      plan = copyMagicContextState({
         cortexkitDb,
         sourceSessionId: session.id,
-        piSessionId: buildResult.piSessionId,
+        piSessionId,
+        messageIdToFirstPiEntryId: buildResult.messageIdToFirstPiEntryId,
         messageIdToLastPiEntryId: buildResult.messageIdToLastPiEntryId,
         orderedSourceMessageIds: buildResult.orderedSourceMessageIds,
         now: now.getTime(),
         dryRun: Boolean(opts.dryRun)
       });
       copyResult = plan;
-      commitMagicContextState = plan.commit;
     }
     const compactionMarker = insertCompactionMarker(buildResult.entries, copyResult.lastCompartmentEndPiEntryId);
-    const outputPath = join18(outputDir, `${formatPiFilenameTimestamp(now)}_${buildResult.piSessionId}.jsonl`);
+    if (plan)
+      applyRuntimeOrdinals(plan.remappedCompartments, buildResult.entries);
     const jsonl = `${buildResult.entries.map((entry) => JSON.stringify(entry)).join(`
 `)}
 `;
     if (!opts.dryRun) {
-      fs3.writeFileAtomic(outputPath, jsonl);
-      try {
-        commitMagicContextState?.();
-      } catch (commitError) {
-        try {
-          fs3.unlinkSync(outputPath);
-        } catch {}
-        throw commitError;
+      if (journalActive && cortexkitDb !== null && migrationKey !== undefined && plan) {
+        const contentSha256 = createHash3("sha256").update(jsonl, "utf8").digest("hex");
+        commitStagedChecksum(cortexkitDb, migrationKey, contentSha256);
+        fs3.writeFileAtomic(stagePath, jsonl);
+        plan.commit(migrationKey);
+        fs3.mkdirSync(dirname12(finalPath), { recursive: true });
+        fs3.renameSync(stagePath, finalPath);
+        stmt(cortexkitDb, "DELETE FROM migration_pending WHERE migration_key = ?").run(migrationKey);
+      } else {
+        fs3.writeFileAtomic(finalPath, jsonl);
       }
     }
     return {
-      outputPath,
-      piSessionId: buildResult.piSessionId,
+      outputPath: finalPath,
+      piSessionId,
       messageCount: buildResult.entries.length - 2,
       byteCount: Buffer.byteLength(jsonl, "utf8"),
       sourceMessageCount,
@@ -39762,6 +40175,9 @@ function migrateOpenCodeSessionToPi(opts) {
       compactionMarkerWritten: compactionMarker.written,
       compactionBoundaryEntryId: compactionMarker.boundaryEntryId,
       compactionFirstKeptEntryId: compactionMarker.firstKeptEntryId,
+      ...migrationKey !== undefined ? { migrationKey } : {},
+      ...journalActive ? { journalResumed } : {},
+      ...recovery !== undefined ? { recovery } : {},
       ...cortexkitSchemaVersionBefore !== null && cortexkitDb !== null ? {
         cortexkitSchemaVersionBefore,
         cortexkitSchemaVersionAfter: getPersistedSchemaVersion2(cortexkitDb)
@@ -39828,9 +40244,32 @@ function printMigrateHelp() {
     - compartments + session_facts are copied to the new Pi session_id;
       compartment boundary message IDs are remapped to the corresponding
       Pi entry IDs (nearest-at-or-before for boundaries that don't have
-      a direct message-level Pi entry)
+      a direct message-level Pi entry), and compartment start/end ordinals
+      are recomputed in the ordinal basis the Pi runtime reader produces
+
+  Crash safety:
+    - each migration is tracked in the shared DB's migration_pending journal
+      and staged outside the sessions tree; an interrupted run is reconciled
+      by phase on the next 'doctor migrate' or plain 'doctor' run, reusing the
+      original Pi session id instead of minting a second one
 `);
 }
+function formatMigrationSweepLines(report) {
+  const lines = [];
+  if (report.rolledForward > 0) {
+    lines.push(`Recovered ${report.rolledForward} interrupted session migration(s) by completing the staged file rename.`);
+  }
+  if (report.rolledBack > 0) {
+    lines.push(`Rolled back ${report.rolledBack} incomplete session migration(s) that never committed shared state.`);
+  }
+  if (report.completed > 0) {
+    lines.push(`Cleared ${report.completed} finished session-migration journal row(s).`);
+  }
+  for (const row of report.lost) {
+    lines.push(`LOST session migration content: source ${row.source_session_id} → ${row.target_harness} session ${row.pi_session_id}; expected file ${row.final_path} (sha256 ${row.content_sha256}). Re-run doctor migrate for this session to rebuild it.`);
+  }
+  return lines;
+}
 async function runMigrateCli(args) {
   try {
     const parsed = parseMigrateArgs(args);
@@ -39840,8 +40279,14 @@ async function runMigrateCli(args) {
       sessionId: parsed.session,
       maxMessages: parsed.maxMessages,
       dryRun: parsed.dryRun,
-      piSessionsRoot: parsed.to === "omp" ? getOmpSessionsRoot() : undefined
+      piSessionsRoot: parsed.to === "omp" ? getOmpSessionsRoot() : undefined,
+      targetHarness: parsed.to === "omp" ? "omp" : "pi"
     });
+    if (result.recovery) {
+      for (const line of formatMigrationSweepLines(result.recovery)) {
+        console.log(line);
+      }
+    }
     const action = result.dryRun ? "Would write" : "Wrote";
     console.log(`${action} ${target} session JSONL:`);
     console.log(`  path: ${result.outputPath}`);
@@ -39858,6 +40303,9 @@ async function runMigrateCli(args) {
     if (result.boundariesApproximated > 0) {
       console.log(`  boundaries approximated: ${result.boundariesApproximated} (nearest-at-or-before)`);
     }
+    if (result.migrationKey !== undefined) {
+      console.log(`  journal: ${result.migrationKey.slice(0, 12)}…${result.journalResumed ? " (resumed interrupted attempt)" : ""}`);
+    }
     if (!result.dryRun) {
       console.log(`${target} may need to be restarted to pick up the new session file.`);
       if (result.cortexkitSchemaVersionBefore !== undefined) {
@@ -39875,7 +40323,9 @@ async function runMigrateCli(args) {
     return 1;
   }
 }
-var DEFAULT_PROVIDER = "openai-codex", DEFAULT_MODEL = "gpt-5.5", MIGRATION_COMPACTION_SUMMARY = "Magic Context compacted prior conversation. See <session-history> block for the structured summary.", PART_LOOKUP_CHUNK_SIZE = 900;
+var DEFAULT_PROVIDER = "openai-codex", DEFAULT_MODEL = "gpt-5.5", MIGRATION_COMPACTION_SUMMARY = "Magic Context compacted prior conversation. See <session-history> block for the structured summary.", PART_LOOKUP_CHUNK_SIZE = 900, MIGRATION_STAGE_DIRNAME = ".mc-migrations", JOURNAL_SELECT_SQL = `SELECT migration_key, source_session_id, target_harness, pi_session_id,
+               final_path, stage_path, content_sha256, phase, created_at
+          FROM migration_pending WHERE migration_key = ?`;
 var init_migrate = __esm(async () => {
   init_data_path();
   init_atomic_write();
@@ -39979,15 +40429,72 @@ var exports_migrate_session = {};
 __export(exports_migrate_session, {
   runMigrateSessionCli: () => runMigrateSessionCli,
   planMigrateSession: () => planMigrateSession,
+  assertMigrateSessionIsSafeToRehome: () => assertMigrateSessionIsSafeToRehome,
   applyMigrateSession: () => applyMigrateSession
 });
-import { existsSync as existsSync21, realpathSync as realpathSync4 } from "node:fs";
+import { existsSync as existsSync22, realpathSync as realpathSync4 } from "node:fs";
 import { homedir as homedir13 } from "node:os";
 import path4, { join as join19 } from "node:path";
 function existingSessionColumns(db) {
   const rows = db.prepare("PRAGMA table_info(session)").all();
   return new Set(rows.map((r2) => r2.name).filter((n2) => typeof n2 === "string"));
 }
+function isModuleCacheStatePresent(status) {
+  if (!status || typeof status !== "object")
+    return false;
+  const rowVersion = status.row_version;
+  return typeof rowVersion === "number";
+}
+function drainCommandsForMarkers(markers, projects) {
+  const byProject = new Map(projects.map((project) => [project.projectPath, project]));
+  return [
+    ...new Set(markers.map((marker) => authorityDrainCommand(byProject.get(marker.project_path) ?? {
+      role: "marked",
+      projectPath: marker.project_path,
+      projectRoot: null
+    })))
+  ].join("; ");
+}
+async function assertMigrateSessionIsSafeToRehome(args) {
+  const projects = [
+    {
+      role: "source",
+      projectPath: args.plan.fromMcIdentity,
+      projectRoot: args.plan.currentDirectory
+    },
+    {
+      role: "target",
+      projectPath: args.plan.toMcIdentity,
+      projectRoot: args.plan.targetDirectory
+    }
+  ];
+  const authority = await assertProjectsUseTsAuthority({
+    db: args.contextDb,
+    projects,
+    module: args.module
+  });
+  let sessionStatus;
+  try {
+    sessionStatus = await args.module.sessionStatus({
+      sessionId: args.plan.sessionId,
+      projectRoot: args.plan.currentDirectory ?? args.plan.targetDirectory
+    });
+  } catch (error51) {
+    const message = error51 instanceof Error ? error51.message : String(error51);
+    if (authority.markers.length === 0) {
+      return {
+        warnings: [
+          `Module session-cache state was not checked because the module is unreachable: ${message}. No durable authority markers exist, so continuing for this pure-TypeScript installation.`
+        ]
+      };
+    }
+    throw new Error("Migration refused: module session-cache state is unreachable while durable authority markers exist; writes remain fenced. " + `Drain marked projects first: ${drainCommandsForMarkers(authority.markers, projects)}. ` + `Module error: ${message}`);
+  }
+  if (isModuleCacheStatePresent(sessionStatus)) {
+    throw new Error(`Migration refused: the module still holds transform cache state for session ${args.plan.sessionId}. ` + "Use TypeScript transform mode for the session's project, or run `ck session delete` after preserving any needed state, then re-run this migration.");
+  }
+  return { warnings: [] };
+}
 function planMigrateSession(sessionId, rawTargetDirectory, deps) {
   const sessionRow = deps.opencodeDb.prepare("SELECT id, directory FROM session WHERE id = ?").get(sessionId);
   if (!sessionRow) {
@@ -40144,7 +40651,7 @@ function realDeps(opencodeDb, contextDb) {
     opencodeDb,
     contextDb,
     resolveIdentity: resolveProjectIdentity,
-    hasGitDir: (dir) => existsSync21(join19(dir, ".git")),
+    hasGitDir: (dir) => existsSync22(join19(dir, ".git")),
     realpath: (p2) => realpathSync4(p2)
   };
 }
@@ -40223,7 +40730,7 @@ async function runMigrateSessionCli(args) {
     return 1;
   }
   const expandedTo = toDir.startsWith("~") ? join19(homedir13(), toDir.slice(1).replace(/^[/\\]/, "")) : toDir;
-  if (!existsSync21(expandedTo)) {
+  if (!existsSync22(expandedTo)) {
     console.error(`Target directory does not exist: ${expandedTo}`);
     return 1;
   }
@@ -40249,6 +40756,27 @@ async function runMigrateSessionCli(args) {
     } catch {}
     const deps = realDeps(opencodeDb, contextDb);
     const plan = planMigrateSession(sessionId, expandedTo, deps);
+    const transport = new SubcModuleTransport;
+    const safety = await assertMigrateSessionIsSafeToRehome({
+      plan,
+      contextDb,
+      module: {
+        authorityStatus: (request) => transport.authorityStatus(request),
+        sessionStatus: ({ sessionId: statusSessionId, projectRoot }) => transport.call({
+          sessionId: statusSessionId,
+          projectRoot,
+          method: "session.status",
+          body: {
+            method: "session.status",
+            v: 1,
+            session_id: statusSessionId
+          }
+        })
+      }
+    });
+    for (const warning of safety.warnings) {
+      promptIO.log.warn(warning);
+    }
     promptIO.note([
       `session:        ${plan.sessionId}`,
       `from:           ${plan.currentDirectory ?? "(unknown)"}`,
@@ -40332,10 +40860,14 @@ var init_migrate_session = __esm(async () => {
   init_project_identity();
   init_relocate_memory();
   init_storage_project_state();
+  init_module_transport();
   init_data_path();
   init_migration_paths();
   init_prompts();
-  await init_database_access();
+  await __promiseAll([
+    init_database_access(),
+    init_doctor_authority()
+  ]);
   VALID_MEMORY_ACTIONS = new Set([
     "move-all",
     "move-originated",
@@ -40346,7 +40878,7 @@ var init_migrate_session = __esm(async () => {
 });
 
 // ../plugin/src/features/magic-context/v22-deferred-backfill.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash4 } from "node:crypto";
 import { realpathSync as realpathSync5 } from "node:fs";
 import path5 from "node:path";
 function readMeta(db, key) {
@@ -40395,7 +40927,7 @@ function computeLegacyRustDirIdentity(rawProjectPath) {
   } catch {
     canonical = path5.isAbsolute(rawProjectPath) ? rawProjectPath : path5.join(process.cwd(), rawProjectPath);
   }
-  return `dir:${createHash3("sha256").update(canonical, "utf8").digest("hex")}`;
+  return `dir:${createHash4("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)
@@ -40580,7 +41112,7 @@ var init_v22_backfill_commands = __esm(async () => {
 });
 
 // ../pi-plugin/src/config/index.ts
-import { existsSync as existsSync22, readFileSync as readFileSync14 } from "node:fs";
+import { existsSync as existsSync23, readFileSync as readFileSync14 } from "node:fs";
 function getProjectConfigPaths(cwd) {
   const basePath = cortexKitProjectConfigBasePath(cwd);
   return [`${basePath}.jsonc`, `${basePath}.json`];
@@ -40590,10 +41122,10 @@ function getUserConfigPaths() {
   return [`${basePath}.jsonc`, `${basePath}.json`];
 }
 function resolveFirstExisting(paths) {
-  return paths.find((path6) => existsSync22(path6));
+  return paths.find((path6) => existsSync23(path6));
 }
 function resolvePiLegacyFallback(sources) {
-  return sources.find((source) => existsSync22(source.path)) ?? null;
+  return sources.find((source) => existsSync23(source.path)) ?? null;
 }
 function loadConfigFile(path6, scope) {
   try {
@@ -40750,7 +41282,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync22(source.path));
+  const legacyProjectUnmigrated = !projectPath && !projectLegacyFallback && legacySources.project.some((source) => existsSync23(source.path));
   const userPath = resolveFirstExisting(getUserConfigPaths());
   const userLegacyFallback = userPath ? null : resolvePiLegacyFallback(harnessLegacy.user);
   const userReadPath = userPath ?? userLegacyFallback?.path;
@@ -40759,7 +41291,7 @@ function loadPiConfig(opts = {}) {
     if (loaded)
       loadedFiles.push(loaded);
   }
-  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync22(source.path));
+  const legacyUserUnmigrated = !userPath && !userLegacyFallback && legacySources.user.some((source) => existsSync23(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) {
@@ -40803,6 +41335,7 @@ function loadPiConfig(opts = {}) {
   }
   const parsed = parsePiConfig(rawConfig);
   setOutputReserveConfig(parsed.config.output_reserve);
+  setWindowOverlayPath(parsed.config.models?.window_overlay_path);
   warnings.push(...parsed.warnings.map((warning) => `[merged config] ${warning}`));
   return {
     config: parsed.config,
@@ -40821,6 +41354,7 @@ var init_config2 = __esm(() => {
   init_variable();
   init_jsonc_parser();
   init_models_dev_cache();
+  init_window_geometry();
   import_comment_json7 = __toESM(require_src3(), 1);
 });
 
@@ -41040,9 +41574,9 @@ var init_redaction2 = __esm(() => {
 
 // src/commands/doctor-omp.ts
 import { execFileSync as execFileSync5, spawnSync as spawnSync4 } from "node:child_process";
-import { existsSync as existsSync23, mkdirSync as mkdirSync8, readFileSync as readFileSync15 } from "node:fs";
+import { existsSync as existsSync24, mkdirSync as mkdirSync9, readFileSync as readFileSync15 } from "node:fs";
 import { createRequire as createRequire2 } from "node:module";
-import { dirname as dirname12, join as join20, resolve as resolve5 } from "node:path";
+import { dirname as dirname13, join as join20, resolve as resolve5 } 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;
@@ -41084,7 +41618,7 @@ function selfVersion() {
   return "unknown";
 }
 function readConfig2(path6) {
-  if (!existsSync23(path6))
+  if (!existsSync24(path6))
     return {};
   try {
     const parsed = import_comment_json8.parse(readFileSync15(path6, "utf-8"));
@@ -41178,7 +41712,7 @@ async function runHealthChecks(options) {
     }
   }
   const userConfigPath = getOmpUserConfigPath();
-  if (!existsSync23(userConfigPath)) {
+  if (!existsSync24(userConfigPath)) {
     add(results, "warn", `No Magic Context user config at ${userConfigPath}`);
     repairPlan.writeUserConfig = true;
   } else {
@@ -41195,7 +41729,7 @@ async function runHealthChecks(options) {
     for (const warning of loaded.warnings.slice(0, 5))
       add(results, "warn", warning);
   const dbPath = join20(getMagicContextStorageDir(), "context.db");
-  if (!existsSync23(dbPath))
+  if (!existsSync24(dbPath))
     add(results, "info", `Shared context DB will be created at ${dbPath}`);
   else {
     let db = null;
@@ -41224,7 +41758,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     add(results, "info", `OMP non-global config: ${source}`);
   }
   const logPath = getMagicContextLogPath2("pi");
-  add(results, "info", `Pi-compatible runtime log: ${logPath}${existsSync23(logPath) ? "" : " (not created yet)"}`);
+  add(results, "info", `Pi-compatible runtime log: ${logPath}${existsSync24(logPath) ? "" : " (not created yet)"}`);
   if (!options.quiet)
     for (const result of results)
       printResult(options.prompts, result);
@@ -41237,7 +41771,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   };
 }
 function writeDefaultConfig(path6) {
-  mkdirSync8(dirname12(path6), { recursive: true });
+  mkdirSync9(dirname13(path6), { recursive: true });
   const config2 = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
@@ -41247,7 +41781,7 @@ function writeDefaultConfig(path6) {
 }
 async function repair(plan, deps, prompts, cwd) {
   let fixed = 0;
-  if (plan.writeUserConfig && !existsSync23(getOmpUserConfigPath())) {
+  if (plan.writeUserConfig && !existsSync24(getOmpUserConfigPath())) {
     writeDefaultConfig(getOmpUserConfigPath());
     prompts.log.success(`Wrote default Magic Context config to ${getOmpUserConfigPath()}`);
     fixed += 1;
@@ -41510,14 +42044,14 @@ var DEFAULT_TIMEOUT_MS = 1e4, MAX_PREVIEW_CHARS = 240;
 // ../plugin/src/shared/tui-config.ts
 import {
   chmodSync as chmodSync4,
-  existsSync as existsSync24,
-  mkdirSync as mkdirSync9,
+  existsSync as existsSync25,
+  mkdirSync as mkdirSync10,
   readFileSync as readFileSync16,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   statSync as statSync9,
   writeFileSync as writeFileSync6
 } from "node:fs";
-import { dirname as dirname13, join as join21 } from "node:path";
+import { dirname as dirname14, join as join21 } from "node:path";
 function pluginEntryId(entry) {
   if (typeof entry === "string")
     return entry;
@@ -41554,15 +42088,15 @@ function writeTuiConfigAtomic(configPath, config2) {
       chmodSync4(tmpPath, statSync9(configPath).mode & 511);
     }
   } catch {}
-  renameSync4(tmpPath, configPath);
+  renameSync5(tmpPath, configPath);
 }
 function resolveTuiConfigPath(configDirOverride) {
   const configDir = configDirOverride ?? getOpenCodeConfigPaths({ binary: "opencode" }).configDir;
   const jsoncPath = join21(configDir, "tui.jsonc");
   const jsonPath = join21(configDir, "tui.json");
-  if (existsSync24(jsoncPath))
+  if (existsSync25(jsoncPath))
     return jsoncPath;
-  if (existsSync24(jsonPath))
+  if (existsSync25(jsonPath))
     return jsonPath;
   return jsoncPath;
 }
@@ -41570,7 +42104,7 @@ function ensureTuiPluginEntry(options = {}) {
   try {
     const configPath = resolveTuiConfigPath(options.configDir);
     let config2 = {};
-    if (existsSync24(configPath)) {
+    if (existsSync25(configPath)) {
       const raw = readFileSync16(configPath, "utf-8");
       config2 = import_comment_json9.parse(raw) ?? {};
     }
@@ -41605,7 +42139,7 @@ function ensureTuiPluginEntry(options = {}) {
       }
     }
     config2.plugin = plugins;
-    mkdirSync9(dirname13(configPath), { recursive: true });
+    mkdirSync10(dirname14(configPath), { recursive: true });
     writeTuiConfigAtomic(configPath, config2);
     log3(`[magic-context] updated TUI plugin entry in ${configPath}`);
     return true;
@@ -41623,7 +42157,7 @@ var init_tui_config = __esm(() => {
 });
 
 // src/lib/diagnostics-opencode.ts
-import { existsSync as existsSync25, readdirSync as readdirSync3, readFileSync as readFileSync17, statSync as statSync10 } from "node:fs";
+import { existsSync as existsSync26, readdirSync as readdirSync3, readFileSync as readFileSync17, statSync as statSync10 } from "node:fs";
 import { createRequire as createRequire3 } from "node:module";
 import { homedir as homedir15 } from "node:os";
 import { join as join22 } from "node:path";
@@ -41644,7 +42178,7 @@ function getPluginCacheInfo() {
   let cached2;
   for (const installedPkgPath of getOpenCodePluginPackageJsonPaths()) {
     try {
-      if (existsSync25(installedPkgPath)) {
+      if (existsSync26(installedPkgPath)) {
         const pkg = JSON.parse(readFileSync17(installedPkgPath, "utf-8"));
         cached2 = typeof pkg.version === "string" ? pkg.version : undefined;
         if (cached2)
@@ -41662,7 +42196,7 @@ function getStorageDir() {
 }
 function fileSize(path6) {
   try {
-    return existsSync25(path6) ? statSync10(path6).size : 0;
+    return existsSync26(path6) ? statSync10(path6).size : 0;
   } catch {
     return 0;
   }
@@ -41674,7 +42208,7 @@ function sanitizeValue(value) {
   return sanitizeConfigValue(value);
 }
 function readConfig3(path6) {
-  if (!existsSync25(path6))
+  if (!existsSync26(path6))
     return { value: null };
   try {
     const raw = readFileSync17(path6, "utf-8");
@@ -41735,7 +42269,7 @@ function parseHistorianDumpMeta(path6) {
   }
 }
 function listDumpsInDir(dir, limit) {
-  if (!existsSync25(dir))
+  if (!existsSync26(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync3(dir).filter((name) => name.endsWith(".xml")).map((name) => {
@@ -41805,7 +42339,7 @@ function collectHistorianDumps(recentSessions) {
 async function collectRecentSessions() {
   const dataHome = process.env.XDG_DATA_HOME || join22(process.env.HOME || homedir15(), ".local", "share");
   const opencodeDbPath = join22(dataHome, "opencode", "opencode.db");
-  if (!existsSync25(opencodeDbPath))
+  if (!existsSync26(opencodeDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -41840,7 +42374,7 @@ async function collectRecentSessions() {
 }
 async function collectHistorianFailures(storageDirPath) {
   const contextDbPath = join22(storageDirPath, "context.db");
-  if (!existsSync25(contextDbPath))
+  if (!existsSync26(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined") {
     return [];
@@ -41874,7 +42408,7 @@ async function collectHistorianFailures(storageDirPath) {
 }
 async function collectHistorianRuns(storageDirPath) {
   const contextDbPath = join22(storageDirPath, "context.db");
-  if (!existsSync25(contextDbPath))
+  if (!existsSync26(contextDbPath))
     return [];
   if (typeof globalThis.Bun === "undefined")
     return [];
@@ -41945,7 +42479,7 @@ async function collectDiagnostics() {
   const storageDirPath = getStorageDir();
   const contextDbPath = join22(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("opencode");
-  const logFileSize = existsSync25(logPath) ? statSync10(logPath).size : 0;
+  const logFileSize = existsSync26(logPath) ? statSync10(logPath).size : 0;
   let compactionEnabled = false;
   try {
     compactionEnabled = isCompactionEnabled(loadPluginConfig(process.cwd()));
@@ -41973,14 +42507,14 @@ async function collectDiagnostics() {
     opencodeConfigHasPlugin: configHasPluginEntry(opencodeConfig.value),
     tuiConfigHasPlugin: configHasPluginEntry(tuiConfig.value),
     magicContextConfig: {
-      exists: existsSync25(configPaths.magicContextConfig),
+      exists: existsSync26(configPaths.magicContextConfig),
       ...magicContextConfig.error ? { parseError: magicContextConfig.error } : {},
       flags: sanitizeValue(magicContextConfig.value ?? {}) ?? {}
     },
     pluginCache: getPluginCacheInfo(),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync25(storageDirPath),
+      exists: existsSync26(storageDirPath),
       contextDbSizeBytes: fileSize(contextDbPath)
     },
     conflicts: {
@@ -41991,7 +42525,7 @@ async function collectDiagnostics() {
     },
     logFile: {
       path: logPath,
-      exists: existsSync25(logPath),
+      exists: existsSync26(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     recentSessions,
@@ -42144,9 +42678,9 @@ var init_diagnostics_opencode = __esm(() => {
 
 // src/lib/embedding-runtime.ts
 import { spawnSync as spawnSync5 } from "node:child_process";
-import { existsSync as existsSync26 } from "node:fs";
+import { existsSync as existsSync27 } from "node:fs";
 import { createRequire as createRequire4 } from "node:module";
-import { dirname as dirname14, join as join23, sep } from "node:path";
+import { dirname as dirname15, join as join23, sep } from "node:path";
 function describeError(error51) {
   const message = error51 instanceof Error ? error51.message : String(error51 ?? "unknown error");
   const code = error51?.code;
@@ -42259,7 +42793,7 @@ function expectedBinaryRelPath(platform, arch) {
 }
 function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform, arch = process.arch) {
   const packageDir = join23(installRoot, "node_modules", "onnxruntime-node");
-  if (!existsSync26(join23(packageDir, "package.json"))) {
+  if (!existsSync27(join23(packageDir, "package.json"))) {
     return { state: "package-missing", packageDir };
   }
   const rel = expectedBinaryRelPath(platform, arch);
@@ -42267,13 +42801,13 @@ function checkLocalEmbeddingRuntimeAt(installRoot, platform = process.platform,
     return probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath: packageDir };
   }
   const binaryPath = join23(packageDir, rel);
-  if (!existsSync26(binaryPath)) {
+  if (!existsSync27(binaryPath)) {
     return { state: "binary-missing", packageDir, expectedBinary: binaryPath };
   }
   return probeOnnxRuntimeNodeLoad(packageDir) ?? { state: "ok", binaryPath };
 }
 function checkLocalEmbeddingRuntime(installRoots, platform = process.platform, arch = process.arch) {
-  const existing = installRoots.filter((root) => existsSync26(root));
+  const existing = installRoots.filter((root) => existsSync27(root));
   if (existing.length === 0) {
     return {
       state: "unknown",
@@ -42293,10 +42827,10 @@ 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) : dirname14(resolvedPath);
+  return idx >= 0 ? resolvedPath.slice(0, idx + marker.length) : dirname15(resolvedPath);
 }
 function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.platform, arch = process.arch) {
-  if (!existsSync26(join23(pluginDir, "package.json"))) {
+  if (!existsSync27(join23(pluginDir, "package.json"))) {
     return { state: "unknown", reason: "plugin package dir not found" };
   }
   let onnxDir = null;
@@ -42332,7 +42866,7 @@ function checkLocalEmbeddingRuntimeByResolution(pluginDir, platform = process.pl
     return probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath: onnxDir };
   }
   const binaryPath = join23(onnxDir, rel);
-  if (!existsSync26(binaryPath)) {
+  if (!existsSync27(binaryPath)) {
     return { state: "binary-missing", packageDir: onnxDir, expectedBinary: binaryPath };
   }
   return probeOnnxRuntimeNodeLoad(onnxDir) ?? { state: "ok", binaryPath };
@@ -42927,11 +43461,11 @@ var init_storage_versions = __esm(async () => {
 });
 
 // src/commands/doctor-opencode-cache.ts
-import { existsSync as existsSync27, readFileSync as readFileSync19, rmSync as rmSync3 } from "node:fs";
+import { existsSync as existsSync28, readFileSync as readFileSync19, rmSync as rmSync3 } from "node:fs";
 function readCachedPluginVersion(pluginCacheDir) {
   try {
     const installedPkgPath = getOpenCodePluginPackageJsonPath(pluginCacheDir);
-    if (!existsSync27(installedPkgPath))
+    if (!existsSync28(installedPkgPath))
       return;
     const pkg = JSON.parse(readFileSync19(installedPkgPath, "utf-8"));
     return typeof pkg.version === "string" ? pkg.version : undefined;
@@ -42942,7 +43476,7 @@ function readCachedPluginVersion(pluginCacheDir) {
 async function clearPluginCache(options = {}, deps = {}) {
   const remove = deps.remove ?? ((path6) => rmSync3(path6, { recursive: true, force: true }));
   const pluginCacheRoots = getOpenCodePluginCacheRoots();
-  const existingRoots = pluginCacheRoots.filter((root) => existsSync27(root));
+  const existingRoots = pluginCacheRoots.filter((root) => existsSync28(root));
   if (existingRoots.length === 0) {
     return { action: "not_found", path: pluginCacheRoots[0] ?? "" };
   }
@@ -43010,7 +43544,7 @@ var init_doctor_opencode_cache = __esm(() => {
 
 // src/commands/doctor-opencode.ts
 import { execSync as execSync2, spawnSync as spawnSync6 } from "node:child_process";
-import { existsSync as existsSync28, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
+import { existsSync as existsSync29, readFileSync as readFileSync20, statSync as statSync11 } from "node:fs";
 import { createRequire as createRequire5 } from "node:module";
 import { homedir as homedir16 } from "node:os";
 import { join as join25 } from "node:path";
@@ -43117,7 +43651,7 @@ function getUserNpmrcPath() {
 function collectNpmReleaseAgeWarnings() {
   const ageWarnings = [];
   const npmrcPath = getUserNpmrcPath();
-  if (!existsSync28(npmrcPath))
+  if (!existsSync29(npmrcPath))
     return ageWarnings;
   try {
     const npmrc = readFileSync20(npmrcPath, "utf-8");
@@ -43259,7 +43793,7 @@ function checkLocalEmbeddingRuntimeForDoctor() {
   return { issues: 0 };
 }
 async function checkEmbeddingConfig(magicContextConfigPath) {
-  if (!existsSync28(magicContextConfigPath)) {
+  if (!existsSync29(magicContextConfigPath)) {
     return checkLocalEmbeddingRuntimeForDoctor();
   }
   let rawText;
@@ -43470,7 +44004,7 @@ async function runDoctor2(options = {}) {
   } else {
     pass(`OpenCode config: ${paths.opencodeConfig}`);
   }
-  if (existsSync28(paths.magicContextConfig)) {
+  if (existsSync29(paths.magicContextConfig)) {
     pass(`Magic Context config: ${paths.magicContextConfig}`);
     try {
       const raw = readFileSync20(paths.magicContextConfig, "utf-8");
@@ -43498,7 +44032,7 @@ async function runDoctor2(options = {}) {
     warn(`No magic-context.jsonc found — using defaults`);
     log2.info("  Run 'setup' to create one with model recommendations");
   }
-  if (existsSync28(paths.magicContextConfig)) {
+  if (existsSync29(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync20(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json11.parse(mcRaw);
@@ -43674,6 +44208,7 @@ async function runDoctor2(options = {}) {
   const cwd = process.cwd();
   const compactionEnabled = resolveCompactionEnabledForDoctor();
   const conflictResult = detectConflicts(cwd, { compactionEnabled });
+  log2.info("Compaction check: file-based; the running server's resolved config may differ — `opencode debug config` is authoritative");
   if (conflictResult.hasConflict) {
     for (const reason of conflictResult.reasons) {
       fail(`Conflict: ${reason}`);
@@ -43702,7 +44237,7 @@ async function runDoctor2(options = {}) {
     pass("Added TUI sidebar plugin to tui.json");
     warn("Restart OpenCode to see the sidebar");
     fixed++;
-  } else if (existsSync28(paths.tuiConfig)) {
+  } else if (existsSync29(paths.tuiConfig)) {
     try {
       const tuiRaw = readFileSync20(paths.tuiConfig, "utf-8");
       const tuiConfig = import_comment_json11.parse(tuiRaw);
@@ -43753,7 +44288,7 @@ async function runDoctor2(options = {}) {
   } else {
     fail("Could not create or verify the TUI sidebar config");
   }
-  if (existsSync28(paths.magicContextConfig)) {
+  if (existsSync29(paths.magicContextConfig)) {
     try {
       const mcRaw = readFileSync20(paths.magicContextConfig, "utf-8");
       const mcConfig = import_comment_json11.parse(mcRaw);
@@ -43773,7 +44308,7 @@ async function runDoctor2(options = {}) {
   else
     passCount++;
   const dbPath = join25(getMagicContextStorageDir(), "context.db");
-  if (!existsSync28(dbPath)) {
+  if (!existsSync29(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}`);
@@ -43880,7 +44415,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     }
   }
   const logPath = getMagicContextLogPath2("opencode");
-  if (existsSync28(logPath)) {
+  if (existsSync29(logPath)) {
     const logStat = statSync11(logPath);
     const sizeKb = (logStat.size / 1024).toFixed(0);
     log2.info(`Log file: ${logPath} (${sizeKb} KB)`);
@@ -43960,8 +44495,8 @@ var init_doctor_opencode = __esm(async () => {
 });
 
 // src/lib/diagnostics-pi.ts
-import { createHash as createHash4 } from "node:crypto";
-import { existsSync as existsSync29, readdirSync as readdirSync4, readFileSync as readFileSync21, statSync as statSync12 } from "node:fs";
+import { createHash as createHash5 } from "node:crypto";
+import { existsSync as existsSync30, readdirSync as readdirSync4, readFileSync as readFileSync21, statSync as statSync12 } from "node:fs";
 import { createRequire as createRequire6 } from "node:module";
 import { homedir as homedir17, userInfo as userInfo2 } from "node:os";
 import { join as join26 } from "node:path";
@@ -43979,7 +44514,7 @@ function getSelfVersion3() {
 }
 function fileSize2(path6) {
   try {
-    return existsSync29(path6) ? statSync12(path6).size : 0;
+    return existsSync30(path6) ? statSync12(path6).size : 0;
   } catch {
     return 0;
   }
@@ -43989,7 +44524,7 @@ function escapeRegex3(value) {
 }
 function currentUserHash() {
   const username = userInfo2().username || "unknown";
-  return createHash4("sha256").update(username).digest("hex").slice(0, 12);
+  return createHash5("sha256").update(username).digest("hex").slice(0, 12);
 }
 function redactSecretString(value) {
   return redactSecretText(value).replace(/Bearer\s+[A-Za-z0-9._~+\-/=]+/g, "Bearer <REDACTED>").replace(/sk-[A-Za-z0-9_-]{12,}/g, "sk-<REDACTED>").replace(/api[_-]?key=([^\s&]+)/gi, "api_key=<REDACTED>").replace(/token=([^\s&]+)/gi, "token=<REDACTED>");
@@ -44031,7 +44566,7 @@ function sanitizeValue2(value, key = "") {
   return value;
 }
 function readJsonc(path6) {
-  if (!existsSync29(path6))
+  if (!existsSync30(path6))
     return { value: {} };
   try {
     return {
@@ -44051,7 +44586,7 @@ function readConfigDiagnostic(path6) {
   const parsed = readJsonc(path6);
   return {
     path: path6,
-    exists: existsSync29(path6),
+    exists: existsSync30(path6),
     ...parsed.parseError ? { parseError: parsed.parseError } : {},
     flags: sanitizeValue2(parsed.value)
   };
@@ -44069,7 +44604,7 @@ function reverseSlugToDirectory(slug) {
 }
 function collectPiRecentSessions() {
   const sessionsRoot = getPiSessionsRoot();
-  if (!existsSync29(sessionsRoot))
+  if (!existsSync30(sessionsRoot))
     return [];
   try {
     const slugs = readdirSync4(sessionsRoot, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => entry.name);
@@ -44138,7 +44673,7 @@ function parseHistorianDumpMeta2(path6) {
   }
 }
 function listDumpsInDir2(dir, limit) {
-  if (!existsSync29(dir))
+  if (!existsSync30(dir))
     return { count: 0, recent: [] };
   try {
     const entries = readdirSync4(dir).filter((name) => name.endsWith(".xml")).map((name) => {
@@ -44216,7 +44751,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
   const storageDirPath = getMagicContextStorageDir();
   const dbPath = join26(storageDirPath, "context.db");
   const logPath = getMagicContextLogPath2("pi");
-  const logFileSize = existsSync29(logPath) ? statSync12(logPath).size : 0;
+  const logFileSize = existsSync30(logPath) ? statSync12(logPath).size : 0;
   const otherPiExtensions = packages.filter((entry) => !isPiMagicContextPackageEntry(entry)).map(describePiPackageEntry);
   const recentSessions = collectPiRecentSessions();
   const historianDumps = collectPiHistorianDumps(recentSessions);
@@ -44231,7 +44766,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     piVersion: pi ? getPiVersion(pi.path) : null,
     settings: {
       path: settingsPath,
-      exists: existsSync29(settingsPath),
+      exists: existsSync30(settingsPath),
       ...settingsParsed.parseError ? { parseError: settingsParsed.parseError } : {},
       hasMagicContextPackage: hasPiMagicContextPackage(packages),
       packages: sanitizeValue2(packages)
@@ -44247,7 +44782,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     loadWarnings: loaded.warnings.map(sanitizeString2),
     storageDir: {
       path: storageDirPath,
-      exists: existsSync29(storageDirPath),
+      exists: existsSync30(storageDirPath),
       contextDbSizeBytes: fileSize2(dbPath)
     },
     conflicts: {
@@ -44256,7 +44791,7 @@ async function collectDiagnostics2(cwd = process.cwd()) {
     },
     logFile: {
       path: logPath,
-      exists: existsSync29(logPath),
+      exists: existsSync30(logPath),
       sizeKb: Math.round(logFileSize / 1024)
     },
     recentSessions,
@@ -44428,10 +44963,10 @@ var init_logs_pi = __esm(() => {
 
 // src/commands/doctor-pi.ts
 import { execFileSync as execFileSync6, spawnSync as spawnSync7 } from "node:child_process";
-import { existsSync as existsSync30, mkdirSync as mkdirSync10, readdirSync as readdirSync5, readFileSync as readFileSync23, rmSync as rmSync4, statSync as statSync13 } from "node:fs";
+import { existsSync as existsSync31, mkdirSync as mkdirSync11, readdirSync as readdirSync5, readFileSync as readFileSync23, rmSync as rmSync4, statSync as statSync13 } from "node:fs";
 import { createRequire as createRequire7 } from "node:module";
 import { homedir as homedir18 } from "node:os";
-import { dirname as dirname15, isAbsolute as isAbsolute4, join as join28 } from "node:path";
+import { dirname as dirname16, isAbsolute as isAbsolute4, join as join28 } from "node:path";
 function depsFrom(options) {
   return {
     ...DEFAULT_DEPS3,
@@ -44545,13 +45080,13 @@ function piPluginDirCandidates(packages, cwd) {
   }
   dirs.push(join28(agentDir, "npm", "node_modules", PACKAGE_NAME));
   dirs.push(join28(cwd, ".pi", "npm", "node_modules", PACKAGE_NAME));
-  return dirs.filter((dir) => existsSync30(join28(dir, "package.json")));
+  return dirs.filter((dir) => existsSync31(join28(dir, "package.json")));
 }
 function projectConfigPath(cwd) {
   return resolveCortexKitProjectConfigPath(cwd);
 }
 function readConfigForEmbedding(path6, isProjectConfig) {
-  if (!existsSync30(path6))
+  if (!existsSync31(path6))
     return null;
   try {
     const rawText = readFileSync23(path6, "utf-8");
@@ -44647,7 +45182,7 @@ function cacheRoots(cwd) {
 function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
   const found = new Map;
   const visit = (path6, depth) => {
-    if (depth < 0 || !existsSync30(path6))
+    if (depth < 0 || !existsSync31(path6))
       return;
     let stat;
     try {
@@ -44658,7 +45193,7 @@ function findPiMagicContextCacheDirs(cwd, expectedVersion, force = false) {
     if (!stat.isDirectory())
       return;
     const packageJson = join28(path6, "package.json");
-    if (existsSync30(packageJson)) {
+    if (existsSync31(packageJson)) {
       try {
         const pkg = JSON.parse(readFileSync23(packageJson, "utf-8"));
         const name = typeof pkg.name === "string" ? pkg.name : "";
@@ -44725,7 +45260,7 @@ async function runHealthChecks2(options) {
   }
   const settingsPath = getPiUserExtensionsPath();
   let packages = [];
-  if (!existsSync30(settingsPath)) {
+  if (!existsSync31(settingsPath)) {
     add2(results, "fail", `Pi settings not found at ${settingsPath}`);
     repairPlan.addPackageEntry = true;
   } else {
@@ -44749,7 +45284,7 @@ async function runHealthChecks2(options) {
     ["user", userConfigPath, true],
     ["project", projectPath, false]
   ]) {
-    if (!existsSync30(path6)) {
+    if (!existsSync31(path6)) {
       if (required2) {
         add2(results, "warn", `No ${label} magic-context.jsonc found at ${path6}`);
         if (userConfigMigrationRefused) {
@@ -44787,7 +45322,7 @@ async function runHealthChecks2(options) {
   }
   const storageDir = getMagicContextStorageDir();
   const dbPath = join28(storageDir, "context.db");
-  const existedBeforeOpen = existsSync30(dbPath);
+  const existedBeforeOpen = existsSync31(dbPath);
   if (existedBeforeOpen)
     add2(results, "pass", `Shared context DB exists at ${dbPath}`);
   else
@@ -44924,7 +45459,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
     add2(results, "pass", "Pi extension cache clean (no stale cached package found)");
   }
   const logPath = getMagicContextLogPath2("pi");
-  if (existsSync30(logPath)) {
+  if (existsSync31(logPath)) {
     const stat = statSync13(logPath);
     const sizeKb = (stat.size / 1024).toFixed(0);
     const lines = readFileSync23(logPath, "utf-8").split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
@@ -44962,7 +45497,7 @@ ${formatDatabaseRepairGuidance(dbPath)}`);
   return { results, repairPlan, ...summarize(results) };
 }
 function writeDefaultMagicContextConfig(path6) {
-  mkdirSync10(dirname15(path6), { recursive: true });
+  mkdirSync11(dirname16(path6), { recursive: true });
   const config2 = {
     $schema: "https://raw.githubusercontent.com/cortexkit/magic-context/master/assets/magic-context.schema.json",
     ...MagicContextConfigSchema.parse({})
@@ -44984,7 +45519,7 @@ function repair2(plan, prompts) {
   }
   if (plan.writeUserConfig) {
     const configPath = getPiUserConfigPath();
-    if (!existsSync30(configPath)) {
+    if (!existsSync31(configPath)) {
       try {
         writeDefaultMagicContextConfig(configPath);
         prompts.log.success(`Wrote default Magic Context config to ${configPath}`);
@@ -45216,7 +45751,7 @@ var exports_doctor = {};
 __export(exports_doctor, {
   runDoctor: () => runDoctor4
 });
-import { existsSync as existsSync31, rmSync as rmSync5 } from "node:fs";
+import { existsSync as existsSync32, rmSync as rmSync5 } from "node:fs";
 import { join as join29 } from "node:path";
 async function runDoctor4(options) {
   if (options.clear)
@@ -45248,6 +45783,27 @@ async function runDoctor4(options) {
     if (result.handled)
       return result.exitCode;
   }
+  const { sweepPendingMigrations: sweepPendingMigrations2, formatMigrationSweepLines: formatMigrationSweepLines2 } = await init_migrate().then(() => exports_migrate);
+  const sweepDbPath = join29(getMagicContextStorageDir(), "context.db");
+  let sweepDb = null;
+  try {
+    sweepDb = openExistingContextDatabaseForMutation(sweepDbPath);
+  } catch {}
+  if (sweepDb !== null) {
+    try {
+      const report = sweepPendingMigrations2(sweepDb);
+      for (const line of formatMigrationSweepLines2(report)) {
+        if (line.startsWith("LOST"))
+          log2.error(line);
+        else
+          log2.info(line);
+      }
+    } catch (error51) {
+      log2.warn(`Session-migration recovery sweep failed: ${error51 instanceof Error ? error51.message : String(error51)}`);
+    } finally {
+      sweepDb.close();
+    }
+  }
   let anyFailure = false;
   for (const adapter of adapters) {
     log2.step(`Running doctor for ${adapter.displayName}…`);
@@ -45324,7 +45880,7 @@ async function runClear() {
     const s = spinner2();
     s.start(`Clearing ${item.path}`);
     try {
-      if (existsSync31(item.path)) {
+      if (existsSync32(item.path)) {
         rmSync5(item.path, { recursive: true, force: true });
       }
       s.stop(`Cleared ${item.path}`);
@@ -45340,9 +45896,9 @@ async function runClear() {
 function formatSize(bytes) {
   if (bytes < 1024)
     return `${bytes} B`;
-  if (bytes < 1024 * 1024)
+  if (bytes < 1048576)
     return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024)
+  if (bytes < 1073741824)
     return `${(bytes / 1024 / 1024).toFixed(1)} MB`;
   return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
 }