@cortexkit/pi-magic-context 0.45.0 → 0.46.1

package/dist/index-td885aah.js

@@ -0,0 +1,576 @@
+import {
+  sessionLog
+} from "./index-7n8gb6j3.js";
+
+// ../plugin/src/shared/sqlite-helpers.ts
+function closeQuietly(db) {
+  if (!db)
+    return;
+  try {
+    db.close();
+  } catch {}
+}
+function isKnownAutocommit(db) {
+  const state = db;
+  try {
+    return state.inTransaction === false || state.isTransaction === false;
+  } catch {
+    return false;
+  }
+}
+
+// ../plugin/src/shared/stable-json.ts
+function stableStringify(value, seen = new WeakSet) {
+  if (value === undefined)
+    return "undefined";
+  if (value === null || typeof value !== "object")
+    return JSON.stringify(value) ?? String(value);
+  if (seen.has(value))
+    return '"[Circular]"';
+  seen.add(value);
+  if (Array.isArray(value)) {
+    return `[${value.map((item) => stableStringify(item, seen)).join(",")}]`;
+  }
+  const entries = Object.entries(value).sort(([a], [b]) => {
+    if (a < b)
+      return -1;
+    if (a > b)
+      return 1;
+    return 0;
+  });
+  return `{${entries.map(([key, child]) => `${JSON.stringify(key)}:${stableStringify(child, seen)}`).join(",")}}`;
+}
+
+// ../plugin/src/features/magic-context/storage-schema-helpers.ts
+var columnCaches = new WeakMap;
+function readColumnNames(db, table) {
+  const rows = db.prepare(`PRAGMA table_info(${table})`).all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function columnNames(db, table) {
+  if (!isKnownAutocommit(db)) {
+    columnCaches.delete(db);
+    return readColumnNames(db, table);
+  }
+  let cache = columnCaches.get(db);
+  if (!cache) {
+    cache = { version: -1, stamp: db.prepare("PRAGMA schema_version"), tables: new Map };
+    columnCaches.set(db, cache);
+  }
+  const [{ schema_version: version }] = cache.stamp.all();
+  if (version !== cache.version) {
+    cache.tables.clear();
+    cache.version = version;
+  }
+  let columns = cache.tables.get(table);
+  if (!columns) {
+    columns = readColumnNames(db, table);
+    cache.tables.set(table, columns);
+  }
+  return columns;
+}
+function getTableColumnNames(db, table) {
+  if (!/^[a-z][a-z0-9_]*$/.test(table))
+    throw new Error(`Unsafe schema identifier: ${table}`);
+  return columnNames(db, table);
+}
+function ensureColumn(db, table, column, definition) {
+  if (!/^[a-z][a-z0-9_]*$/.test(table) || !/^[a-z][a-z0-9_]*$/.test(column) || !/^[A-Z0-9_"'(),[\]\s]+$/i.test(definition)) {
+    throw new Error(`Unsafe schema identifier: ${table}.${column} ${definition}`);
+  }
+  if (columnNames(db, table).has(column)) {
+    return;
+  }
+  try {
+    db.exec(`ALTER TABLE ${table} ADD COLUMN ${column} ${definition}`);
+  } catch (err) {
+    columnCaches.delete(db);
+    const recheck = db.prepare(`PRAGMA table_info(${table})`).all();
+    if (recheck.some((row) => row.name === column)) {
+      return;
+    }
+    throw err;
+  }
+}
+function healAllNullColumns(db) {
+  const existingColumns = getSessionMetaColumns(db);
+  const fallbacks = [
+    ["cache_ttl", ""],
+    ["last_nudge_band", ""],
+    ["last_nudge_level", ""],
+    ["channel2_nudge_claim_token", ""],
+    ["last_transform_error", ""],
+    ["nudge_anchor_message_id", ""],
+    ["nudge_anchor_text", ""],
+    ["sticky_turn_reminder_text", ""],
+    ["sticky_turn_reminder_message_id", ""],
+    ["note_nudge_trigger_message_id", ""],
+    ["note_nudge_sticky_text", ""],
+    ["note_nudge_sticky_message_id", ""],
+    ["last_todo_state", ""],
+    ["todo_synthetic_call_id", ""],
+    ["todo_synthetic_anchor_message_id", ""],
+    ["todo_synthetic_state_json", ""],
+    ["system_prompt_hash", ""],
+    ["stripped_placeholder_ids", ""],
+    ["stale_reduce_stripped_ids", ""],
+    ["processed_image_stripped_ids", ""],
+    ["merged_reasoning_stripped_ids", ""],
+    ["thinking_binding_recovery_target", ""],
+    ["trailing_blank_decisions", ""],
+    ["memory_block_cache", ""],
+    ["memory_block_ids", ""],
+    ["compaction_marker_state", ""],
+    ["key_files", ""],
+    ["times_execute_threshold_reached", 0],
+    ["compartment_in_progress", 0],
+    ["historian_failure_count", 0],
+    ["cleared_reasoning_through_tag", 0],
+    ["memory_block_count", 0],
+    ["system_prompt_tokens", 0],
+    ["conversation_tokens", 0],
+    ["tool_call_tokens", 0],
+    ["note_nudge_trigger_pending", 0],
+    ["observed_safe_input_tokens", 0],
+    ["cache_alert_sent", 0],
+    ["new_work_tokens", 0],
+    ["total_input_tokens", 0],
+    ["last_emergency_input_sample", 0],
+    ["channel2_nudge_claimed_at", 0],
+    ["last_usage_context_limit", 0],
+    ["prior_boundary_ordinal", 1],
+    ["protected_tail_policy_version", 0],
+    ["protected_tail_drain_window_started_at", 0],
+    ["protected_tail_drain_tokens", 0],
+    ["recovery_no_eligible_head_count", 0],
+    ["force_emergency_bypass_window_start", 0],
+    ["force_emergency_bypass_used", 0],
+    ["emergency_drain_active", 0],
+    ["historian_drain_failure_at", 0]
+  ];
+  const presentFallbacks = fallbacks.filter(([column]) => existingColumns.has(column));
+  if (presentFallbacks.length > 0) {
+    const assignments = presentFallbacks.map(([column]) => `${column} = COALESCE(${column}, ?)`).join(", ");
+    const nullPredicate = presentFallbacks.map(([column]) => `${column} IS NULL`).join(" OR ");
+    db.prepare(`UPDATE session_meta SET ${assignments} WHERE ${nullPredicate}`).run(...presentFallbacks.map(([, fallback]) => fallback));
+  }
+  healMissingMemoryBlockIds(db, existingColumns);
+}
+function getSessionMetaColumns(db) {
+  const rows = db.prepare("PRAGMA table_info(session_meta)").all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function healMissingMemoryBlockIds(db, columns) {
+  if (!columns.has("memory_block_cache") || !columns.has("memory_block_ids") || !columns.has("memory_block_count")) {
+    return;
+  }
+  db.prepare("UPDATE session_meta SET memory_block_cache = '' WHERE memory_block_cache != '' AND (memory_block_ids IS NULL OR memory_block_ids = '') AND memory_block_count > 0").run();
+}
+
+// ../plugin/src/features/magic-context/temporal-decisions.ts
+var PREFIX = "temporal-message-v1:";
+function decodeTemporalDecision(entry) {
+  if (!entry.startsWith(PREFIX))
+    return null;
+  try {
+    const pair = JSON.parse(entry.slice(PREFIX.length));
+    if (Array.isArray(pair) && pair.length === 2 && typeof pair[0] === "string" && pair[0] && typeof pair[1] === "string")
+      return [pair[0], pair[1]];
+  } catch {}
+  return null;
+}
+function readRows(db, sessionId, messageIds) {
+  if (!messageIds)
+    return db.prepare("SELECT message_id,marker FROM temporal_decisions WHERE session_id=?").all(sessionId);
+  const ids = [...messageIds];
+  const result = [];
+  for (let offset = 0;offset < ids.length; offset += 400) {
+    const chunk = ids.slice(offset, offset + 400);
+    result.push(...db.prepare(`SELECT message_id,marker FROM temporal_decisions WHERE session_id=? AND message_id IN (${chunk.map(() => "?").join(",")})`).all(sessionId, ...chunk));
+  }
+  return result;
+}
+function getTemporalDecisions(db, sessionId, messageIds) {
+  return new Map(readRows(db, sessionId, messageIds).flatMap((row) => row.marker === null ? [] : [[row.message_id, row.marker]]));
+}
+function observeTemporalDecisions(db, sessionId, candidates, previouslyServed, messageIds) {
+  const ids = new Set([...candidates.keys(), ...messageIds ?? []]);
+  const rows = readRows(db, sessionId, ids);
+  const known = new Set(rows.map((row) => row.message_id));
+  const missing = [...candidates].filter(([id]) => !known.has(id));
+  if (!missing.length)
+    return new Map(rows.flatMap((row) => row.marker === null ? [] : [[row.message_id, row.marker]]));
+  const transient = new Map;
+  db.transaction(() => {
+    const insert = db.prepare("INSERT OR IGNORE INTO temporal_decisions(session_id,message_id,marker) VALUES (?,?,?)");
+    const servedTag = db.prepare("SELECT 1 FROM tags WHERE session_id=? AND message_id=? UNION ALL SELECT 1 FROM tags WHERE session_id=? AND message_id>=? AND message_id<? LIMIT 1");
+    let served;
+    for (const [id, candidate] of missing) {
+      const historical = servedTag.get(sessionId, id, sessionId, `${id}:p`, `${id}:q`);
+      if (historical) {
+        served ??= previouslyServed?.(missing.map(([missingId]) => missingId)) ?? new Map;
+        const previous = served.get(id);
+        if (previous === undefined) {
+          transient.set(id, candidate);
+          continue;
+        }
+        insert.run(sessionId, id, previous === "" && candidate !== "" ? null : previous);
+      } else {
+        insert.run(sessionId, id, null);
+      }
+    }
+  }).immediate();
+  return new Map([...transient, ...getTemporalDecisions(db, sessionId, ids)]);
+}
+function freezeTemporalDecisions(db, sessionId, candidates) {
+  if (candidates.size === 0)
+    return new Map;
+  return db.transaction(() => {
+    const insert = db.prepare("INSERT INTO temporal_decisions(session_id,message_id,marker) VALUES (?,?,?) ON CONFLICT(session_id,message_id) DO UPDATE SET marker=excluded.marker WHERE temporal_decisions.marker IS NULL");
+    for (const [id, marker] of candidates) {
+      insert.run(sessionId, id, marker);
+    }
+    return getTemporalDecisions(db, sessionId, candidates.keys());
+  }).immediate();
+}
+
+// ../plugin/src/features/magic-context/migration-v95-perf-indexes.ts
+var TEMPORAL_DECISIONS_DDL = `CREATE TABLE temporal_decisions (
+    session_id TEXT NOT NULL,
+    message_id TEXT NOT NULL,
+    marker TEXT,
+    PRIMARY KEY (session_id, message_id)
+) WITHOUT ROWID`;
+var indexes = [
+  ["message_fts_rowid_map", "idx_message_fts_rowid_map_session_rowid", "session_id, fts_rowid"],
+  ["transform_decisions", "idx_transform_decisions_retention", "session_id, harness, ts_ms"],
+  ["plugin_messages", "idx_plugin_messages_session", "session_id"],
+  ["user_memory_candidates", "idx_user_memory_candidates_session", "session_id"]
+];
+var V95_REDUNDANT_INDEXES = [
+  "idx_tags_session_tag_number",
+  "idx_compartments_session",
+  "idx_pending_ops_session",
+  "idx_source_contents_session",
+  "idx_compression_depth_session",
+  "idx_transform_decisions_session_harness",
+  "idx_project_key_files_project"
+];
+var GIT_COMMIT_FTS_ROWID_MAP_DDL = `CREATE TABLE git_commit_fts_rowid_map (
+    fts_rowid INTEGER PRIMARY KEY,
+    sha BLOB
+)`;
+var GIT_FTS_MAP_REPAIR_COMMAND = "magic-context doctor git-fts-map --repair";
+var GIT_FTS_MAP_DISAGREEMENT_SQL = `
+    SELECT 1 FROM git_commits_fts AS f
+    LEFT JOIN git_commit_fts_rowid_map AS m ON m.fts_rowid = f.rowid
+    WHERE m.fts_rowid IS NULL OR m.sha IS NOT f.sha OR typeof(m.sha) IS NOT typeof(f.sha)
+    UNION ALL
+    SELECT 1 FROM git_commit_fts_rowid_map AS m
+    WHERE NOT EXISTS (SELECT 1 FROM git_commits_fts AS f WHERE f.rowid = m.fts_rowid)
+    LIMIT 1`;
+function gitFtsMapRepairMessage(detail) {
+  return `${detail}; stop all hosts, then run \`${GIT_FTS_MAP_REPAIR_COMMAND}\` to back up both stores and rebuild only the map`;
+}
+var mapIndex = "CREATE INDEX idx_git_commit_fts_rowid_map_sha ON git_commit_fts_rowid_map(sha)";
+var remove = (row) => `
+    DELETE FROM git_commits_fts WHERE rowid IN (
+        SELECT fts_rowid FROM git_commit_fts_rowid_map WHERE sha = ${row}.sha
+    );
+    DELETE FROM git_commit_fts_rowid_map WHERE sha = ${row}.sha;`;
+var insert = `
+    INSERT INTO git_commits_fts(sha, project_path, message)
+    VALUES (NEW.sha, NEW.project_path, NEW.message);
+    INSERT INTO git_commit_fts_rowid_map(fts_rowid, sha)
+    VALUES (last_insert_rowid(), NEW.sha);`;
+var triggers = [
+  [
+    "git_commits_fts_insert",
+    `CREATE TRIGGER git_commits_fts_insert AFTER INSERT ON git_commits BEGIN${remove("NEW")}${insert}
+END`
+  ],
+  [
+    "git_commits_fts_delete",
+    `CREATE TRIGGER git_commits_fts_delete AFTER DELETE ON git_commits BEGIN${remove("OLD")}
+END`
+  ],
+  [
+    "git_commits_fts_update",
+    `CREATE TRIGGER git_commits_fts_update AFTER UPDATE OF message, project_path ON git_commits BEGIN${remove("OLD")}${insert}
+END`
+  ]
+];
+function installV95PerfSchema(db, verifyExistingMap = false, allowCreateMap = true) {
+  const schema = new Map(db.prepare("SELECT name, sql FROM sqlite_master").all().map((row) => [row.name, row.sql]));
+  if (!schema.has("temporal_decisions")) {
+    db.exec(TEMPORAL_DECISIONS_DDL);
+    if (schema.has("session_meta")) {
+      ensureColumn(db, "session_meta", "merged_reasoning_stripped_ids", "TEXT DEFAULT ''");
+      const rows = db.prepare("SELECT session_id, merged_reasoning_stripped_ids AS entries FROM session_meta WHERE merged_reasoning_stripped_ids LIKE '%temporal-message-v1:%'").all();
+      const insert = db.prepare("INSERT OR IGNORE INTO temporal_decisions(session_id,message_id,marker) VALUES (?,?,?)");
+      for (const row of rows) {
+        let entries;
+        try {
+          entries = JSON.parse(row.entries);
+        } catch {
+          sessionLog(row.session_id, "v95 temporal metadata: malformed JSON skipped; original blob retained");
+          continue;
+        }
+        if (!Array.isArray(entries)) {
+          sessionLog(row.session_id, "v95 temporal metadata: non-array JSON skipped; original blob retained");
+          continue;
+        }
+        const kept = [];
+        for (const entry of entries) {
+          const decision = typeof entry === "string" ? decodeTemporalDecision(entry) : null;
+          if (decision)
+            insert.run(row.session_id, ...decision);
+          else
+            kept.push(entry);
+        }
+        db.prepare("UPDATE session_meta SET merged_reasoning_stripped_ids=? WHERE session_id=?").run(JSON.stringify(kept), row.session_id);
+      }
+    }
+  }
+  for (const [table, name, columns] of indexes) {
+    if (schema.has(table) && !schema.has(name))
+      db.exec(`CREATE INDEX ${name} ON ${table}(${columns})`);
+  }
+  for (const name of V95_REDUNDANT_INDEXES) {
+    if (schema.has(name))
+      db.exec(`DROP INDEX ${name}`);
+  }
+  if (!schema.has("git_commits") || !schema.has("git_commits_fts"))
+    return;
+  const installed = schema.get("git_commit_fts_rowid_map");
+  if (installed === undefined) {
+    if (!allowCreateMap)
+      throw new Error(gitFtsMapRepairMessage("git FTS rowid map is missing"));
+    db.exec(GIT_COMMIT_FTS_ROWID_MAP_DDL);
+    db.exec("INSERT INTO git_commit_fts_rowid_map(fts_rowid, sha) SELECT rowid, sha FROM git_commits_fts");
+  } else if (installed !== GIT_COMMIT_FTS_ROWID_MAP_DDL) {
+    throw new Error(gitFtsMapRepairMessage("git_commit_fts_rowid_map schema differs; refusing to replace rowid data"));
+  }
+  if (verifyExistingMap && installed !== undefined && db.prepare(GIT_FTS_MAP_DISAGREEMENT_SQL).get()) {
+    throw new Error(gitFtsMapRepairMessage("git FTS rowid inventory differs; refusing migration replay"));
+  }
+  if (!schema.has("idx_git_commit_fts_rowid_map_sha"))
+    db.exec(mapIndex);
+  for (const [name, ddl] of triggers) {
+    if (schema.get(name) === ddl)
+      continue;
+    db.exec(`DROP TRIGGER IF EXISTS ${name}`);
+    db.exec(ddl);
+  }
+}
+var tagOrderIndexes = new WeakMap;
+
+// ../plugin/src/shared/opencode-db-path.ts
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { homedir } from "node:os";
+import { isAbsolute, join, resolve } from "node:path";
+var cachedResolution = null;
+var lastReadFailure = null;
+var claimedDiagnostics = new Set;
+function openCodeDataDir(env = process.env, dataHome) {
+  return join(dataHome ?? env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "opencode");
+}
+function environmentKey(dataDir, hostGeneration, channel, env) {
+  return [
+    hostGeneration,
+    dataDir,
+    env.OPENCODE_DB ?? "",
+    env.OPENCODE_DISABLE_CHANNEL_DB ?? "",
+    channel ?? 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 resolveV1Fresh(dataDir, env = process.env) {
+  const explicit = 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 = env.OPENCODE_DISABLE_CHANNEL_DB;
+  if (disableChannelDb === "1" || disableChannelDb === "true") {
+    return { path: join(dataDir, "opencode.db"), source: "default", channel: null };
+  }
+  const channel = env.OPENCODE_CHANNEL;
+  if (channel !== undefined && channel.length > 0) {
+    return { path: channelPath(dataDir, channel), source: "channel", channel };
+  }
+  return discoverOpenCodeDb(dataDir);
+}
+function sourceOpenCodeDatabaseFilename(hostGeneration, channel, env = process.env) {
+  if (hostGeneration === "v1") {
+    const explicit = env.OPENCODE_DB;
+    if (explicit !== undefined && explicit.length > 0)
+      return explicit;
+    if (env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true") {
+      return "opencode.db";
+    }
+    return ["latest", "beta", "prod"].includes(channel) ? "opencode.db" : `opencode-${channel}.db`;
+  }
+  return env.OPENCODE_DB ?? (["latest", "dev", "beta", "next", "prod"].includes(channel) || env.OPENCODE_DISABLE_CHANNEL_DB === "1" || env.OPENCODE_DISABLE_CHANNEL_DB === "true" ? "opencode.db" : `opencode-${channel.replace(/[^a-zA-Z0-9._-]/g, "")}.db`);
+}
+function resolveV2Fresh(dataDir, channel, env) {
+  const filename = sourceOpenCodeDatabaseFilename("v2", channel, env);
+  const explicit = env.OPENCODE_DB !== undefined;
+  return {
+    path: filename === ":memory:" ? filename : resolve(dataDir, filename),
+    source: explicit ? "OPENCODE_DB" : env.OPENCODE_CHANNEL ? "channel" : "default",
+    channel: explicit ? null : channel
+  };
+}
+function resolveOpenCodeDbPath(hostGeneration = "v1", options = {}) {
+  const env = options.env ?? process.env;
+  const dataDir = openCodeDataDir(env, options.dataHome);
+  const channel = options.channel ?? env.OPENCODE_CHANNEL;
+  const key = environmentKey(dataDir, hostGeneration, channel, env);
+  if (cachedResolution?.key === key && (!cachedResolution.existed || existsSync(cachedResolution.resolution.path))) {
+    if (cachedResolution.existed)
+      return cachedResolution.resolution;
+  }
+  const resolution = hostGeneration === "v2" ? resolveV2Fresh(dataDir, channel ?? "latest", env) : resolveV1Fresh(dataDir, env);
+  cachedResolution = {
+    key,
+    resolution,
+    existed: resolution.path !== ":memory:" && existsSync(resolution.path)
+  };
+  return resolution;
+}
+function schemaTableNames(db, schema = "main") {
+  const rows = db.prepare(`SELECT name FROM ${schema}.sqlite_master WHERE type = 'table' AND name IN ('message', 'part', 'session', 'project', 'session_message', 'session_v2')`).all();
+  return new Set(rows.flatMap((row) => typeof row.name === "string" ? [row.name] : []));
+}
+function hasV1MessageTables(db, schema = "main") {
+  const tables = schemaTableNames(db, schema);
+  return tables.has("message") && tables.has("part");
+}
+function detectOpenCodeStoreGeneration(db, schema = "main") {
+  const tables = schemaTableNames(db, schema);
+  const hasV1Messages = tables.has("message") && tables.has("part");
+  if (hasV1Messages)
+    return "v1";
+  if (tables.has("session_message"))
+    return "v2";
+  if (tables.has("session") || tables.has("project"))
+    return "v1";
+  return "unknown";
+}
+function hasMigratedV2Schema(tables) {
+  return tables.has("session_message") && tables.has("session_v2");
+}
+function isOpenCodeV2Store(db, schema = "main") {
+  return detectOpenCodeStoreGeneration(db, schema) === "v2" || hasMigratedV2Schema(schemaTableNames(db, schema));
+}
+function assertOpenCodeStoreGeneration(db, expected, path, schema = "main") {
+  const actual = detectOpenCodeStoreGeneration(db, schema);
+  if (actual === expected)
+    return;
+  if (expected === "v2" && isOpenCodeV2Store(db, schema))
+    return;
+  if (actual === "unknown")
+    return;
+  throw new Error(`OpenCode store generation mismatch at ${path}: expected ${expected}, found ${actual}; refusing generation-specific database access`);
+}
+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 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 claimOpenCodeDbDiagnosticOnce(surface, resolution) {
+  const key = `${surface}\x00${resolution.path}\x00${resolution.source}`;
+  if (claimedDiagnostics.has(key))
+    return false;
+  claimedDiagnostics.add(key);
+  return true;
+}
+
+// ../plugin/src/features/magic-context/tool-definition-tokens.ts
+var measurements = new Map;
+var fingerprints = new Map;
+var persistenceDb = null;
+var cachedInsertStmt = null;
+function keyFor(providerID, modelID, agentName) {
+  const agent = agentName && agentName.length > 0 ? agentName : "default";
+  return `${providerID}/${modelID}/${agent}`;
+}
+function setDatabase(db) {
+  persistenceDb = db;
+  cachedInsertStmt = null;
+}
+function loadToolDefinitionMeasurements(db) {
+  let rows = [];
+  try {
+    rows = db.prepare("SELECT provider_id, model_id, agent_name, tool_id, token_count FROM tool_definition_measurements").all();
+  } catch {
+    return;
+  }
+  for (const row of rows) {
+    const key = keyFor(row.provider_id, row.model_id, row.agent_name);
+    let inner = measurements.get(key);
+    if (!inner) {
+      inner = new Map;
+      measurements.set(key, inner);
+    }
+    inner.set(row.tool_id, row.token_count);
+  }
+}
+
+export { stableStringify, closeQuietly, isKnownAutocommit, getTableColumnNames, ensureColumn, healAllNullColumns, observeTemporalDecisions, freezeTemporalDecisions, installV95PerfSchema, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, setDatabase, loadToolDefinitionMeasurements };