mixdog 1.3.5 → 1.4.0

package/src/session-runtime/notification-bus.mjs

@@ -3,27 +3,17 @@
 // pending queue so the model sees it next turn. The delivered registry keeps
 // those two paths from double-injecting the same completion.
 import { modelVisibleToolCompletionMessage } from '../runtime/shared/tool-execution-contract.mjs';
-import {
-  PENDING_MODE_TASK_NOTIFICATION,
-  markCompletionEntry,
-} from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
-import {
-  isDeliveredCompletion,
-  logDuplicateSkip,
-  recordDeliveredCompletion,
-} from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+import { PENDING_MODE_TASK_NOTIFICATION } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import { recordDeliveredCompletion } from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
 import { shouldMirrorCompletionToPendingQueue } from './runtime-tool-routing.mjs';
 import { notifyTrace } from '../runtime/shared/notify-trace.mjs';
+import { cleanSessionId, createListenerBindings, sessionListenersOf } from './notification-listeners.mjs';
+import { createCompletionQueue } from './notification-completion-queue.mjs';
 
-const sessionNotificationListeners = new Map();
 // A completion that waits this long between enqueue and wake is reported: the
 // queue is durable, so the delay is a scheduling symptom, not a lost message.
 const WAKE_DELAY_REPORT_MS = 1_000;
 
-function cleanSessionId(value) {
-  return String(value || '').trim();
-}
-
 // A queued completion only reaches the model on the next turn, so a session
 // with no user input pending is woken with an empty turn. One wake per session
 // runs at a time, and a completion suppressed by that in-flight wake is
@@ -63,7 +53,9 @@ export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi,
         if (typeof beforeWake === 'function') {
           try {
             await beforeWake(ownerSessionId);
-          } catch {}
+          } catch {
+            // The pre-wake hook is best-effort; the wake proceeds without it.
+          }
           if (cleanSessionId(getCurrentSessionId()) !== ownerSessionId || !ownerOpen(ownerSessionId)) return;
         }
         // The wake continues the user turn that launched the worker, so its
@@ -102,10 +94,15 @@ export function createCompletionWakeScheduler({ getCurrentSessionId, getTurnApi,
   };
 }
 
-function emitToListeners(source, content, meta = {}) {
+function emitToListeners(source, content, meta = {}, origin = null) {
   const text = String(content || '').trim();
   if (!text) return { handled: false, modelVisibleDelivered: false };
-  const event = { content: text, meta: meta && typeof meta === 'object' ? meta : {} };
+  const event = {
+    content: text,
+    meta: meta && typeof meta === 'object' ? meta : {},
+    // The notification's provenance apart from its meta (PROMPT_ORIGIN_CHANNEL).
+    ...(origin ? { origin } : {}),
+  };
   let handled = false;
   for (const listener of [...source]) {
     try {
@@ -118,8 +115,9 @@ function emitToListeners(source, content, meta = {}) {
 }
 
 export function createNotificationBus({ listeners, mgr, onCompletionQueued, getOwnerLifecycle }) {
-  const boundSessionListeners = new Map();
-  const queuedCompletionIds = new Map();
+  const { subscribeRuntimeNotification, bindRuntimeNotificationSession, clearRuntimeNotifications } =
+    createListenerBindings({ listeners });
+  const enqueueCompletion = createCompletionQueue({ mgr, onCompletionQueued });
 
   // Owner identity + lifecycle generation. A closing/terminal owner (or a
   // callback captured under an earlier generation) keeps its result for
@@ -137,12 +135,14 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
     return emitToListeners(listeners, content, meta);
   }
 
-  function notifySession(sessionId, content, meta = {}) {
+  // `origin`: the notification's provenance (PROMPT_ORIGIN_CHANNEL for an
+  // inbound channel message), carried to the queue beside its mode.
+  function notifySession(sessionId, content, meta = {}, { origin = null } = {}) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     const open = ownerOpen(targetSessionId);
-    const { handled } = emitToListeners(targetListeners, content, open ? meta : closedMeta(meta));
+    const { handled } = emitToListeners(targetListeners, content, open ? meta : closedMeta(meta), origin);
     if (handled) return true;
     if (!open) return false;
     if (typeof mgr.enqueuePendingMessage !== 'function') return false;
@@ -151,7 +151,13 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
       // is the runtime reporting, exactly as an attached TUI queues it: a
       // task notification, so text inside it — fenced external webhook values
       // included — never drives explicit skill selection.
-      return mgr.enqueuePendingMessage(targetSessionId, { content, mode: PENDING_MODE_TASK_NOTIFICATION }) > 0;
+      return (
+        mgr.enqueuePendingMessage(targetSessionId, {
+          content,
+          mode: PENDING_MODE_TASK_NOTIFICATION,
+          ...(origin ? { origin } : {}),
+        }) > 0
+      );
     } catch {
       return false;
     }
@@ -164,50 +170,14 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
   function notifySessionUi(sessionId, content, meta = {}) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     return emitToListeners(targetListeners, content, meta).handled;
   }
 
-  // Enqueue the model-visible twin unless it was already delivered; returns
-  // true when the caller may treat the completion as delivered.
-  function enqueueCompletion(callerSessionId, text, meta, path) {
-    const visible = modelVisibleToolCompletionMessage(text, meta);
-    // Non-completion notifications yield '' here and are never queued.
-    if (!visible) return false;
-    if (isDeliveredCompletion({ executionId: meta?.execution_id, text: visible })) {
-      // Delivered + ACKed on the TUI path: suppress the duplicate but report
-      // DELIVERED so the caller stops retrying.
-      logDuplicateSkip(path, { executionId: meta?.execution_id, text: visible });
-      return true;
-    }
-    const entry = markCompletionEntry(visible, { executionId: meta?.execution_id, meta });
-    const queueKey = `${callerSessionId}:${entry.id}`;
-    if (queuedCompletionIds.has(queueKey)) {
-      logDuplicateSkip(`${path}-queued`, { executionId: meta?.execution_id, text: visible });
-      return true;
-    }
-    const enqueued = mgr.enqueuePendingMessage(callerSessionId, entry) > 0;
-    if (!enqueued) return false;
-    queuedCompletionIds.set(queueKey, Date.now());
-    while (queuedCompletionIds.size > 512) queuedCompletionIds.delete(queuedCompletionIds.keys().next().value);
-    if (typeof onCompletionQueued === 'function') {
-      try {
-        onCompletionQueued({
-          sessionId: callerSessionId,
-          executionId: meta?.execution_id || null,
-          enqueuedAt: entry.enqueuedAt,
-        });
-      } catch {
-        /* wake-up is best-effort; the durable queue remains authoritative */
-      }
-    }
-    return true;
-  }
-
   function notifySessionCompletion(sessionId, text, meta = {}, capturedGeneration = undefined) {
     const targetSessionId = cleanSessionId(sessionId);
     if (!targetSessionId) return false;
-    const targetListeners = sessionNotificationListeners.get(targetSessionId) || [];
+    const targetListeners = sessionListenersOf(targetSessionId);
     const open = ownerOpen(targetSessionId, capturedGeneration);
     const ownerMeta = {
       ...(meta && typeof meta === 'object' ? meta : {}),
@@ -262,62 +232,6 @@ export function createNotificationBus({ listeners, mgr, onCompletionQueued, getO
     return (text, meta = {}) => notifySessionCompletion(ownerSessionId, text, meta, generation);
   }
 
-  function bindListenerToSession(sessionId, listener) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (!ownerSessionId || typeof listener !== 'function') return;
-    let bucket = sessionNotificationListeners.get(ownerSessionId);
-    if (!bucket) {
-      bucket = new Set();
-      sessionNotificationListeners.set(ownerSessionId, bucket);
-    }
-    bucket.add(listener);
-    let ownedBucket = boundSessionListeners.get(ownerSessionId);
-    if (!ownedBucket) {
-      ownedBucket = new Set();
-      boundSessionListeners.set(ownerSessionId, ownedBucket);
-    }
-    ownedBucket.add(listener);
-  }
-
-  function unbindListener(listener) {
-    for (const [sessionId, ownedBucket] of boundSessionListeners) {
-      if (!ownedBucket.delete(listener)) continue;
-      const bucket = sessionNotificationListeners.get(sessionId);
-      bucket?.delete(listener);
-      if (bucket?.size === 0) sessionNotificationListeners.delete(sessionId);
-      if (ownedBucket.size === 0) boundSessionListeners.delete(sessionId);
-    }
-  }
-
-  function subscribeRuntimeNotification(sessionId, listener) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (typeof listener !== 'function') return () => {};
-    listeners.add(listener);
-    bindListenerToSession(ownerSessionId, listener);
-    return () => {
-      listeners.delete(listener);
-      unbindListener(listener);
-    };
-  }
-
-  function bindRuntimeNotificationSession(sessionId) {
-    const ownerSessionId = cleanSessionId(sessionId);
-    if (!ownerSessionId) return false;
-    for (const listener of listeners) bindListenerToSession(ownerSessionId, listener);
-    return true;
-  }
-
-  function clearRuntimeNotifications() {
-    for (const [sessionId, ownedBucket] of boundSessionListeners) {
-      const bucket = sessionNotificationListeners.get(sessionId);
-      if (!bucket) continue;
-      for (const listener of ownedBucket) bucket.delete(listener);
-      if (bucket.size === 0) sessionNotificationListeners.delete(sessionId);
-    }
-    boundSessionListeners.clear();
-    listeners.clear();
-  }
-
   return {
     emitRuntimeNotification,
     notifySession,

package/src/session-runtime/notification-completion-queue.mjs

@@ -0,0 +1,54 @@
+// The model-visible queue path of a terminal tool completion
+// (notification-bus.mjs): enqueue its twin once, skipping a completion the TUI
+// path already delivered or this bus already queued.
+import { modelVisibleToolCompletionMessage } from '../runtime/shared/tool-execution-contract.mjs';
+import { markCompletionEntry } from '../runtime/agent/orchestrator/session/manager/pending-messages.mjs';
+import {
+  isDeliveredCompletion,
+  logDuplicateSkip,
+} from '../runtime/agent/orchestrator/session/manager/delivered-completions.mjs';
+
+// Bounded memory of `${session}:${entry id}` keys this bus queued.
+const QUEUED_COMPLETION_IDS_MAX = 512;
+
+export function createCompletionQueue({ mgr, onCompletionQueued }) {
+  const queuedCompletionIds = new Map();
+
+  // Enqueue the model-visible twin unless it was already delivered; returns
+  // true when the caller may treat the completion as delivered.
+  return function enqueueCompletion(callerSessionId, text, meta, path) {
+    const visible = modelVisibleToolCompletionMessage(text, meta);
+    // Non-completion notifications yield '' here and are never queued.
+    if (!visible) return false;
+    if (isDeliveredCompletion({ executionId: meta?.execution_id, text: visible })) {
+      // Delivered + ACKed on the TUI path: suppress the duplicate but report
+      // DELIVERED so the caller stops retrying.
+      logDuplicateSkip(path, { executionId: meta?.execution_id, text: visible });
+      return true;
+    }
+    const entry = markCompletionEntry(visible, { executionId: meta?.execution_id, meta });
+    const queueKey = `${callerSessionId}:${entry.id}`;
+    if (queuedCompletionIds.has(queueKey)) {
+      logDuplicateSkip(`${path}-queued`, { executionId: meta?.execution_id, text: visible });
+      return true;
+    }
+    const enqueued = mgr.enqueuePendingMessage(callerSessionId, entry) > 0;
+    if (!enqueued) return false;
+    queuedCompletionIds.set(queueKey, Date.now());
+    while (queuedCompletionIds.size > QUEUED_COMPLETION_IDS_MAX) {
+      queuedCompletionIds.delete(queuedCompletionIds.keys().next().value);
+    }
+    if (typeof onCompletionQueued === 'function') {
+      try {
+        onCompletionQueued({
+          sessionId: callerSessionId,
+          executionId: meta?.execution_id || null,
+          enqueuedAt: entry.enqueuedAt,
+        });
+      } catch {
+        /* wake-up is best-effort; the durable queue remains authoritative */
+      }
+    }
+    return true;
+  };
+}

package/src/session-runtime/notification-listeners.mjs

@@ -0,0 +1,76 @@
+// Session-bound runtime notification listeners (notification-bus.mjs). The
+// per-session listener sets are process-wide; each bus owns which of its
+// listeners it bound to which session, and unbinds only those.
+
+const sessionNotificationListeners = new Map();
+
+export function cleanSessionId(value) {
+  return String(value || '').trim();
+}
+
+/** The listeners bound to one session (an empty array when none). */
+export function sessionListenersOf(sessionId) {
+  return sessionNotificationListeners.get(sessionId) || [];
+}
+
+export function createListenerBindings({ listeners }) {
+  const boundSessionListeners = new Map();
+
+  function bindListenerToSession(sessionId, listener) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (!ownerSessionId || typeof listener !== 'function') return;
+    let bucket = sessionNotificationListeners.get(ownerSessionId);
+    if (!bucket) {
+      bucket = new Set();
+      sessionNotificationListeners.set(ownerSessionId, bucket);
+    }
+    bucket.add(listener);
+    let ownedBucket = boundSessionListeners.get(ownerSessionId);
+    if (!ownedBucket) {
+      ownedBucket = new Set();
+      boundSessionListeners.set(ownerSessionId, ownedBucket);
+    }
+    ownedBucket.add(listener);
+  }
+
+  function unbindListener(listener) {
+    for (const [sessionId, ownedBucket] of boundSessionListeners) {
+      if (!ownedBucket.delete(listener)) continue;
+      const bucket = sessionNotificationListeners.get(sessionId);
+      bucket?.delete(listener);
+      if (bucket?.size === 0) sessionNotificationListeners.delete(sessionId);
+      if (ownedBucket.size === 0) boundSessionListeners.delete(sessionId);
+    }
+  }
+
+  function subscribeRuntimeNotification(sessionId, listener) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (typeof listener !== 'function') return () => {};
+    listeners.add(listener);
+    bindListenerToSession(ownerSessionId, listener);
+    return () => {
+      listeners.delete(listener);
+      unbindListener(listener);
+    };
+  }
+
+  function bindRuntimeNotificationSession(sessionId) {
+    const ownerSessionId = cleanSessionId(sessionId);
+    if (!ownerSessionId) return false;
+    for (const listener of listeners) bindListenerToSession(ownerSessionId, listener);
+    return true;
+  }
+
+  function clearRuntimeNotifications() {
+    for (const [sessionId, ownedBucket] of boundSessionListeners) {
+      const bucket = sessionNotificationListeners.get(sessionId);
+      if (!bucket) continue;
+      for (const listener of ownedBucket) bucket.delete(listener);
+      if (bucket.size === 0) sessionNotificationListeners.delete(sessionId);
+    }
+    boundSessionListeners.clear();
+    listeners.clear();
+  }
+
+  return { subscribeRuntimeNotification, bindRuntimeNotificationSession, clearRuntimeNotifications };
+}

package/src/session-runtime/owned-automation-run.mjs

@@ -131,7 +131,8 @@ export async function runOwnedAutomation(kind, row, run, deps = {}) {
     reserved = false,
     signal = null,
     now = Date.now,
-    ownerProblem = routineOwnerProblem,
+    // `row` is stored: for Mixy, itself evidence of her (routine-owner.mjs).
+    ownerProblem = (ownerAgentId) => routineOwnerProblem(ownerAgentId, null, { stored: true }),
     log = defaultLog,
   } = deps;
   const name = row.name;

package/src/session-runtime/prewarm/channel-start.mjs

@@ -39,9 +39,7 @@ export function createChannelStart({
   async function onChannelStartTimer() {
     timers.channelStartTimer = null;
     if (isCloseRequested()) return;
-    // Channels-module and remote toggles gate MESSAGING; automation
-    // (enabled schedules/webhooks) keeps the worker boot alive — its
-    // channel worker runs headless: only active automation boots it.
+    // Only active automation (enabled schedules/webhooks) boots the worker.
     const automation = await hasActiveAutomation().catch(() => false);
     if (!automation) {
       bootProfile('channels:start-disabled');
@@ -69,10 +67,8 @@ export function createChannelStart({
     timers.channelStartTimer.unref?.();
   }
 
-  // Boot-time automation autostart. Automation decoupling (user decision):
-  // enabled schedules/webhooks boot the worker on their own — no messaging
-  // provider. The worker runs headless (scheduler/webhooks/voice only).
-  // Unlike scheduleChannelStart this probes once at the boot delay and never
+  // Boot-time automation autostart: enabled schedules/webhooks boot the worker
+  // on their own (scheduler/webhooks/voice only). Unlike scheduleChannelStart this probes once at the boot delay and never
   // re-arms. The probe itself is shared process-wide (channel-admin
   // hasActiveAutomation), so N runtimes booting together check once.
   function scheduleAutomationAutostart(delayMs) {