@cortexkit/pi-magic-context 0.45.0 → 0.46.1

package/dist/{index-k0yd1ph9.js → index-4vfrjwf6.js}

@@ -8,14 +8,17 @@ import {
   log
 } from "./index-7n8gb6j3.js";
 import {
+  closeQuietly,
+  ensureColumn,
+  healAllNullColumns,
+  installV95PerfSchema,
   resolveOpenCodeDbPath,
   hasV1MessageTables,
   openCodeDbPathExists,
   getOpenCodeDbProbeDescriptions,
-  closeQuietly,
   setDatabase,
   loadToolDefinitionMeasurements
-} from "./index-e16q5sd7.js";
+} from "./index-td885aah.js";
 import {
   registerSlowWriteReporter,
   registerSqliteDiagnosticSink,
@@ -25,13 +28,19 @@ import {
   withoutSqliteTransformPass,
   isTransientSqliteError,
   withPrivilegedWriter
-} from "./index-2pbbk3en.js";
+} from "./index-wv28nczk.js";
 import {
-  shouldEnforcePrivateStoragePermissions
-} from "./index-4d3cba70.js";
+  shouldEnforcePrivateStoragePermissions,
+  ensureStorageDirectorySync,
+  writeStorageFileSync,
+  writeStorageFileAtomicSync,
+  copyStorageFileSync,
+  copyStorageTreeSync,
+  tightenStorageTreeSync
+} from "./index-vf38qhee.js";
 import {
   logSlowWriteTransaction
-} from "./index-7s5yk3za.js";
+} from "./index-2p1e8706.js";
 
 // ../plugin/src/features/magic-context/fail-closed-block.ts
 var FAIL_CLOSED_DOCTOR_COMMAND = "npx @cortexkit/magic-context@latest doctor";
@@ -265,8 +274,8 @@ import { homedir } from "node:os";
 import path3 from "node:path";
 
 // ../plugin/src/features/magic-context/memory/project-identity-cache.ts
-import { createHash, randomUUID } from "node:crypto";
-import { mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { createHash } from "node:crypto";
+import { readFileSync } from "node:fs";
 import path2 from "node:path";
 
 // ../plugin/src/shared/project-directory-key.ts
@@ -287,10 +296,7 @@ function cachePath(directory, storageDir = getMagicContextStorageDir()) {
 function rememberGitIdentity(directory, identity) {
   try {
     const destination = cachePath(directory);
-    mkdirSync(path2.dirname(destination), { recursive: true });
-    const temporary = `${destination}.${randomUUID()}.tmp`;
-    writeFileSync(temporary, JSON.stringify({ directory: projectDirectoryKey(directory), identity }), { mode: 384 });
-    renameSync(temporary, destination);
+    writeStorageFileAtomicSync(destination, JSON.stringify({ directory: projectDirectoryKey(directory), identity }));
   } catch {}
 }
 function readRememberedGitIdentity(directory, storageDir) {
@@ -1591,100 +1597,6 @@ function installCompartmentHistoryVersions(db) {
   }).immediate();
 }
 
-// ../plugin/src/features/magic-context/storage-schema-helpers.ts
-function ensureColumn(db, table, column, definition) {
-  if (!/^[a-z][a-z0-9_]*$/.test(table) || !/^[a-z][a-z0-9_]*$/.test(column) || !/^[A-Z0-9_"'(),[\]\s]+$/i.test(definition)) {
-    throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
-  }
-  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
-  if (rows.some((row) => row.name === column)) {
-    return;
-  }
-  try {
-    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
-  } catch (err) {
-    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
-    if (recheck.some((row) => row.name === column)) {
-      return;
-    }
-    throw err;
-  }
-}
-function healAllNullColumns(db) {
-  const existingColumns = getSessionMetaColumns(db);
-  const fallbacks = [
-    ["cache_ttl", ""],
-    ["last_nudge_band", ""],
-    ["last_nudge_level", ""],
-    ["channel2_nudge_claim_token", ""],
-    ["last_transform_error", ""],
-    ["nudge_anchor_message_id", ""],
-    ["nudge_anchor_text", ""],
-    ["sticky_turn_reminder_text", ""],
-    ["sticky_turn_reminder_message_id", ""],
-    ["note_nudge_trigger_message_id", ""],
-    ["note_nudge_sticky_text", ""],
-    ["note_nudge_sticky_message_id", ""],
-    ["last_todo_state", ""],
-    ["todo_synthetic_call_id", ""],
-    ["todo_synthetic_anchor_message_id", ""],
-    ["todo_synthetic_state_json", ""],
-    ["system_prompt_hash", ""],
-    ["stripped_placeholder_ids", ""],
-    ["stale_reduce_stripped_ids", ""],
-    ["processed_image_stripped_ids", ""],
-    ["merged_reasoning_stripped_ids", ""],
-    ["thinking_binding_recovery_target", ""],
-    ["trailing_blank_decisions", ""],
-    ["memory_block_cache", ""],
-    ["memory_block_ids", ""],
-    ["compaction_marker_state", ""],
-    ["key_files", ""],
-    ["times_execute_threshold_reached", 0],
-    ["compartment_in_progress", 0],
-    ["historian_failure_count", 0],
-    ["cleared_reasoning_through_tag", 0],
-    ["memory_block_count", 0],
-    ["system_prompt_tokens", 0],
-    ["conversation_tokens", 0],
-    ["tool_call_tokens", 0],
-    ["note_nudge_trigger_pending", 0],
-    ["observed_safe_input_tokens", 0],
-    ["cache_alert_sent", 0],
-    ["new_work_tokens", 0],
-    ["total_input_tokens", 0],
-    ["last_emergency_input_sample", 0],
-    ["channel2_nudge_claimed_at", 0],
-    ["last_usage_context_limit", 0],
-    ["prior_boundary_ordinal", 1],
-    ["protected_tail_policy_version", 0],
-    ["protected_tail_drain_window_started_at", 0],
-    ["protected_tail_drain_tokens", 0],
-    ["recovery_no_eligible_head_count", 0],
-    ["force_emergency_bypass_window_start", 0],
-    ["force_emergency_bypass_used", 0],
-    ["emergency_drain_active", 0],
-    ["historian_drain_failure_at", 0]
-  ];
-  const presentFallbacks = fallbacks.filter(([column]) => existingColumns.has(column));
-  if (presentFallbacks.length > 0) {
-    const assignments = presentFallbacks.map(([column]) => `${column} = COALESCE(${column}, ?)`).join(", ");
-    const nullPredicate = presentFallbacks.map(([column]) => `${column} IS NULL`).join(" OR ");
-    db.prepare(`UPDATE session_meta SET ${assignments} WHERE ${nullPredicate}`).run(...presentFallbacks.map(([, fallback]) => fallback));
-  }
-  healMissingMemoryBlockIds(db, existingColumns);
-}
-function getSessionMetaColumns(db) {
-  const rows = db.prepare("PRAGMA table_info(session_meta)").all();
-  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
-}
-function healMissingMemoryBlockIds(db, columns) {
-  if (!columns.has("memory_block_cache") || !columns.has("memory_block_ids") || !columns.has("memory_block_count")) {
-    return;
-  }
-  db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0").run();
-}
-
 // ../plugin/src/features/magic-context/workspaces.ts
 import { createHash as createHash4 } from "node:crypto";
 var VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
@@ -4296,6 +4208,13 @@ var MIGRATIONS = [
       splitLkgSlotPrefixes(db);
       splitReplayDecisions(db);
     }
+  },
+  {
+    version: 95,
+    description: "cover cleanup and retention reads, index git FTS rowids and store temporal replay decisions",
+    up(db) {
+      installV95PerfSchema(db, true);
+    }
   }
 ];
 var LATEST_MIGRATION_VERSION = MIGRATIONS.reduce((max, m) => Math.max(max, m.version), 0);
@@ -4323,6 +4242,9 @@ function hasPendingMigrations(db) {
   return MIGRATIONS.some((candidate) => candidate.version > currentVersion && !isMigrationApplied(db, candidate.version));
 }
 var mainThreadMigrationBodies = 0;
+function getMainThreadMigrationBodyCount() {
+  return mainThreadMigrationBodies;
+}
 function isSiblingMigrationConflict(db, error, version) {
   if (!(error instanceof Error))
     return false;
@@ -4453,11 +4375,7 @@ function scheduleAfterBootQuiet(task, additionalDelayMs = 0) {
 
 // ../plugin/src/features/magic-context/storage-db.ts
 import {
-  chmodSync,
-  copyFileSync,
-  cpSync,
   existsSync as existsSync3,
-  mkdirSync as mkdirSync2,
   readdirSync,
   readFileSync as readFileSync3,
   rmdirSync,
@@ -5249,8 +5167,20 @@ function inspectWindowsProcessesSync() {
   };
 }
 
+// ../plugin/src/shared/sqlite-context-pragmas.ts
+function configureContextDatabasePragmas(db, readonly = false) {
+  const [row] = db.prepare(readonly ? "PRAGMA journal_mode" : "PRAGMA journal_mode=WAL").all();
+  const mode = row?.journal_mode?.toLowerCase();
+  if (mode === "memory" || readonly && mode !== "wal")
+    return;
+  if (mode !== "wal") {
+    throw new Error(`context.db requires WAL before synchronous=NORMAL (got ${mode ?? "unknown"})`);
+  }
+  db.exec("PRAGMA synchronous=NORMAL");
+}
+
 // ../plugin/src/features/magic-context/context-store-uuid.ts
-import { randomUUID as randomUUID2 } from "node:crypto";
+import { randomUUID } from "node:crypto";
 function getContextStoreUuid(db) {
   const row = db.prepare("SELECT value FROM context_store_meta WHERE key = 'store_uuid'").get();
   return typeof row?.value === "string" && row.value.length > 0 ? row.value : null;
@@ -5259,7 +5189,7 @@ function ensureContextStoreUuid(db) {
   const existing = getContextStoreUuid(db);
   if (existing)
     return existing;
-  const minted = randomUUID2();
+  const minted = randomUUID();
   withPrivilegedWriter(db, () => {
     db.transaction(() => {
       db.prepare("INSERT INTO context_store_meta(key, value) VALUES ('store_uuid', ?) ON CONFLICT(key) DO NOTHING").run(minted);
@@ -5516,6 +5446,9 @@ function startBootDeadline(timeoutMs, onDeferred) {
 }
 
 // ../plugin/src/features/magic-context/migration-worker-client.ts
+function workerStartError(detail) {
+  return new Error(`the migration worker could not start (${detail}); reinstall or rebuild the plugin`);
+}
 function defaultWorkerEntry() {
   return new URL(new URL(import.meta.url).pathname.endsWith(".ts") ? "./migration-worker.ts" : "./migration-worker.js", import.meta.url);
 }
@@ -5526,8 +5459,7 @@ function runMigrationsOffThread(data) {
     try {
       worker = new Worker(workerEntryOverride ?? defaultWorkerEntry(), { workerData: data });
     } catch (error) {
-      log(`[migrations] could not start the migration worker (${error instanceof Error ? error.message : String(error)}); applying migrations on the main thread`);
-      resolve("worker_unavailable");
+      reject(workerStartError(error instanceof Error ? error.message : String(error)));
       return;
     }
     log(`[migrations] applying pending migrations on a worker thread: ${data.dbPath}`);
@@ -5551,14 +5483,14 @@ function runMigrationsOffThread(data) {
     };
     const unavailable = (detail) => {
       settle(() => {
-        log(`[migrations] the migration worker did not start (${detail}); applying migrations on the main thread`);
-        resolve("worker_unavailable");
+        reject(workerStartError(detail));
       });
     };
     worker.on("message", (message) => {
       switch (message.type) {
         case "ready":
           ready = true;
+          log(`[migrations] migration worker ready: ${data.dbPath}`);
           return;
         case "log":
           writeForwardedLogLine(message.line);
@@ -5568,9 +5500,17 @@ function runMigrationsOffThread(data) {
             setBusy(!message.waiting);
           return;
         case "done":
+          if (!ready) {
+            unavailable("reported completion before ready");
+            return;
+          }
           settle(() => resolve("migrated"));
           return;
         case "failed":
+          if (!ready) {
+            unavailable(message.message);
+            return;
+          }
           settle(() => reject(new Error(message.message)));
           return;
       }
@@ -5869,38 +5809,14 @@ function getSchemaFenceRejection() {
 function getMigrationOnOpenRefusal() {
   return lastMigrationOnOpenRefusal;
 }
-var LATEST_SUPPORTED_VERSION = 94;
+var LATEST_SUPPORTED_VERSION = 95;
 var BOOT_SQLITE_BUSY_TIMEOUT_MS = 5000;
-var PERMISSIONS_ENFORCEABLE = process.platform !== "win32";
-var defaultStoragePermissionFs = { chmodSync, mkdirSync: mkdirSync2 };
-var storagePermissionFs = defaultStoragePermissionFs;
 function ensureSecureStorageDir(dir) {
-  if (!shouldEnforcePrivateStoragePermissions()) {
-    storagePermissionFs.mkdirSync(dir, { recursive: true });
-    return;
-  }
-  storagePermissionFs.mkdirSync(dir, { recursive: true, mode: 448 });
-  if (!PERMISSIONS_ENFORCEABLE)
-    return;
-  try {
-    storagePermissionFs.chmodSync(dir, 448);
-  } catch (error) {
-    log(`[magic-context] could not restrict storage dir permissions on ${dir}: ${getErrorMessage(error)}`);
-  }
+  ensureStorageDirectorySync(dir);
 }
-function restrictDatabaseFilePermissions(dbPath) {
-  if (!PERMISSIONS_ENFORCEABLE || !shouldEnforcePrivateStoragePermissions())
-    return;
-  for (const suffix of ["", "-wal", "-shm"]) {
-    const file = `${dbPath}${suffix}`;
-    if (!existsSync3(file))
-      continue;
-    try {
-      storagePermissionFs.chmodSync(file, 384);
-    } catch (error) {
-      log(`[magic-context] could not restrict DB file permissions on ${file}: ${getErrorMessage(error)}`);
-    }
-  }
+function tightenStorageTree(dir) {
+  const { failures } = tightenStorageTreeSync(dir);
+  log(`[magic-context] storage permission tightening failures=${failures}`);
 }
 function resolveBootBusyTimeoutMs(value) {
   if (value === undefined)
@@ -5939,6 +5855,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   try {
     const legacyDb = new Database(legacyDbPath);
     try {
+      configureContextDatabasePragmas(legacyDb, true);
       legacyDb.exec("PRAGMA wal_checkpoint(TRUNCATE)");
     } finally {
       closeQuietly(legacyDb);
@@ -5951,7 +5868,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
     const dst = join(targetDbDir, `context.db${suffix}`);
     if (existsSync3(src)) {
       try {
-        copyFileSync(src, dst);
+        copyStorageFileSync(src, dst);
       } catch (error) {
         log(`[magic-context] failed to copy ${src}:`, getErrorMessage(error));
       }
@@ -5961,7 +5878,7 @@ function migrateLegacyStorageIfNeeded(targetDbPath, targetDbDir) {
   const targetModelsDir = join(targetDbDir, "models");
   if (existsSync3(legacyModelsDir) && !existsSync3(targetModelsDir)) {
     try {
-      cpSync(legacyModelsDir, targetModelsDir, { recursive: true });
+      copyStorageTreeSync(legacyModelsDir, targetModelsDir);
     } catch (error) {
       log("[magic-context] failed to copy embedding model cache:", getErrorMessage(error));
     }
@@ -6326,8 +6243,8 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
       startMessageFtsRowidMapBackfill(db).then(async () => {
         if (!readsOpenCodeStore)
           return;
-        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-kmt7a6zj.js"));
-        const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-g83dkh8m.js"));
+        const { readRawSessionMessagePage, readRawSessionMessages } = await importPluginModule(() => import("./read-session-chunk-tc6yn2pe.js"));
+        const { startMessageTimeBackfill } = await importPluginModule(() => import("./message-time-backfill-4688z1k2.js"));
         await startMessageTimeBackfill(db, Object.assign(readRawSessionMessages, {
           readPage: readRawSessionMessagePage
         }));
@@ -6350,7 +6267,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
   }
   setDatabase(db);
   loadToolDefinitionMeasurements(db);
-  restrictDatabaseFilePermissions(dbPath);
+  tightenStorageTree(dirname(dbPath));
   databases.set(dbPath, db);
   pathByDatabase.set(db, dbPath);
   persistenceByDatabase.set(db, true);
@@ -6363,7 +6280,7 @@ function finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion)
 function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
   db.exec(`PRAGMA busy_timeout=${resolveBootBusyTimeoutMs(busyTimeoutMs)}`);
   db.exec("PRAGMA foreign_keys=ON");
-  db.exec("PRAGMA journal_mode=WAL");
+  configureContextDatabasePragmas(db);
   applySqliteTuningPragmas(db);
   db.exec(`
     CREATE TABLE IF NOT EXISTS tags (
@@ -6425,7 +6342,6 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       harness TEXT NOT NULL DEFAULT 'opencode',
       UNIQUE(session_id, sequence)
     );
-    CREATE INDEX IF NOT EXISTS idx_compartments_session ON compartments(session_id);
 
     CREATE TABLE IF NOT EXISTS compartment_chunk_embeddings (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -6486,7 +6402,6 @@ function initializeDatabase(db, busyTimeoutMs = BOOT_SQLITE_BUSY_TIMEOUT_MS) {
       harness TEXT NOT NULL DEFAULT 'opencode',
       PRIMARY KEY(session_id, message_ordinal)
     );
-    CREATE INDEX IF NOT EXISTS idx_compression_depth_session ON compression_depth(session_id);
 
     CREATE TABLE IF NOT EXISTS session_facts (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -6792,7 +6707,6 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       stale_reason           TEXT,
       PRIMARY KEY (project_path, path)
     );
-    CREATE INDEX IF NOT EXISTS idx_project_key_files_project ON project_key_files(project_path);
     CREATE INDEX IF NOT EXISTS idx_project_key_files_generated_at ON project_key_files(project_path, generated_at);
 
     CREATE TABLE IF NOT EXISTS project_key_files_version (
@@ -7177,10 +7091,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       input_tokens       INTEGER NOT NULL DEFAULT 0,
       PRIMARY KEY (session_id, harness, message_id)
     );
-    CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
-      ON transform_decisions(session_id, harness);
 
-    CREATE INDEX IF NOT EXISTS idx_tags_session_tag_number ON tags(session_id, tag_number);
     CREATE INDEX IF NOT EXISTS idx_tags_session_message_id ON tags(session_id, message_id);
 
     -- Clone/import paths can write tags before session bootstrap. Keep trigger-created
@@ -7226,9 +7137,7 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
       WHERE NEW.session_id != OLD.session_id
       ON CONFLICT(session_id) DO UPDATE SET tags_version = tags_version + 1;
     END;
-    CREATE INDEX IF NOT EXISTS idx_pending_ops_session ON pending_ops(session_id);
     CREATE INDEX IF NOT EXISTS idx_pending_ops_session_tag_id ON pending_ops(session_id, tag_id);
-    CREATE INDEX IF NOT EXISTS idx_source_contents_session ON source_contents(session_id);
     
     CREATE TABLE IF NOT EXISTS recomp_compartments (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
@@ -7581,8 +7490,6 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         input_tokens       INTEGER NOT NULL DEFAULT 0,
         PRIMARY KEY (session_id, harness, message_id)
       );
-      CREATE INDEX IF NOT EXISTS idx_transform_decisions_session_harness
-        ON transform_decisions(session_id, harness);
     `);
   ensureColumn(db, "transform_decisions", "system_hash_prev", "TEXT");
   ensureColumn(db, "transform_decisions", "system_hash_new", "TEXT");
@@ -7604,12 +7511,26 @@ CREATE INDEX IF NOT EXISTS idx_dream_queue_pending ON dream_queue(started_at, en
         ON message_history_index(harness, session_id, updated_at);
     `);
   ensureColumn(db, "workspaces", "share_categories", `TEXT NOT NULL DEFAULT '["CONSTRAINTS"]'`);
+  const version = getPersistedSchemaVersion(db);
+  if (version === 0 || version >= 95)
+    installV95PerfSchema(db, false, version === 0);
 }
 var CHANNEL2_CLAIM_TTL_MS = 10 * 60000;
+var channel2HealStatements = new WeakMap;
 function healWedgedChannel2Claims(db) {
   try {
     const staleBefore = Date.now() - CHANNEL2_CLAIM_TTL_MS;
-    db.prepare("UPDATE session_meta SET channel2_nudge_state = '', channel2_nudge_claimed_at = 0, channel2_nudge_claim_token = '' WHERE channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)").run(staleBefore);
+    let statements = channel2HealStatements.get(db);
+    if (!statements) {
+      const predicate = "channel2_nudge_state = 'claimed' AND (channel2_nudge_claimed_at IS NULL OR channel2_nudge_claimed_at = 0 OR channel2_nudge_claimed_at <= ?)";
+      statements = {
+        stale: db.prepare(`SELECT 1 FROM session_meta WHERE ${predicate} LIMIT 1`),
+        heal: db.prepare(`UPDATE session_meta SET channel2_nudge_state = '', channel2_nudge_claimed_at = 0, channel2_nudge_claim_token = '' WHERE ${predicate}`)
+      };
+      channel2HealStatements.set(db, statements);
+    }
+    if (statements.stale.get(staleBefore))
+      statements.heal.run(staleBefore);
   } catch {}
 }
 function openDatabase(dbPathOrOptions) {
@@ -7641,18 +7562,38 @@ function openDatabase(dbPathOrOptions) {
       migrateLegacyStorageIfNeeded(dbPath, dbDir);
     }
     ensureSecureStorageDir(dbDir);
+    tightenStorageTree(dbDir);
+    if (!existsSync3(dbPath) && shouldEnforcePrivateStoragePermissions()) {
+      try {
+        writeStorageFileSync(dbPath, new Uint8Array, { flag: "wx" });
+      } catch (error) {
+        if (error.code !== "EEXIST")
+          throw error;
+      }
+    }
     db = new Database(dbPath);
     installBootBusyTimeout(db, dbPath, busyTimeoutMs, options?.onBootBusyTimeout);
     if (!enforceSchemaFence(db, dbPath, latestSupportedVersion)) {
       closeQuietly(db);
       return null;
     }
+    if (options?.allowMigrations === false && hasPendingMigrations(db)) {
+      log(`[magic-context] storage not ready: pending migrations at ${dbPath}; host callers must await the async opener`);
+      closeQuietly(db);
+      return null;
+    }
     if (!enforceMigrationOnOpenGuard(db, dbPath, dbDir, latestSupportedVersion)) {
       closeQuietly(db);
       return null;
     }
     initializeDatabase(db, busyTimeoutMs);
-    runMigrations(db);
+    if (options?.allowMigrations === false) {
+      if (hasPendingMigrations(db)) {
+        closeQuietly(db);
+        return null;
+      }
+    } else
+      runMigrations(db);
     ensureContextStoreUuid(db);
     return finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion);
   } catch (error) {
@@ -7663,6 +7604,9 @@ function openDatabase(dbPathOrOptions) {
     throw new Error(`[magic-context] storage unavailable: ${detail}. Magic Context is disabled for this run; check log for details.`);
   }
 }
+function openCurrentDatabase(options = {}) {
+  return openDatabase({ ...options, allowMigrations: false });
+}
 async function openDatabaseAsync(dbPathOrOptions) {
   const options = typeof dbPathOrOptions === "string" ? { dbPath: dbPathOrOptions } : dbPathOrOptions;
   const explicitDbPath = options?.dbPath !== undefined;
@@ -7690,8 +7634,12 @@ async function openDatabaseAsync(dbPathOrOptions) {
   const pending = pendingAsyncOpens.get(dbPath);
   if (pending)
     return pending;
+  if (!isFileBackedPath(dbPath)) {
+    throw new Error("async migration requires a file-backed database; use the explicit synchronous opener for in-memory or URI test databases");
+  }
   const opening = (async () => {
     let db;
+    const mainThreadBodiesBefore = getMainThreadMigrationBodyCount();
     const openStartedAt = performance.now();
     let openMs = 0;
     let guardMs = 0;
@@ -7702,6 +7650,15 @@ async function openDatabaseAsync(dbPathOrOptions) {
       if (!explicitDbPath)
         migrateLegacyStorageIfNeeded(dbPath, dbDir);
       ensureSecureStorageDir(dbDir);
+      tightenStorageTree(dbDir);
+      if (!existsSync3(dbPath) && shouldEnforcePrivateStoragePermissions()) {
+        try {
+          writeStorageFileSync(dbPath, new Uint8Array, { flag: "wx" });
+        } catch (error) {
+          if (error.code !== "EEXIST")
+            throw error;
+        }
+      }
       db = new Database(dbPath);
       installBootBusyTimeout(db, dbPath, busyTimeoutMs, options?.onBootBusyTimeout);
       openMs = performance.now() - openStartedAt;
@@ -7719,15 +7676,20 @@ async function openDatabaseAsync(dbPathOrOptions) {
       }
       guardMs = performance.now() - guardStartedAt;
       migrateStartedAt = performance.now();
-      if (isFileBackedPath(dbPath) && hasPendingMigrations(db)) {
+      if (hasPendingMigrations(db)) {
         await runMigrationsOffThread({
           dbPath,
           busyTimeoutMs,
           sqlitePragmaConfig: { ...sqlitePragmaConfig }
         });
       }
+      if (hasPendingMigrations(db)) {
+        throw new Error("the migration worker did not complete the pending migration; reinstall or rebuild the plugin");
+      }
       initializeDatabase(db, busyTimeoutMs);
-      await runMigrationsWithRetry(db);
+      if (hasPendingMigrations(db)) {
+        throw new Error("storage initialization left a pending migration; reinstall or rebuild the plugin");
+      }
       ensureContextStoreUuid(db);
       const opened = finishDatabaseOpen(db, dbPath, explicitDbPath, latestSupportedVersion);
       migrateMs = performance.now() - migrateStartedAt;
@@ -7739,6 +7701,7 @@ async function openDatabaseAsync(dbPathOrOptions) {
       log(`[magic-context] storage fatal: failed to open ${dbPath}: ${detail}`);
       throw new Error(`[magic-context] storage unavailable: ${detail}. Magic Context is disabled for this run; check log for details.`);
     } finally {
+      log(`[migrations] async open main-thread migration-body count: ${getMainThreadMigrationBodyCount() - mainThreadBodiesBefore} (total=${getMainThreadMigrationBodyCount()}) path=${dbPath}`);
       if (openMs === 0)
         openMs = performance.now() - openStartedAt;
       if (guardStartedAt !== null && guardMs === 0) {
@@ -7771,4 +7734,4 @@ function closeDatabase() {
   }
 }
 
-export { FAIL_CLOSED_DOCTOR_COMMAND, formatFailClosedBlockingMessage, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, createFailClosedController, setHomeProjectPermission, ProjectIdentityError, resolveProjectIdentityStrict, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, recordMessageFtsRowid, recordIndexedMessageTime, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows, piHarnessKindFromExecutable, isPidAlive, V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL, unescapeXml, parseCompartmentOutput, layoutLkgPrefix, assembleLkgPrefix, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, managedAuthorityNoteRow, runMigrationsWithRetry, beginBootQuietPeriod, scheduleAfterBootQuiet, getErrorMessage, describeError, startBootDeadline, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, initializeDatabase, openDatabase, openDatabaseAsync, closeDatabase };
+export { FAIL_CLOSED_DOCTOR_COMMAND, formatFailClosedBlockingMessage, createFailClosedBlockingError, isFailClosedBlockingError, shouldBypassFailClosedBlock, createFailClosedController, setHomeProjectPermission, ProjectIdentityError, resolveProjectIdentityStrict, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, recordMessageFtsRowid, recordIndexedMessageTime, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows, piHarnessKindFromExecutable, isPidAlive, V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL, unescapeXml, parseCompartmentOutput, layoutLkgPrefix, assembleLkgPrefix, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, managedAuthorityNoteRow, runMigrationsWithRetry, beginBootQuietPeriod, scheduleAfterBootQuiet, getErrorMessage, describeError, configureContextDatabasePragmas, startBootDeadline, getSchemaFenceRejection, getMigrationOnOpenRefusal, LATEST_SUPPORTED_VERSION, getDatabasePath, getPersistedSchemaVersion, setSqlitePragmaConfig, applySqliteTuningPragmas, runSqliteOptimize, initializeDatabase, openDatabase, openCurrentDatabase, openDatabaseAsync, closeDatabase };

package/dist/{index-g0xfx1c2.js → index-phh7e055.js}

@@ -272,4 +272,19 @@ function renderToolTemplate(source, input, output) {
   return truncate(render(bareOutputNodes, root), 1000);
 }
 
-export { canonicalModelIdentity, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, ompModelRefToCanonical, resolveModelRefForOmp, toolTemplateError, renderToolTemplate };
+// ../plugin/src/shared/protected-tools-policy.ts
+var DEFAULT_PROTECTED_TOOLS = {
+  todowrite: 1,
+  ctx_reduce: 3
+};
+function normalizeProtectedToolName(name) {
+  return (name ?? "").toLowerCase().replace(/^mcp_/, "");
+}
+function mergeProtectedTools(...maps) {
+  return Object.fromEntries([DEFAULT_PROTECTED_TOOLS, ...maps].flatMap((map) => Object.entries(map ?? {}).map(([name, count]) => [
+    normalizeProtectedToolName(name),
+    count
+  ])));
+}
+
+export { canonicalModelIdentity, piModelRefToCanonical, resolveModelRefForPi, modelRefLookupOrder, ompModelRefToCanonical, resolveModelRefForOmp, toolTemplateError, renderToolTemplate, DEFAULT_PROTECTED_TOOLS, normalizeProtectedToolName, mergeProtectedTools };