@retaw106/mmc-oc 2.2.1 → 2.3.0

package/dist/index-18yrysyj.js

@@ -0,0 +1,1477 @@
+import {
+  Database,
+  getSqliteDatabasePath
+} from "./index-czba8tw3.js";
+import {
+  harnessOwnsOpenCodeStore,
+  log
+} from "./index-k59af64t.js";
+
+// src/hooks/magic-context/read-session-raw.ts
+import { isMainThread } from "node:worker_threads";
+function isStrictGapHealingMessage(message) {
+  if (message.storeType === "synthetic")
+    return true;
+  let sawTool = false;
+  for (const part of message.parts) {
+    if (!part || typeof part !== "object" || Array.isArray(part))
+      return false;
+    const record = part;
+    const type = typeof record.type === "string" ? record.type : "";
+    if (type === "tool" || type === "tool_use" || type === "tool_result") {
+      sawTool = true;
+      continue;
+    }
+    const text = typeof record.text === "string" ? record.text : typeof record.content === "string" ? record.content : "";
+    if (text.trim().length > 0 || type.length > 0)
+      return false;
+  }
+  return sawTool;
+}
+var RAW_MESSAGE_PARTS_BY_ID_SQL = "SELECT message_id, data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id = ?, 0.000001) ORDER BY time_created ASC, id ASC";
+function isRawMessageRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.id === "string" && typeof candidate.data === "string";
+}
+function isRawPartRow(row) {
+  if (row === null || typeof row !== "object")
+    return false;
+  const candidate = row;
+  return typeof candidate.message_id === "string" && typeof candidate.data === "string";
+}
+function parseJsonRecord(value) {
+  try {
+    const parsed = JSON.parse(value);
+    if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+      return null;
+    }
+    return parsed;
+  } catch {
+    return null;
+  }
+}
+function isRawCompactionSummaryInfo(info) {
+  if (info === null || typeof info !== "object" || Array.isArray(info))
+    return false;
+  const candidate = info;
+  return candidate.summary === true && candidate.finish === "stop";
+}
+var RAW_METADATA_KEEP_CHARS = 16384;
+var RAW_METADATA_KEPT_KEYS = [
+  "description",
+  "title",
+  "userAnswer",
+  "answers",
+  "answer",
+  "selectedOptions",
+  "customInput",
+  "results"
+];
+var RAW_PART_DATA_SQL = `CASE
+    WHEN json_valid(data) = 1
+     AND json_type(data, '$.state.metadata') = 'object'
+     AND COALESCE(json_extract(data, '$.state.status'), '') <> 'error'
+     AND length(json_extract(data, '$.state.metadata')) > ${RAW_METADATA_KEEP_CHARS}
+    THEN json_set(data, '$.state.metadata', json_patch('{}', json_object(${RAW_METADATA_KEPT_KEYS.map((key) => `'${key}', json_extract(data, '$.state.metadata.${key}')`).join(", ")})))
+    ELSE data
+END`;
+function parseJsonUnknown(value) {
+  try {
+    return JSON.parse(value);
+  } catch {
+    return null;
+  }
+}
+function attachRawPartVersion(value, timeUpdated) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    return value;
+  if (typeof timeUpdated !== "number")
+    return value;
+  try {
+    Object.defineProperty(value, "__magicContextPartUpdatedAt", {
+      value: timeUpdated,
+      enumerable: false,
+      configurable: true
+    });
+  } catch {}
+  return value;
+}
+function readRawSessionMessagesFromDb(db, sessionId) {
+  const messageRows = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? ORDER BY time_created ASC, id ASC").all(sessionId).filter(isRawMessageRow);
+  const partsByMessageId = new Map;
+  const partMessageBatchSize = 128;
+  for (let offset = 0;offset < messageRows.length; offset += partMessageBatchSize) {
+    const messageIds = messageRows.slice(offset, offset + partMessageBatchSize).map((row) => row.id);
+    if (messageIds.length === 0)
+      continue;
+    const placeholders = messageIds.map(() => "?").join(", ");
+    const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated
+                 FROM part
+                 WHERE +session_id = ?
+                   AND likelihood(message_id IN (${placeholders}), 0.000001)
+                 ORDER BY message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageIds).filter(isRawPartRow);
+    for (const part of partRows) {
+      const list = partsByMessageId.get(part.message_id) ?? [];
+      list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
+      partsByMessageId.set(part.message_id, list);
+    }
+  }
+  const filtered = messageRows.filter((row) => !isRawCompactionSummaryInfo(parseJsonRecord(row.data)));
+  return filtered.flatMap((row, index) => {
+    const info = parseJsonRecord(row.data);
+    if (!info)
+      return [];
+    const role = typeof info.role === "string" ? info.role : "unknown";
+    return {
+      ordinal: index + 1,
+      id: row.id,
+      role,
+      parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
+      version: row.time_updated ?? null
+    };
+  });
+}
+function readRawSessionMessagePageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark = Number.MAX_SAFE_INTEGER, after) {
+  const messageRows = readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  if (messageRows.length === 0)
+    return [];
+  const placeholders = messageRows.map(() => "?").join(", ");
+  const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated
+             FROM part
+             WHERE +session_id = ?
+               AND likelihood(message_id IN (${placeholders}), 0.000001)
+             ORDER BY message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageRows.map((row) => row.id)).filter(isRawPartRow);
+  return assembleRawMessagePage(messageRows, partRows);
+}
+function readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
+  try {
+    return readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  } catch (error) {
+    if (error !== ORDINALS_COLD)
+      throw error;
+    if (warmRawSessionOrdinalsForDb(db, sessionId)) {
+      try {
+        return readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+      } catch (retry) {
+        if (retry !== ORDINALS_COLD)
+          throw retry;
+      }
+    }
+    return readRawMessagePageRowsOffset(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  }
+}
+var ORDINALS_COLD = Symbol("mmcCanonicalOrdinalsCold");
+function readRawMessagePageRowsBounded(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
+  const remaining = Math.max(0, Math.floor(finalWatermark) - Math.floor(afterOrdinal));
+  const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
+  if (pageSize === 0)
+    return [];
+  return withReadSnapshot(db, () => {
+    const ordinal = Math.max(0, Math.floor(afterOrdinal));
+    const points = currentOrdinalCheckpoints(db, sessionId)?.scan.checkpoints ?? [];
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (points[middle].ordinal <= ordinal)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    const floor = points[low - 1];
+    const useFloor = floor && (!after || compareOrdinalKeys(floor, after) > 0);
+    const anchor = useFloor ? floor : after;
+    const skip = anchor === after && after ? 0 : ordinal - (floor?.ordinal ?? 0);
+    if (skip > ORDINAL_LOOKUP_LIMIT)
+      throw ORDINALS_COLD;
+    const rawLimit = skip + pageSize + ORDINAL_LOOKUP_LIMIT;
+    const rows = db.prepare(`SELECT id, data, time_created, time_updated, ${EXCLUDED_ROW_SQL} AS excluded
+                FROM message WHERE id IN (
+                    SELECT id FROM message WHERE session_id = ?
+                    ${anchor ? "AND (time_created, id) > (?, ?)" : ""}
+                    ORDER BY time_created, id LIMIT ?)
+                ORDER BY time_created, id`).all(sessionId, ...anchor ? [anchor.timeCreated, anchor.id] : [], rawLimit);
+    rawMessagePageRowsVisited += rows.length;
+    const eligible = rows.filter((row) => row.excluded !== 1);
+    if (eligible.length <= skip && rows.length === rawLimit)
+      throw ORDINALS_COLD;
+    return eligible.slice(skip, skip + pageSize).filter(isRawMessageRow).map((row, index) => ({
+      ...row,
+      ordinal: ordinal + index + 1
+    }));
+  });
+}
+var rawMessagePageRowsVisited = 0;
+function readRawMessagePageRowsOffset(db, sessionId, afterOrdinal, limit, finalWatermark, after) {
+  const remaining = Math.max(0, Math.floor(finalWatermark) - Math.floor(afterOrdinal));
+  const pageSize = Math.min(Math.max(1, Math.floor(limit)), remaining);
+  if (pageSize === 0)
+    return [];
+  const parameters = [sessionId];
+  if (after)
+    parameters.push(after.timeCreated, after.timeCreated, after.timeCreated, after.id);
+  parameters.push(pageSize);
+  if (!after)
+    parameters.push(Math.max(0, Math.floor(afterOrdinal)));
+  return db.prepare(`SELECT id, data, time_created, time_updated
+             FROM message
+             WHERE session_id = ?
+                ${after ? "AND time_created >= ? AND (time_created > ? OR (time_created = ? AND id > ?))" : ""}
+                AND NOT (
+                   CASE WHEN json_valid(data) = 1
+                        THEN COALESCE(json_extract(data, '$.summary'), 0)
+                        ELSE 0 END = 1
+                   AND CASE WHEN json_valid(data) = 1
+                            THEN COALESCE(json_extract(data, '$.finish'), '')
+                            ELSE '' END = 'stop'
+               )
+             ORDER BY time_created ASC, id ASC
+             LIMIT ? ${after ? "" : "OFFSET ?"}`).all(...parameters).filter(isRawMessageRow).map((row, index) => ({
+    ...row,
+    ordinal: Math.floor(afterOrdinal) + index + 1
+  }));
+}
+function assembleRawMessagePage(messageRows, partRows) {
+  const partsByMessageId = new Map;
+  for (const part of partRows) {
+    const list = partsByMessageId.get(part.message_id) ?? [];
+    list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
+    partsByMessageId.set(part.message_id, list);
+  }
+  return messageRows.map((row) => {
+    const info = parseJsonRecord(row.data);
+    return {
+      ordinal: row.ordinal,
+      id: row.id,
+      role: typeof info?.role === "string" ? info.role : "unknown",
+      parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
+      version: row.time_updated ?? null
+    };
+  });
+}
+var RAW_SUMMARY_TEXT_MAX_CHARS = 8192;
+var RAW_SUMMARY_ARG_MAX_CHARS = 512;
+var RAW_SUMMARY_TOOL_INPUT_KEYS = [
+  "description",
+  "filePath",
+  "path",
+  "pattern",
+  "query",
+  "symbol",
+  "module",
+  "action"
+];
+function summaryStringField(jsonPath) {
+  return `CASE WHEN json_type(data, '${jsonPath}') = 'text' THEN substr(json_extract(data, '${jsonPath}'), 1, ${RAW_SUMMARY_ARG_MAX_CHARS}) END`;
+}
+var RAW_SUMMARY_PART_DATA_SQL = `CASE
+    WHEN json_extract(data, '$.type') = 'text'
+        THEN json_set(data, '$.text', substr(json_extract(data, '$.text'), 1, ${RAW_SUMMARY_TEXT_MAX_CHARS}))
+    ELSE json_object(
+        'type', 'tool',
+        'tool', ${summaryStringField("$.tool")},
+        'callID', ${summaryStringField("$.callID")},
+        'state', json_object(
+            'status', ${summaryStringField("$.state.status")},
+            'input', json_object(${RAW_SUMMARY_TOOL_INPUT_KEYS.map((key) => `'${key}', ${summaryStringField(`$.state.input.${key}`)}`).join(", ")}),
+            'metadata', json_object('description', ${summaryStringField("$.state.metadata.description")})
+        )
+    )
+END`;
+function readRawSessionMessageSummaryPageFromDb(db, sessionId, afterOrdinal, limit, finalWatermark = Number.MAX_SAFE_INTEGER, after) {
+  const messageRows = readRawMessagePageRows(db, sessionId, afterOrdinal, limit, finalWatermark, after);
+  if (messageRows.length === 0)
+    return [];
+  const placeholders = messageRows.map(() => "?").join(", ");
+  const partRows = db.prepare(`SELECT message_id, ${RAW_SUMMARY_PART_DATA_SQL} AS data, time_updated
+             FROM part
+             WHERE +session_id = ?
+               AND likelihood(message_id IN (${placeholders}), 0.000001)
+               AND json_valid(data) = 1
+               AND json_extract(data, '$.type') IN ('text', 'tool')
+             ORDER BY message_id ASC, time_created ASC, id ASC`).all(sessionId, ...messageRows.map((row) => row.id)).filter(isRawPartRow);
+  return assembleRawMessagePage(messageRows, partRows);
+}
+function countRawSessionMessageOrdinalsFromDb(db, sessionId) {
+  const indexed = countCanonicalOrdinalsIndexed(db, sessionId, null, null);
+  if (indexed !== null)
+    return indexed;
+  const row = db.prepare(`SELECT COUNT(*) AS count
+             FROM message
+             WHERE session_id = ?
+               AND NOT (
+                   CASE WHEN json_valid(data) = 1
+                        THEN COALESCE(json_extract(data, '$.summary'), 0)
+                        ELSE 0 END = 1
+                   AND CASE WHEN json_valid(data) = 1
+                            THEN COALESCE(json_extract(data, '$.finish'), '')
+                            ELSE '' END = 'stop'
+               )`).get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function readRawSessionMessageIdOrdinalsForRangeFromDb(db, sessionId, fromOrdinal, toOrdinal) {
+  const from = Math.max(1, Math.floor(fromOrdinal));
+  const to = Math.floor(toOrdinal);
+  if (to < from)
+    return new Map;
+  const rows = db.prepare(`
+        SELECT id, data FROM message WHERE session_id = ?
+          AND CASE WHEN json_valid(data) THEN NOT (
+            COALESCE(json_type(data, '$.summary'), '') = 'true'
+            AND COALESCE(json_extract(data, '$.finish'), '') = 'stop'
+          ) ELSE 1 END
+        ORDER BY time_created, id LIMIT ? OFFSET ?
+    `).all(sessionId, to - from + 1, from - 1).filter(isRawMessageRow);
+  const result = new Map;
+  for (const [index, row] of rows.entries()) {
+    if (parseJsonRecord(row.data))
+      result.set(row.id, from + index);
+  }
+  return result;
+}
+function isAnchorRow(row) {
+  return row !== null && typeof row === "object" && typeof row.time_created === "number" && typeof row.id === "string";
+}
+function readRawSessionTailFromDb(db, sessionId, baseOrdinal, anchorMessageId) {
+  const anchorRow = db.prepare("SELECT time_created, id, data FROM message WHERE id = ? AND session_id = ?").get(anchorMessageId, sessionId);
+  if (!isAnchorRow(anchorRow))
+    return null;
+  const anchorInfo = parseJsonRecord(anchorRow.data ?? "");
+  if (anchorInfo?.summary === true && anchorInfo?.finish === "stop")
+    return null;
+  const messageRows = db.prepare(`SELECT id, data, time_created, time_updated FROM message
+             WHERE session_id = ?
+               AND (time_created > ? OR (time_created = ? AND id >= ?))
+             ORDER BY time_created ASC, id ASC`).all(sessionId, anchorRow.time_created, anchorRow.time_created, anchorRow.id).filter(isRawMessageRow);
+  const filtered = messageRows.filter((row) => {
+    const info = parseJsonRecord(row.data);
+    return !(info?.summary === true && info?.finish === "stop");
+  });
+  const ids = filtered.map((row) => row.id);
+  const partsByMessageId = new Map;
+  if (ids.length > 0) {
+    const CHUNK = 800;
+    for (let i = 0;i < ids.length; i += CHUNK) {
+      const slice = ids.slice(i, i + CHUNK);
+      const placeholders = slice.map(() => "?").join(",");
+      const partRows = db.prepare(`SELECT message_id, ${RAW_PART_DATA_SQL} AS data, time_updated FROM part WHERE +session_id = ? AND likelihood(message_id IN (${placeholders}), 0.000001) ORDER BY time_created ASC, id ASC`).all(sessionId, ...slice).filter(isRawPartRow);
+      for (const part of partRows) {
+        const list = partsByMessageId.get(part.message_id) ?? [];
+        list.push(attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated));
+        partsByMessageId.set(part.message_id, list);
+      }
+    }
+  }
+  const messages = [];
+  let ord = baseOrdinal;
+  for (const row of filtered) {
+    const info = parseJsonRecord(row.data);
+    if (!info) {
+      ord += 1;
+      continue;
+    }
+    messages.push({
+      ordinal: ord,
+      id: row.id,
+      role: typeof info.role === "string" ? info.role : "unknown",
+      parts: partsByMessageId.get(row.id) ?? [],
+      createdAt: row.time_created ?? null,
+      version: row.time_updated ?? null
+    });
+    ord += 1;
+  }
+  return { messages, absoluteMessageCount: Math.max(0, ord - 1) };
+}
+function extractInMemoryMessageViews(messages) {
+  return messages.map((m) => {
+    const info = m.info ?? {};
+    return {
+      id: typeof info.id === "string" ? info.id : "",
+      role: typeof info.role === "string" ? info.role : "unknown",
+      parts: Array.isArray(m.parts) ? m.parts : [],
+      summary: info.summary === true ? true : undefined,
+      finish: typeof info.finish === "string" ? info.finish : undefined
+    };
+  });
+}
+function buildInMemoryTailRawMessages(args) {
+  const { messages, lastCompartmentEnd, anchorMessageId } = args;
+  const filtered = messages.filter((m) => !(m.summary === true && m.finish === "stop"));
+  if (filtered.length === 0)
+    return null;
+  let startIndex = 0;
+  let baseOrdinal;
+  let anchorFound = false;
+  if (anchorMessageId) {
+    const anchorIndex = filtered.findIndex((m) => m.id === anchorMessageId);
+    if (anchorIndex >= 0) {
+      anchorFound = true;
+      startIndex = anchorIndex;
+      baseOrdinal = lastCompartmentEnd;
+    } else {
+      baseOrdinal = Math.max(1, lastCompartmentEnd + 1);
+    }
+  } else {
+    baseOrdinal = Math.max(1, lastCompartmentEnd + 1);
+  }
+  const out = [];
+  let ord = baseOrdinal;
+  for (let i = startIndex;i < filtered.length; i += 1) {
+    const m = filtered[i];
+    if (!m.id || typeof m.id !== "string") {
+      ord += 1;
+      continue;
+    }
+    out.push({
+      ordinal: ord,
+      id: m.id,
+      role: typeof m.role === "string" ? m.role : "unknown",
+      parts: m.parts ?? [],
+      version: null
+    });
+    ord += 1;
+  }
+  return { messages: out, absoluteMessageCount: Math.max(0, ord - 1), anchorFound };
+}
+var ORDINAL_SUMMARY_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.summary'), 0)
+        ELSE 0 END = 1)`;
+var ORDINAL_STOP_FLAG_SQL = `(CASE WHEN json_valid(data) = 1
+        THEN COALESCE(json_extract(data, '$.finish'), '')
+        ELSE '' END = 'stop')`;
+function ordinalRangeSql(lowerBound) {
+  return `SELECT COUNT(*) AS visited,
+                   COALESCE(SUM(CASE WHEN ${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL}
+                                     THEN 0 ELSE 1 END), 0) AS eligible
+            FROM message
+            WHERE session_id = ?
+              ${lowerBound ? "AND (time_created, id) > (?, ?)" : ""}
+              AND (time_created, id) <= (?, ?)`;
+}
+var ORDINAL_RANGE_FROM_START_SQL = ordinalRangeSql(false);
+var ORDINAL_RANGE_BETWEEN_SQL = ordinalRangeSql(true);
+function readStoreStamp(db) {
+  try {
+    const row = db.prepare(`SELECT data_version AS dataVersion, total_changes() AS totalChanges,
+                        (SELECT schema_version FROM pragma_schema_version) AS schemaVersion
+                 FROM pragma_data_version`).get();
+    if (typeof row?.dataVersion !== "number" || typeof row.totalChanges !== "number" || typeof row.schemaVersion !== "number")
+      return null;
+    return {
+      dataVersion: row.dataVersion,
+      totalChanges: row.totalChanges,
+      schemaVersion: row.schemaVersion
+    };
+  } catch {
+    return null;
+  }
+}
+function sameStoreStamp(left, right) {
+  return left !== null && right !== null && left.dataVersion === right.dataVersion && left.totalChanges === right.totalChanges && left.schemaVersion === right.schemaVersion;
+}
+var ordinalWatermarks = new WeakMap;
+var ordinalWatermarkEpochs = new Map;
+var ordinalRowsVisited = 0;
+var STABLE_STORE_ATTEMPTS = 3;
+function compareOrdinalKeys(left, right) {
+  if (left.timeCreated !== right.timeCreated)
+    return left.timeCreated < right.timeCreated ? -1 : 1;
+  if (left.id === right.id)
+    return 0;
+  return Buffer.compare(Buffer.from(left.id, "utf8"), Buffer.from(right.id, "utf8"));
+}
+function countEligibleOrdinals(db, sessionId, after, through) {
+  const indexed = countCanonicalOrdinalsIndexed(db, sessionId, after, through);
+  if (indexed !== null)
+    return indexed;
+  const row = after ? db.prepare(ORDINAL_RANGE_BETWEEN_SQL).get(sessionId, after.timeCreated, after.id, through.timeCreated, through.id) : db.prepare(ORDINAL_RANGE_FROM_START_SQL).get(sessionId, through.timeCreated, through.id);
+  const visited = typeof row?.visited === "number" ? row.visited : 0;
+  ordinalRowsVisited += visited;
+  ordinalJsonRowsRead += visited;
+  return typeof row?.eligible === "number" ? row.eligible : 0;
+}
+var EXCLUDED_ROW_SQL = `${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL}`;
+var SUMMARY_ANCHOR_SPAN = 256;
+var SUMMARY_ANCHOR_LIMIT = 64;
+var summaryCandidateSets = new WeakMap;
+var summaryCandidateEpochs = new Map;
+var writtenSummaryIds = new Map;
+var indexedCountUnsupported = new WeakSet;
+var ordinalJsonRowsRead = 0;
+var summaryFullScans = 0;
+var ANCHOR_ROWS_SQL = `SELECT rowid AS rid, id, 1 AS kind FROM message
+    WHERE rowid > (SELECT MAX(rowid) FROM message) - ${SUMMARY_ANCHOR_SPAN}`;
+var SUMMARY_FULL_SCAN_SQL = `${ANCHOR_ROWS_SQL}
+    UNION ALL
+    SELECT rowid, id, 2 FROM message WHERE session_id = ? AND ${ORDINAL_SUMMARY_FLAG_SQL}
+    UNION ALL
+    SELECT COUNT(*), NULL, 4 FROM message WHERE session_id = ?`;
+var SUMMARY_SCAN_AFTER_SQL = `${ANCHOR_ROWS_SQL}
+    UNION ALL
+    SELECT rowid, id, CASE WHEN ${ORDINAL_SUMMARY_FLAG_SQL} THEN 2 ELSE 3 END
+    FROM message WHERE rowid > ? AND +session_id = ?`;
+var ANCHOR_CHECK_SQL = "SELECT rowid AS rid, id FROM message WHERE rowid IN (SELECT value FROM json_each(?))";
+function survivingAnchor(db, set) {
+  if (set.anchors.length === 0)
+    return null;
+  const current = new Map(db.prepare(ANCHOR_CHECK_SQL).all(JSON.stringify(set.anchors.map((anchor) => anchor.rowid))).map((row) => [row.rid, row.id]));
+  return set.anchors.find((anchor) => current.get(anchor.rowid) === anchor.id);
+}
+var ordinalCheckpoints = new WeakMap;
+var ordinalSummarySeeds = new WeakMap;
+var ORDINAL_LOOKUP_LIMIT = 512;
+function currentOrdinalCheckpoints(db, sessionId) {
+  const cached = ordinalCheckpoints.get(db)?.get(sessionId);
+  if (!cached)
+    return;
+  return withReadSnapshot(db, () => {
+    if (!extendOrdinalCheckpoints(db, sessionId, cached.scan, ORDINAL_LOOKUP_LIMIT))
+      return;
+    cached.epoch = getRawSessionSummaryEpoch(sessionId);
+    return cached;
+  });
+}
+function extendOrdinalCheckpoints(db, sessionId, scan, limit) {
+  const points = scan.checkpoints ?? [];
+  const exists = (point) => Boolean(db.prepare("SELECT 1 FROM message WHERE id=? AND session_id=? AND time_created=?").get(point.id, sessionId, point.timeCreated));
+  if (points.length && !exists(points[points.length - 1])) {
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (exists(points[middle]))
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    points.length = low;
+    scan.total = points.at(-1)?.ordinal ?? 0;
+    scan.sessionRows = points.at(-1)?.storedCount ?? 0;
+  }
+  const tail = points.at(-1);
+  const rows = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message
+        WHERE session_id=?${tail ? " AND (time_created,id) > (?,?)" : ""}
+        ORDER BY time_created,id${limit === undefined ? "" : ` LIMIT ${limit + 1}`}`).all(sessionId, ...tail ? [tail.timeCreated, tail.id] : []);
+  ordinalJsonRowsRead += rows.length;
+  if (limit !== undefined && rows.length > limit)
+    return false;
+  let total = scan.total ?? 0;
+  if (rows.length && tail && (tail.storedCount ?? 0) % 256 !== 0)
+    points.pop();
+  for (let index = 0;index < rows.length; index++) {
+    const row = rows[index];
+    if (row.excluded !== 1)
+      total++;
+    const storedCount = scan.sessionRows + index + 1;
+    if (storedCount % 256 === 0 || index === rows.length - 1)
+      points.push({ id: row.id, timeCreated: row.timeCreated, ordinal: total, storedCount });
+  }
+  scan.checkpoints = points;
+  scan.sessionRows += rows.length;
+  scan.total = total;
+  return true;
+}
+function warmRawSessionOrdinalsForDb(db, sessionId) {
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return true;
+  try {
+    const epoch = getRawSessionSummaryEpoch(sessionId);
+    const scan = scanRawSessionSummaryRows(db, sessionId);
+    installRawSessionSummaryScan(db, sessionId, scan, epoch, true);
+  } catch {
+    return false;
+  }
+  return isRawSessionSummaryWarm(db, sessionId);
+}
+function boundedOrdinalPrefix(db, sessionId, through) {
+  try {
+    return boundedOrdinalPrefixBounded(db, sessionId, through);
+  } catch (error) {
+    if (error !== ORDINALS_COLD)
+      throw error;
+    if (warmRawSessionOrdinalsForDb(db, sessionId)) {
+      try {
+        return boundedOrdinalPrefixBounded(db, sessionId, through);
+      } catch (retry) {
+        if (retry !== ORDINALS_COLD)
+          throw retry;
+      }
+    }
+    const bindings = [sessionId];
+    if (through)
+      bindings.push(through.timeCreated, through.id);
+    const rows = db.prepare(`SELECT ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE id IN (
+        SELECT id FROM message WHERE session_id = ?${through ? " AND (time_created, id) <= (?, ?)" : ""}
+        ORDER BY time_created, id)`).all(...bindings);
+    ordinalRowsVisited += rows.length;
+    ordinalJsonRowsRead += rows.length;
+    return rows.reduce((sum, row) => sum + (row.excluded === 1 ? 0 : 1), 0);
+  }
+}
+function boundedOrdinalPrefixBounded(db, sessionId, through) {
+  const cached = currentOrdinalCheckpoints(db, sessionId);
+  if (cached && through === null)
+    return cached.scan.total ?? 0;
+  let floor;
+  if (cached && through) {
+    const points = cached.scan.checkpoints ?? [];
+    let low = 0;
+    let high = points.length;
+    while (low < high) {
+      const middle = Math.floor((low + high) / 2);
+      if (compareOrdinalKeys(points[middle], through) <= 0)
+        low = middle + 1;
+      else
+        high = middle;
+    }
+    floor = points[low - 1];
+    if (floor && compareOrdinalKeys(floor, through) === 0)
+      return floor.ordinal;
+  }
+  const bindings = [sessionId];
+  if (floor)
+    bindings.push(floor.timeCreated, floor.id);
+  if (through)
+    bindings.push(through.timeCreated, through.id);
+  const rows = db.prepare(`SELECT ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE id IN (
+        SELECT id FROM message WHERE session_id = ?${floor ? " AND (time_created, id) > (?, ?)" : ""}${through ? " AND (time_created, id) <= (?, ?)" : ""}
+        ORDER BY time_created, id LIMIT ${ORDINAL_LOOKUP_LIMIT + 1})`).all(...bindings);
+  ordinalRowsVisited += rows.length;
+  ordinalJsonRowsRead += rows.length;
+  if (rows.length > ORDINAL_LOOKUP_LIMIT)
+    throw ORDINALS_COLD;
+  return (floor?.ordinal ?? 0) + rows.reduce((sum, row) => sum + (row.excluded === 1 ? 0 : 1), 0);
+}
+function scanRawSessionSummaryRows(db, sessionId, previous) {
+  return withReadSnapshot(db, () => {
+    if (previous?.checkpoints) {
+      extendOrdinalCheckpoints(db, sessionId, previous);
+      return previous;
+    }
+    if (previous) {
+      const sessions = summaryCandidateSets.get(db) ?? new Map;
+      sessions.set(sessionId, {
+        epoch: getRawSessionSummaryEpoch(sessionId),
+        anchors: previous.anchors,
+        ids: new Set(previous.ids)
+      });
+      summaryCandidateSets.set(db, sessions);
+    }
+    const incremental = previous && isRawSessionSummaryWarm(db, sessionId) ? summaryCandidatesOf(db, sessionId) : undefined;
+    const rows = incremental ? [] : db.prepare(SUMMARY_FULL_SCAN_SQL).all(sessionId, sessionId);
+    const anchors = [];
+    const ids = [];
+    let sessionRows = 0;
+    for (const row of rows) {
+      if (row.kind === 1 && typeof row.rid === "number" && typeof row.id === "string")
+        anchors.push({ rowid: row.rid, id: row.id });
+      else if (row.kind === 2 && typeof row.id === "string")
+        ids.push(row.id);
+      else if (row.kind === 4 && typeof row.rid === "number")
+        sessionRows = row.rid;
+    }
+    if (incremental) {
+      ids.push(...incremental.ids);
+      anchors.push(...summaryCandidateSets.get(db)?.get(sessionId)?.anchors ?? []);
+      sessionRows = countStoredRawSessionRowsIndexed(db, sessionId);
+    }
+    anchors.sort((left, right) => right.rowid - left.rowid);
+    anchors.length = Math.min(anchors.length, SUMMARY_ANCHOR_LIMIT);
+    const keys = db.prepare(`SELECT id, time_created AS timeCreated, ${EXCLUDED_ROW_SQL} AS excluded FROM message WHERE session_id = ?
+        ORDER BY time_created, id`).all(sessionId);
+    const checkpoints = [];
+    let total = 0;
+    for (let index = 0;index < keys.length; index++) {
+      const key = keys[index];
+      if (key.excluded !== 1)
+        total++;
+      if (index % 256 === 255 || index === keys.length - 1)
+        checkpoints.push({
+          id: key.id,
+          timeCreated: key.timeCreated,
+          ordinal: total,
+          storedCount: index + 1
+        });
+    }
+    return { anchors, ids, sessionRows, checkpoints, total };
+  });
+}
+function getRawSessionSummaryEpoch(sessionId) {
+  return summaryCandidateEpochs.get(sessionId) ?? 0;
+}
+function installRawSessionSummaryScan(db, sessionId, scan, epoch, workerPrepared = false) {
+  if (epoch !== getRawSessionSummaryEpoch(sessionId))
+    return false;
+  const seeds = ordinalSummarySeeds.get(db) ?? new Map;
+  seeds.set(sessionId, { epoch, scan });
+  ordinalSummarySeeds.set(db, seeds);
+  if (scan.checkpoints && workerPrepared) {
+    const counts = ordinalCheckpoints.get(db) ?? new Map;
+    counts.set(sessionId, { epoch, scan });
+    ordinalCheckpoints.set(db, counts);
+  } else if (getSqliteDatabasePath(db) && isMainThread)
+    return false;
+  if (isRawSessionSummaryWarm(db, sessionId))
+    return true;
+  let sessions = summaryCandidateSets.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    summaryCandidateSets.set(db, sessions);
+  }
+  sessions.set(sessionId, { epoch, anchors: [...scan.anchors], ids: new Set(scan.ids) });
+  return isRawSessionSummaryWarm(db, sessionId);
+}
+function isRawSessionSummaryWarm(db, sessionId) {
+  if (isMainThread && getSqliteDatabasePath(db)) {
+    return Boolean(currentOrdinalCheckpoints(db, sessionId));
+  }
+  const set = summaryCandidateSets.get(db)?.get(sessionId);
+  if (!set || set.epoch !== getRawSessionSummaryEpoch(sessionId))
+    return false;
+  try {
+    return survivingAnchor(db, set) !== undefined;
+  } catch {
+    return false;
+  }
+}
+function countStoredRawSessionRowsIndexed(db, sessionId) {
+  const row = db.prepare("SELECT COUNT(*) AS count FROM message WHERE session_id = ?").get(sessionId);
+  return typeof row?.count === "number" ? row.count : 0;
+}
+function summaryCandidatesOf(db, sessionId) {
+  let sessions = summaryCandidateSets.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    summaryCandidateSets.set(db, sessions);
+  }
+  const epoch = getRawSessionSummaryEpoch(sessionId);
+  const cached = sessions.get(sessionId);
+  const floor = cached && cached.epoch === epoch ? survivingAnchor(db, cached) : undefined;
+  let ids;
+  let anchors;
+  if (floor === undefined) {
+    const scan = scanRawSessionSummaryRows(db, sessionId);
+    summaryFullScans += 1;
+    ordinalJsonRowsRead += scan.sessionRows;
+    ids = new Set(scan.ids);
+    anchors = scan.anchors;
+  } else {
+    const rows = db.prepare(SUMMARY_SCAN_AFTER_SQL).all(floor?.rowid ?? 0, sessionId);
+    ids = cached?.ids ?? new Set;
+    anchors = [];
+    for (const row of rows) {
+      if (row.kind === 1 && typeof row.rid === "number" && typeof row.id === "string")
+        anchors.push({ rowid: row.rid, id: row.id });
+      else if (row.kind === 2 && typeof row.id === "string")
+        ids.add(row.id);
+      if (row.kind === 2 || row.kind === 3)
+        ordinalJsonRowsRead += 1;
+    }
+    anchors.sort((left, right) => right.rowid - left.rowid);
+    anchors.length = Math.min(anchors.length, SUMMARY_ANCHOR_LIMIT);
+  }
+  for (const id of writtenSummaryIds.get(sessionId) ?? [])
+    ids.add(id);
+  sessions.set(sessionId, { epoch, anchors, ids });
+  const top = anchors[0];
+  return { ids: [...ids], floorRowid: top?.rowid ?? 0, floorId: top?.id ?? null };
+}
+function canonicalCountSql(lower, upper) {
+  const range = `${lower ? " AND (time_created, id) > (?, ?)" : ""}${upper ? " AND (time_created, id) <= (?, ?)" : ""}`;
+  return `SELECT
+        (SELECT COUNT(*) FROM message WHERE session_id = ?${range}) AS stored,
+        (SELECT COUNT(*) FROM message
+          WHERE id IN (SELECT value FROM json_each(?)) AND +session_id = ?${range}
+            AND ${EXCLUDED_ROW_SQL}) AS knownExcluded,
+        (SELECT COUNT(*) FROM message
+          WHERE rowid > ? AND +session_id = ? AND id NOT IN (SELECT value FROM json_each(?))${range}
+            AND ${EXCLUDED_ROW_SQL}) AS newExcluded,
+        (SELECT id FROM message WHERE rowid = ?) AS floorId`;
+}
+var CANONICAL_COUNT_SQL = new Map;
+function canonicalCountStatementText(lower, upper) {
+  const key = `${lower}:${upper}`;
+  let sql = CANONICAL_COUNT_SQL.get(key);
+  if (!sql) {
+    sql = canonicalCountSql(lower, upper);
+    CANONICAL_COUNT_SQL.set(key, sql);
+  }
+  return sql;
+}
+function countCanonicalOrdinalsIndexed(db, sessionId, after, through) {
+  if (isMainThread && getSqliteDatabasePath(db)) {
+    return withReadSnapshot(db, () => boundedOrdinalPrefix(db, sessionId, through) - (after ? boundedOrdinalPrefix(db, sessionId, after) : 0));
+  }
+  if (indexedCountUnsupported.has(db))
+    return null;
+  const range = [];
+  if (after)
+    range.push(after.timeCreated, after.id);
+  if (through)
+    range.push(through.timeCreated, through.id);
+  try {
+    return withReadSnapshot(db, () => {
+      for (let attempt = 0;attempt < STABLE_STORE_ATTEMPTS; attempt += 1) {
+        const view = summaryCandidatesOf(db, sessionId);
+        const ids = JSON.stringify(view.ids);
+        const row = db.prepare(canonicalCountStatementText(after !== null, through !== null)).get(sessionId, ...range, ids, sessionId, ...range, view.floorRowid, sessionId, ids, ...range, view.floorRowid);
+        if (view.floorId !== null && row?.floorId !== view.floorId)
+          continue;
+        const stored = typeof row?.stored === "number" ? row.stored : 0;
+        const excluded = (typeof row?.knownExcluded === "number" ? row.knownExcluded : 0) + (typeof row?.newExcluded === "number" ? row.newExcluded : 0);
+        ordinalRowsVisited += stored;
+        ordinalJsonRowsRead += view.ids.length;
+        return stored - excluded;
+      }
+      return null;
+    });
+  } catch (error) {
+    if (/no such (column|table|function)|json_each/i.test(String(error))) {
+      indexedCountUnsupported.add(db);
+      return null;
+    }
+    throw error;
+  }
+}
+function connectionHasOpenTransaction(db) {
+  const state = db;
+  return state.inTransaction === true || state.isTransaction === true;
+}
+function withReadSnapshot(db, read) {
+  if (connectionHasOpenTransaction(db))
+    return read();
+  db.exec("BEGIN");
+  try {
+    return read();
+  } finally {
+    if (connectionHasOpenTransaction(db))
+      db.exec("ROLLBACK");
+  }
+}
+function reusableWatermark(db, sessionId, stamp) {
+  const watermark = ordinalWatermarks.get(db)?.get(sessionId);
+  if (!watermark || watermark.epoch !== (ordinalWatermarkEpochs.get(sessionId) ?? 0) || !sameStoreStamp(watermark.stamp, stamp))
+    return null;
+  return watermark;
+}
+function rememberOrdinalWatermark(db, sessionId, key, ordinal, stamp) {
+  let sessions = ordinalWatermarks.get(db);
+  if (!sessions) {
+    sessions = new Map;
+    ordinalWatermarks.set(db, sessions);
+  }
+  const current = sessions.get(sessionId);
+  if (current && sameStoreStamp(current.stamp, stamp) && compareOrdinalKeys(current, key) >= 0)
+    return;
+  sessions.set(sessionId, {
+    timeCreated: key.timeCreated,
+    id: key.id,
+    ordinal,
+    stamp,
+    epoch: ordinalWatermarkEpochs.get(sessionId) ?? 0
+  });
+}
+function canonicalOrdinalOf(db, sessionId, readTarget) {
+  for (let attempt = 1;; attempt += 1) {
+    const before = readStoreStamp(db);
+    const target = readTarget();
+    if (!target)
+      return null;
+    const watermark = attempt < STABLE_STORE_ATTEMPTS ? reusableWatermark(db, sessionId, before) : null;
+    if (!watermark) {
+      const ordinal = countEligibleOrdinals(db, sessionId, null, target);
+      if (before && sameStoreStamp(before, readStoreStamp(db)))
+        rememberOrdinalWatermark(db, sessionId, target, ordinal, before);
+      return { target, ordinal };
+    }
+    const order = compareOrdinalKeys(target, watermark);
+    const ordinal = order === 0 ? watermark.ordinal : order < 0 ? watermark.ordinal - countEligibleOrdinals(db, sessionId, target, watermark) : watermark.ordinal + countEligibleOrdinals(db, sessionId, watermark, target);
+    if (sameStoreStamp(before, readStoreStamp(db))) {
+      rememberOrdinalWatermark(db, sessionId, target, ordinal, before);
+      return { target, ordinal };
+    }
+  }
+}
+function readRawSessionMessageOrdinalByIdFromDb(db, sessionId, messageId) {
+  const counted = canonicalOrdinalOf(db, sessionId, () => {
+    const row = db.prepare(`SELECT id, time_created, ${ORDINAL_SUMMARY_FLAG_SQL} AND ${ORDINAL_STOP_FLAG_SQL} AS excluded
+                 FROM message WHERE session_id = ? AND id = ?`).get(sessionId, messageId);
+    if (typeof row?.id !== "string" || typeof row.time_created !== "number")
+      return null;
+    return { id: row.id, timeCreated: row.time_created, excluded: row.excluded === 1 };
+  });
+  if (!counted || counted.target.excluded)
+    return null;
+  return counted.ordinal > 0 ? counted.ordinal : null;
+}
+function readRawSessionMessageByIdFromDb(db, sessionId, messageId) {
+  const counted = canonicalOrdinalOf(db, sessionId, () => {
+    const row = db.prepare("SELECT id, data, time_created, time_updated FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
+    if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number")
+      return null;
+    const parsed = parseJsonRecord(row.data);
+    if (!parsed || isRawCompactionSummaryInfo(parsed))
+      return null;
+    return { ...row, timeCreated: row.time_created, info: parsed };
+  });
+  if (!counted)
+    return null;
+  const { target: row, ordinal } = counted;
+  const info = row.info;
+  if (ordinal <= 0) {
+    return null;
+  }
+  const partRows = db.prepare(RAW_MESSAGE_PARTS_BY_ID_SQL).all(sessionId, messageId).filter(isRawPartRow);
+  const role = typeof info.role === "string" ? info.role : "unknown";
+  return {
+    ordinal,
+    id: row.id,
+    role,
+    parts: partRows.map((part) => attachRawPartVersion(parseJsonUnknown(part.data), part.time_updated)),
+    createdAt: row.time_created,
+    version: row.time_updated ?? null
+  };
+}
+function hasRawSessionMessageByIdFromDb(db, sessionId, messageId) {
+  const row = db.prepare("SELECT id, data, time_created FROM message WHERE session_id = ? AND id = ?").get(sessionId, messageId);
+  if (!row || !isRawMessageRow(row) || typeof row.time_created !== "number")
+    return false;
+  const info = parseJsonRecord(row.data);
+  if (!info || isRawCompactionSummaryInfo(info))
+    return false;
+  if (info.summary === 1 && info.finish === "stop")
+    return readRawSessionMessageByIdFromDb(db, sessionId, messageId) !== null;
+  return true;
+}
+var boundaryEndpointCaches = new WeakMap;
+
+// 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 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;
+}
+
+// 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;
+  }
+}
+
+// src/hooks/magic-context/read-session-db.ts
+function openCodeDbExists() {
+  return harnessOwnsOpenCodeStore() && 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() {
+  if (!harnessOwnsOpenCodeStore()) {
+    throw new Error("OpenCode session database is not readable from a Pi-compatible process; its history lives in Pi sessions");
+  }
+  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 });
+  try {
+    assertOpenCodeStoreGeneration(db, "v1", dbPath);
+  } catch (error) {
+    closeQuietly(db);
+    throw error;
+  }
+  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) {
+  let assistant;
+  let user;
+  for (const message of session.messages.values()) {
+    if (message.role === "assistant" && (!assistant || message.timeCreated >= assistant.timeCreated))
+      assistant = message;
+    if (message.role === "user" && (!user || message.timeCreated >= user.timeCreated) && (message.parts.size === 0 || ![...message.parts.values()].every(isMachineGeneratedPart)))
+      user = message;
+  }
+  return [user, assistant].filter((message) => !!message).map((message) => ({
+    info: {
+      id: message.id,
+      role: message.role,
+      time: { created: message.timeCreated },
+      ...message.finish === undefined ? {} : { finish: message.finish }
+    },
+    parts: [...message.parts.values()]
+  }));
+}
+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();
+  if (!harnessOwnsOpenCodeStore())
+    return { resolution, available: false };
+  const available = openCodeDbPathExists(resolution);
+  if (available)
+    clearOpenCodeDbReadFailure(resolution.path);
+  else
+    logProbeFailureOnce(resolution, "opencode_db_missing");
+  return { resolution, available };
+}
+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.MMC_NOTICE_GATE === "bypass")
+    return false;
+  if (process.env.MMC_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 latestRealUserTurnIdFromOpenCodeDb(sessionId) {
+  try {
+    return withReadOnlySessionDb((db) => {
+      const row = db.prepare(`SELECT m.id FROM message m
+                WHERE m.session_id = ? AND json_extract(m.data, '$.role') = 'user'
+                  AND COALESCE(json_type(m.data, '$.synthetic'), 'null') != 'true'
+                  AND m.id NOT LIKE 'synth-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_type(p.data, '$.synthetic'), 'null') != 'true'
+                      AND COALESCE(json_type(p.data, '$.ignored'), 'null') != 'true'
+                      AND COALESCE(json_extract(p.data, '$.type'), '') NOT IN
+                          ('tool_result', 'toolResult', 'tool-result')))
+                ORDER BY m.time_created DESC, m.id DESC LIMIT 1`).get(sessionId);
+      return typeof row?.id === "string" ? row.id : undefined;
+    }) ?? undefined;
+  } catch {
+    return;
+  }
+}
+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 || !harnessOwnsOpenCodeStore())
+    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) {
+  if (!harnessOwnsOpenCodeStore())
+    return null;
+  const resolution = resolveOpenCodeDbPath();
+  try {
+    if (!openCodeDbPathExists(resolution)) {
+      throw new Error(`OpenCode session database is unavailable at ${resolution.path}`);
+    }
+    const db = new Database(resolution.path, { readonly: true });
+    try {
+      const queryV2 = () => db.prepare(`SELECT json_extract(data, '$.model.providerID') as providerID,
+                                json_extract(data, '$.model.id') as modelID,
+                                json_extract(data, '$.agent') as agent
+                         FROM session_message
+                         WHERE session_id = ?
+                           AND type = 'assistant'
+                           AND json_extract(data, '$.model.providerID') IS NOT NULL
+                           AND json_extract(data, '$.model.id') IS NOT NULL
+                         ORDER BY seq DESC
+                         LIMIT 1`).get(sessionId);
+      const queryV1 = () => 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);
+      let row = null;
+      try {
+        assertOpenCodeStoreGeneration(db, "v2", resolution.path);
+        row = queryV2();
+      } catch {}
+      if (!row) {
+        try {
+          assertOpenCodeStoreGeneration(db, "v1", resolution.path);
+          row = queryV1();
+        } catch {}
+      }
+      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 } : {}
+      };
+    } finally {
+      closeQuietly(db);
+    }
+  } catch (error) {
+    logProbeFailureOnce(resolution, error);
+    return null;
+  }
+}
+
+export { closeQuietly, isKnownAutocommit, resolveOpenCodeDbPath, hasV1MessageTables, assertOpenCodeStoreGeneration, openCodeDbPathExists, claimOpenCodeDbDiagnosticOnce, isStrictGapHealingMessage, readRawSessionMessagesFromDb, readRawSessionMessagePageFromDb, readRawSessionMessageSummaryPageFromDb, countRawSessionMessageOrdinalsFromDb, readRawSessionMessageIdOrdinalsForRangeFromDb, readRawSessionTailFromDb, extractInMemoryMessageViews, buildInMemoryTailRawMessages, warmRawSessionOrdinalsForDb, readRawSessionMessageOrdinalByIdFromDb, readRawSessionMessageByIdFromDb, hasRawSessionMessageByIdFromDb, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, shouldHoldIgnoredNotification, latestRealUserTurnIdFromOpenCodeDb, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };