@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/{v2/server-njt3np1k.js → index-7mx8v0pw.js}

@@ -1,610 +1,244 @@
 import {
-  getMagicContextStorageDir,
-  log
-} from "./server-1qbnzc80.js";
+  V2_MEMORY_CATEGORIES
+} from "./index-fr0wbhdn.js";
+import {
+  log2
+} from "./index-8j7gqj40.js";
 import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./server-vs5gpnd4.js";
+} from "./index-db7zwa3v.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
   getOpenCodeDbProbeDescriptions
-} from "./server-ajzeteqw.js";
+} from "./index-58e3y90n.js";
 import {
-  Database,
-  withSqliteBackgroundWriter,
-  withoutSqliteTransformPass
-} from "./server-wx8a6bw3.js";
+  Database2
+} from "./index-kb9nn0a0.js";
 import {
-  writeStorageFileAtomicSync
-} from "./server-1bc61ans.js";
+  normalizeStoredProjectPath,
+  storedPathBelongsToIdentity
+} from "./index-knh4y330.js";
 import {
   logSlowWriteTransaction
-} from "./server-14vq4kpm.js";
-
-// src/features/magic-context/memory/project-identity.ts
-import { execFileSync } from "node:child_process";
-import { createHash as createHash2 } from "node:crypto";
-import { existsSync, realpathSync as realpathSync2, statSync } from "node:fs";
-import { homedir } from "node:os";
-import path3 from "node:path";
+} from "./index-2y0s2hep.js";
 
-// src/features/magic-context/memory/project-identity-cache.ts
+// src/features/magic-context/lkg-prefix-chunks.ts
 import { createHash } from "node:crypto";
-import { readFileSync } from "node:fs";
-import path2 from "node:path";
-
-// src/shared/project-directory-key.ts
-import { realpathSync } from "node:fs";
-import path from "node:path";
-function projectDirectoryKey(directory) {
-  const slashed = directory.replaceAll("\\", "/").replace(/^\/\/\?\/UNC\//i, "//").replace(/^\/\/\?\//, "");
-  if (/^[a-z]:\//i.test(slashed) || slashed.startsWith("//")) {
-    return path.win32.normalize(slashed).replaceAll("\\", "/").replace(/\/$/, "").toLowerCase();
-  }
-  return path.resolve(directory);
-}
-var realpathForCanonicalDirectory = (directory) => realpathSync.native(directory);
-function canonicalProjectDirectory(directory) {
-  let resolved = directory;
-  try {
-    resolved = realpathForCanonicalDirectory(directory);
-  } catch {}
-  return projectDirectoryKey(resolved);
-}
-
-// src/features/magic-context/memory/project-identity-cache.ts
-function cachePath(directory, storageDir = getMagicContextStorageDir()) {
-  const hash = createHash("sha256").update(projectDirectoryKey(directory)).digest("hex");
-  return path2.join(storageDir, "project-identities", `${hash}.json`);
-}
-function rememberGitIdentity(directory, identity) {
-  try {
-    const destination = cachePath(directory);
-    writeStorageFileAtomicSync(destination, JSON.stringify({ directory: projectDirectoryKey(directory), identity }));
-  } catch {}
-}
-function readRememberedGitIdentity(directory, storageDir) {
-  try {
-    const record = JSON.parse(readFileSync(cachePath(directory, storageDir), "utf8"));
-    if (record.directory === projectDirectoryKey(directory) && /^git:[0-9a-f]{7,64}$/.test(record.identity))
-      return record.identity;
-  } catch {}
-  return;
-}
-
-// src/features/magic-context/memory/project-identity.ts
-var GIT_TIMEOUT_MS = 5000;
-var TRANSIENT_FAILURE_COOLDOWN_MS = 5 * 60 * 1000;
-var identityCache = new Map;
-var linkedGitWorktreeCache = new Map;
-var lastKnownGitIdentityCache = new Map;
-var directoryFallbackCache = new Map;
-var transientFailureCooldown = new Map;
-var dubiousOwnershipFallbackDirectories = new Set;
-var dubiousOwnershipLoggedDirectories = new Set;
-var dubiousOwnershipWarnedDirectories = new Set;
-var transientGitIdentityReuseLoggedDirectories = new Set;
-var sessionIdentityCache = new Map;
-var homeProjectPermission = false;
-var homeProjectSkipLogged = false;
-var pausedIdentityReasons = new Map;
-var pausedIdentityLogged = new Set;
-function setHomeProjectPermission(allowed) {
-  homeProjectPermission = allowed;
-}
-function shouldSkipHomeProjectMemory(directory) {
-  try {
-    assertProjectAllowed(directory, homeProjectPermission);
-    return false;
-  } catch (error) {
-    if (!(error instanceof ProjectIdentityError) || error.errorClass !== "home_project_disabled")
-      throw error;
-    if (!homeProjectSkipLogged) {
-      homeProjectSkipLogged = true;
-      log("[magic-context] home project memory disabled; skipping memory features");
+var LKG_PREFIX_CHUNK_CHARS = 64 * 1024;
+function splitLkgPrefix(jsonPrefix) {
+  const chunks = [];
+  let start = 0;
+  while (start < jsonPrefix.length) {
+    let end = Math.min(start + LKG_PREFIX_CHUNK_CHARS, jsonPrefix.length);
+    if (end < jsonPrefix.length) {
+      const last = jsonPrefix.charCodeAt(end - 1);
+      if (last >= 55296 && last <= 56319)
+        end -= 1;
     }
-    return true;
+    chunks.push(jsonPrefix.slice(start, end));
+    start = end;
   }
+  return chunks;
 }
-var execFileSyncForIdentity = execFileSync;
-var userHomeDirectoryForIdentity = () => homedir();
-var nowMs = () => Date.now();
-var filesystemProbeObserverForTests;
-
-class ProjectIdentityError extends Error {
-  errorClass;
-  rawDirectory;
-  constructor(errorClass, rawDirectory, message, cause) {
-    super(message);
-    this.name = "ProjectIdentityError";
-    this.errorClass = errorClass;
-    this.rawDirectory = rawDirectory;
-    if (cause) {
-      this.cause = cause;
-    }
-  }
+function hashLkgChunk(body) {
+  return createHash("sha256").update(body).digest("hex");
 }
-function asError(error) {
-  return error instanceof Error ? error : undefined;
+function hashLkgChunkList(chunkHashes) {
+  return createHash("sha256").update(chunkHashes.join(`
+`)).digest("hex");
 }
-function getErrorCode(error) {
-  if (error === null || typeof error !== "object" || !("code" in error)) {
-    return;
-  }
-  const code = error.code;
-  return typeof code === "string" ? code : undefined;
+function layoutLkgPrefix(jsonPrefix) {
+  const chunks = splitLkgPrefix(jsonPrefix);
+  const chunkHashes = chunks.map(hashLkgChunk);
+  return { chunks, chunkHashes, chars: jsonPrefix.length, hash: hashLkgChunkList(chunkHashes) };
 }
-function getErrorSignal(error) {
-  if (error === null || typeof error !== "object" || !("signal" in error)) {
+function assembleLkgPrefix(expected, rows) {
+  const { chars, chunks, hash } = expected;
+  if (typeof chars !== "number" || !Number.isSafeInteger(chars) || typeof chunks !== "number" || !Number.isSafeInteger(chunks) || typeof hash !== "string" || rows.length !== chunks) {
     return;
   }
-  const signal = error.signal;
-  return typeof signal === "string" ? signal : undefined;
-}
-function getErrorKilled(error) {
-  if (error === null || typeof error !== "object" || !("killed" in error)) {
-    return false;
-  }
-  return error.killed === true;
-}
-function getErrorStderr(error) {
-  if (error === null || typeof error !== "object" || !("stderr" in error)) {
-    return "";
-  }
-  const stderr = error.stderr;
-  if (typeof stderr === "string") {
-    return stderr;
-  }
-  if (Buffer.isBuffer(stderr)) {
-    return stderr.toString("utf8");
-  }
-  return "";
-}
-function directoryFallback(directory) {
-  const canonical = path3.resolve(directory);
-  const hash = createHash2("md5").update(canonical, "utf8").digest("hex").slice(0, 12);
-  return `dir:${hash}`;
-}
-function rememberedIdentityOrDirectoryFallback(canonical) {
-  return readRememberedGitIdentity(canonical) ?? directoryFallback(canonical);
-}
-function assertDirectoryUsable(canonicalDirectory, rawDirectory) {
-  try {
-    const stat = statSync(canonicalDirectory);
-    if (!stat.isDirectory()) {
-      throw new ProjectIdentityError("unknown", rawDirectory, `Project path is not a directory: ${canonicalDirectory}`);
-    }
-  } catch (error) {
-    if (error instanceof ProjectIdentityError) {
-      throw error;
-    }
-    const code = getErrorCode(error);
-    if (code === "EACCES" || code === "EPERM") {
-      throw new ProjectIdentityError("permission_denied", rawDirectory, `Permission denied while accessing project directory: ${canonicalDirectory}`, asError(error));
-    }
-    throw new ProjectIdentityError("unknown", rawDirectory, `Unable to access project directory: ${canonicalDirectory}`, asError(error));
-  }
-}
-function isGitTimeoutError(error) {
-  const code = getErrorCode(error);
-  const signal = getErrorSignal(error);
-  return code === "ETIMEDOUT" || signal === "SIGTERM" || signal === "SIGKILL" || getErrorKilled(error);
-}
-function hasUnbornHead(directory) {
-  const options = {
-    cwd: directory,
-    encoding: "utf8",
-    env: { ...process.env, LC_ALL: "C", LANG: "C" },
-    stdio: ["ignore", "pipe", "pipe"],
-    timeout: GIT_TIMEOUT_MS,
-    windowsHide: true
-  };
-  try {
-    execFileSyncForIdentity("git", ["rev-parse", "--git-dir"], options);
-    try {
-      execFileSyncForIdentity("git", ["rev-parse", "--verify", "--quiet", "HEAD"], options);
-      return false;
-    } catch (error) {
-      return !isGitTimeoutError(error) && typeof error === "object" && error !== null && "status" in error && error.status === 1 && getErrorStderr(error) === "";
-    }
-  } catch {
-    return false;
-  }
-}
-function classifyGitError(error, rawDirectory) {
-  if (isGitTimeoutError(error)) {
-    return new ProjectIdentityError("git_timeout", rawDirectory, `git rev-list timed out after ${GIT_TIMEOUT_MS}ms`, asError(error));
-  }
-  const code = getErrorCode(error);
-  if (code === "ENOENT") {
-    return new ProjectIdentityError("git_missing", rawDirectory, "git binary is not available in PATH", asError(error));
-  }
-  if (code === "EACCES" || code === "EPERM") {
-    return new ProjectIdentityError("permission_denied", rawDirectory, "Permission denied while spawning git", asError(error));
-  }
-  const stderr = getErrorStderr(error).toLowerCase();
-  if (stderr.includes("detected dubious ownership")) {
-    return new ProjectIdentityError("dubious_ownership", rawDirectory, "git refused to read the repository because it detected dubious ownership", asError(error));
-  }
-  if (stderr.includes("not a git repository") || stderr.includes("does not have any commits yet") || stderr.includes("ambiguous argument 'head'") || stderr.includes("unknown revision or path")) {
-    return new ProjectIdentityError("not_git_repo", rawDirectory, "Directory has no git root commit; caller may use directory fallback", asError(error));
-  }
-  return new ProjectIdentityError("unknown", rawDirectory, "git rev-list failed while resolving project identity", asError(error));
-}
-function resolveProjectIdentityStrict(directory, allowHomeProject = homeProjectPermission) {
-  assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path3.resolve(directory);
-  const cached = identityCache.get(canonical);
-  if (cached !== undefined) {
-    return cached;
-  }
-  assertDirectoryUsable(canonical, directory);
-  if (!hasGitDir(canonical)) {
-    throw new ProjectIdentityError("not_git_repo", directory, "Directory has no git metadata; caller may use directory fallback");
-  }
-  let output;
-  try {
-    output = execFileSyncForIdentity("git", ["rev-list", "--max-parents=0", "HEAD"], {
-      cwd: canonical,
-      encoding: "utf8",
-      env: { ...process.env, LC_ALL: "C", LANG: "C" },
-      stdio: ["ignore", "pipe", "pipe"],
-      timeout: GIT_TIMEOUT_MS,
-      windowsHide: true
-    });
-  } catch (error) {
-    const classified = classifyGitError(error, directory);
-    if (classified.errorClass === "not_git_repo" && hasUnbornHead(canonical)) {
-      throw new ProjectIdentityError("no_commits", directory, "Git repository has no commits yet");
-    }
-    throw classified;
-  }
-  const rootCommit = output.split(`
-`).map((line) => line.trim().slice(0, 64)).filter((line) => /^[0-9a-f]{7,64}$/.test(line)).sort()[0];
-  if (!rootCommit) {
-    throw new ProjectIdentityError("unknown", directory, "git rev-list returned no valid root commit hash");
+  const bodies = [];
+  let length = 0;
+  for (let index = 0;index < rows.length; index += 1) {
+    const row = rows[index];
+    if (row?.chunk !== index || typeof row.body !== "string")
+      return;
+    bodies.push(row.body);
+    length += row.body.length;
   }
-  const identity = `git:${rootCommit}`;
-  identityCache.set(canonical, identity);
-  lastKnownGitIdentityCache.set(canonical, identity);
-  rememberGitIdentity(canonical, identity);
-  const root = gitRootDirectory(canonical);
-  if (root && root !== canonical)
-    rememberGitIdentity(root, identity);
-  transientFailureCooldown.delete(canonical);
-  dubiousOwnershipFallbackDirectories.delete(canonical);
-  transientGitIdentityReuseLoggedDirectories.delete(canonical);
-  return identity;
-}
-function shouldUseDirectoryFallback(error) {
-  return error.errorClass !== "home_project_disabled";
-}
-function getActiveCooldown(canonical) {
-  const until = transientFailureCooldown.get(canonical);
-  if (until === undefined)
-    return;
-  if (nowMs() < until)
-    return until;
-  transientFailureCooldown.delete(canonical);
-  return;
-}
-function lastKnownGitIdentity(canonical) {
-  return lastKnownGitIdentityCache.get(canonical) ?? identityCache.get(canonical) ?? readRememberedGitIdentity(canonical);
-}
-function nearestLastKnownGitIdentity(canonical) {
-  const visited = new Set;
-  const walk = (start) => {
-    let current = start;
-    while (!visited.has(current)) {
-      visited.add(current);
-      const cached = lastKnownGitIdentity(current);
-      if (cached !== undefined)
-        return { identity: cached, source: current };
-      if (existsSync(path3.join(current, ".git")))
-        break;
-      const parent = path3.dirname(current);
-      if (parent === current)
-        break;
-      current = parent;
-    }
+  if (length !== chars)
     return;
-  };
-  const exactOrAncestor = walk(canonical);
-  if (exactOrAncestor)
-    return exactOrAncestor;
-  try {
-    const realCanonical = realpathSync2.native(canonical);
-    if (realCanonical !== canonical)
-      return walk(realCanonical);
-  } catch {}
-  return;
-}
-function reuseLastKnownGitIdentity(canonical) {
-  const cached = nearestLastKnownGitIdentity(canonical);
-  if (cached === undefined)
+  const chunkHashes = bodies.map(hashLkgChunk);
+  if (chunkHashes.some((chunkHash, index) => rows[index]?.hash !== chunkHash))
     return;
-  if (!transientGitIdentityReuseLoggedDirectories.has(canonical)) {
-    transientGitIdentityReuseLoggedDirectories.add(canonical);
-    const sourceNote = cached.source === canonical ? "" : ` from ancestor ${cached.source}`;
-    log(`[magic-context] git identity resolution is temporarily unavailable for ${canonical}; reusing the last successful project identity${sourceNote} to avoid splitting project-scoped memory`);
-  }
-  return cached.identity;
-}
-function formatDubiousOwnershipWarning(canonical) {
-  return `Magic Context: git refused to read ${canonical} (dubious ownership — the repo is owned by a different user). Memory features are paused unless a previous git identity is available. Fix: git config --global --add safe.directory ${canonical}`;
-}
-function recordDubiousOwnershipFallback(canonical) {
-  dubiousOwnershipFallbackDirectories.add(canonical);
-  if (dubiousOwnershipLoggedDirectories.has(canonical))
+  if (hashLkgChunkList(chunkHashes) !== hash)
     return;
-  dubiousOwnershipLoggedDirectories.add(canonical);
-  log(`[magic-context] ${formatDubiousOwnershipWarning(canonical)}`);
-}
-function takeDubiousOwnershipProjectIdentityWarning(directory) {
-  const canonical = path3.resolve(directory);
-  if (!dubiousOwnershipFallbackDirectories.has(canonical))
-    return null;
-  if (dubiousOwnershipWarnedDirectories.has(canonical))
-    return null;
-  dubiousOwnershipWarnedDirectories.add(canonical);
-  return formatDubiousOwnershipWarning(canonical);
-}
-function canonicalUserHomeDirectory() {
-  const homeDirectory = userHomeDirectoryForIdentity();
-  try {
-    return realpathSync2.native(homeDirectory);
-  } catch {
-    return homeDirectory;
-  }
-}
-function isUserHomeDirectory(directory) {
-  if (projectDirectoryKey(directory) === projectDirectoryKey(userHomeDirectoryForIdentity()))
-    return true;
-  try {
-    return projectDirectoryKey(realpathSync2.native(path3.resolve(directory))) === projectDirectoryKey(canonicalUserHomeDirectory());
-  } catch {
-    return false;
-  }
-}
-function assertProjectAllowed(directory, allowHomeProject) {
-  const canonical = path3.resolve(directory);
-  if (!allowHomeProject && (isUserHomeDirectory(directory) || isUserHomeDirectory(gitRootDirectory(canonical) ?? canonical))) {
-    throw new ProjectIdentityError("home_project_disabled", directory, "Home project memory is disabled; set allow_home_project to opt in");
-  }
-}
-function resolveProjectIdentity(directory, allowHomeProject = homeProjectPermission) {
-  assertProjectAllowed(directory, allowHomeProject);
-  const canonical = path3.resolve(directory);
-  const cachedFallback = directoryFallbackCache.get(canonical);
-  if (cachedFallback !== undefined) {
-    if (!hasGitDir(canonical)) {
-      return cachedFallback;
-    }
-    directoryFallbackCache.delete(canonical);
-  }
-  if (getActiveCooldown(canonical) !== undefined) {
-    if (hasGitDir(canonical)) {
-      const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
-      if (cachedGitIdentity !== undefined) {
-        return cachedGitIdentity;
-      }
-      throw new ProjectIdentityError("git_identity_unavailable", directory, "Git identity unavailable; memory features paused until the retry cooldown expires");
-    }
-    return rememberedIdentityOrDirectoryFallback(canonical);
-  }
-  try {
-    return resolveProjectIdentityStrict(directory, allowHomeProject);
-  } catch (error) {
-    if (error instanceof ProjectIdentityError && shouldUseDirectoryFallback(error)) {
-      if (error.errorClass === "no_commits")
-        return directoryFallback(canonical);
-      if (!hasGitDir(canonical)) {
-        if (error.errorClass === "permission_denied")
-          throw error;
-        const resolved = rememberedIdentityOrDirectoryFallback(canonical);
-        directoryFallbackCache.set(canonical, resolved);
-        transientFailureCooldown.delete(canonical);
-        return resolved;
-      }
-      transientFailureCooldown.set(canonical, nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS);
-      const cachedGitIdentity = reuseLastKnownGitIdentity(canonical);
-      if (error.errorClass === "dubious_ownership")
-        recordDubiousOwnershipFallback(canonical);
-      if (cachedGitIdentity !== undefined) {
-        return cachedGitIdentity;
-      }
-      throw error;
-    }
-    throw error;
-  }
-}
-function resolveProjectIdentityOrFallback(directory, allowHomeProject = homeProjectPermission) {
-  try {
-    return resolveProjectIdentity(directory, allowHomeProject);
-  } catch (error) {
-    const canonical = path3.resolve(directory);
-    if (hasGitDir(canonical) || error instanceof ProjectIdentityError && error.errorClass === "home_project_disabled")
-      throw error;
-    const fallback = rememberedIdentityOrDirectoryFallback(canonical);
-    const message = error instanceof Error ? error.message : String(error);
-    log(`[magic-context] project identity resolution failed for ${canonical}; using directory fallback ${fallback}: ${message}`);
-    return fallback;
-  }
-}
-function hasGitDir(canonical) {
-  if (hasGitDirInAncestorChain(canonical)) {
-    return true;
-  }
-  try {
-    const realCanonical = realpathSync2.native(canonical);
-    return realCanonical !== canonical && hasGitDirInAncestorChain(realCanonical);
-  } catch {
-    return false;
-  }
-}
-function gitRootInAncestorChain(startDirectory) {
-  let current = startDirectory;
-  while (true) {
-    if (existsSync(path3.join(current, ".git"))) {
-      try {
-        return realpathSync2.native(current);
-      } catch {
-        return path3.resolve(current);
-      }
-    }
-    const parent = path3.dirname(current);
-    if (parent === current) {
-      return null;
-    }
-    current = parent;
-  }
-}
-function hasGitDirInAncestorChain(startDirectory) {
-  return gitRootInAncestorChain(startDirectory) !== null;
-}
-function gitRootDirectory(canonical) {
-  const direct = gitRootInAncestorChain(canonical);
-  if (direct)
-    return direct;
-  try {
-    const realCanonical = realpathSync2.native(canonical);
-    return realCanonical === canonical ? null : gitRootInAncestorChain(realCanonical);
-  } catch {
-    return null;
-  }
+  return { jsonPrefix: bodies.join(""), chunkHashes, hash };
 }
-function directoryHasGitMetadata(directory) {
-  return gitRootDirectory(path3.resolve(directory)) !== null;
+
+// src/features/magic-context/migration-v94-write-split.ts
+var LKG_SLOT_CHUNKS_DDL = `
+    CREATE TABLE IF NOT EXISTS lkg_slot_chunks (
+        session_id TEXT NOT NULL,
+        chunk INTEGER NOT NULL,
+        hash TEXT NOT NULL,
+        body TEXT NOT NULL,
+        PRIMARY KEY (session_id, chunk)
+    );
+`;
+var SESSION_REPLAY_DECISIONS_DDL = `
+    CREATE TABLE IF NOT EXISTS session_replay_decisions (
+        session_id TEXT NOT NULL,
+        message_id TEXT NOT NULL,
+        decision TEXT NOT NULL,
+        PRIMARY KEY (session_id, message_id)
+    ) WITHOUT ROWID;
+`;
+function lkgSlotsDdl(table) {
+  return `
+        CREATE TABLE IF NOT EXISTS ${table} (
+            session_id TEXT PRIMARY KEY,
+            json_prefix_chars INTEGER NOT NULL,
+            json_prefix_chunks INTEGER NOT NULL,
+            json_prefix_hash TEXT NOT NULL,
+            input_id_seq TEXT NOT NULL,
+            input_content_digests TEXT NOT NULL,
+            input_content_signatures TEXT,
+            last_input_message_id TEXT NOT NULL,
+            model_key TEXT,
+            provider_key TEXT,
+            captured_at INTEGER NOT NULL,
+            row_version INTEGER,
+            capture_sequence INTEGER
+        );
+    `;
 }
-function describeUnresolvedProjectIdentity(directory) {
-  const resolvedDirectory = path3.resolve(directory);
-  const canonicalHome = canonicalUserHomeDirectory();
-  const canonicalDirectory = (() => {
-    try {
-      return realpathSync2.native(resolvedDirectory);
-    } catch {
-      return resolvedDirectory;
-    }
-  })();
-  if (isUserHomeDirectory(directory) || gitRootDirectory(canonicalDirectory) === canonicalHome) {
-    return `this session runs in your home directory (${canonicalHome}), which Magic Context does not treat as a project. ` + "Start OpenCode inside a project folder, or set `allow_home_project: true` in the user-level " + "magic-context.jsonc (~/.config/cortexkit/) to give home sessions their own memory.";
-  }
-  if (hasGitDir(resolvedDirectory))
-    return `git identity resolution for ${resolvedDirectory} is temporarily unavailable. Memory features are paused; retry after git access recovers.`;
-  return `the session directory ${resolvedDirectory} could not be read as a project.`;
+var LKG_SLOTS_DDL = lkgSlotsDdl("lkg_slots");
+var LKG_MOVE_WINDOW_MS = 24 * 60 * 60 * 1000;
+function tableExists(db, name) {
+  return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
 }
-function isUsableProjectIdentity(identity) {
-  return typeof identity === "string" && identity.trim().length > 0;
+function columnExists(db, table, column) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return rows.some((row) => row.name === column);
 }
-function resolveProjectIdentityForSession(directory, allowHomeProject = homeProjectPermission) {
-  const resolvedDirectory = path3.resolve(directory);
-  const cacheKey = `${allowHomeProject ? "1" : "0"}\x00${resolvedDirectory}`;
-  const cached = sessionIdentityCache.get(cacheKey);
-  if (cached && (cached.revalidateAt === null || nowMs() < cached.revalidateAt) && !(cached.identity?.startsWith("dir:") && hasGitDir(resolvedDirectory))) {
-    return cached.identity;
+function splitLkgSlotPrefixes(db, now = Date.now()) {
+  db.exec(LKG_SLOT_CHUNKS_DDL);
+  if (!tableExists(db, "lkg_slots")) {
+    db.exec(LKG_SLOTS_DDL);
+    return;
   }
-  sessionIdentityCache.delete(cacheKey);
-  filesystemProbeObserverForTests?.();
-  const canonicalDirectory = (() => {
-    try {
-      filesystemProbeObserverForTests?.();
-      return realpathSync2.native(resolvedDirectory);
-    } catch {
-      return resolvedDirectory;
-    }
-  })();
-  filesystemProbeObserverForTests?.();
-  const homeRoot = gitRootDirectory(canonicalDirectory);
-  const inheritsHomeRepository = homeRoot !== null && isUserHomeDirectory(homeRoot);
-  let identity;
-  if (!allowHomeProject && (isUserHomeDirectory(directory) || inheritsHomeRepository)) {
-    identity = undefined;
-  } else {
-    try {
-      identity = resolveProjectIdentityOrFallback(isUserHomeDirectory(directory) ? canonicalUserHomeDirectory() : directory, allowHomeProject);
-    } catch (error) {
-      if (!(error instanceof ProjectIdentityError))
-        throw error;
-      const reason = error.errorClass === "git_identity_unavailable" ? pausedIdentityReasons.get(resolvedDirectory) ?? error.errorClass : error.errorClass;
-      pausedIdentityReasons.set(resolvedDirectory, reason);
-      const logKey = `${resolvedDirectory}\x00${reason}`;
-      if (!pausedIdentityLogged.has(logKey)) {
-        pausedIdentityLogged.add(logKey);
-        log(`[magic-context] memory features paused for ${resolvedDirectory}: ${reason}`);
-      }
-      identity = undefined;
+  if (!columnExists(db, "lkg_slots", "json_prefix"))
+    return;
+  db.prepare("DELETE FROM lkg_slots WHERE NOT (captured_at >= ?)").run(now - LKG_MOVE_WINDOW_MS);
+  db.exec("DROP TABLE IF EXISTS lkg_slots_v94");
+  db.exec(lkgSlotsDdl("lkg_slots_v94"));
+  const sessionIds = db.prepare("SELECT session_id FROM lkg_slots").all().map((row) => row.session_id);
+  const readPrefix = db.prepare("SELECT json_prefix FROM lkg_slots WHERE session_id IS ?");
+  const insertSlot = db.prepare(`INSERT OR IGNORE INTO lkg_slots_v94 (
+            session_id, json_prefix_chars, json_prefix_chunks, json_prefix_hash,
+            input_id_seq, input_content_digests, input_content_signatures,
+            last_input_message_id, model_key, provider_key,
+            captured_at, row_version, capture_sequence
+        )
+        SELECT session_id, ?, ?, ?,
+            input_id_seq, input_content_digests, input_content_signatures,
+            last_input_message_id, model_key, provider_key,
+            captured_at, row_version, capture_sequence
+        FROM lkg_slots WHERE session_id IS ?`);
+  const insertChunk = db.prepare("INSERT INTO lkg_slot_chunks (session_id, chunk, hash, body) VALUES (?, ?, ?, ?)");
+  db.prepare("DELETE FROM lkg_slot_chunks").run();
+  for (const sessionId of sessionIds) {
+    if (typeof sessionId !== "string")
+      continue;
+    const row = readPrefix.get(sessionId);
+    if (typeof row?.json_prefix !== "string")
+      continue;
+    const layout = layoutLkgPrefix(row.json_prefix);
+    const inserted = insertSlot.run(layout.chars, layout.chunks.length, layout.hash, sessionId);
+    if (Number(inserted.changes) !== 1)
+      continue;
+    for (let index = 0;index < layout.chunks.length; index += 1) {
+      insertChunk.run(sessionId, index, layout.chunkHashes[index], layout.chunks[index]);
     }
   }
-  if (identity !== undefined)
-    pausedIdentityReasons.delete(resolvedDirectory);
-  sessionIdentityCache.set(cacheKey, {
-    identity,
-    revalidateAt: identity?.startsWith("git:") === true ? null : nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS
-  });
-  return identity;
+  db.exec("DROP TABLE lkg_slots");
+  db.exec("ALTER TABLE lkg_slots_v94 RENAME TO lkg_slots");
 }
-function normalizeStoredProjectPath(rawOrStored) {
-  if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
-    return rawOrStored;
-  }
-  try {
-    return resolveProjectIdentity(rawOrStored);
-  } catch {
-    return rawOrStored;
-  }
+function validDecisionSql(type, value) {
+  return `(${type} = 'text' AND (
+        ${value} IN ('keep', 'strip') OR (
+            ${value} GLOB 'keep:[1-9]*'
+            AND substr(${value}, 6) NOT GLOB '*[^0-9]*'
+            AND length(${value}) <= 10
+            AND CAST(substr(${value}, 6) AS INTEGER) BETWEEN 2 AND 10000
+        )
+    ))`;
 }
-function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
-  return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
+function splitReplayDecisions(db) {
+  db.exec(SESSION_REPLAY_DECISIONS_DDL);
+  if (!tableExists(db, "session_meta"))
+    return;
+  if (!columnExists(db, "session_meta", "trailing_blank_decisions"))
+    return;
+  const doc = "sm.trailing_blank_decisions";
+  const hasVersionKey = `json_type(${doc}, '$.version') IS NOT NULL`;
+  const versionIsDecision = validDecisionSql(`json_type(${doc}, '$.version')`, `json_extract(${doc}, '$.version')`);
+  const isV2 = `(${hasVersionKey} AND NOT ${versionIsDecision})`;
+  const v2Valid = `(
+        json_type(${doc}, '$.version') IN ('integer', 'real')
+        AND json_extract(${doc}, '$.version') = 2
+        AND json_type(${doc}, '$.trailingBlank') = 'object'
+        AND NOT EXISTS (
+            SELECT 1 FROM json_each(${doc}, '$.trailingBlank') AS entry
+            WHERE entry.key = '' OR NOT ${validDecisionSql("entry.type", "entry.value")}
+        )
+    )`;
+  const v1Valid = `NOT EXISTS (
+        SELECT 1 FROM json_each(${doc}) AS entry
+        WHERE entry.key = '' OR NOT ${validDecisionSql("entry.type", "entry.value")}
+    )`;
+  db.exec("DROP TABLE IF EXISTS temp.v94_replay_documents");
+  db.exec(`
+        CREATE TEMP TABLE v94_replay_documents AS
+        SELECT session_id, version FROM (
+            SELECT sm.session_id AS session_id, CASE WHEN ${isV2} THEN 2 ELSE 1 END AS version,
+                CASE WHEN ${isV2} THEN ${v2Valid} ELSE ${v1Valid} END AS strictly_valid
+            FROM session_meta AS sm
+            WHERE typeof(${doc}) = 'text' AND ${doc} <> ''
+                AND json_valid(${doc}) AND json_type(${doc}) = 'object'
+        ) WHERE strictly_valid;
+    `);
+  db.exec(`
+        INSERT INTO session_replay_decisions (session_id, message_id, decision)
+        SELECT sm.session_id, entry.key, entry.value
+        FROM v94_replay_documents AS moved
+        JOIN session_meta AS sm ON sm.session_id = moved.session_id
+        JOIN json_each(
+            ${doc}, CASE moved.version WHEN 2 THEN '$.trailingBlank' ELSE '$' END
+        ) AS entry
+        WHERE true
+        ON CONFLICT(session_id, message_id) DO UPDATE SET decision = excluded.decision;
+    `);
+  db.exec(`
+        UPDATE session_meta SET trailing_blank_decisions = (
+            SELECT CASE moved.version
+                WHEN 2 THEN json_set(session_meta.trailing_blank_decisions, '$.trailingBlank', json('{}'))
+                ELSE ''
+            END
+            FROM v94_replay_documents AS moved WHERE moved.session_id = session_meta.session_id
+        )
+        WHERE session_id IN (SELECT session_id FROM v94_replay_documents);
+    `);
+  db.exec("DROP TABLE temp.v94_replay_documents");
 }
 
 // src/features/magic-context/migrations.ts
 import { isMainThread } from "node:worker_threads";
 
-// src/features/magic-context/memory/constants.ts
-var V2_MEMORY_CATEGORIES = [
-  "PROJECT_RULES",
-  "ARCHITECTURE",
-  "CONSTRAINTS",
-  "CONFIG_VALUES",
-  "NAMING"
-];
-var PROMOTABLE_CATEGORIES = [
-  ...V2_MEMORY_CATEGORIES,
-  "ARCHITECTURE_DECISIONS",
-  "CONFIG_DEFAULTS",
-  "USER_PREFERENCES",
-  "USER_DIRECTIVES",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var CATEGORY_PRIORITY = [
-  ...V2_MEMORY_CATEGORIES,
-  "USER_DIRECTIVES",
-  "USER_PREFERENCES",
-  "CONFIG_DEFAULTS",
-  "ARCHITECTURE_DECISIONS",
-  "ENVIRONMENT",
-  "WORKFLOW_RULES",
-  "KNOWN_ISSUES"
-];
-var MEMORY_CATEGORY_ORDER_UNKNOWN = 99;
-var MEMORY_CATEGORY_ORDER_PRIORITY = CATEGORY_PRIORITY.reduce((acc, category, index) => {
-  acc[category] = index;
-  return acc;
-}, {});
-var MEMORY_CATEGORY_ORDER_SQL = `CASE category ${CATEGORY_PRIORITY.map((category, index) => `WHEN '${category}' THEN ${index}`).join(" ")} ELSE ${MEMORY_CATEGORY_ORDER_UNKNOWN} END`;
-function getMemoryCategoryOrder(category) {
-  return MEMORY_CATEGORY_ORDER_PRIORITY[category] ?? MEMORY_CATEGORY_ORDER_UNKNOWN;
-}
-var CATEGORY_DEFAULT_TTL = {
-  WORKFLOW_RULES: 90 * 24 * 60 * 60 * 1000,
-  KNOWN_ISSUES: 30 * 24 * 60 * 60 * 1000
-};
-
 // src/shared/xml-unescape.ts
 var XML_ENTITY_REGEX = /&(amp|apos|quot|lt|gt);/g;
 var XML_ENTITIES = {
@@ -814,7 +448,7 @@ function parseCompartmentOutput(text) {
         continue;
       droppedFactBlocks++;
       droppedFacts += items.length;
-      log(`[historian] Dropped <facts> category ${category} (${items.length} facts)`);
+      log2(`[historian] Dropped <facts> category ${category} (${items.length} facts)`);
       continue;
     }
     for (const content of items)
@@ -897,217 +531,6 @@ function parseEvents(text) {
   return events;
 }
 
-// src/features/magic-context/lkg-prefix-chunks.ts
-import { createHash as createHash3 } from "node:crypto";
-var LKG_PREFIX_CHUNK_CHARS = 64 * 1024;
-function splitLkgPrefix(jsonPrefix) {
-  const chunks = [];
-  let start = 0;
-  while (start < jsonPrefix.length) {
-    let end = Math.min(start + LKG_PREFIX_CHUNK_CHARS, jsonPrefix.length);
-    if (end < jsonPrefix.length) {
-      const last = jsonPrefix.charCodeAt(end - 1);
-      if (last >= 55296 && last <= 56319)
-        end -= 1;
-    }
-    chunks.push(jsonPrefix.slice(start, end));
-    start = end;
-  }
-  return chunks;
-}
-function hashLkgChunk(body) {
-  return createHash3("sha256").update(body).digest("hex");
-}
-function hashLkgChunkList(chunkHashes) {
-  return createHash3("sha256").update(chunkHashes.join(`
-`)).digest("hex");
-}
-function layoutLkgPrefix(jsonPrefix) {
-  const chunks = splitLkgPrefix(jsonPrefix);
-  const chunkHashes = chunks.map(hashLkgChunk);
-  return { chunks, chunkHashes, chars: jsonPrefix.length, hash: hashLkgChunkList(chunkHashes) };
-}
-function assembleLkgPrefix(expected, rows) {
-  const { chars, chunks, hash } = expected;
-  if (typeof chars !== "number" || !Number.isSafeInteger(chars) || typeof chunks !== "number" || !Number.isSafeInteger(chunks) || typeof hash !== "string" || rows.length !== chunks) {
-    return;
-  }
-  const bodies = [];
-  let length = 0;
-  for (let index = 0;index < rows.length; index += 1) {
-    const row = rows[index];
-    if (row?.chunk !== index || typeof row.body !== "string")
-      return;
-    bodies.push(row.body);
-    length += row.body.length;
-  }
-  if (length !== chars)
-    return;
-  const chunkHashes = bodies.map(hashLkgChunk);
-  if (chunkHashes.some((chunkHash, index) => rows[index]?.hash !== chunkHash))
-    return;
-  if (hashLkgChunkList(chunkHashes) !== hash)
-    return;
-  return { jsonPrefix: bodies.join(""), chunkHashes, hash };
-}
-
-// src/features/magic-context/migration-v94-write-split.ts
-var LKG_SLOT_CHUNKS_DDL = `
-    CREATE TABLE IF NOT EXISTS lkg_slot_chunks (
-        session_id TEXT NOT NULL,
-        chunk INTEGER NOT NULL,
-        hash TEXT NOT NULL,
-        body TEXT NOT NULL,
-        PRIMARY KEY (session_id, chunk)
-    );
-`;
-var SESSION_REPLAY_DECISIONS_DDL = `
-    CREATE TABLE IF NOT EXISTS session_replay_decisions (
-        session_id TEXT NOT NULL,
-        message_id TEXT NOT NULL,
-        decision TEXT NOT NULL,
-        PRIMARY KEY (session_id, message_id)
-    ) WITHOUT ROWID;
-`;
-function lkgSlotsDdl(table) {
-  return `
-        CREATE TABLE IF NOT EXISTS ${table} (
-            session_id TEXT PRIMARY KEY,
-            json_prefix_chars INTEGER NOT NULL,
-            json_prefix_chunks INTEGER NOT NULL,
-            json_prefix_hash TEXT NOT NULL,
-            input_id_seq TEXT NOT NULL,
-            input_content_digests TEXT NOT NULL,
-            input_content_signatures TEXT,
-            last_input_message_id TEXT NOT NULL,
-            model_key TEXT,
-            provider_key TEXT,
-            captured_at INTEGER NOT NULL,
-            row_version INTEGER,
-            capture_sequence INTEGER
-        );
-    `;
-}
-var LKG_SLOTS_DDL = lkgSlotsDdl("lkg_slots");
-var LKG_MOVE_WINDOW_MS = 24 * 60 * 60 * 1000;
-function tableExists(db, name) {
-  return Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
-}
-function columnExists(db, table, column) {
-  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
-  return rows.some((row) => row.name === column);
-}
-function splitLkgSlotPrefixes(db, now = Date.now()) {
-  db.exec(LKG_SLOT_CHUNKS_DDL);
-  if (!tableExists(db, "lkg_slots")) {
-    db.exec(LKG_SLOTS_DDL);
-    return;
-  }
-  if (!columnExists(db, "lkg_slots", "json_prefix"))
-    return;
-  db.prepare("DELETE FROM lkg_slots WHERE NOT (captured_at >= ?)").run(now - LKG_MOVE_WINDOW_MS);
-  db.exec("DROP TABLE IF EXISTS lkg_slots_v94");
-  db.exec(lkgSlotsDdl("lkg_slots_v94"));
-  const sessionIds = db.prepare("SELECT session_id FROM lkg_slots").all().map((row) => row.session_id);
-  const readPrefix = db.prepare("SELECT json_prefix FROM lkg_slots WHERE session_id IS ?");
-  const insertSlot = db.prepare(`INSERT OR IGNORE INTO lkg_slots_v94 (
-            session_id, json_prefix_chars, json_prefix_chunks, json_prefix_hash,
-            input_id_seq, input_content_digests, input_content_signatures,
-            last_input_message_id, model_key, provider_key,
-            captured_at, row_version, capture_sequence
-        )
-        SELECT session_id, ?, ?, ?,
-            input_id_seq, input_content_digests, input_content_signatures,
-            last_input_message_id, model_key, provider_key,
-            captured_at, row_version, capture_sequence
-        FROM lkg_slots WHERE session_id IS ?`);
-  const insertChunk = db.prepare("INSERT INTO lkg_slot_chunks (session_id, chunk, hash, body) VALUES (?, ?, ?, ?)");
-  db.prepare("DELETE FROM lkg_slot_chunks").run();
-  for (const sessionId of sessionIds) {
-    if (typeof sessionId !== "string")
-      continue;
-    const row = readPrefix.get(sessionId);
-    if (typeof row?.json_prefix !== "string")
-      continue;
-    const layout = layoutLkgPrefix(row.json_prefix);
-    const inserted = insertSlot.run(layout.chars, layout.chunks.length, layout.hash, sessionId);
-    if (Number(inserted.changes) !== 1)
-      continue;
-    for (let index = 0;index < layout.chunks.length; index += 1) {
-      insertChunk.run(sessionId, index, layout.chunkHashes[index], layout.chunks[index]);
-    }
-  }
-  db.exec("DROP TABLE lkg_slots");
-  db.exec("ALTER TABLE lkg_slots_v94 RENAME TO lkg_slots");
-}
-function validDecisionSql(type, value) {
-  return `(${type} = 'text' AND (
-        ${value} IN ('keep', 'strip') OR (
-            ${value} GLOB 'keep:[1-9]*'
-            AND substr(${value}, 6) NOT GLOB '*[^0-9]*'
-            AND length(${value}) <= 10
-            AND CAST(substr(${value}, 6) AS INTEGER) BETWEEN 2 AND 10000
-        )
-    ))`;
-}
-function splitReplayDecisions(db) {
-  db.exec(SESSION_REPLAY_DECISIONS_DDL);
-  if (!tableExists(db, "session_meta"))
-    return;
-  if (!columnExists(db, "session_meta", "trailing_blank_decisions"))
-    return;
-  const doc = "sm.trailing_blank_decisions";
-  const hasVersionKey = `json_type(${doc}, '$.version') IS NOT NULL`;
-  const versionIsDecision = validDecisionSql(`json_type(${doc}, '$.version')`, `json_extract(${doc}, '$.version')`);
-  const isV2 = `(${hasVersionKey} AND NOT ${versionIsDecision})`;
-  const v2Valid = `(
-        json_type(${doc}, '$.version') IN ('integer', 'real')
-        AND json_extract(${doc}, '$.version') = 2
-        AND json_type(${doc}, '$.trailingBlank') = 'object'
-        AND NOT EXISTS (
-            SELECT 1 FROM json_each(${doc}, '$.trailingBlank') AS entry
-            WHERE entry.key = '' OR NOT ${validDecisionSql("entry.type", "entry.value")}
-        )
-    )`;
-  const v1Valid = `NOT EXISTS (
-        SELECT 1 FROM json_each(${doc}) AS entry
-        WHERE entry.key = '' OR NOT ${validDecisionSql("entry.type", "entry.value")}
-    )`;
-  db.exec("DROP TABLE IF EXISTS temp.v94_replay_documents");
-  db.exec(`
-        CREATE TEMP TABLE v94_replay_documents AS
-        SELECT session_id, version FROM (
-            SELECT sm.session_id AS session_id, CASE WHEN ${isV2} THEN 2 ELSE 1 END AS version,
-                CASE WHEN ${isV2} THEN ${v2Valid} ELSE ${v1Valid} END AS strictly_valid
-            FROM session_meta AS sm
-            WHERE typeof(${doc}) = 'text' AND ${doc} <> ''
-                AND json_valid(${doc}) AND json_type(${doc}) = 'object'
-        ) WHERE strictly_valid;
-    `);
-  db.exec(`
-        INSERT INTO session_replay_decisions (session_id, message_id, decision)
-        SELECT sm.session_id, entry.key, entry.value
-        FROM v94_replay_documents AS moved
-        JOIN session_meta AS sm ON sm.session_id = moved.session_id
-        JOIN json_each(
-            ${doc}, CASE moved.version WHEN 2 THEN '$.trailingBlank' ELSE '$' END
-        ) AS entry
-        WHERE true
-        ON CONFLICT(session_id, message_id) DO UPDATE SET decision = excluded.decision;
-    `);
-  db.exec(`
-        UPDATE session_meta SET trailing_blank_decisions = (
-            SELECT CASE moved.version
-                WHEN 2 THEN json_set(session_meta.trailing_blank_decisions, '$.trailingBlank', json('{}'))
-                ELSE ''
-            END
-            FROM v94_replay_documents AS moved WHERE moved.session_id = session_meta.session_id
-        )
-        WHERE session_id IN (SELECT session_id FROM v94_replay_documents);
-    `);
-  db.exec("DROP TABLE temp.v94_replay_documents");
-}
-
 // src/features/magic-context/opencode2-relabel.ts
 var OPENCODE2_RELABEL_STATE_KEY = "v87_opencode2_relabel";
 var V87_HARNESS_TWIN_RULES = [
@@ -1163,7 +586,7 @@ function collectCandidateSessions(db, shapes) {
   return [...sessions].sort();
 }
 function openEvidenceStore(path) {
-  const store = new Database(path, { readonly: true, fileMustExist: true });
+  const store = new Database2(path, { readonly: true, fileMustExist: true });
   try {
     const hasV1Messages = tableExists2(store, "message");
     const hasV1Session = tableExists2(store, "session");
@@ -1274,13 +697,13 @@ function repairOpenCode2HarnessLabels(db, options) {
         reason = "store_schema_unknown";
     } catch (error) {
       reason = "store_unreadable";
-      log(`[migration] OpenCode session database at ${resolution.path} could not be read: ${error instanceof Error ? error.message : String(error)}`);
+      log2(`[migration] OpenCode session database at ${resolution.path} could not be read: ${error instanceof Error ? error.message : String(error)}`);
     }
   }
   if (!evidence || reason !== null) {
     evidence?.close();
     writeUnresolvedState(db, reason ?? "store_not_found", resolution, candidateSessionIds);
-    log(`[migration] OpenCode harness labels left unverified for ${candidateSessionIds.length} session(s): ` + `no readable OpenCode session database (${reason ?? "store_not_found"}) at ${resolution.path}. ` + "Nothing was relabelled; `magic-context doctor` reports the affected sessions.");
+    log2(`[migration] OpenCode harness labels left unverified for ${candidateSessionIds.length} session(s): ` + `no readable OpenCode session database (${reason ?? "store_not_found"}) at ${resolution.path}. ` + "Nothing was relabelled; `magic-context doctor` reports the affected sessions.");
     return {
       status: "unresolved",
       reason: reason ?? "store_not_found",
@@ -1314,7 +737,7 @@ function repairOpenCode2HarnessLabels(db, options) {
   clearUnresolvedState(db);
   if (relabelledSessions.length > 0) {
     const toOpenCode2 = relabelledSessions.filter((entry) => entry.harness === "opencode2").length;
-    log(`[migration] OpenCode harness labels repaired from ${resolution.path}: ` + `${toOpenCode2} session(s) restored to opencode2, ` + `${relabelledSessions.length - toOpenCode2} session(s) set to opencode.`);
+    log2(`[migration] OpenCode harness labels repaired from ${resolution.path}: ` + `${toOpenCode2} session(s) restored to opencode2, ` + `${relabelledSessions.length - toOpenCode2} session(s) set to opencode.`);
   }
   return {
     status: "resolved",
@@ -1406,7 +829,7 @@ function installCompartmentHistoryVersions(db) {
 }
 
 // src/features/magic-context/workspaces.ts
-import { createHash as createHash4 } from "node:crypto";
+import { createHash as createHash2 } from "node:crypto";
 var VALID_SHARE_CATEGORIES = new Set(V2_MEMORY_CATEGORIES);
 var DEFAULT_WORKSPACE_SHARE_CATEGORIES = ["CONSTRAINTS"];
 function tableExists3(db, tableName) {
@@ -1427,7 +850,7 @@ function defaultWorkspaceShareCategories() {
   return [...DEFAULT_WORKSPACE_SHARE_CATEGORIES];
 }
 function warnInvalidShareCategories(reason, raw) {
-  log("[magic-context] WARN: invalid workspace share_categories; sharing no foreign memory categories", {
+  log2("[magic-context] WARN: invalid workspace share_categories; sharing no foreign memory categories", {
     reason,
     raw
   });
@@ -1474,7 +897,7 @@ function selectWorkspaceShareCategories(db, identities) {
   if (!hasMembership)
     return null;
   if (!tableExists3(db, "workspaces")) {
-    log("[magic-context] WARN: workspace member has no workspaces table; sharing no foreign memory categories");
+    log2("[magic-context] WARN: workspace member has no workspaces table; sharing no foreign memory categories");
     return [];
   }
   if (!columnExists2(db, "workspaces", "share_categories")) {
@@ -1487,7 +910,7 @@ function selectWorkspaceShareCategories(db, identities) {
               ORDER BY workspace.id ASC
               LIMIT 1`).get(...candidates);
   if (!row) {
-    log("[magic-context] WARN: workspace member has no workspace share_categories row; sharing no foreign memory categories");
+    log2("[magic-context] WARN: workspace member has no workspace share_categories row; sharing no foreign memory categories");
     return [];
   }
   return normalizeShareCategories(row.shareCategories);
@@ -1592,7 +1015,7 @@ function computeWorkspaceEpochFingerprint(db, identities) {
   const canonical = uniqueSorted(identities.filter((identity) => identity.length > 0));
   const epochs = getEpochMap(db, canonical);
   const shareCategories = selectWorkspaceShareCategories(db, canonical);
-  const hash = createHash4("sha256");
+  const hash = createHash2("sha256");
   hash.update("share_categories", "utf8");
   hash.update("\x00");
   hash.update(shareCategories === null ? "NO_WORKSPACE" : JSON.stringify(shareCategories), "utf8");
@@ -2075,10 +1498,10 @@ var MIGRATIONS = [
       const hasTable = (name) => Boolean(db.prepare("SELECT name FROM sqlite_master WHERE type='table' AND name = ?").get(name));
       const memoryEmbeddings = hasTable("memory_embeddings") ? db.prepare(`DELETE FROM memory_embeddings
                            WHERE memory_id NOT IN (SELECT id FROM memories)`).run().changes : 0;
-      log(`[migrations] v12 cleaned ${memoryEmbeddings} orphan memory_embeddings row(s)`);
+      log2(`[migrations] v12 cleaned ${memoryEmbeddings} orphan memory_embeddings row(s)`);
       const gitCommitEmbeddings = hasTable("git_commit_embeddings") ? db.prepare(`DELETE FROM git_commit_embeddings
                            WHERE sha NOT IN (SELECT sha FROM git_commits)`).run().changes : 0;
-      log(`[migrations] v12 cleaned ${gitCommitEmbeddings} orphan git_commit_embeddings row(s)`);
+      log2(`[migrations] v12 cleaned ${gitCommitEmbeddings} orphan git_commit_embeddings row(s)`);
     }
   },
   {
@@ -4095,7 +3518,7 @@ function runMigrations(db) {
           return false;
         if (!loggedPlan) {
           const pendingCount = MIGRATIONS.filter((candidate) => candidate.version > currentVersion && !isMigrationApplied(db, candidate.version)).length;
-          log(`[migrations] current upstream migration lane: ${currentVersion}, applying ${pendingCount} migration(s)`);
+          log2(`[migrations] current upstream migration lane: ${currentVersion}, applying ${pendingCount} migration(s)`);
           loggedPlan = true;
         }
         if (isMainThread)
@@ -4110,13 +3533,13 @@ function runMigrations(db) {
         break;
       if (migration.version <= 61)
         touchedLegacyAuthorityBatch = true;
-      log(`[migrations] applied v${migration.version}: ${migration.description}`);
+      log2(`[migrations] applied v${migration.version}: ${migration.description}`);
     } catch (error) {
       if (!migration && isSqliteLockError(error)) {
         throw new MigrationLockBusyError(`failed to acquire migration write lock: ${error instanceof Error ? error.message : String(error)}`);
       }
       if (migration && isSiblingMigrationConflict(db, error, migration.version)) {
-        log(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
+        log2(`[migrations] v${migration.version} already applied by sibling instance — resuming with re-read version`);
         const reReadVersion = getCurrentVersion(db);
         if (reReadVersion > currentVersion)
           continue;
@@ -4124,7 +3547,7 @@ function runMigrations(db) {
       }
       const version = migration?.version ?? currentVersion + 1;
       const description = migration?.description ?? "acquire migration write lock";
-      log(`[migrations] FAILED v${version}: ${description} — ${error instanceof Error ? error.message : String(error)}`);
+      log2(`[migrations] FAILED v${version}: ${description} — ${error instanceof Error ? error.message : String(error)}`);
       throw new Error(`Migration v${version} failed: ${error instanceof Error ? error.message : String(error)}. Database may need manual repair.`);
     }
   }
@@ -4141,7 +3564,7 @@ function runMigrations(db) {
     }
   }
   if (loggedPlan) {
-    log(`[migrations] upstream migration lane now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
+    log2(`[migrations] upstream migration lane now: ${MIGRATIONS[MIGRATIONS.length - 1].version}`);
   }
 }
 async function runMigrationsWithRetry(db, options = {}) {
@@ -4149,7 +3572,7 @@ async function runMigrationsWithRetry(db, options = {}) {
   const sleep = options.sleep ?? ((delayMs) => new Promise((resolve) => setTimeout(resolve, delayMs)));
   const totalAttempts = retryDelaysMs.length + 1;
   for (let attempt = 1;attempt <= totalAttempts; attempt += 1) {
-    log(`[migrations] migration lock check attempt ${attempt}/${totalAttempts}`);
+    log2(`[migrations] migration lock check attempt ${attempt}/${totalAttempts}`);
     try {
       runMigrations(db);
       return;
@@ -4159,174 +3582,10 @@ async function runMigrationsWithRetry(db, options = {}) {
       const delayMs = retryDelaysMs[attempt - 1];
       if (delayMs === undefined)
         throw error;
-      log(`[migrations] migration write lock is busy; retrying attempt ${attempt + 1}/${totalAttempts} in ${delayMs}ms`);
+      log2(`[migrations] migration write lock is busy; retrying attempt ${attempt + 1}/${totalAttempts} in ${delayMs}ms`);
       await sleep(delayMs);
     }
   }
 }
 
-// src/plugin/boot-quiet.ts
-var BOOT_QUIET_MS = 120000;
-var bootQuietUntilMs = 0;
-function beginBootQuietPeriod(now = Date.now()) {
-  if (bootQuietUntilMs === 0)
-    bootQuietUntilMs = now + BOOT_QUIET_MS;
-}
-function bootQuietRemainingMs(now = Date.now()) {
-  return Math.max(0, bootQuietUntilMs - now);
-}
-function scheduleAfterBootQuiet(task, additionalDelayMs = 0) {
-  const timer = setTimeout(task, bootQuietRemainingMs() + Math.max(0, additionalDelayMs));
-  timer.unref?.();
-  return timer;
-}
-
-// src/features/magic-context/message-fts-rowid-map.ts
-import { createHash as createHash5 } from "node:crypto";
-var MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE = 100;
-var BACKFILL_STATE_ID = 1;
-var EMPTY_INDEX_CONTENT_HASH = createHash5("sha256").update("").digest("hex");
-var upsertMapStatements = new WeakMap;
-var rangeReadyStatements = new WeakMap;
-var updateTimeStatements = new WeakMap;
-var activeBackfills = new WeakMap;
-function getUpsertMapStatement(db) {
-  let statement = upsertMapStatements.get(db);
-  if (!statement) {
-    statement = db.prepare(`INSERT INTO message_fts_rowid_map
-                 (session_id, message_ordinal, fts_rowid, message_time_ms)
-             VALUES (?, ?, ?, ?)
-             ON CONFLICT(session_id, message_ordinal) DO UPDATE SET
-                 fts_rowid = excluded.fts_rowid,
-                 message_time_ms = COALESCE(
-                     excluded.message_time_ms,
-                     message_fts_rowid_map.message_time_ms
-                 )`);
-    upsertMapStatements.set(db, statement);
-  }
-  return statement;
-}
-function getBackfillState(db) {
-  const row = db.prepare(`SELECT watermark_rowid AS watermarkRowid, completed
-             FROM message_fts_rowid_map_backfill_state
-             WHERE id = ?`).get(BACKFILL_STATE_ID);
-  return {
-    processed: 0,
-    watermarkRowid: typeof row?.watermarkRowid === "number" && Number.isSafeInteger(row.watermarkRowid) ? row.watermarkRowid : 0,
-    completed: row?.completed === 1
-  };
-}
-function recordMessageFtsRowid(db, sessionId, messageOrdinal, ftsRowid, messageTimeMs = null) {
-  const numericRowid = Number(ftsRowid);
-  if (!Number.isSafeInteger(numericRowid) || numericRowid <= 0) {
-    throw new Error(`invalid message FTS rowid: ${String(ftsRowid)}`);
-  }
-  const normalizedTime = typeof messageTimeMs === "number" && Number.isSafeInteger(messageTimeMs) && messageTimeMs >= 0 ? messageTimeMs : null;
-  getUpsertMapStatement(db).run(sessionId, messageOrdinal, numericRowid, normalizedTime);
-}
-function backfillMessageFtsRowidMapBatch(db, batchSize = MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE) {
-  const boundedBatchSize = Number.isFinite(batchSize) ? Math.min(MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE, Math.max(1, Math.floor(batchSize))) : MESSAGE_FTS_ROWID_MAP_BACKFILL_BATCH_SIZE;
-  let progress = {
-    processed: 0,
-    watermarkRowid: 0,
-    completed: false
-  };
-  let transactionStartedAt = 0;
-  db.transaction(() => {
-    transactionStartedAt = performance.now();
-    db.prepare(`INSERT OR IGNORE INTO message_fts_rowid_map_backfill_state
-            (id, watermark_rowid, completed) VALUES (?, 0, 0)`).run(BACKFILL_STATE_ID);
-    const state = getBackfillState(db);
-    if (state.completed) {
-      progress = state;
-      return;
-    }
-    const rows = db.prepare(`SELECT rowid AS ftsRowid,
-            session_id AS sessionId, message_ordinal AS messageOrdinal
-            FROM message_history_fts WHERE rowid > ? ORDER BY rowid ASC LIMIT ?`).all(state.watermarkRowid, boundedBatchSize);
-    let watermarkRowid = state.watermarkRowid;
-    for (const row of rows) {
-      const ftsRowid = Number(row.ftsRowid);
-      const messageOrdinal = Number(row.messageOrdinal);
-      if (Number.isSafeInteger(ftsRowid) && ftsRowid > watermarkRowid) {
-        watermarkRowid = ftsRowid;
-      }
-      if (typeof row.sessionId === "string" && Number.isSafeInteger(messageOrdinal) && messageOrdinal >= 0 && Number.isSafeInteger(ftsRowid) && ftsRowid > 0) {
-        recordMessageFtsRowid(db, row.sessionId, messageOrdinal, ftsRowid);
-      }
-    }
-    const completed = rows.length < boundedBatchSize;
-    db.prepare(`UPDATE message_fts_rowid_map_backfill_state
-             SET watermark_rowid = ?, completed = ?, updated_at = ?
-             WHERE id = ?`).run(watermarkRowid, completed ? 1 : 0, Date.now(), BACKFILL_STATE_ID);
-    progress = {
-      processed: rows.length,
-      watermarkRowid,
-      completed
-    };
-  }).immediate();
-  logSlowWriteTransaction("message_fts_rowid_backfill", transactionStartedAt);
-  return progress;
-}
-async function runMessageFtsRowidMapBackfill(db) {
-  await new Promise((resolve) => setTimeout(resolve, 0));
-  for (;; ) {
-    const progress = backfillMessageFtsRowidMapBatch(db);
-    if (progress.completed)
-      return;
-    await new Promise((resolve) => setTimeout(resolve, 0));
-  }
-}
-function startMessageFtsRowidMapBackfill(db) {
-  const active = activeBackfills.get(db);
-  if (active)
-    return active;
-  const run = withoutSqliteTransformPass(() => withSqliteBackgroundWriter(() => runMessageFtsRowidMapBackfill(db))).finally(() => {
-    activeBackfills.delete(db);
-  });
-  activeBackfills.set(db, run);
-  return run;
-}
-function messageFtsOrdinalRangeIsMapped(db, sessionId, startOrdinal, endOrdinal) {
-  if (endOrdinal < startOrdinal)
-    return true;
-  if (getBackfillState(db).completed)
-    return true;
-  let statement = rangeReadyStatements.get(db);
-  if (!statement) {
-    statement = db.prepare(`SELECT COUNT(DISTINCT source.message_ordinal) AS sourceOrdinalCount,
-                    COUNT(DISTINCT CASE
-                        WHEN source.role IN ('user', 'assistant')
-                         AND source.normalized_content_hash != ?
-                        THEN source.message_ordinal
-                    END) AS expectedMapCount,
-                    COUNT(DISTINCT CASE
-                        WHEN source.role IN ('user', 'assistant')
-                         AND source.normalized_content_hash != ?
-                         AND map.fts_rowid IS NOT NULL
-                        THEN source.message_ordinal
-                    END) AS mappedCount
-             FROM message_history_source AS source
-             LEFT JOIN message_fts_rowid_map AS map
-               ON map.session_id = source.session_id
-              AND map.message_ordinal = source.message_ordinal
-             WHERE source.session_id = ?
-               AND source.message_ordinal BETWEEN ? AND ?`);
-    rangeReadyStatements.set(db, statement);
-  }
-  const row = statement.get(EMPTY_INDEX_CONTENT_HASH, EMPTY_INDEX_CONTENT_HASH, sessionId, startOrdinal, endOrdinal);
-  const ordinalCount = endOrdinal - startOrdinal + 1;
-  return row?.sourceOrdinalCount === ordinalCount && row.expectedMapCount === row.mappedCount;
-}
-function deleteUnmappedMessageFtsRows(db, sessionIds) {
-  if (sessionIds.length === 0)
-    return;
-  const state = getBackfillState(db);
-  if (state.completed)
-    return;
-  const placeholders = sessionIds.map(() => "?").join(", ");
-  db.prepare(`DELETE FROM message_history_fts
-         WHERE rowid > ? AND session_id IN (${placeholders})`).run(state.watermarkRowid, ...sessionIds);
-}
-
-export { canonicalProjectDirectory, setHomeProjectPermission, shouldSkipHomeProjectMemory, ProjectIdentityError, takeDubiousOwnershipProjectIdentityWarning, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, describeUnresolvedProjectIdentity, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, recordMessageFtsRowid, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows, V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL, unescapeXml, parseCompartmentOutput, layoutLkgPrefix, assembleLkgPrefix, LKG_SLOT_CHUNKS_DDL, SESSION_REPLAY_DECISIONS_DDL, LKG_SLOTS_DDL, installCompartmentHistoryVersions, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, FORK_MIGRATION_VERSION_FLOOR, managedAuthorityNoteRow, hasPendingMigrations, getMainThreadMigrationBodyCount, runMigrations, runMigrationsWithRetry, beginBootQuietPeriod, bootQuietRemainingMs, scheduleAfterBootQuiet };
+export { layoutLkgPrefix, assembleLkgPrefix, LKG_SLOT_CHUNKS_DDL, SESSION_REPLAY_DECISIONS_DDL, LKG_SLOTS_DDL, unescapeXml, parseCompartmentOutput, installCompartmentHistoryVersions, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, FORK_MIGRATION_VERSION_FLOOR, managedAuthorityNoteRow, hasPendingMigrations, getMainThreadMigrationBodyCount, runMigrations, runMigrationsWithRetry };