@cortexkit/opencode-magic-context 0.44.3 → 0.45.0

package/dist/index-remp7e2g.js

@@ -0,0 +1,214 @@
+// src/shared/historian-tool-template.ts
+class Parser {
+  source;
+  pos = 0;
+  constructor(source) {
+    this.source = source;
+  }
+  error() {
+    throw new Error(`Invalid tool expansion template at character ${this.pos + 1}`);
+  }
+  take(value) {
+    if (!this.source.startsWith(value, this.pos))
+      return false;
+    this.pos += value.length;
+    return true;
+  }
+  field() {
+    const match = /^[A-Za-z_][A-Za-z0-9_-]*/.exec(this.source.slice(this.pos));
+    if (!match)
+      return this.error();
+    this.pos += match[0].length;
+    return match[0];
+  }
+  quoted() {
+    const start = this.pos;
+    if (!this.take('"'))
+      return this.error();
+    while (this.pos < this.source.length) {
+      if (this.take("\\")) {
+        this.pos++;
+        continue;
+      }
+      if (this.take('"')) {
+        try {
+          return JSON.parse(this.source.slice(start, this.pos));
+        } catch {
+          return this.error();
+        }
+      }
+      this.pos++;
+    }
+    return this.error();
+  }
+  integer() {
+    const match = /^\d+/.exec(this.source.slice(this.pos));
+    if (!match)
+      return this.error();
+    this.pos += match[0].length;
+    const n = Number(match[0]);
+    if (!Number.isSafeInteger(n))
+      return this.error();
+    return n;
+  }
+  expression(relative) {
+    const steps = [];
+    if (!(relative && this.take("."))) {
+      const root = this.field();
+      if (!relative && root !== "input" && root !== "output")
+        return this.error();
+      steps.push({ field: root });
+    }
+    while (true) {
+      if (this.take("[")) {
+        if (this.take("*]."))
+          steps.push({ project: this.field() });
+        else {
+          const index = this.integer();
+          if (!this.take("]"))
+            return this.error();
+          steps.push({ index });
+        }
+      } else if (this.source[this.pos] === "." && !/^\.(each\(|join\(|count(?:\.|\})|truncate\()/.test(this.source.slice(this.pos))) {
+        this.pos++;
+        steps.push({ field: this.field() });
+        if (this.source[this.pos] === "(")
+          return this.error();
+      } else
+        break;
+    }
+    const expression = { steps, cap: 300 };
+    if (this.take(".each(")) {
+      if (relative)
+        return this.error();
+      expression.each = parseTemplate(this.quoted(), true);
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (this.take(".join(")) {
+      expression.join = this.quoted();
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (this.take(".count")) {
+      if (expression.each || expression.join !== undefined)
+        return this.error();
+      expression.count = true;
+    }
+    if (this.take(".truncate(")) {
+      expression.cap = this.integer();
+      if (!this.take(")"))
+        return this.error();
+    }
+    if (!this.take("}"))
+      return this.error();
+    return expression;
+  }
+  template(relative) {
+    const nodes = [];
+    while (this.pos < this.source.length) {
+      const next = this.source.indexOf("${", this.pos);
+      if (next < 0) {
+        nodes.push(this.source.slice(this.pos));
+        break;
+      }
+      nodes.push(this.source.slice(this.pos, next));
+      this.pos = next + 2;
+      nodes.push(this.expression(relative));
+    }
+    return nodes;
+  }
+}
+function parseTemplate(source, relative = false) {
+  return new Parser(source).template(relative);
+}
+function toolTemplateError(source) {
+  try {
+    parseTemplate(source);
+    return;
+  } catch (error) {
+    return error.message;
+  }
+}
+var templates = new Map;
+function compiled(source) {
+  if (!templates.has(source)) {
+    try {
+      templates.set(source, parseTemplate(source));
+    } catch {
+      templates.set(source, null);
+    }
+  }
+  return templates.get(source) ?? null;
+}
+function oneLine(value) {
+  return value.replace(/[\r\n\u2028\u2029]+/g, " ");
+}
+function truncate(value, cap) {
+  const chars = Array.from(oneLine(value));
+  return chars.length > cap ? `${chars.slice(0, cap).join("")}…` : chars.join("");
+}
+function scalar(value) {
+  if (value === undefined)
+    return "";
+  return typeof value === "string" ? value : compactJson(value);
+}
+function compactJson(value) {
+  if (Array.isArray(value))
+    return `[${value.map((v) => compactJson(v)).join(",")}]`;
+  if (value !== null && typeof value === "object")
+    return `{${Object.keys(value).sort().map((key) => `${JSON.stringify(key)}:${compactJson(value[key])}`).join(",")}}`;
+  return JSON.stringify(value) ?? "null";
+}
+function field(value, key) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) && Object.hasOwn(value, key) ? value[key] : undefined;
+}
+function render(nodes, root) {
+  return nodes.map((node) => {
+    if (typeof node === "string")
+      return node;
+    let value = root;
+    let list = false;
+    for (const step of node.steps) {
+      if ("field" in step)
+        value = list && Array.isArray(value) ? value.map((item) => field(item, step.field)) : field(value, step.field);
+      else if ("index" in step)
+        value = Array.isArray(value) ? value[step.index] : undefined;
+      else {
+        value = Array.isArray(value) ? value.map((item) => field(item, step.project)) : undefined;
+        list = true;
+      }
+    }
+    if (node.count)
+      return truncate(Array.isArray(value) ? String(value.length) : "", node.cap);
+    if (node.each || list || node.join !== undefined) {
+      if (!Array.isArray(value))
+        return "";
+      const elements = value.slice(0, 10).map((item) => truncate(node.each ? render(node.each, item) : scalar(item), 300));
+      if (value.length > 10)
+        elements.push(`… +${value.length - 10} more`);
+      return truncate(elements.join(node.join ?? (node.each ? "; " : ", ")), node.cap);
+    }
+    return truncate(scalar(value), node.cap);
+  }).join("");
+}
+function renderToolTemplate(source, input, output) {
+  const nodes = compiled(source);
+  if (!nodes)
+    return null;
+  const text = typeof output === "string" ? output : output === undefined ? "" : compactJson(output);
+  let structured = output;
+  if (typeof output === "string") {
+    try {
+      const parsed = JSON.parse(output);
+      structured = parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : undefined;
+    } catch {
+      structured = undefined;
+    }
+  }
+  const root = { input, output: structured };
+  const bareOutputNodes = nodes.map((node) => typeof node !== "string" && node.steps.length === 1 && ("field" in node.steps[0]) && node.steps[0].field === "output" && !node.each && !node.count && node.join === undefined ? truncate(text ?? "", node.cap) : node);
+  return truncate(render(bareOutputNodes, root), 1000);
+}
+
+export { toolTemplateError, renderToolTemplate };

package/dist/{index-7k55qm8a.js → index-sfpzqvdz.js}

@@ -15,7 +15,7 @@ function resolveHarnessBlock(container, harness) {
   const selected = harness === "omp" ? container?.omp ?? container?.pi : container?.[harness];
   return asRecord(selected);
 }
-function normalizeModelEntry(entry, harness) {
+function normalizeModelEntry2(entry, harness) {
   if (typeof entry === "string") {
     const model = readString(entry);
     return model ? { model } : undefined;
@@ -36,11 +36,11 @@ function isValidModelReference(entry) {
 function sameAttempt(a, b) {
   return a.model === b.model && a.qualifier === b.qualifier;
 }
-function resolveFallbackEntries(value, harness) {
+function resolveFallbackEntries2(value, harness) {
   const values = Array.isArray(value) ? value : value === undefined ? [] : [value];
   const resolved = [];
   for (const value of values) {
-    const entry = normalizeModelEntry(value, harness);
+    const entry = normalizeModelEntry2(value, harness);
     if (!entry || !isValidModelReference(entry))
       continue;
     if (resolved.some((candidate) => sameAttempt(candidate, entry)))
@@ -50,7 +50,7 @@ function resolveFallbackEntries(value, harness) {
   return resolved;
 }
 function resolvePrimaryEntry(args) {
-  const entry = normalizeModelEntry(args.entry, args.harness);
+  const entry = normalizeModelEntry2(args.entry, args.harness);
   if (!entry)
     return;
   const qualifier = entry.qualifier ?? readString(args.defaultQualifier);
@@ -67,7 +67,7 @@ function resolveHistorianModel2(config, harness) {
       defaultQualifier: block[harness === "opencode" ? "variant" : "thinking_level"],
       harness
     }),
-    fallbacks: resolveFallbackEntries(block.fallback_models, harness)
+    fallbacks: resolveFallbackEntries2(block.fallback_models, harness)
   };
 }
 function resolveDreamerTaskModel2(args) {
@@ -84,7 +84,7 @@ function resolveDreamerTaskModel2(args) {
     };
   }
   const taskQualifier = taskBlock?.[args.harness === "opencode" ? "variant" : "thinking_level"];
-  const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry(harnessBlock.model, args.harness)?.qualifier;
+  const harnessQualifier = harnessBlock[args.harness === "opencode" ? "variant" : "thinking_level"] ?? normalizeModelEntry2(harnessBlock.model, args.harness)?.qualifier;
   const taskHasModel = taskBlock !== undefined && hasOwn(taskBlock, "model");
   const usesMuralModel = !taskHasModel && args.task === "compress-cues" && Boolean(readString(args.muralModel));
   const primarySource = taskHasModel ? taskBlock?.model : usesMuralModel ? args.muralModel : harnessBlock.model;
@@ -95,7 +95,7 @@ function resolveDreamerTaskModel2(args) {
       defaultQualifier: usesMuralModel ? harnessQualifier : taskQualifier ?? harnessQualifier,
       harness: args.harness
     }),
-    fallbacks: resolveFallbackEntries(fallbackSource, args.harness),
+    fallbacks: resolveFallbackEntries2(fallbackSource, args.harness),
     schedule: readString(schedulingTask?.schedule),
     timeoutMinutes: typeof taskBlock?.timeout_minutes === "number" ? taskBlock.timeout_minutes : undefined,
     promotionThreshold: typeof schedulingTask?.promotion_threshold === "number" ? schedulingTask.promotion_threshold : undefined
@@ -134,4 +134,4 @@ function resolveHistorianAgentOverrides2(agent) {
   };
 }
 
-export { resolveHistorianModel2, resolveDreamerTaskModel2, resolveOpenCodeAgentOverrides2, resolveHistorianAgentOverrides2 };
+export { normalizeModelEntry2, resolveFallbackEntries2, resolveHistorianModel2, resolveDreamerTaskModel2, resolveOpenCodeAgentOverrides2, resolveHistorianAgentOverrides2 };

package/dist/{index-9y5p0d50.js → index-vvtfyw1z.js}

@@ -2,89 +2,26 @@ import {
   getHarness,
   getDataDir,
   getMagicContextStorageDir
-} from "./index-s70wtd8k.js";
+} from "./index-q6hef7fh.js";
 import {
+  log,
   sessionLog
-} from "./index-3bygzk2d.js";
+} from "./index-hybnrwq0.js";
 import {
   localBudget,
   calibrationForModelKey
-} from "./index-y5145x8k.js";
+} from "./index-n96ag4rk.js";
+import {
+  shouldEnforcePrivateStoragePermissions
+} from "./index-e44zzy84.js";
+import {
+  modelRefLookupOrder
+} from "./index-avwt563y.js";
 
 // src/shared/models-dev-cache.ts
 import { mkdirSync, readFileSync as readFileSync2, renameSync, writeFileSync } from "node:fs";
 import { join as join2 } from "node:path";
 
-// src/shared/harness-provider-map.ts
-var CANONICAL_TO_PI_PROVIDER = {
-  openai: "openai-codex",
-  google: "google-antigravity"
-};
-var PI_TO_CANONICAL_PROVIDER = {
-  "openai-codex": "openai",
-  "google-antigravity": "google"
-};
-var CANONICAL_TO_OMP_PROVIDER = {
-  openai: "openai-codex",
-  google: "google-antigravity",
-  opencode: "opencode-zen"
-};
-var OMP_TO_CANONICAL_PROVIDER = {
-  "openai-codex": "openai",
-  "google-antigravity": "google",
-  "opencode-zen": "opencode"
-};
-var CANONICAL_MODEL_IDENTITY_ALIASES = {
-  "github-copilot/gpt-6-astra": "openai/gpt-6-astra"
-};
-function remapProviderPrefix(ref, map) {
-  if (typeof ref !== "string")
-    return ref;
-  const slash = ref.indexOf("/");
-  if (slash <= 0)
-    return ref;
-  const provider = ref.slice(0, slash);
-  if (!Object.hasOwn(map, provider))
-    return ref;
-  return `${map[provider]}${ref.slice(slash)}`;
-}
-function canonicalModelIdentity(ref) {
-  const harnessCanonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
-  return CANONICAL_MODEL_IDENTITY_ALIASES[harnessCanonical.toLowerCase()] ?? harnessCanonical;
-}
-function piModelRefToCanonical(ref) {
-  return remapProviderPrefix(ref, PI_TO_CANONICAL_PROVIDER);
-}
-function resolveModelRefForPi(ref) {
-  return remapProviderPrefix(piModelRefToCanonical(ref), CANONICAL_TO_PI_PROVIDER);
-}
-function modelRefLookupOrder(ref) {
-  const canonical = piModelRefToCanonical(ompModelRefToCanonical(ref));
-  return [
-    ...new Set([
-      canonical,
-      ref,
-      resolveModelRefForPi(canonical),
-      resolveModelRefForOmp(canonical)
-    ])
-  ];
-}
-function ompModelRefToCanonical(ref) {
-  return remapProviderPrefix(ref, OMP_TO_CANONICAL_PROVIDER);
-}
-function resolveModelRefForOmp(ref) {
-  return remapProviderPrefix(ompModelRefToCanonical(ref), CANONICAL_TO_OMP_PROVIDER);
-}
-
-// src/shared/storage-permissions.ts
-var enforcePrivateStoragePermissions = true;
-function setStoragePrivatePermissionEnforcement(enforce) {
-  enforcePrivateStoragePermissions = enforce;
-}
-function shouldEnforcePrivateStoragePermissions() {
-  return enforcePrivateStoragePermissions;
-}
-
 // src/shared/window-geometry.ts
 import { readFileSync } from "node:fs";
 import { join } from "node:path";
@@ -745,7 +682,7 @@ function getSdkWindowGeometry(providerID, modelID, detectedContextLimit, options
   });
   if (!result || promptOnlyDetected === undefined)
     return result;
-  const usableSoft = promptOnlyDetected;
+  const usableSoft = isFinitePositive2(metadata.inputLimit) ? Math.min(promptOnlyDetected, result.usableSoft) : promptOnlyDetected;
   return {
     ...result,
     usableSoft,
@@ -877,7 +814,7 @@ function resolveHistorianContextLimit2(historianModelOverride) {
     return resolveKnownHistorianContextLimit2(historianModelOverride) ?? DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
   }
   if (typeof historianModelOverride === "string" && historianModelOverride.trim() !== "") {
-    console.warn(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
+    log(`[magic-context] historian.model "${historianModelOverride}" lacks provider prefix ("provider/model-id"); using the default context limit for chunk-budget derivation.`);
   }
   return DEFAULT_HISTORIAN_CONTEXT_FALLBACK;
 }
@@ -887,4 +824,4 @@ function producerSourceLocalBudget2(providerTokens, modelKey) {
   return ratio === 1 ? providerTokens : localBudget(providerTokens, ratio);
 }
 
-export { canonicalModelIdentity, piModelRefToCanonical, modelRefLookupOrder, setStoragePrivatePermissionEnforcement, shouldEnforcePrivateStoragePermissions, catalogOutputReserve, setWindowOverlayPath, reloadWindowOverlay, hasTrustedAbsoluteWall, applyProvenInputFloor, formatWindowDerivationLine, isSaneLimit, setOutputReserveConfig, resolveLimit, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkWindowGeometry, getSdkContextLimit, modelSupportsVision, getSdkOutputLimit, getModelsDevCacheState, deriveTriggerBudget2, deriveHistorianChunkTokens2, resolveKnownHistorianContextLimit2, resolveHistorianProducerLimits2, resolveHistorianContextLimit2, producerSourceLocalBudget2 };
+export { catalogOutputReserve, setWindowOverlayPath, reloadWindowOverlay, hasTrustedAbsoluteWall, applyProvenInputFloor, formatWindowDerivationLine, isSaneLimit, setOutputReserveConfig, resolveLimit, refreshModelLimitsFromApi, refreshModelLimitsAfterAuthOnce, getSdkWindowGeometry, getSdkContextLimit, modelSupportsVision, getSdkOutputLimit, getModelsDevCacheState, deriveTriggerBudget2, deriveHistorianChunkTokens2, resolveKnownHistorianContextLimit2, resolveHistorianProducerLimits2, resolveHistorianContextLimit2, producerSourceLocalBudget2 };

package/dist/index-w9jwmntv.js

@@ -0,0 +1,202 @@
+// 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 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 {}
+}
+
+export { resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, getOpenCodeDbProbeDescriptions, formatOpenCodeDbMissingBanner, formatOpenCodeDbMissingStatusLine, formatOpenCodeDbReadFailureStatusLine, recordOpenCodeDbReadFailure, clearOpenCodeDbReadFailure, getOpenCodeDbReadFailure, claimOpenCodeDbDiagnosticOnce, closeQuietly };

package/dist/{index-kr5qehbd.js → index-x23gah8c.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./index-3bygzk2d.js";
+} from "./index-hybnrwq0.js";
 
 // src/shared/write-transaction-timing.ts
 var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;

package/dist/{index-jdxxq8cz.js → index-x8a7jmkh.js}

@@ -46,6 +46,11 @@ function acknowledgeNotifications2(ids) {
     return;
   queue = queue.filter((notification) => !acknowledged.has(notification.id));
 }
+function __resetNotificationStateForTests2() {
+  queue = [];
+  nextNotificationId = 1;
+  sinks.clear();
+}
 function cursor(value) {
   return typeof value === "number" && Number.isFinite(value) && value > 0 ? value : 0;
 }
@@ -96,4 +101,4 @@ function isTuiConnected2(sessionId) {
   return false;
 }
 
-export { registerNotificationSink2, pushNotification2, acknowledgeNotifications2, drainNotifications2, isTuiConnected2 };
+export { registerNotificationSink2, pushNotification2, acknowledgeNotifications2, __resetNotificationStateForTests2, drainNotifications2, isTuiConnected2 };