@cortexkit/opencode-magic-context 0.41.2 → 0.41.3

package/dist/{index-eq9wr75c.js → index-npx8vhmy.js}

@@ -1,15 +1,12 @@
-import {
-  readJsoncFile
-} from "./index-8mtsfhyg.js";
-import {
-  waitForSafeNotificationTarget
-} from "./index-vnz6jvdc.js";
 import {
   log
-} from "./index-4x691bz5.js";
+} from "./index-dkv2dn46.js";
 import {
-  __require
-} from "./index-1yh8g550.js";
+  sendIgnoredMessage2
+} from "./index-q264erdp.js";
+import {
+  readJsoncFile
+} from "./index-jfpk81yt.js";
 
 // src/plugin/conflict-warning-hook.ts
 import { existsSync, readFileSync } from "node:fs";
@@ -97,11 +94,20 @@ function detectConflicts(directory, options) {
   };
 }
 async function resolveCompactionForBoot(client, timeoutMs = 2000) {
+  const controller = new AbortController;
+  let timer;
   try {
-    const result = await Promise.race([
-      client.config.get(),
-      new Promise((_, reject) => setTimeout(() => reject(new Error("config.get() timed out")), timeoutMs))
-    ]);
+    const timeout = new Promise((resolve) => {
+      timer = setTimeout(() => {
+        controller.abort(new Error("config.get() timed out"));
+        resolve(null);
+      }, Math.max(0, timeoutMs));
+      timer.unref?.();
+    });
+    const request = Promise.resolve().then(() => client.config.get({ signal: controller.signal }));
+    const result = await Promise.race([request, timeout]);
+    if (result === null)
+      return null;
     const compaction = result?.data?.compaction;
     if (typeof compaction?.auto !== "boolean" || typeof compaction?.prune !== "boolean") {
       log(`[magic-context] conflict-detector: resolved config carried no explicit compaction block (${JSON.stringify(compaction) ?? "absent"}); falling back to file-based detection`);
@@ -110,6 +116,9 @@ async function resolveCompactionForBoot(client, timeoutMs = 2000) {
     return { auto: compaction.auto, prune: compaction.prune };
   } catch {
     return null;
+  } finally {
+    if (timer)
+      clearTimeout(timer);
   }
 }
 function checkCompaction(directory) {
@@ -392,43 +401,21 @@ async function getSessionMessages(client, sessionId) {
   }
   return [];
 }
-async function sendConflictWarning(client, directory, conflictResult) {
+async function sendConflictWarning2(client, directory, conflictResult) {
   const { sessionId } = getDesktopState(directory);
   if (!sessionId) {
     log("[magic-context] conflict-warning: could not find active session for Desktop warning");
     return;
   }
-  if (await waitForSafeNotificationTarget(client, sessionId) === "skip")
-    return;
   const warningText = formatConflictShort(conflictResult);
   log(`[magic-context] sending conflict warning to session ${sessionId}: ${conflictResult.reasons.join(", ")}`);
   try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [
-          {
-            type: "text",
-            text: warningText,
-            ignored: true
-          }
-        ]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    } else {
-      log("[magic-context] conflict-warning: session prompt API unavailable");
-    }
+    await sendIgnoredMessage2(client, sessionId, warningText, {});
   } catch (error) {
     log(`[magic-context] conflict-warning: failed to send: ${error instanceof Error ? error.message : String(error)}`);
   }
 }
-async function cleanupConflictWarnings(client, directory, serverUrl) {
+async function cleanupConflictWarnings2(client, directory, serverUrl) {
   const { sessionId } = getDesktopState(directory);
   if (!sessionId) {
     log("[magic-context] cleanup: no active Desktop session found");
@@ -467,43 +454,33 @@ async function cleanupConflictWarnings(client, directory, serverUrl) {
       log(`[magic-context] deleted conflict warning message ${messageId}`);
     }
   }
-  if (await waitForSafeNotificationTarget(client, sessionId) === "skip")
-    return;
   const enabledText = `${ENABLED_MARKER}. Enjoy! ✨`;
+  const scheduleEnabledCleanup = () => {
+    setTimeout(async () => {
+      try {
+        const freshMessages = await getSessionMessages(client, sessionId);
+        for (let i = freshMessages.length - 1;i >= 0; i--) {
+          const msg = freshMessages[i];
+          const msgId = msg.info?.id;
+          const msgRole = msg.info?.role;
+          if (!msgId || msgRole !== "user")
+            break;
+          const parts = msg.parts ?? [];
+          const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
+          if (isEnabled) {
+            await deleteMessage(serverUrl, sessionId, msgId);
+          } else {
+            break;
+          }
+        }
+      } catch {}
+    }, 1000);
+  };
   try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text: enabledText, ignored: true }]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    }
+    await sendIgnoredMessage2(client, sessionId, enabledText, {
+      onDelivered: scheduleEnabledCleanup
+    });
   } catch {}
-  setTimeout(async () => {
-    try {
-      const freshMessages = await getSessionMessages(client, sessionId);
-      for (let i = freshMessages.length - 1;i >= 0; i--) {
-        const msg = freshMessages[i];
-        const msgId = msg.info?.id;
-        const msgRole = msg.info?.role;
-        if (!msgId || msgRole !== "user")
-          break;
-        const parts = msg.parts ?? [];
-        const isEnabled = parts.length > 0 && parts.every((p) => p.ignored === true && p.type === "text" && typeof p.text === "string" && p.text.startsWith(ENABLED_MARKER));
-        if (isEnabled) {
-          await deleteMessage(serverUrl, sessionId, msgId);
-        } else {
-          break;
-        }
-      }
-    } catch {}
-  }, 1000);
 }
 async function cleanupEnabledMessages(messages, serverUrl, sessionId) {
   if (!serverUrl)
@@ -523,12 +500,10 @@ async function cleanupEnabledMessages(messages, serverUrl, sessionId) {
     }
   }
 }
-async function sendSchemaFenceWarning(client, directory, detail) {
+async function sendSchemaFenceWarning2(client, directory, detail) {
   const { sessionId } = getDesktopState(directory);
   if (!sessionId)
     return;
-  if (await waitForSafeNotificationTarget(client, sessionId) === "skip")
-    return;
   const text = [
     `${SCHEMA_FENCE_MARKER}`,
     "",
@@ -546,32 +521,21 @@ async function sendSchemaFenceWarning(client, directory, detail) {
   ].join(`
 `);
   try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: { noReply: true, parts: [{ type: "text", text, ignored: true }] }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    }
+    await sendIgnoredMessage2(client, sessionId, text, {});
   } catch {
     return;
   }
 }
-async function sendStartupAnnouncement(client, directory, version, features, footer, markSeen) {
+async function sendStartupAnnouncement2(client, directory, version, features, footer, markSeen) {
   if (!version || features.length === 0)
     return;
   const { sessionId } = getDesktopState(directory);
   if (!sessionId) {
     return;
   }
-  const { isTuiConnected } = await import("./rpc-notifications-1ffm755w.js");
+  const { isTuiConnected } = await import("./rpc-notifications-4amf6mf4.js");
   if (isTuiConnected(sessionId) || isTuiConnected())
     return;
-  if (await waitForSafeNotificationTarget(client, sessionId) === "skip")
-    return;
   const bullets = features.map((line) => `  • ${line}`).join(`
 `);
   const sections = [`${ANNOUNCEMENT_MARKER} v${version}:`, "", bullets];
@@ -582,27 +546,12 @@ async function sendStartupAnnouncement(client, directory, version, features, foo
 `);
   log(`[magic-context] sending startup announcement for v${version} to session ${sessionId}`);
   try {
-    const c = client;
-    const promptInput = {
-      path: { id: sessionId },
-      body: {
-        noReply: true,
-        parts: [{ type: "text", text, ignored: true }]
-      }
-    };
-    if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(promptInput));
-    } else if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(promptInput);
-    } else {
-      log("[magic-context] announcement: session prompt API unavailable");
-      return;
-    }
+    await sendIgnoredMessage2(client, sessionId, text, {
+      onDelivered: () => markSeen(version)
+    });
   } catch (error) {
     log(`[magic-context] announcement: failed to send: ${error instanceof Error ? error.message : String(error)}`);
-    return;
   }
-  markSeen(version);
 }
 
-export { detectConflicts, resolveCompactionForBoot, sendConflictWarning, cleanupConflictWarnings, sendSchemaFenceWarning, sendStartupAnnouncement };
+export { detectConflicts, resolveCompactionForBoot, sendConflictWarning2, cleanupConflictWarnings2, sendSchemaFenceWarning2, sendStartupAnnouncement2 };

package/dist/{index-zwjhba2r.js → index-q264erdp.js}

@@ -1,12 +1,9 @@
-import {
-  isMidTurn
-} from "./index-b9j85d29.js";
 import {
   sessionLog
-} from "./index-4x691bz5.js";
+} from "./index-dkv2dn46.js";
 import {
-  __require
-} from "./index-1yh8g550.js";
+  shouldHoldIgnoredNotification
+} from "./index-raatkvw5.js";
 
 // src/shared/error-message.ts
 function getErrorMessage(error) {
@@ -88,7 +85,14 @@ function safeString(value) {
 var MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
 var queuedIgnoredNotifications = new Map;
 var flushingIgnoredNotifications = new Set;
-var midTurnDetector = (sessionId) => isMidTurn(undefined, sessionId);
+var midTurnDetector = (sessionId) => shouldHoldIgnoredNotification(sessionId);
+var notificationServerUrl;
+var noticeDeleter;
+var notificationDiagnosticObserverForTests;
+function notificationDiagnostic(sessionId, message) {
+  notificationDiagnosticObserverForTests?.(message);
+  sessionLog(sessionId, message);
+}
 function queueIgnoredNotification(notification) {
   const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
   queued.push(notification);
@@ -98,6 +102,10 @@ function queueIgnoredNotification(notification) {
   }
   queuedIgnoredNotifications.set(notification.sessionId, queued);
 }
+function holdIgnoredNotification(notification, checkpoint) {
+  queueIgnoredNotification(notification);
+  notificationDiagnostic(notification.sessionId, `ignored notification held ${checkpoint} (session active); queued`);
+}
 async function trySendTuiToast(sessionId, text, params, forcePersist) {
   if (forcePersist)
     return false;
@@ -105,11 +113,11 @@ async function trySendTuiToast(sessionId, text, params, forcePersist) {
   const message = text.length > 200 ? `${text.slice(0, 200)}…` : text;
   const toastVariant = inferToastVariant(text);
   const duration = params.toastDurationMs ?? 5000;
-  const { isTuiConnected: checkTui } = await import("./rpc-notifications-1ffm755w.js");
+  const { isTuiConnected: checkTui } = await import("./rpc-notifications-4amf6mf4.js");
   if (!checkTui(sessionId))
     return false;
   try {
-    const { pushNotification } = await import("./rpc-notifications-1ffm755w.js");
+    const { pushNotification } = await import("./rpc-notifications-4amf6mf4.js");
     pushNotification("toast", {
       title,
       message,
@@ -122,19 +130,16 @@ async function trySendTuiToast(sessionId, text, params, forcePersist) {
     return false;
   }
 }
-var __ignoredNotificationTest = {
-  pendingTexts(sessionId) {
-    return (queuedIgnoredNotifications.get(sessionId) ?? []).map((item) => item.text);
-  },
-  reset() {
-    queuedIgnoredNotifications.clear();
-    flushingIgnoredNotifications.clear();
-    midTurnDetector = (sessionId) => isMidTurn(undefined, sessionId);
-  },
-  setMidTurnDetector(detector) {
-    midTurnDetector = detector;
+function setNotificationServerUrl2(url) {
+  notificationServerUrl = typeof url === "string" && url.length > 0 ? url.replace(/\/$/, "") : undefined;
+}
+function notifyDelivered(sessionId, params) {
+  try {
+    params.onDelivered?.();
+  } catch (error) {
+    sessionLog(sessionId, "notification delivery callback failed:", getErrorMessage(error));
   }
-};
+}
 function hasNotificationSessionClient(client) {
   if (client === null || typeof client !== "object")
     return false;
@@ -168,16 +173,16 @@ function extractToastTitle(text) {
 }
 async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
   if (midTurnDetector(sessionId)) {
-    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
     return "queued";
   }
-  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-2a8py95v.js");
+  const { waitForSafeNotificationTarget } = await import("./safe-notification-target-q9z81zt3.js");
   if (await waitForSafeNotificationTarget(client, sessionId) === "skip") {
     sessionLog(sessionId, "notification skipped (session not titled yet)");
     return "skipped";
   }
   if (midTurnDetector(sessionId)) {
-    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
     return "queued";
   }
   if (!hasNotificationSessionClient(client)) {
@@ -190,7 +195,7 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
   let model = params.providerId && params.modelId ? { providerID: params.providerId, modelID: params.modelId } : undefined;
   if (!agent || !model || !variant) {
     try {
-      const { resolvePromptContext } = await import("./prompt-context-29qkb28f.js");
+      const { resolvePromptContext } = await import("./prompt-context-5y5ms8f9.js");
       const resolved = await resolvePromptContext(client, sessionId);
       if (resolved) {
         agent = agent ?? resolved.agent;
@@ -200,7 +205,7 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
     } catch {}
   }
   if (midTurnDetector(sessionId)) {
-    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before append");
     return "queued";
   }
   const input = {
@@ -220,32 +225,108 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
     }
   };
   try {
+    let result;
     if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(input));
-      return "sent";
+      result = await Promise.resolve(c.session.prompt(input));
+    } else if (typeof c.session?.promptAsync === "function") {
+      result = await c.session.promptAsync(input);
+    } else {
+      sessionLog(sessionId, "session prompt API unavailable for notification");
+      return "failed";
     }
-    if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(input);
-      return "sent";
+    const messageId = extractPromptedMessageId(result);
+    if (await revertNoticeIfUnsafe({
+      client,
+      sessionId,
+      text,
+      params,
+      forcePersist,
+      messageId
+    })) {
+      return "queued";
     }
-    sessionLog(sessionId, "session prompt API unavailable for notification");
-    return "failed";
+    notifyDelivered(sessionId, params);
+    return "sent";
   } catch (error) {
     const msg = getErrorMessage(error);
     sessionLog(sessionId, "failed to send notification:", msg);
     return "failed";
   }
 }
-async function sendIgnoredMessage(client, sessionId, text, params, forcePersist = false) {
-  if (await trySendTuiToast(sessionId, text, params, forcePersist))
+function extractPromptedMessageId(result) {
+  if (result === null || typeof result !== "object")
+    return;
+  const root = result;
+  const data = root.data !== null && typeof root.data === "object" ? root.data : root;
+  const info = data.info !== null && typeof data.info === "object" ? data.info : data;
+  return typeof info.id === "string" && info.id.length > 0 ? info.id : undefined;
+}
+function getServerAuth() {
+  const password = process.env.OPENCODE_SERVER_PASSWORD;
+  if (!password)
+    return;
+  const username = process.env.OPENCODE_SERVER_USERNAME ?? "opencode";
+  return `Basic ${Buffer.from(`${username}:${password}`, "utf8").toString("base64")}`;
+}
+async function deleteNoticeMessage(sessionId, messageId) {
+  if (noticeDeleter)
+    return noticeDeleter(sessionId, messageId);
+  if (!notificationServerUrl) {
+    sessionLog(sessionId, "cannot roll back notice: no server URL for session.message.delete");
+    return false;
+  }
+  const url = `${notificationServerUrl}/session/${encodeURIComponent(sessionId)}/message/${encodeURIComponent(messageId)}`;
+  try {
+    const auth = getServerAuth();
+    const response = await fetch(url, {
+      method: "DELETE",
+      headers: auth ? { Authorization: auth } : {},
+      signal: AbortSignal.timeout(1e4)
+    });
+    if (!response.ok) {
+      sessionLog(sessionId, `notice rollback DELETE failed status=${response.status} url=${url}`);
+      return false;
+    }
+    return true;
+  } catch (error) {
+    sessionLog(sessionId, "notice rollback DELETE error:", getErrorMessage(error));
+    return false;
+  }
+}
+async function revertNoticeIfUnsafe(notification) {
+  if (!midTurnDetector(notification.sessionId))
+    return false;
+  if (notification.messageId) {
+    const deleted = await deleteNoticeMessage(notification.sessionId, notification.messageId);
+    if (deleted) {
+      notificationDiagnostic(notification.sessionId, `notice rolled back (deleted row ${notification.messageId}); queued for idle delivery`);
+    } else {
+      sessionLog(notification.sessionId, "failed to roll back a notice that landed while a run was active");
+    }
+  } else {
+    sessionLog(notification.sessionId, "notice landed while a run was active but the new row id was not returned");
+  }
+  queueIgnoredNotification({
+    client: notification.client,
+    sessionId: notification.sessionId,
+    text: notification.text,
+    params: notification.params,
+    forcePersist: notification.forcePersist
+  });
+  return true;
+}
+async function sendIgnoredMessage2(client, sessionId, text, params, forcePersist = false) {
+  if (await trySendTuiToast(sessionId, text, params, forcePersist)) {
+    notifyDelivered(sessionId, params);
     return "sent";
+  }
   if (midTurnDetector(sessionId)) {
-    queueIgnoredNotification({ client, sessionId, text, params, forcePersist });
+    holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before target checks");
     return "queued";
   }
   return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
 }
-async function flushIgnoredMessages(sessionId) {
+async function flushIgnoredMessages2(sessionId) {
   if (flushingIgnoredNotifications.has(sessionId) || midTurnDetector(sessionId))
     return;
   const queued = queuedIgnoredNotifications.get(sessionId);
@@ -255,7 +336,7 @@ async function flushIgnoredMessages(sessionId) {
   flushingIgnoredNotifications.add(sessionId);
   try {
     for (const notification of queued) {
-      const disposition = await sendIgnoredMessage(notification.client, notification.sessionId, notification.text, notification.params, notification.forcePersist);
+      const disposition = await sendIgnoredMessage2(notification.client, notification.sessionId, notification.text, notification.params, notification.forcePersist);
       if (disposition === "queued") {
         for (const remaining of queued.slice(queued.indexOf(notification) + 1)) {
           queueIgnoredNotification(remaining);
@@ -267,11 +348,11 @@ async function flushIgnoredMessages(sessionId) {
     flushingIgnoredNotifications.delete(sessionId);
   }
 }
-function clearIgnoredMessages(sessionId) {
+function clearIgnoredMessages2(sessionId) {
   queuedIgnoredNotifications.delete(sessionId);
   flushingIgnoredNotifications.delete(sessionId);
 }
-async function sendUserPrompt(client, sessionId, text) {
+async function sendUserPrompt2(client, sessionId, text) {
   if (!hasNotificationSessionClient(client)) {
     sessionLog(sessionId, "session prompt API unavailable for user prompt");
     return;
@@ -297,4 +378,4 @@ async function sendUserPrompt(client, sessionId, text) {
   }
 }
 
-export { getErrorMessage, describeError, MAX_QUEUED_IGNORED_NOTIFICATIONS, __ignoredNotificationTest, sendIgnoredMessage, flushIgnoredMessages, clearIgnoredMessages, sendUserPrompt };
+export { getErrorMessage, describeError, setNotificationServerUrl2, sendIgnoredMessage2, flushIgnoredMessages2, clearIgnoredMessages2, sendUserPrompt2 };

package/dist/{index-b9j85d29.js → index-raatkvw5.js}

@@ -1,9 +1,9 @@
 import {
   log
-} from "./index-4x691bz5.js";
+} from "./index-dkv2dn46.js";
 import {
   getDataDir
-} from "./index-37yzyeca.js";
+} from "./index-3fe78beq.js";
 
 // src/shared/sqlite-helpers.ts
 function closeQuietly(db) {
@@ -223,15 +223,29 @@ function isMidTurn(_deps, sessionId) {
     return false;
   }
 }
+function shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId) {
+  if (isMidTurnFromOpenCodeDb(db, sessionId))
+    return true;
+  if (hasUnfinishedAssistant(db, sessionId))
+    return true;
+  if (hasUnansweredRealUser(db, sessionId))
+    return true;
+  return false;
+}
+function shouldHoldIgnoredNotification(sessionId) {
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "bypass")
+    return false;
+  if (process.env.MAGIC_CONTEXT_NOTICE_GATE === "hold")
+    return true;
+  try {
+    return withReadOnlySessionDb((db) => shouldHoldIgnoredNotificationFromOpenCodeDb(db, sessionId));
+  } catch (error) {
+    log("[magic-context] failed to inspect notice-hold state:", error);
+    return false;
+  }
+}
 function isMidTurnFromOpenCodeDb(db, sessionId) {
-  const latestAssistant = 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);
+  const latestAssistant = latestAssistantRow(db, sessionId);
   if (typeof latestAssistant?.id !== "string")
     return false;
   if (hasNewerRealUserMessage(db, sessionId, latestAssistant.timeCreated))
@@ -271,6 +285,30 @@ function hasNewerRealUserMessage(db, sessionId, latestAssistantTimeCreated) {
              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)
@@ -319,4 +357,4 @@ function findLastAssistantModelFromOpenCodeDb(sessionId) {
   }
 }
 
-export { Database, withPrivilegedWriter, closeQuietly, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, isMidTurn, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };
+export { detectSqliteRuntime, Database, withPrivilegedWriter, closeQuietly, openCodeDbExists, withReadOnlySessionDb, getRawSessionMessageCountFromDb, isMidTurn, shouldHoldIgnoredNotification, getMessageTimesFromOpenCodeDb, findLastAssistantModelFromOpenCodeDb };

package/dist/{index-9xexf8s7.js → index-rn7gafjr.js}

@@ -1,16 +1,8 @@
 // ../../node_modules/.bun/@jitl+quickjs-ffi-types@0.32.0/node_modules/@jitl/quickjs-ffi-types/dist/index.mjs
-function assertSync(fn) {
-  return function(...args) {
-    let result = fn(...args);
-    if (result && typeof result == "object" && result instanceof Promise)
-      throw new Error("Function unexpectedly returned a Promise");
-    return result;
-  };
-}
 var EvalFlags = { JS_EVAL_TYPE_GLOBAL: 0, JS_EVAL_TYPE_MODULE: 1, JS_EVAL_TYPE_DIRECT: 2, JS_EVAL_TYPE_INDIRECT: 3, JS_EVAL_TYPE_MASK: 3, JS_EVAL_FLAG_STRICT: 8, JS_EVAL_FLAG_STRIP: 16, JS_EVAL_FLAG_COMPILE_ONLY: 32, JS_EVAL_FLAG_BACKTRACE_BARRIER: 64 };
 var IntrinsicsFlags = { BaseObjects: 1, Date: 2, Eval: 4, StringNormalize: 8, RegExp: 16, RegExpCompiler: 32, JSON: 64, Proxy: 128, MapSet: 256, TypedArrays: 512, Promise: 1024, BigInt: 2048, BigFloat: 4096, BigDecimal: 8192, OperatorOverloading: 16384, BignumExt: 32768 };
 var JSPromiseStateEnum = { Pending: 0, Fulfilled: 1, Rejected: 2 };
 var GetOwnPropertyNamesFlags = { JS_GPN_STRING_MASK: 1, JS_GPN_SYMBOL_MASK: 2, JS_GPN_PRIVATE_MASK: 4, JS_GPN_ENUM_ONLY: 16, JS_GPN_SET_ENUM: 32, QTS_GPN_NUMBER_MASK: 64, QTS_STANDARD_COMPLIANT_NUMBER: 128 };
 var IsEqualOp = { IsStrictlyEqual: 0, IsSameValue: 1, IsSameValueZero: 2 };
 
-export { assertSync, EvalFlags, IntrinsicsFlags, JSPromiseStateEnum, GetOwnPropertyNamesFlags, IsEqualOp };
+export { EvalFlags, IntrinsicsFlags, JSPromiseStateEnum, GetOwnPropertyNamesFlags, IsEqualOp };

package/dist/index-v6t0tg85.js

@@ -0,0 +1,13 @@
+// ../../node_modules/.bun/quickjs-emscripten-core@0.32.0/node_modules/quickjs-emscripten-core/dist/index.mjs
+async function newQuickJSAsyncWASMModuleFromVariant(variantOrPromise) {
+  let variant = smartUnwrap(await variantOrPromise), [wasmModuleLoader, QuickJSAsyncFFI, { QuickJSAsyncWASMModule: QuickJSAsyncWASMModule2 }] = await Promise.all([variant.importModuleLoader().then(smartUnwrap), variant.importFFI(), import("./module-asyncify-2EFITU5U-rkqjhjxd.js").then(smartUnwrap)]), wasmModule = await wasmModuleLoader();
+  wasmModule.type = "async";
+  let ffi = new QuickJSAsyncFFI(wasmModule);
+  return new QuickJSAsyncWASMModule2(wasmModule, ffi);
+}
+function smartUnwrap(val) {
+  return val && "default" in val && val.default ? val.default && "default" in val.default && val.default.default ? val.default.default : val.default : val;
+}
+export {
+  newQuickJSAsyncWASMModuleFromVariant
+};