mixdog 0.9.34 → 0.9.35

package/src/runtime/memory/lib/query-handlers.mjs

@@ -477,13 +477,14 @@ export function createQueryHandlers({
     const applyFreshness = !isCalendarPeriod
 
     // period='last': no time window and no session exclusion — 'last' is a
-    // plain "walk back through ALL prior conversation, newest first" browse.
+    // recent-session browse; with a query, filter those recent sessions by
+    // topic instead of falling through to the unbounded semantic search path.
     // No boot-timestamp cap (the old cap hid every session that ran while a
     // long-lived daemon stayed up), no gap-bounded burst, no current-session
     // filter: limit/offset page through history and the grouped renderer
     // separates sessions. temporal stays unbounded (mode marker only).
 
-    if (query) {
+    if (query && temporal?.mode !== 'last') {
       const _t0 = Date.now()
       if (signal?.aborted) throw signal.reason ?? new Error('aborted')
       let queryVector = null
@@ -673,6 +674,20 @@ export function createQueryHandlers({
     if (temporal?.mode === 'last') {
       const sessionCount = Number.isFinite(requestedLimit) ? limit : 5
       const PER_SESSION_ROW_CAP = 10
+      const PER_SESSION_SEARCH_CAP = 50
+      const queryTerms = sessionRecallTerms(query)
+      const matchesQueryTerms = (row) => {
+        if (queryTerms.length === 0) return true
+        const rowText = `${row?.content ?? ''} ${row?.element ?? ''} ${row?.summary ?? ''}`.toLowerCase()
+        if (queryTerms.some((term) => rowText.includes(term))) return true
+        if (Array.isArray(row?.members)) {
+          return row.members.some((member) => {
+            const memberText = `${member?.content ?? ''} ${member?.element ?? ''} ${member?.summary ?? ''}`.toLowerCase()
+            return queryTerms.some((term) => memberText.includes(term))
+          })
+        }
+        return false
+      }
       const excludeStatuses = includeArchived ? [] : ['archived']
       const VALID_LAST_CATS = new Set(['rule', 'constraint', 'decision', 'fact', 'goal', 'preference', 'task', 'issue'])
       const catList = category == null
@@ -684,7 +699,7 @@ export function createQueryHandlers({
       //    the fill draws from — roots (status-filtered) + unchunked raw
       //    leaves, member rows excluded — so a session ranked here can never
       //    fill empty (e.g. an archived-root session whose only surviving rows
-      //    are members). projectScope + excludeStatuses + category + promoted
+      //    are members). projectScope + excludeStatuses + promoted
       //    exclusion all match the fill filters below.
       const selWhere = [
         'session_id IS NOT NULL',
@@ -702,10 +717,6 @@ export function createQueryHandlers({
         const ph = excludeStatuses.map((s) => { selParams.push(s); return `$${selParams.length}` }).join(',')
         selWhere.push(`(status IS NULL OR status NOT IN (${ph}))`)
       }
-      if (catList.length > 0) {
-        const ph = catList.map((c) => { selParams.push(c); return `$${selParams.length}` }).join(',')
-        selWhere.push(`category IN (${ph})`)
-      }
       for (const c of buildPromotedExclusionClauses()) selWhere.push(c)
       selParams.push(sessionCount, offset)
       // Deterministic tie-breaker: equal MAX(ts) across sessions would let the
@@ -724,14 +735,15 @@ export function createQueryHandlers({
       for (const s of sessRows) {
         const sid = String(s?.session_id || '').trim()
         if (!sid) continue
-        const sf = { limit: PER_SESSION_ROW_CAP, session_id: sid, projectScope, sort: 'date' }
+        const perSessionFetchCap = queryTerms.length > 0 ? PER_SESSION_SEARCH_CAP : PER_SESSION_ROW_CAP
+        const sf = { limit: perSessionFetchCap, session_id: sid, projectScope, sort: 'date' }
         if (includeMembers) sf.includeMembers = true
         if (excludeStatuses.length > 0) sf.excludeStatuses = excludeStatuses
         if (catList.length > 0) sf.category = catList
         const sRows = await retrieveEntries(db, sf)
         let merged = sRows
         if (includeRaw) {
-          const rawRows = await readRawRowsInWindow(db, null, Date.now(), PER_SESSION_ROW_CAP, { projectScope, sessionId: sid })
+          const rawRows = await readRawRowsInWindow(db, null, Date.now(), perSessionFetchCap, { projectScope, sessionId: sid, terms: queryTerms })
           const seenIds = new Set(sRows.map((r) => Number(r.id)))
           for (const r of sRows) if (Array.isArray(r.members)) for (const m of r.members) seenIds.add(Number(m.id))
           // readRawRowsInWindow carries no category filter, so a category-
@@ -754,9 +766,12 @@ export function createQueryHandlers({
           if (newRaw.length > 0) {
             merged = [...sRows, ...newRaw]
             merged.sort((a, b) => (Number(b.ts) || 0) - (Number(a.ts) || 0) || (Number(b.id) || 0) - (Number(a.id) || 0))
-            merged = merged.slice(0, PER_SESSION_ROW_CAP)
           }
         }
+        if (queryTerms.length > 0) {
+          merged = merged.filter(matchesQueryTerms)
+        }
+        merged = merged.slice(0, PER_SESSION_ROW_CAP)
         for (const r of merged) allRows.push(r)
       }
       const _currentSessionHint = String(args?.currentSessionId || '').trim()

package/src/runtime/memory/tool-defs.mjs

@@ -30,13 +30,13 @@ export const TOOL_DEFS = [
     name: 'recall',
     title: 'Recall',
     annotations: { title: 'Recall', readOnlyHint: true, destructiveHint: false, idempotentHint: true, openWorldHint: false },
-    description: 'Retrieve stored memory/session history. Call when a task ties to prior work — resumes, continuations, or references to earlier decisions/messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" for previous conversation; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
+    description: 'Retrieve stored memory/session history. Call when a task ties to prior work — resumes, continuations, or references to earlier decisions/messages. Do not call as a reflexive pre-step, to verify a just-made decision, or before storing memory. Query is topic/semantic search, not regex. Patterns: period:"last" browses recent sessions; +query narrows topic; sessionId without query for current session; period:"3h"/"30m"/"24h" for recent; YYYY-MM-DD, date ranges, or HH:MM~HH:MM for time windows; id for exact follow-up.',
     inputSchema: {
       type: 'object',
       properties: {
         query: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' }, minItems: 1 }], description: 'Search text, or array for independent fan-out queries.' },
         id: { anyOf: [{ type: 'number' }, { type: 'array', items: { type: 'number' }, minItems: 1 }], description: 'Exact #id(s) from recall. Do not invent ids.' },
-        period: { type: 'string', description: "last (recent sessions grouped, newest-active first; limit=session count [default 5], offset=session paging), Nm/Nh/Nd (rolling), today/yesterday/this_week/last_week, all, YYYY-MM-DD, YYYY-MM-DD~YYYY-MM-DD, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
+        period: { type: 'string', description: "last (recent sessions; +query topic-filter; limit=session count [default 5], offset=session paging), Nm/Nh/Nd (rolling), today/yesterday/this_week/last_week, all, YYYY-MM-DD, YYYY-MM-DD~YYYY-MM-DD, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
         limit: { type: 'number', description: 'Max entries.' },
         offset: { type: 'number', description: 'Skip entries.' },
         sort: { type: 'string', enum: ['importance', 'date'], description: 'importance or date.' },
@@ -63,7 +63,7 @@ export const TOOL_DEFS = [
       type: 'object',
       properties: {
         query: { type: 'string', description: 'Search text.' },
-        period: { type: 'string', description: "last, Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date range, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
+        period: { type: 'string', description: "last (recent sessions; +query topic-filter), Nm/Nh/Nd, today/yesterday/this_week/last_week, all, YYYY-MM-DD, date range, HH:MM~HH:MM (today), or 'YYYY-MM-DD HH:MM~HH:MM'." },
         sort: { type: 'string', enum: ['date', 'importance'], description: 'date or importance.' },
         category: { anyOf: [{ type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, { type: 'array', items: { type: 'string', enum: ['rule','constraint','decision','fact','goal','preference','task','issue'] }, minItems: 1 }], description: 'Category filter.' },
         limit: { type: 'number', default: 30, description: 'Max entries.' },

package/src/runtime/shared/background-tasks.mjs

@@ -358,6 +358,17 @@ export function notifyTaskCompletion(task, instruction) {
     context: task.notifyContext,
     enqueueFallback: _enqueueFallback || undefined,
     logPrefix: `background-${task.surface}`,
+    // Async notifyFn: `sent` is reported optimistically while the delivery
+    // promise is still in flight, so mark delivered now but let settlement
+    // confirm it. If the notifyFn rejects/declines AND the fallback rescue also
+    // fails, un-mark so a later reconcile can retry rather than leaving the
+    // completion silently unsent. A successful/rescued async delivery keeps the
+    // marks, preserving exact-once.
+    onSettled: (delivered) => {
+      if (delivered) return;
+      task.notified = false;
+      task.notifiedWithBody = false;
+    },
   });
   if (sent) {
     task.notified = true;
@@ -382,7 +393,16 @@ export function reconcileBackgroundTask(taskId, {
 } = {}) {
   const task = getBackgroundTask(taskId);
   if (!task) return null;
-  if (TERMINAL_STATUSES.has(task.status)) return task;
+  if (TERMINAL_STATUSES.has(task.status)) {
+    // Already terminal, but a prior async completion notify may have un-marked
+    // itself after a reject/decline whose fallback rescue also missed
+    // (notifyTaskCompletion's onSettled clears notified/notifiedWithBody). The
+    // task never leaves its terminal status, so without retrying here the
+    // body-carrying completion stays silently unsent. Re-fire the notification;
+    // it is idempotent once notifiedWithBody is set, preserving exact-once.
+    if (task.notifiedWithBody !== true) notifyTaskCompletion(task, instruction);
+    return task;
+  }
   return completeBackgroundTask(task.taskId, {
     status,
     result,

package/src/runtime/shared/tool-execution-contract.mjs

@@ -253,6 +253,7 @@ export function notifyToolCompletion({
   context,
   enqueueFallback,
   logPrefix = 'tool-execution',
+  onSettled,
 } = {}) {
   const ctx = normalizeToolNotifyContext(context);
   const message = String(text || '');
@@ -275,22 +276,34 @@ export function notifyToolCompletion({
     try {
       const notifyResult = ctx.notifyFn(message, meta);
       if (notifyResult !== false) {
-        // Optimistically report delivered (keeps this fn synchronous). But a
-        // notifyFn that returns a Promise can still reject — or resolve to an
-        // explicit false/0 (declined/failed) — *after* we returned. In that
-        // case rescue the completion via enqueueFallback so the owner isn't
-        // left without a notification. The normal success path (truthy
-        // resolve) never enqueues, preserving exact-once delivery.
-        Promise.resolve(notifyResult).then((settled) => {
-          if (settled === false || settled === 0) {
-            tryEnqueueFallback(ctx, message, meta, enqueueFallback, logPrefix, id);
-          }
-        }).catch((err) => {
-          try {
-            process.stderr.write(`[${logPrefix}] async completion notify failed: id=${id || 'unknown'} err=${err?.message || err}\n`);
-          } catch {}
-          tryEnqueueFallback(ctx, message, meta, enqueueFallback, logPrefix, id);
-        });
+        const isThenable = notifyResult && typeof notifyResult.then === 'function';
+        if (isThenable) {
+          // A Promise notifyFn has NOT delivered yet — settlement decides the
+          // real outcome. Return `true` synchronously so the caller does not
+          // double-deliver through the sync fallback, but signal the FINAL
+          // delivered state via onSettled so the caller only *marks* the
+          // completion delivered after settlement. On a reject or explicit
+          // false/0 resolve, rescue via enqueueFallback; onSettled then reports
+          // whether that rescue (or the notifyFn itself) actually delivered, so
+          // a caller can un-mark and retry when nothing landed. The truthy
+          // resolve path never enqueues, preserving exact-once delivery.
+          Promise.resolve(notifyResult).then((settled) => {
+            if (settled === false || settled === 0) {
+              const rescued = tryEnqueueFallback(ctx, message, meta, enqueueFallback, logPrefix, id);
+              if (typeof onSettled === 'function') onSettled(rescued);
+            } else if (typeof onSettled === 'function') {
+              onSettled(true);
+            }
+          }).catch((err) => {
+            try {
+              process.stderr.write(`[${logPrefix}] async completion notify failed: id=${id || 'unknown'} err=${err?.message || err}\n`);
+            } catch {}
+            const rescued = tryEnqueueFallback(ctx, message, meta, enqueueFallback, logPrefix, id);
+            if (typeof onSettled === 'function') onSettled(rescued);
+          });
+          return true;
+        }
+        // Synchronous non-false result → confirmed delivered now.
         return true;
       }
     } catch (err) {

package/src/session-runtime/model-route-api.mjs

@@ -29,7 +29,7 @@ export function createModelRouteApi(deps) {
     getConfigHasSecrets, getSearchRouteState, setSearchRouteState,
     cfgMod, reg, mgr, statusRoutes,
     resolveRoute, searchCapableFor, lookupModelMeta,
-    adoptConfig, saveConfigAndAdopt, ensureFullConfig,
+    adoptConfig, saveConfigAndAdopt, ensureFullConfig, ensureProvidersReady,
     persistLeadRoute, refreshRouteEffort,
     refreshStatuslineUsageSnapshot, scheduleStatuslineUsageRefresh,
     invalidateContextStatusCache, invalidateProviderCaches,
@@ -70,7 +70,7 @@ export function createModelRouteApi(deps) {
         throw new Error(`provider "${selectedRoute.provider}" does not support Mixdog native search`);
       }
       ensureFullConfig();
-      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
       const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
       if (!searchCapableFor(selectedRoute.provider, modelMeta)) {
         throw new Error(`model "${selectedRoute.model}" is not marked as web-search capable`);
@@ -107,7 +107,7 @@ export function createModelRouteApi(deps) {
         requested.provider = getRoute().provider;
       }
       let selectedRoute = resolveRoute(getConfig(), requested);
-      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
       const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
       if (!providerExplicitlyRequested
         && !selectedRoute.preset

package/src/session-runtime/provider-auth-api.mjs

@@ -24,10 +24,16 @@ export function createProviderAuthApi({
   reloadFullConfig,
   invalidateProviderCaches,
   warmProviderModelCache,
+  refreshProviderCatalogs,
   cachedProviderSetup,
   getUsageDashboard,
   collectProviderModels,
 }) {
+  function refreshProviderCatalogsSoon() {
+    if (typeof refreshProviderCatalogs !== 'function') return;
+    try { void Promise.resolve(refreshProviderCatalogs()).catch(() => {}); } catch { /* best-effort */ }
+  }
+
   return {
     listProviders() {
       return renderProviderStatus(displayConfig());
@@ -44,6 +50,7 @@ export function createProviderAuthApi({
         : await loginOAuthProvider(cfgMod, providerId);
       reloadFullConfig();
       invalidateProviderCaches();
+      refreshProviderCatalogsSoon();
       warmProviderModelCache();
       return result;
     },
@@ -51,6 +58,7 @@ export function createProviderAuthApi({
       const result = await loginOAuthProvider(cfgMod, providerId);
       reloadFullConfig();
       invalidateProviderCaches();
+      refreshProviderCatalogsSoon();
       warmProviderModelCache();
       return result;
     },
@@ -63,6 +71,7 @@ export function createProviderAuthApi({
           reloadFullConfig();
           if (completed) {
             invalidateProviderCaches();
+            refreshProviderCatalogsSoon();
             warmProviderModelCache();
           }
           return completed;
@@ -71,6 +80,7 @@ export function createProviderAuthApi({
           const completed = await result.completeCode(code);
           reloadFullConfig();
           invalidateProviderCaches();
+          refreshProviderCatalogsSoon();
           warmProviderModelCache();
           return completed;
         },
@@ -80,6 +90,7 @@ export function createProviderAuthApi({
       const result = saveProviderApiKey(cfgMod, providerId, secret);
       reloadFullConfig();
       invalidateProviderCaches();
+      refreshProviderCatalogsSoon();
       warmProviderModelCache();
       return result;
     },
@@ -105,6 +116,7 @@ export function createProviderAuthApi({
       const result = setLocalProvider(cfgMod, providerId, opts);
       reloadFullConfig();
       invalidateProviderCaches();
+      refreshProviderCatalogsSoon();
       warmProviderModelCache();
       return result;
     },
@@ -112,6 +124,7 @@ export function createProviderAuthApi({
       const result = forgetProviderAuth(cfgMod, providerId);
       reloadFullConfig();
       invalidateProviderCaches();
+      refreshProviderCatalogsSoon();
       warmProviderModelCache();
       return result;
     },

package/src/session-runtime/runtime-core.mjs

@@ -581,7 +581,8 @@ export async function createMixdogSessionRuntime({
     providerSetupQuickCache: { setup: null, at: 0 },
     providerSetupPromise: null,
   };
-  let providerInitPromise = null;
+  const providerInitPromises = new Map();
+  let startupProviderCatalogRefreshStarted = false;
   let lastProjectMcpKey = null;
   // MCP connect state, owned here so teardown/reconnect paths still observe it;
   // the mcp-glue factory mutates this object in place (see createMcpGlue).
@@ -1150,7 +1151,7 @@ export async function createMixdogSessionRuntime({
     providerUsageCaches.providerSetupCache = { setup: null, at: 0 };
     providerUsageCaches.providerSetupQuickCache = { setup: null, at: 0 };
     providerUsageCaches.providerSetupPromise = null;
-    providerInitPromise = null;
+    providerInitPromises.clear();
     modelMetaByRoute.clear();
   }
 
@@ -1197,13 +1198,43 @@ export async function createMixdogSessionRuntime({
     STANDALONE_DATA_DIR,
   });
 
+  function providerInitCacheKey(value) {
+    function sortKeysDeep(v) {
+      if (Array.isArray(v)) return v.map(sortKeysDeep);
+      if (v && typeof v === 'object') {
+        const out = {};
+        for (const key of Object.keys(v).sort()) out[key] = sortKeysDeep(v[key]);
+        return out;
+      }
+      return v;
+    }
+    try {
+      return JSON.stringify(sortKeysDeep(value));
+    } catch {
+      return `uncacheable:${Date.now()}:${Math.random()}`;
+    }
+  }
+
   async function ensureProvidersReady(providerConfig = config.providers || {}) {
-    if (providerInitPromise) return await providerInitPromise;
-    providerInitPromise = reg.initProviders(providerConfig)
+    const initKey = providerInitCacheKey(providerConfig);
+    const existing = providerInitPromises.get(initKey);
+    if (existing) return await existing;
+    const providerInitPromise = reg.initProviders(providerConfig)
       .finally(() => {
-        providerInitPromise = null;
+        if (providerInitPromises.get(initKey) === providerInitPromise) providerInitPromises.delete(initKey);
       });
-    return await providerInitPromise;
+    providerInitPromises.set(initKey, providerInitPromise);
+    const result = await providerInitPromise;
+    if (!startupProviderCatalogRefreshStarted && !closeRequested) {
+      startupProviderCatalogRefreshStarted = true;
+      try {
+        reg.refreshProviderCatalogsOnStartup();
+        bootProfile('provider-catalogs:refresh-started');
+      } catch (error) {
+        bootProfile('provider-catalogs:refresh-failed', { error: error?.message || String(error) });
+      }
+    }
+    return result;
   }
 
   const {
@@ -1982,6 +2013,7 @@ export async function createMixdogSessionRuntime({
     reloadFullConfig,
     invalidateProviderCaches,
     warmProviderModelCache,
+    refreshProviderCatalogs: () => ensureProvidersReady(config.providers || {}).then(() => reg.refreshCatalogs()),
     cachedProviderSetup,
     getUsageDashboard,
     collectProviderModels,
@@ -2063,6 +2095,7 @@ export async function createMixdogSessionRuntime({
     adoptConfig,
     saveConfigAndAdopt,
     ensureFullConfig,
+    ensureProvidersReady,
     persistLeadRoute,
     refreshRouteEffort,
     refreshStatuslineUsageSnapshot,
@@ -2086,6 +2119,7 @@ export async function createMixdogSessionRuntime({
     lookupModelMeta,
     adoptConfig,
     saveConfigAndAdopt,
+    ensureProvidersReady,
     displayConfig,
     agentRouteFromConfig,
     loadAgentDefinition,

package/src/session-runtime/tool-catalog.mjs

@@ -757,8 +757,9 @@ function pendingAndFailedMcpServers(mcpStatus) {
 // tools PLUS pending/failed MCP servers. No listing, no ranking, no substring
 // filter. `options.mcpStatus` is the runtime getter for per-server status.
 export function renderToolSearch(args = {}, session, mode = 'full', options = {}) {
-  const catalog = Array.isArray(session?.deferredToolCatalog)
-    ? session.deferredToolCatalog
+  const unionCatalog = deferredCatalogUnion(session);
+  const catalog = unionCatalog.length
+    ? unionCatalog
     : (Array.isArray(session?.tools) ? session.tools : []);
   const requestedNames = parseLoadToolNames(args);
   const { pending: pendingMcpServers, failed: failedMcpServers } = pendingAndFailedMcpServers(options?.mcpStatus);

package/src/session-runtime/workflow-agents-api.mjs

@@ -25,7 +25,7 @@ export function createWorkflowAgentsApi(deps) {
   const {
     getConfig, getRoute, setRouteState, getSession, setSession, getConfigHasSecrets,
     cfgMod, reg, mgr, STANDALONE_DATA_DIR,
-    resolveRoute, lookupModelMeta, adoptConfig, saveConfigAndAdopt, displayConfig,
+    resolveRoute, lookupModelMeta, adoptConfig, saveConfigAndAdopt, displayConfig, ensureProvidersReady,
     agentRouteFromConfig, loadAgentDefinition, activeWorkflowId, listWorkflowPacks,
     loadWorkflowPack, workflowSummary,
     getOutputStyleStatusCached, seedOutputStyleStatusCache, scheduleOutputStyleSave,
@@ -204,7 +204,7 @@ export function createWorkflowAgentsApi(deps) {
       const id = normalizeAgentId(agentId);
       if (!id) throw new Error(`unknown agent "${agentId}"`);
       let selectedRoute = resolveRoute(getConfig(), { ...(next || {}) });
-      await reg.initProviders(ensureProviderEnabled(getConfig(), selectedRoute.provider));
+      await ensureProvidersReady(ensureProviderEnabled(getConfig(), selectedRoute.provider));
       const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
       const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
       selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };

package/src/standalone/agent-tool/notify.mjs

@@ -37,7 +37,20 @@ export function createNotify(mgr) {
         try {
           const result = upstream(text, meta);
           ownerDelivered = result !== false;
-          if (ownerDelivered) Promise.resolve(result).catch(() => {});
+          if (ownerDelivered && result && typeof result.then === 'function') {
+            // Async notifyFn: `ownerDelivered` is optimistic while the delivery
+            // promise is in flight — settlement decides the real outcome. On a
+            // reject or explicit false/0 resolve, rescue via the owner-session
+            // enqueue fallback so the completion is not silently swallowed. A
+            // truthy resolve never enqueues, preserving exact-once delivery.
+            Promise.resolve(result).then((settled) => {
+              if ((settled === false || settled === 0) && ownerSessionId) {
+                enqueueCompletionMessage(ownerSessionId, text, meta);
+              }
+            }).catch(() => {
+              if (ownerSessionId) enqueueCompletionMessage(ownerSessionId, text, meta);
+            });
+          }
         } catch {
           ownerDelivered = false;
         }

package/src/tui/dist/index.mjs

@@ -50,6 +50,39 @@ var require_mixdog_debug = __commonJS({
     function isMixdogDebugEnabled() {
       return isTruthyEnv(process.env.MIXDOG_DEBUG) || isTruthyEnv(process.env.MIXDOG_DEBUG_SESSION_START);
     }
+    var _cachedFromSource = null;
+    function _detectFromSourceCheckout() {
+      if (_cachedFromSource !== null) return _cachedFromSource;
+      try {
+        const moduleDir = module && module.filename ? path2.dirname(module.filename) : process.cwd();
+        const roots = [
+          path2.resolve(moduleDir, "..", ".."),
+          process.cwd()
+        ];
+        _cachedFromSource = roots.some((root) => fs.existsSync(path2.join(root, ".git")));
+      } catch {
+        _cachedFromSource = false;
+      }
+      return _cachedFromSource;
+    }
+    function resolveMixdogMode() {
+      const raw = String(process.env.MIXDOG_MODE || "").trim().toLowerCase();
+      if (raw === "dev" || raw === "development" || raw === "debug") return "dev";
+      if (raw === "ship" || raw === "shipping" || raw === "prod" || raw === "production") return "ship";
+      if (isTruthyEnv(process.env.MIXDOG_SHIP)) return "ship";
+      if (isMixdogDebugEnabled()) return "dev";
+      return _detectFromSourceCheckout() ? "dev" : "ship";
+    }
+    function isShippingMode() {
+      return resolveMixdogMode() === "ship";
+    }
+    function isDevMode() {
+      return resolveMixdogMode() === "dev";
+    }
+    function isDiagnosticIOEnabled() {
+      if (isTruthyEnv(process.env.MIXDOG_DIAGNOSTICS)) return true;
+      return !isShippingMode();
+    }
     var CANONICAL_PLUGIN_LOG_NAMES = /* @__PURE__ */ new Set([
       "boot.log",
       "crash.log",
@@ -143,6 +176,10 @@ var require_mixdog_debug = __commonJS({
     }
     module.exports = {
       isMixdogDebugEnabled,
+      resolveMixdogMode,
+      isShippingMode,
+      isDevMode,
+      isDiagnosticIOEnabled,
       pruneStalePluginDataLogSiblings,
       appendSessionStartCriticalLog,
       DEFAULT_STALE_LOG_SIBLING_MAX,
@@ -23702,18 +23739,24 @@ function createSessionFlow(bag) {
     return true;
   }
   function drainPendingSteering() {
-    const batch = dequeueQueueBatch("next", { predicate: (entry) => !isSlashQueuedEntry(entry) });
-    if (batch.length === 0) return [];
-    const out = batch.map((entry) => {
-      const content = entry.content;
-      if (typeof content === "string") return content.trim();
-      return { text: String(entry.text || "").trim(), content };
-    }).filter((entry) => {
-      if (typeof entry === "string") return entry.length > 0;
-      if (Array.isArray(entry?.content)) return entry.content.length > 0;
-      return String(entry?.content ?? "").trim().length > 0;
-    });
-    commitSteeringQueueEntries(batch);
+    const predicate = (entry) => !isSlashQueuedEntry(entry);
+    const out = [];
+    for (; ; ) {
+      const batch = dequeueQueueBatch("later", { predicate });
+      if (batch.length === 0) break;
+      for (const entry of batch) {
+        const content = entry.content;
+        const value = typeof content === "string" ? content.trim() : { text: String(entry.text || "").trim(), content };
+        if (typeof value === "string") {
+          if (value.length > 0) out.push(value);
+        } else if (Array.isArray(value.content)) {
+          if (value.content.length > 0) out.push(value);
+        } else if (String(value.content ?? "").trim().length > 0) {
+          out.push(value);
+        }
+      }
+      commitSteeringQueueEntries(batch);
+    }
     return out;
   }
   async function restoreLeadSteeringFromDisk() {
@@ -24055,18 +24098,13 @@ function createRunTurn(bag) {
     const deferredEntries = [];
     const flushDeferredUpTo = (entry) => {
       if (!entry) return;
-      for (const e of deferredEntries) {
-        if (e.seq > entry.seq) break;
-        if (e.pushed) continue;
-        e.pushed = true;
-        if (e.timer) {
-          clearTimeout(e.timer);
-          e.timer = null;
-        }
-        try {
-          e.push();
-        } catch {
-        }
+      const specs = collectDeferredUpTo(entry);
+      if (!specs.length) return;
+      flags.pushingFromDeferredEntry = true;
+      try {
+        appendItemsBatch(specs);
+      } finally {
+        flags.pushingFromDeferredEntry = false;
       }
     };
     flags.flushDeferredBeforeImmediatePush = () => {
@@ -25988,7 +26026,7 @@ var TOOL_APPROVAL_TIMEOUT_MS = (() => {
 })();
 var LEAD_TURN_TIMEOUT_MS = (() => {
   const value = Number(process.env.MIXDOG_LEAD_TURN_TIMEOUT_MS);
-  return Number.isFinite(value) && value > 0 ? Math.max(1e4, Math.round(value)) : 30 * 6e4;
+  return Number.isFinite(value) && value > 0 ? Math.max(1e4, Math.round(value)) : 5 * 6e4;
 })();
 var TUI_DEBUG = /^(1|true|yes|on)$/i.test(String(process.env.MIXDOG_TUI_DEBUG || ""));
 var tuiDebug = (msg) => {

package/src/tui/engine/session-flow.mjs

@@ -210,20 +210,33 @@ export function createSessionFlow(bag) {
     // through the normal command processor after the turn, not be sent as plain
     // text. Consumed entries are spliced out of `pending` here, so the post-turn
     // drain() loop will not re-execute them.
-    const batch = dequeueQueueBatch('next', { predicate: (entry) => !isSlashQueuedEntry(entry) });
-    if (batch.length === 0) return [];
-    const out = batch
-      .map((entry) => {
+    //
+    // dequeueQueueBatch drains ONE priority/mode bucket per call, capped at a
+    // max priority. A concurrent user steering prompt (`next`) and a task
+    // notification (`later`) sit in different buckets, so a single `next`-capped
+    // dequeue would leave the notification pending and the post-turn drain()
+    // loop would spawn an unintended follow-up turn/reply. Loop up to `later`
+    // so EVERY non-slash bucket is consumed by the current turn.
+    const predicate = (entry) => !isSlashQueuedEntry(entry);
+    const out = [];
+    for (;;) {
+      const batch = dequeueQueueBatch('later', { predicate });
+      if (batch.length === 0) break;
+      for (const entry of batch) {
         const content = entry.content;
-        if (typeof content === 'string') return content.trim();
-        return { text: String(entry.text || '').trim(), content };
-      })
-      .filter((entry) => {
-        if (typeof entry === 'string') return entry.length > 0;
-        if (Array.isArray(entry?.content)) return entry.content.length > 0;
-        return String(entry?.content ?? '').trim().length > 0;
-      });
-    commitSteeringQueueEntries(batch);
+        const value = typeof content === 'string'
+          ? content.trim()
+          : { text: String(entry.text || '').trim(), content };
+        if (typeof value === 'string') {
+          if (value.length > 0) out.push(value);
+        } else if (Array.isArray(value.content)) {
+          if (value.content.length > 0) out.push(value);
+        } else if (String(value.content ?? '').trim().length > 0) {
+          out.push(value);
+        }
+      }
+      commitSteeringQueueEntries(batch);
+    }
     return out;
   }