@cortexkit/opencode-magic-context 0.41.3 → 0.42.0

package/dist/{index-0bycg0np.js → index-jmtjh2d3.js}

@@ -3,10 +3,10 @@ import {
 } from "./index-dkv2dn46.js";
 import {
   withReadOnlySessionDb
-} from "./index-raatkvw5.js";
+} from "./index-1974jvn3.js";
 import {
   piModelRefToCanonical
-} from "./index-kby1sng5.js";
+} from "./index-avwt563y.js";
 import {
   getHarness
 } from "./index-3fe78beq.js";
@@ -16,9 +16,9 @@ import { Buffer as Buffer2 } from "node:buffer";
 
 // src/shared/write-transaction-timing.ts
 var SLOW_WRITE_TRANSACTION_THRESHOLD_MS = 1000;
-function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS) {
+function logSlowWriteTransaction(site, startedAt, thresholdMs = SLOW_WRITE_TRANSACTION_THRESHOLD_MS, completedAtMs = performance.now()) {
   try {
-    const durationMs = performance.now() - startedAt;
+    const durationMs = completedAtMs - startedAt;
     if (durationMs < thresholdMs)
       return;
     log(`[magic-context] slow write transaction: site=${site} held=${durationMs.toFixed(1)}ms`);

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

@@ -3,7 +3,7 @@ import {
 } from "./index-dkv2dn46.js";
 import {
   shouldHoldIgnoredNotification
-} from "./index-raatkvw5.js";
+} from "./index-1974jvn3.js";
 
 // src/shared/error-message.ts
 function getErrorMessage(error) {
@@ -85,7 +85,11 @@ function safeString(value) {
 var MAX_QUEUED_IGNORED_NOTIFICATIONS = 16;
 var queuedIgnoredNotifications = new Map;
 var flushingIgnoredNotifications = new Set;
-var midTurnDetector = (sessionId) => shouldHoldIgnoredNotification(sessionId);
+var idleSessions = new Set;
+var lastDeliveredText = new Map;
+var activityEpoch = new Map;
+var defaultHoldDetector = (sessionId) => !idleSessions.has(sessionId) || shouldHoldIgnoredNotification(sessionId);
+var holdDetector = defaultHoldDetector;
 var notificationServerUrl;
 var noticeDeleter;
 var notificationDiagnosticObserverForTests;
@@ -95,6 +99,8 @@ function notificationDiagnostic(sessionId, message) {
 }
 function queueIgnoredNotification(notification) {
   const queued = queuedIgnoredNotifications.get(notification.sessionId) ?? [];
+  if (queued.at(-1)?.text === notification.text)
+    return;
   queued.push(notification);
   if (queued.length > MAX_QUEUED_IGNORED_NOTIFICATIONS) {
     queued.splice(0, queued.length - MAX_QUEUED_IGNORED_NOTIFICATIONS);
@@ -172,7 +178,8 @@ function extractToastTitle(text) {
   return "Magic Context";
 }
 async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersist) {
-  if (midTurnDetector(sessionId)) {
+  const epoch = activityEpoch.get(sessionId) ?? 0;
+  if (holdDetector(sessionId)) {
     holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
     return "queued";
   }
@@ -181,7 +188,9 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
     sessionLog(sessionId, "notification skipped (session not titled yet)");
     return "skipped";
   }
-  if (midTurnDetector(sessionId)) {
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
     holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "during target checks");
     return "queued";
   }
@@ -204,7 +213,9 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
       }
     } catch {}
   }
-  if (midTurnDetector(sessionId)) {
+  if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+    return "skipped";
+  if (holdDetector(sessionId)) {
     holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before append");
     return "queued";
   }
@@ -241,10 +252,12 @@ async function sendIgnoredMessageNow(client, sessionId, text, params, forcePersi
       text,
       params,
       forcePersist,
-      messageId
+      messageId,
+      epoch
     })) {
-      return "queued";
+      return "skipped";
     }
+    lastDeliveredText.set(sessionId, text);
     notifyDelivered(sessionId, params);
     return "sent";
   } catch (error) {
@@ -294,25 +307,20 @@ async function deleteNoticeMessage(sessionId, messageId) {
   }
 }
 async function revertNoticeIfUnsafe(notification) {
-  if (!midTurnDetector(notification.sessionId))
+  const superseded = (activityEpoch.get(notification.sessionId) ?? 0) !== notification.epoch;
+  if (!superseded && !holdDetector(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`);
+      notificationDiagnostic(notification.sessionId, `notice rolled back (deleted row ${notification.messageId}); consumed after append`);
     } 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
-  });
+  lastDeliveredText.set(notification.sessionId, notification.text);
   return true;
 }
 async function sendIgnoredMessage2(client, sessionId, text, params, forcePersist = false) {
@@ -320,22 +328,29 @@ async function sendIgnoredMessage2(client, sessionId, text, params, forcePersist
     notifyDelivered(sessionId, params);
     return "sent";
   }
-  if (midTurnDetector(sessionId)) {
+  if (holdDetector(sessionId)) {
     holdIgnoredNotification({ client, sessionId, text, params, forcePersist }, "before target checks");
     return "queued";
   }
+  if (lastDeliveredText.get(sessionId) === text)
+    return "sent";
   return sendIgnoredMessageNow(client, sessionId, text, params, forcePersist);
 }
 async function flushIgnoredMessages2(sessionId) {
-  if (flushingIgnoredNotifications.has(sessionId) || midTurnDetector(sessionId))
+  if (flushingIgnoredNotifications.has(sessionId))
     return;
   const queued = queuedIgnoredNotifications.get(sessionId);
   if (!queued || queued.length === 0)
     return;
+  if (holdDetector(sessionId))
+    return;
+  const epoch = activityEpoch.get(sessionId) ?? 0;
   queuedIgnoredNotifications.delete(sessionId);
   flushingIgnoredNotifications.add(sessionId);
   try {
     for (const notification of queued) {
+      if ((activityEpoch.get(sessionId) ?? 0) !== epoch)
+        break;
       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)) {
@@ -351,31 +366,48 @@ async function flushIgnoredMessages2(sessionId) {
 function clearIgnoredMessages2(sessionId) {
   queuedIgnoredNotifications.delete(sessionId);
   flushingIgnoredNotifications.delete(sessionId);
+  idleSessions.delete(sessionId);
+  lastDeliveredText.delete(sessionId);
+  activityEpoch.delete(sessionId);
 }
-async function sendUserPrompt2(client, sessionId, text) {
-  if (!hasNotificationSessionClient(client)) {
-    sessionLog(sessionId, "session prompt API unavailable for user prompt");
+function observeIgnoredNotificationEvent2(event) {
+  const record = (value) => value !== null && typeof value === "object" ? value : undefined;
+  const props = record(event.properties);
+  const info = record(props?.info);
+  const part = record(props?.part);
+  const sessionId = props?.sessionID ?? info?.sessionID ?? part?.sessionID;
+  if (typeof sessionId !== "string")
+    return;
+  if (event.type === "session.idle") {
+    idleSessions.add(sessionId);
     return;
   }
-  const c = client;
-  const input = {
-    path: { id: sessionId },
-    body: {
-      parts: [{ type: "text", text }]
-    }
-  };
+  if (event.type === "session.deleted") {
+    clearIgnoredMessages2(sessionId);
+    return;
+  }
+  const active = event.type === "session.status" && record(props?.status)?.type !== "idle" || event.type === "message.updated" && info?.role === "assistant" || event.type === "message.part.updated" && part?.ignored !== true && part?.type !== "compaction";
+  if (!active)
+    return;
+  idleSessions.delete(sessionId);
+  activityEpoch.set(sessionId, (activityEpoch.get(sessionId) ?? 0) + 1);
+  queuedIgnoredNotifications.delete(sessionId);
+}
+async function sendStatusNotification2(_client, sessionId, text, params) {
   try {
-    if (typeof c.session?.promptAsync === "function") {
-      await c.session.promptAsync(input);
-    } else if (typeof c.session?.prompt === "function") {
-      await Promise.resolve(c.session.prompt(input));
-    } else {
-      sessionLog(sessionId, "session prompt API unavailable for user prompt");
-    }
+    const { pushNotification } = await import("./rpc-notifications-4amf6mf4.js");
+    pushNotification("toast", {
+      title: extractToastTitle(text),
+      message: text,
+      variant: inferToastVariant(text),
+      duration: params.toastDurationMs ?? 5000
+    }, sessionId);
+    notifyDelivered(sessionId, params);
+    return "sent";
   } catch (error) {
-    const msg = getErrorMessage(error);
-    sessionLog(sessionId, "failed to send user prompt:", msg);
+    sessionLog(sessionId, "status RPC enqueue failed:", getErrorMessage(error));
+    return "failed";
   }
 }
 
-export { getErrorMessage, describeError, setNotificationServerUrl2, sendIgnoredMessage2, flushIgnoredMessages2, clearIgnoredMessages2, sendUserPrompt2 };
+export { getErrorMessage, describeError, setNotificationServerUrl2, sendIgnoredMessage2, flushIgnoredMessages2, clearIgnoredMessages2, observeIgnoredNotificationEvent2, sendStatusNotification2 };