@cortexkit/opencode-magic-context 0.47.0 → 0.48.0

package/dist/{index-x3kwrmqk.js → v2/server-e0vdaae2.js}

@@ -1,628 +1,33 @@
 import {
-  getMagicContextStorageDir
-} from "./index-q6hef7fh.js";
+  V2_MEMORY_CATEGORIES
+} from "./server-fr0wbhdn.js";
 import {
-  log
-} from "./index-hybnrwq0.js";
+  log2
+} from "./server-5m3dt5r1.js";
 import {
   ensureColumn,
   healAllNullColumns,
   installV95PerfSchema
-} from "./index-5gq3b2ya.js";
+} from "./server-52awr2mw.js";
 import {
   resolveOpenCodeDbPath,
   openCodeDbPathExists,
   getOpenCodeDbProbeDescriptions
-} from "./index-b35pxds2.js";
+} from "./server-2ra6pwf3.js";
 import {
-  Database,
-  withSqliteBackgroundWriter,
-  withoutSqliteTransformPass
-} from "./index-wx8a6bw3.js";
+  Database2
+} from "./server-kb9nn0a0.js";
 import {
-  writeStorageFileAtomicSync
-} from "./index-1bc61ans.js";
+  normalizeStoredProjectPath,
+  storedPathBelongsToIdentity
+} from "./server-yczc713m.js";
 import {
   logSlowWriteTransaction
-} from "./index-sj29b3z2.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";
-
-// src/features/magic-context/memory/project-identity-cache.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");
-    }
-    return true;
-  }
-}
-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 asError(error) {
-  return error instanceof Error ? error : undefined;
-}
-function getErrorCode(error) {
-  if (error === null || typeof error !== "object" || !("code" in error)) {
-    return;
-  }
-  const code = error.code;
-  return typeof code === "string" ? code : undefined;
-}
-function getErrorSignal(error) {
-  if (error === null || typeof error !== "object" || !("signal" in error)) {
-    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 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;
-    }
-    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)
-    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))
-    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;
-  }
-}
-function directoryHasGitMetadata(directory) {
-  return gitRootDirectory(path3.resolve(directory)) !== null;
-}
-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.`;
-}
-function isUsableProjectIdentity(identity) {
-  return typeof identity === "string" && identity.trim().length > 0;
-}
-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;
-  }
-  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 (identity !== undefined)
-    pausedIdentityReasons.delete(resolvedDirectory);
-  sessionIdentityCache.set(cacheKey, {
-    identity,
-    revalidateAt: identity?.startsWith("git:") === true ? null : nowMs() + TRANSIENT_FAILURE_COOLDOWN_MS
-  });
-  return identity;
-}
-function normalizeStoredProjectPath(rawOrStored) {
-  if (rawOrStored.startsWith("git:") || rawOrStored.startsWith("dir:")) {
-    return rawOrStored;
-  }
-  try {
-    return resolveProjectIdentity(rawOrStored);
-  } catch {
-    return rawOrStored;
-  }
-}
-function storedPathBelongsToIdentity(storedProjectPath, projectIdentity) {
-  return storedProjectPath === projectIdentity || normalizeStoredProjectPath(storedProjectPath) === projectIdentity;
-}
-
-// 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;
-}
+} from "./server-aan4q8mx.js";
 
 // 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 = {
@@ -832,7 +237,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)
@@ -916,7 +321,7 @@ function parseEvents(text) {
 }
 
 // src/features/magic-context/lkg-prefix-chunks.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash } from "node:crypto";
 var LKG_PREFIX_CHUNK_CHARS = 64 * 1024;
 function splitLkgPrefix(jsonPrefix) {
   const chunks = [];
@@ -934,10 +339,10 @@ function splitLkgPrefix(jsonPrefix) {
   return chunks;
 }
 function hashLkgChunk(body) {
-  return createHash3("sha256").update(body).digest("hex");
+  return createHash("sha256").update(body).digest("hex");
 }
 function hashLkgChunkList(chunkHashes) {
-  return createHash3("sha256").update(chunkHashes.join(`
+  return createHash("sha256").update(chunkHashes.join(`
 `)).digest("hex");
 }
 function layoutLkgPrefix(jsonPrefix) {
@@ -1181,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");
@@ -1292,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",
@@ -1332,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",
@@ -1424,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) {
@@ -1445,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
   });
@@ -1492,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")) {
@@ -1505,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);
@@ -1610,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");
@@ -2093,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)`);
     }
   },
   {
@@ -4113,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)
@@ -4128,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;
@@ -4142,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.`);
     }
   }
@@ -4159,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 = {}) {
@@ -4167,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;
@@ -4177,172 +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/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 recordIndexedMessageTime(db, sessionId, messageOrdinal, messageTimeMs) {
-  if (typeof messageTimeMs !== "number" || !Number.isSafeInteger(messageTimeMs) || messageTimeMs < 0) {
-    return;
-  }
-  let statement = updateTimeStatements.get(db);
-  if (!statement) {
-    statement = db.prepare(`UPDATE message_fts_rowid_map
-                SET message_time_ms = ?
-              WHERE session_id = ? AND message_ordinal = ?
-                AND message_time_ms IS NULL`);
-    updateTimeStatements.set(db, statement);
-  }
-  statement.run(messageTimeMs, sessionId, messageOrdinal);
-}
-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, resolveProjectIdentityStrict, takeDubiousOwnershipProjectIdentityWarning, isUserHomeDirectory, resolveProjectIdentity, directoryHasGitMetadata, describeUnresolvedProjectIdentity, isUsableProjectIdentity, resolveProjectIdentityForSession, normalizeStoredProjectPath, storedPathBelongsToIdentity, beginBootQuietPeriod, bootQuietRemainingMs, scheduleAfterBootQuiet, recordMessageFtsRowid, recordIndexedMessageTime, startMessageFtsRowidMapBackfill, messageFtsOrdinalRangeIsMapped, deleteUnmappedMessageFtsRows, layoutLkgPrefix, assembleLkgPrefix, LKG_SLOT_CHUNKS_DDL, SESSION_REPLAY_DECISIONS_DDL, LKG_SLOTS_DDL, V2_MEMORY_CATEGORIES, PROMOTABLE_CATEGORIES, CATEGORY_PRIORITY, getMemoryCategoryOrder, CATEGORY_DEFAULT_TTL, unescapeXml, parseCompartmentOutput, installCompartmentHistoryVersions, resolveWorkspaceShareCategories, resolveWorkspaceIdentitySet, expandWorkspaceIdentitySetWithAliases, resolveStoredPathWorkspaceIdentity, storedPathBelongsToWorkspace, sourceNameForMemory, computeWorkspaceEpochFingerprint, FORK_MIGRATION_VERSION_FLOOR, managedAuthorityNoteRow, hasPendingMigrations, getMainThreadMigrationBodyCount, runMigrations, runMigrationsWithRetry };
+export { 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 };