@cortexkit/opencode-magic-context 0.41.4 → 0.42.1

package/dist/index-1974jvn3.js

@@ -0,0 +1,783 @@
+import {
+  log
+} from "./index-dkv2dn46.js";
+
+// src/shared/opencode-db-path.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join } from "node:path";
+var cachedResolution = null;
+var lastReadFailure = null;
+var claimedDiagnostics = new Set;
+function openCodeDataDir() {
+  return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
+}
+function environmentKey(dataDir) {
+  return [
+    dataDir,
+    process.env.OPENCODE_DB ?? "",
+    process.env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
+    process.env.OPENCODE_CHANNEL ?? ""
+  ].join("\x00");
+}
+function channelPath(dataDir, channel) {
+  return ["latest", "beta", "prod"].includes(channel) ? join(dataDir, "opencode.db") : join(dataDir, `opencode-${channel}.db`);
+}
+function discoveredCandidateNames(dataDir) {
+  const names = ["opencode.db", "opencode-local.db", "opencode-dev.db"];
+  try {
+    const discovered = readdirSync(dataDir, { withFileTypes: true }).filter((entry) => /^opencode-.+\.db$/.test(entry.name) && !names.includes(entry.name)).map((entry) => entry.name).sort();
+    names.push(...discovered);
+  } catch {}
+  return names;
+}
+function discoverOpenCodeDb(dataDir) {
+  const candidates = discoveredCandidateNames(dataDir).map((name, order) => {
+    const path = join(dataDir, name);
+    try {
+      const metadata = statSync(path);
+      return metadata.isFile() ? { path, order, mtimeMs: metadata.mtimeMs } : null;
+    } catch {
+      return null;
+    }
+  });
+  const existing = candidates.filter((candidate) => candidate !== null).sort((left, right) => right.mtimeMs - left.mtimeMs || left.order - right.order)[0];
+  if (!existing) {
+    return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
+  }
+  const name = existing.path.slice(dataDir.length + 1);
+  const channel = name === "opencode.db" ? null : name.slice("opencode-".length, -".db".length) || null;
+  return { path: existing.path, source: "discovered", channel };
+}
+function resolveFresh(dataDir) {
+  const explicit = process.env.OPENCODE_DB;
+  if (explicit !== undefined && explicit.length > 0) {
+    if (explicit === ":memory:") {
+      return { path: explicit, source: "OPENCODE_DB", channel: null };
+    }
+    return {
+      path: isAbsolute(explicit) ? explicit : join(dataDir, explicit),
+      source: "OPENCODE_DB",
+      channel: null
+    };
+  }
+  const disableChannelDb = process.env.OPENCODE_DISABLE_CHANNEL_DB;
+  if (disableChannelDb === "1" || disableChannelDb === "true") {
+    return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
+  }
+  const channel = process.env.OPENCODE_CHANNEL;
+  if (channel !== undefined && channel.length > 0) {
+    return { path: channelPath(dataDir, channel), source: "channel", channel };
+  }
+  return discoverOpenCodeDb(dataDir);
+}
+function resolveOpenCodeDbPath() {
+  const dataDir = openCodeDataDir();
+  const key = environmentKey(dataDir);
+  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync(cachedResolution.resolution.path))) {
+    if (cachedResolution.existed)
+      return cachedResolution.resolution;
+  }
+  const resolution = resolveFresh(dataDir);
+  cachedResolution = {
+    key,
+    resolution,
+    existed: resolution.path !== ":memory:" && existsSync(resolution.path)
+  };
+  return resolution;
+}
+function openCodeDbPathExists(resolution = resolveOpenCodeDbPath()) {
+  return resolution.path !== ":memory:" && existsSync(resolution.path);
+}
+function getOpenCodeDbProbeDescriptions(resolution = resolveOpenCodeDbPath()) {
+  if (resolution.source === "OPENCODE_DB")
+    return [resolution.path];
+  if (resolution.source === "channel" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "1" || process.env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
+    return [resolution.path];
+  }
+  const dataDir = openCodeDataDir();
+  return [
+    join(dataDir, "opencode.db"),
+    join(dataDir, "opencode-local.db"),
+    join(dataDir, "opencode-dev.db"),
+    join(dataDir, "opencode-<channel>.db")
+  ];
+}
+function lookedForText(resolution) {
+  return getOpenCodeDbProbeDescriptions(resolution).join(", ");
+}
+function formatOpenCodeDbMissingBanner(resolution = resolveOpenCodeDbPath()) {
+  return `Magic Context cannot find OpenCode's session database (looked for ${lookedForText(resolution)}). History compaction (historian) and the mid-turn valve are disabled until it is found; set OPENCODE_DB if OpenCode stores it elsewhere.`;
+}
+function formatOpenCodeDbMissingStatusLine(resolution = resolveOpenCodeDbPath()) {
+  return `OpenCode DB: MISSING (looked for ${lookedForText(resolution)}). History compaction (historian) and the mid-turn valve are disabled; set OPENCODE_DB if OpenCode stores it elsewhere.`;
+}
+function formatOpenCodeDbReadFailureStatusLine(failure) {
+  return `OpenCode DB: READ FAILED (path=${failure.path}, source=${failure.source}) — ${failure.message}`;
+}
+function recordOpenCodeDbReadFailure(resolution, error) {
+  const message = error instanceof Error ? error.message : String(error);
+  lastReadFailure = { ...resolution, message };
+  return lastReadFailure;
+}
+function clearOpenCodeDbReadFailure(path) {
+  if (path === undefined || lastReadFailure?.path === path)
+    lastReadFailure = null;
+}
+function getOpenCodeDbReadFailure() {
+  return lastReadFailure;
+}
+function claimOpenCodeDbDiagnosticOnce(surface, resolution) {
+  const key = `${surface}\x00${resolution.path}\x00${resolution.source}`;
+  if (claimedDiagnostics.has(key))
+    return false;
+  claimedDiagnostics.add(key);
+  return true;
+}
+
+// src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+
+// src/shared/sqlite.ts
+import { statSync as statSync2 } from "node:fs";
+var reportSlowPrivilegedWrite;
+function registerSlowWriteReporter(reporter) {
+  reportSlowPrivilegedWrite = reporter;
+}
+function detectSqliteRuntime() {
+  const hasBunVersion = typeof process !== "undefined" && typeof process.versions?.bun === "string";
+  const hasBunGlobal = typeof globalThis !== "undefined" && typeof globalThis.Bun !== "undefined";
+  return hasBunVersion || hasBunGlobal ? "Bun" : "Node.js";
+}
+var bunSpec = "bun:" + "sqlite";
+var nodeSpec = "node:" + "sqlite";
+async function importSqliteModule(specifier) {
+  return await import(specifier);
+}
+function isModuleNotFoundError(error, specifier) {
+  const candidate = error;
+  const code = typeof candidate?.code === "string" ? candidate.code : "";
+  const name = typeof candidate?.name === "string" ? candidate.name : "";
+  const message = error instanceof Error ? error.message : String(error ?? "");
+  const details = `${code} ${name} ${message}`.toLowerCase();
+  const mentionsSpecifier = details.includes(specifier.toLowerCase());
+  if (!mentionsSpecifier)
+    return false;
+  return code === "ERR_MODULE_NOT_FOUND" || code === "ERR_UNKNOWN_BUILTIN_MODULE" || code === "MODULE_NOT_FOUND" || name === "ResolveMessage" || details.includes("module not found") || details.includes("cannot find module") || details.includes("cannot find package") || details.includes("no such built-in module");
+}
+
+class SqliteRuntimeUnavailableError extends Error {
+  runtime;
+  specifier;
+  constructor(runtime, specifier, cause) {
+    const requirement = specifier === nodeSpec ? "Requires Node.js >= 24, or Bun with bun:sqlite — this Bun build lacks node:sqlite." : "Requires Bun with bun:sqlite, or Node.js >= 24 — this Bun build lacks bun:sqlite.";
+    super(`Magic Context detected ${runtime}, but could not load ${specifier}. ${requirement}`, { cause });
+    this.name = "SqliteRuntimeUnavailableError";
+    this.runtime = runtime;
+    this.specifier = specifier;
+  }
+}
+async function loadSqliteModule(runtime = detectSqliteRuntime(), importer = importSqliteModule) {
+  const specifier = runtime === "Bun" ? bunSpec : nodeSpec;
+  try {
+    return await importer(specifier);
+  } catch (error) {
+    if (isModuleNotFoundError(error, specifier)) {
+      throw new SqliteRuntimeUnavailableError(runtime, specifier, error);
+    }
+    throw error;
+  }
+}
+var detectedRuntime = detectSqliteRuntime();
+var isBun = detectedRuntime === "Bun";
+var sqliteModule = await loadSqliteModule(detectedRuntime);
+var DatabaseImpl = isBun ? sqliteModule.Database : buildNodeSqliteDatabaseClass(sqliteModule.DatabaseSync);
+var trackedSqliteConnections = new Map;
+var nextSqliteConnectionSequence = 1;
+function trackSqliteConnection(db, filename, options) {
+  const originalClose = db.close.bind(db);
+  const sequence = nextSqliteConnectionSequence++;
+  const metadata = {
+    sequence,
+    filename: typeof filename === "string" ? filename : Buffer.isBuffer(filename) ? "<buffer>" : ":memory:",
+    readonly: Boolean(options) && typeof options === "object" && (options.readonly === true || options.readOnly === true)
+  };
+  Object.defineProperty(db, "close", {
+    configurable: true,
+    value: (...args) => {
+      try {
+        return originalClose(...args);
+      } finally {
+        trackedSqliteConnections.delete(sequence);
+      }
+    }
+  });
+  trackedSqliteConnections.set(sequence, {
+    ...metadata,
+    reference: new WeakRef(db)
+  });
+  return db;
+}
+var TrackedDatabase = new Proxy(DatabaseImpl, {
+  construct(target, args) {
+    const db = Reflect.construct(target, args, target);
+    return trackSqliteConnection(db, args[0], args[1]);
+  }
+});
+function buildNodeSqliteDatabaseClass(DatabaseSync) {
+  const SAVEPOINT = "mc_tx_sp";
+
+  class NodeSqliteDatabase extends DatabaseSync {
+    constructor(filename, options) {
+      const translated = { ...options };
+      if (options && "readonly" in options) {
+        translated.readOnly = options.readonly;
+        delete translated.readonly;
+      }
+      super(typeof filename === "string" ? filename : ":memory:", translated);
+    }
+    prepare(sql) {
+      const stmt = super.prepare(sql);
+      for (const method of ["run", "get", "all"]) {
+        const original = stmt[method].bind(stmt);
+        stmt[method] = (...args) => args.length === 1 && Array.isArray(args[0]) ? original(...args[0]) : original(...args);
+      }
+      return stmt;
+    }
+    transaction(fn) {
+      const self = this;
+      const execute = (mode, receiver, args) => {
+        const nested = self.isTransaction === true;
+        self.exec(nested ? `SAVEPOINT ${SAVEPOINT}` : `BEGIN${mode ? ` ${mode}` : ""}`);
+        try {
+          const result = fn.apply(receiver, args);
+          self.exec(nested ? `RELEASE ${SAVEPOINT}` : "COMMIT");
+          return result;
+        } catch (error) {
+          if (nested) {
+            self.exec(`ROLLBACK TO ${SAVEPOINT}`);
+            self.exec(`RELEASE ${SAVEPOINT}`);
+          } else {
+            self.exec("ROLLBACK");
+          }
+          throw error;
+        }
+      };
+      const wrapped = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.default = function(...args) {
+        return execute("", this, args);
+      };
+      wrapped.deferred = function(...args) {
+        return execute("DEFERRED", this, args);
+      };
+      wrapped.immediate = function(...args) {
+        return execute("IMMEDIATE", this, args);
+      };
+      wrapped.exclusive = function(...args) {
+        return execute("EXCLUSIVE", this, args);
+      };
+      return wrapped;
+    }
+  }
+  return NodeSqliteDatabase;
+}
+var Database = TrackedDatabase;
+function pragmaValue(db, name) {
+  const row = db.prepare(`PRAGMA ${name}`).get();
+  if (!row)
+    return;
+  return row[name] ?? Object.values(row)[0];
+}
+function pragmaNumber(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "number" && Number.isFinite(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function pragmaString(db, name) {
+  try {
+    const value = pragmaValue(db, name);
+    return typeof value === "string" ? value : null;
+  } catch {
+    return null;
+  }
+}
+function sqliteSidecarBytes(filename, suffix) {
+  if (filename === ":memory:" || filename === "<buffer>")
+    return 0;
+  try {
+    return statSync2(`${filename}${suffix}`).size;
+  } catch (error) {
+    return error.code === "ENOENT" ? 0 : null;
+  }
+}
+function fts5TableCount(db) {
+  try {
+    const row = db.prepare("SELECT COUNT(*) AS count FROM sqlite_master WHERE type = 'table' AND sql LIKE '%USING fts5%'").get();
+    return typeof row?.count === "number" ? row.count : null;
+  } catch {
+    return null;
+  }
+}
+function getSqliteMemoryStats() {
+  const connections = [];
+  for (const [sequence, tracked] of trackedSqliteConnections) {
+    const db = tracked.reference.deref();
+    if (!db) {
+      trackedSqliteConnections.delete(sequence);
+      continue;
+    }
+    const pageSize = pragmaNumber(db, "page_size");
+    const cacheSize = pragmaNumber(db, "cache_size");
+    const cacheSizeUnit = cacheSize === null ? null : cacheSize < 0 ? "kib" : "pages";
+    const cacheUpperBoundBytes = cacheSize === null ? null : cacheSize < 0 ? Math.abs(cacheSize) * 1024 : pageSize === null ? null : cacheSize * pageSize;
+    connections.push({
+      sequence: tracked.sequence,
+      filename: tracked.filename,
+      readonly: tracked.readonly,
+      pageSize,
+      pageCount: pragmaNumber(db, "page_count"),
+      freelistCount: pragmaNumber(db, "freelist_count"),
+      cacheSize,
+      cacheSizeUnit,
+      cacheUpperBoundBytes,
+      mmapSizeBytes: pragmaNumber(db, "mmap_size"),
+      walFileBytes: sqliteSidecarBytes(tracked.filename, "-wal"),
+      shmFileBytes: sqliteSidecarBytes(tracked.filename, "-shm"),
+      fts5TableCount: fts5TableCount(db),
+      journalMode: pragmaString(db, "journal_mode")
+    });
+  }
+  const sumKnown = (select) => connections.reduce((sum, connection) => sum + (select(connection) ?? 0), 0);
+  return {
+    connectionCount: connections.length,
+    cacheUpperBoundBytes: sumKnown((connection) => connection.cacheUpperBoundBytes),
+    mmapUpperBoundBytes: sumKnown((connection) => connection.mmapSizeBytes),
+    walFileBytes: sumKnown((connection) => connection.walFileBytes),
+    shmFileBytes: sumKnown((connection) => connection.shmFileBytes),
+    sqliteStatusApi: "unavailable",
+    connections
+  };
+}
+var privilegeDepth = new WeakMap;
+function isInTransaction(db) {
+  const candidate = db;
+  return candidate.inTransaction === true || candidate.isTransaction === true;
+}
+function withPrivilegedWriter(db, operation) {
+  const previousDepth = privilegeDepth.get(db) ?? 0;
+  const nested = isInTransaction(db);
+  const savepoint = "mc_privilege_scope";
+  const transactionStartedAt = nested ? undefined : performance.now();
+  if (nested) {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  } else {
+    db.exec("BEGIN IMMEDIATE");
+  }
+  privilegeDepth.set(db, previousDepth + 1);
+  try {
+    db.prepare("INSERT INTO context_privilege_state(id, enabled) VALUES (1, 1) ON CONFLICT(id) DO UPDATE SET enabled = 1").run();
+    const result = operation();
+    if (previousDepth === 0) {
+      db.prepare("UPDATE context_privilege_state SET enabled = 0 WHERE id = 1").run();
+    }
+    if (nested) {
+      db.exec(`RELEASE ${savepoint}`);
+    } else {
+      db.exec("COMMIT");
+      if (transactionStartedAt !== undefined) {
+        reportSlowPrivilegedWrite?.("privileged_writer", transactionStartedAt);
+      }
+    }
+    if (previousDepth > 0)
+      privilegeDepth.set(db, previousDepth);
+    else
+      privilegeDepth.delete(db);
+    return result;
+  } catch (error) {
+    try {
+      if (nested) {
+        db.exec(`ROLLBACK TO ${savepoint}`);
+        db.exec(`RELEASE ${savepoint}`);
+      } else {
+        db.exec("ROLLBACK");
+      }
+    } finally {
+      if (previousDepth > 0)
+        privilegeDepth.set(db, previousDepth);
+      else
+        privilegeDepth.delete(db);
+    }
+    throw error;
+  }
+}
+
+// src/hooks/magic-context/read-session-db.ts
+function openCodeDbExists() {
+  return openCodeDbPathExists(resolveOpenCodeDbPath());
+}
+var cachedReadOnlyDb = null;
+function closeCachedReadOnlyDb() {
+  if (!cachedReadOnlyDb) {
+    return;
+  }
+  try {
+    closeQuietly(cachedReadOnlyDb.db);
+  } catch (error) {
+    log("[magic-context] failed to close cached OpenCode read-only DB:", error);
+  } finally {
+    cachedReadOnlyDb = null;
+  }
+}
+function getReadOnlySessionDb() {
+  const resolution = resolveOpenCodeDbPath();
+  const dbPath = resolution.path;
+  if (!openCodeDbPathExists(resolution)) {
+    throw new Error(`OpenCode session database is unavailable at ${dbPath} (source=${resolution.source})`);
+  }
+  if (cachedReadOnlyDb?.path === dbPath) {
+    return cachedReadOnlyDb.db;
+  }
+  closeCachedReadOnlyDb();
+  const db = new Database(dbPath, { readonly: true });
+  cachedReadOnlyDb = { path: dbPath, db };
+  clearOpenCodeDbReadFailure();
+  return db;
+}
+function withReadOnlySessionDb(fn) {
+  return fn(getReadOnlySessionDb());
+}
+function getRawSessionMessageCountFromDb(db, sessionId) {
+  const row = db.prepare(`SELECT COUNT(*) as count FROM message WHERE session_id = ?
+             AND NOT (COALESCE(json_extract(data, '$.summary'), 0) = 1
+                      AND COALESCE(json_extract(data, '$.finish'), '') = 'stop')`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+var trackedSessions = new Map;
+var pendingParts = new Map;
+var probeLogObserverForTests;
+function asRecord(value) {
+  return value !== null && typeof value === "object" ? value : null;
+}
+function truthyStoredFlag(value) {
+  return value === true || value === 1 || value === "true";
+}
+function isMachineGeneratedPart(value) {
+  const part = asRecord(value);
+  if (!part)
+    return false;
+  const metadata = asRecord(part.metadata);
+  const marker = asRecord(metadata?.marker);
+  return truthyStoredFlag(part.synthetic) || truthyStoredFlag(part.ignored) || marker !== null && marker.kind !== null && marker.kind !== undefined;
+}
+function messageTimeCreated(message, fallback) {
+  const time = asRecord(message.info.time);
+  return typeof time?.created === "number" ? time.created : fallback;
+}
+function latestMessageByRole(messages, role, realUserOnly = false) {
+  let latest = null;
+  for (const [index, message] of messages.entries()) {
+    if (message.info.role !== role)
+      continue;
+    if (realUserOnly && message.parts.length > 0 && message.parts.every(isMachineGeneratedPart)) {
+      continue;
+    }
+    const timeCreated = messageTimeCreated(message, index);
+    if (latest === null || timeCreated > latest.timeCreated || timeCreated === latest.timeCreated && index > latest.index) {
+      latest = { message, timeCreated, index };
+    }
+  }
+  return latest;
+}
+function assistantAwaitingToolsFromMessages(messages) {
+  const latestAssistant = latestMessageByRole(messages, "assistant");
+  if (!latestAssistant)
+    return false;
+  const assistantTime = asRecord(latestAssistant.message.info.time);
+  if (typeof assistantTime?.created !== "number")
+    return false;
+  const latestRealUser = latestMessageByRole(messages, "user", true);
+  if (latestRealUser && latestRealUser.timeCreated > latestAssistant.timeCreated)
+    return false;
+  if (latestAssistant.message.info.finish === "tool-calls")
+    return true;
+  return latestAssistant.message.parts.some((value) => {
+    const part = asRecord(value);
+    return part?.type === "tool" && part.providerExecuted !== true;
+  });
+}
+function shouldHoldIgnoredNotificationFromMessages(messages) {
+  if (assistantAwaitingToolsFromMessages(messages))
+    return true;
+  const latestAssistant = latestMessageByRole(messages, "assistant");
+  if (latestAssistant) {
+    const finish = latestAssistant.message.info.finish;
+    if (typeof finish !== "string" || finish.length === 0)
+      return true;
+    if (finish === "tool-calls" || finish === "unknown")
+      return true;
+  }
+  const latestRealUser = latestMessageByRole(messages, "user", true);
+  return latestRealUser !== null && latestRealUser.timeCreated > (latestAssistant?.timeCreated ?? -1);
+}
+function trackedMessages(session) {
+  return [...session.messages.values()].sort((left, right) => left.timeCreated - right.timeCreated).map((message) => ({
+    info: {
+      id: message.id,
+      role: message.role,
+      time: { created: message.timeCreated },
+      ...message.finish === undefined ? {} : { finish: message.finish }
+    },
+    parts: [...message.parts.values()]
+  }));
+}
+function pendingMessageParts(sessionId, messageId) {
+  return pendingParts.get(sessionId)?.get(messageId) ?? new Map;
+}
+function observeOpenCodeTurnEvent(type, properties) {
+  const props = asRecord(properties);
+  if (!props)
+    return;
+  if (type === "message.part.updated") {
+    const part = asRecord(props.part);
+    if (!part || typeof part.sessionID !== "string" || typeof part.messageID !== "string" || typeof part.id !== "string") {
+      return;
+    }
+    const tracked = trackedSessions.get(part.sessionID)?.messages.get(part.messageID);
+    if (tracked) {
+      tracked.parts.set(part.id, part);
+      return;
+    }
+    let byMessage = pendingParts.get(part.sessionID);
+    if (!byMessage) {
+      byMessage = new Map;
+      pendingParts.set(part.sessionID, byMessage);
+    }
+    let parts = byMessage.get(part.messageID);
+    if (!parts) {
+      parts = new Map;
+      byMessage.set(part.messageID, parts);
+    }
+    parts.set(part.id, part);
+    return;
+  }
+  if (type === "message.updated") {
+    const info = asRecord(props.info);
+    const time = asRecord(info?.time);
+    if (!info || info.role !== "assistant" && info.role !== "user" || typeof info.sessionID !== "string" || typeof info.id !== "string") {
+      return;
+    }
+    let session = trackedSessions.get(info.sessionID);
+    if (!session) {
+      session = { messages: new Map, sequence: 0 };
+      trackedSessions.set(info.sessionID, session);
+    }
+    session.sequence += 1;
+    const existing = session.messages.get(info.id);
+    session.messages.set(info.id, {
+      id: info.id,
+      role: info.role,
+      timeCreated: typeof time?.created === "number" ? time.created : existing?.timeCreated ?? session.sequence,
+      ...typeof info.finish === "string" ? { finish: info.finish } : {},
+      parts: existing?.parts ?? pendingMessageParts(info.sessionID, info.id)
+    });
+    pendingParts.get(info.sessionID)?.delete(info.id);
+    return;
+  }
+  if (type === "message.removed") {
+    if (typeof props.sessionID === "string" && typeof props.messageID === "string") {
+      trackedSessions.get(props.sessionID)?.messages.delete(props.messageID);
+      pendingParts.get(props.sessionID)?.delete(props.messageID);
+    }
+    return;
+  }
+  if (type === "session.deleted" && typeof props.sessionID === "string") {
+    clearTrackedOpenCodeSession(props.sessionID);
+  }
+}
+function clearTrackedOpenCodeSession(sessionId) {
+  trackedSessions.delete(sessionId);
+  pendingParts.delete(sessionId);
+}
+function logProbeFailureOnce(resolution, error) {
+  const failure = recordOpenCodeDbReadFailure(resolution, error);
+  if (!claimOpenCodeDbDiagnosticOnce("session-state-probe", resolution))
+    return;
+  const message = `[magic-context] OpenCode DB probe failed: path=${resolution.path} source=${resolution.source} cause=${failure.message}`;
+  probeLogObserverForTests?.(message);
+  log(message);
+}
+function resolvedDbIsAvailable() {
+  const resolution = resolveOpenCodeDbPath();
+  const available = openCodeDbPathExists(resolution);
+  if (available)
+    clearOpenCodeDbReadFailure(resolution.path);
+  else
+    logProbeFailureOnce(resolution, "opencode_db_missing");
+  return { resolution, available };
+}
+function assistantAwaitingTools(_deps, sessionId) {
+  const availability = resolvedDbIsAvailable();
+  const tracked = trackedSessions.get(sessionId);
+  if (tracked)
+    return assistantAwaitingToolsFromMessages(trackedMessages(tracked));
+  if (!availability.available)
+    return false;
+  try {
+    return withReadOnlySessionDb((db) => assistantAwaitingToolsFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    logProbeFailureOnce(availability.resolution, error);
+    return false;
+  }
+}
+function shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId) {
+  if (assistantAwaitingToolsFromOpenCodeDb(db, sessionId))
+    return true;
+  if (hasUnfinishedAssistant(db, sessionId))
+    return true;
+  if (hasUnansweredRealUser(db, sessionId))
+    return true;
+  return false;
+}
+function shouldHoldIgnoredNotification(sessionId) {
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "bypass")
+    return false;
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "hold")
+    return true;
+  const availability = resolvedDbIsAvailable();
+  const tracked = trackedSessions.get(sessionId);
+  if (tracked)
+    return shouldHoldIgnoredNotificationFromMessages(trackedMessages(tracked));
+  if (!availability.available)
+    return false;
+  try {
+    return withReadOnlySessionDb((db) => shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    logProbeFailureOnce(availability.resolution, error);
+    return false;
+  }
+}
+function assistantAwaitingToolsFromOpenCodeDb(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
+    return false;
+  if (latestAssistant.finish === "tool-calls")
+    return true;
+  const partRows = db.prepare("SELECT data FROM part WHERE session_id = ? AND likelihood(message_id = ?, 0.000001)").all(sessionId, latestAssistant.id);
+  return partRows.some((row) => {
+    if (typeof row.data !== "string" || row.data.length === 0)
+      return false;
+    try {
+      const part = JSON.parse(row.data);
+      return part.type === "tool" && part.providerExecuted !== true;
+    } catch {
+      return false;
+    }
+  });
+}
+function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
+  if (typeof latestAssistantTimeCreated !== "number")
+    return false;
+  const row = db.prepare(`SELECT 1 as one
+             FROM message m
+             WHERE m.session_id = ?
+               AND m.time_created > ?
+               AND json_extract(m.data, '$.role') = 'user'
+               AND NOT (
+                 EXISTS (SELECT 1 FROM part p WHERE p.message_id = m.id)
+                 AND NOT EXISTS (
+                   SELECT 1 FROM part p
+                   WHERE p.message_id = m.id
+                     AND COALESCE(json_extract(p.data, '$.synthetic'), 0) NOT IN (1, 'true')
+                     AND json_extract(p.data, '$.metadata.marker.kind') IS NULL
+                     AND COALESCE(json_extract(p.data, '$.ignored'), 0) NOT IN (1, 'true')
+                 )
+               )
+             LIMIT 1`).get(sessionId, latestAssistantTimeCreated);
+  return row?.one === 1;
+}
+function latestAssistantRow(db, sessionId) {
+  return db.prepare(`SELECT id,
+                    json_extract(data, '$.finish') as finish,
+                    time_created as timeCreated
+             FROM message
+             WHERE session_id = ?
+               AND json_extract(data, '$.role') = 'assistant'
+             ORDER BY time_created DESC
+             LIMIT 1`).get(sessionId);
+}
+function hasUnfinishedAssistant(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  if (typeof latestAssistant?.id !== "string")
+    return false;
+  const finish = latestAssistant.finish;
+  if (typeof finish !== "string" || finish.length === 0)
+    return true;
+  return finish === "tool-calls" || finish === "unknown";
+}
+function hasUnansweredRealUser(db, sessionId) {
+  const latestAssistant = latestAssistantRow(db, sessionId);
+  const latestAssistantTime = typeof latestAssistant?.timeCreated === "number" ? latestAssistant.timeCreated : -1;
+  return hasNewerRealUserMessage(db, sessionId, latestAssistantTime);
+}
+function getMessageTimesFromOpenCodeDb(sessionId, messageIds) {
+  const result = new Map;
+  if (messageIds.length === 0)
+    return result;
+  try {
+    withReadOnlySessionDb((db) => {
+      const placeholders = messageIds.map(() => "?").join(",");
+      const rows = db.prepare(`SELECT id, time_created FROM message WHERE session_id = ? AND id IN (${placeholders})`).all(sessionId, ...messageIds);
+      for (const row of rows) {
+        if (typeof row.id === "string" && typeof row.time_created === "number") {
+          result.set(row.id, row.time_created);
+        }
+      }
+    });
+  } catch (error) {
+    logProbeFailureOnce(resolveOpenCodeDbPath(), error);
+  }
+  return result;
+}
+function findLastAssistantModelFromOpenCodeDb(sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => {
+      const row = db.prepare(`SELECT json_extract(data, '$.providerID') as providerID,
+                            json_extract(data, '$.modelID') as modelID,
+                            json_extract(data, '$.agent') as agent
+                     FROM message
+                     WHERE session_id = ?
+                       AND json_extract(data, '$.role') = 'assistant'
+                       AND json_extract(data, '$.providerID') IS NOT NULL
+                       AND json_extract(data, '$.modelID') IS NOT NULL
+                     ORDER BY time_created DESC
+                     LIMIT 1`).get(sessionId);
+      if (!row || typeof row.providerID !== "string" || typeof row.modelID !== "string") {
+        return null;
+      }
+      const agent = typeof row.agent === "string" && row.agent.length > 0 ? row.agent : undefined;
+      return {
+        providerID: row.providerID,
+        modelID: row.modelID,
+        ...agent ? { agent } : {}
+      };
+    });
+  } catch (error) {
+    logProbeFailureOnce(resolveOpenCodeDbPath(), error);
+    return null;
+  }
+}
+
+export { resolveOpenCodeDbPath, openCodeDbPathExists, formatOpenCodeDbMissingBanner, formatOpenCodeDbMissingStatusLine, formatOpenCodeDbReadFailureStatusLine, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, getOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, registerSlowWriteReporter, detectSqliteRuntime, Database, getSqliteMemoryStats, withPrivilegedWriter, closeQuietly, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, observeOpenCodeTurnEvent, clearTrackedOpenCodeSession, assistantAwaitingTools, shouldHoldIgnoredNotification, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };