mixdog 1.3.4 → 1.4.0

package/src/tui/session/queue-helpers.mjs

@@ -4,7 +4,8 @@
  * flattening, session activity timestamps, and batch merging.
  */
 import { agentJobResultText, parseAgentJob, parseSyntheticAgentMessage } from './agent-envelope.mjs';
-import { attachmentTextForPart, isAttachmentReference } from '../../runtime/attachments/store.mjs';
+import { isAttachmentReference } from '../../runtime/attachments/store.mjs';
+import { promptContentText, sessionActivityTimestamp } from '../../runtime/shared/idle-auto-clear-gate.mjs';
 import { recognisedSlashToken } from '../app/slash-commands.mjs';
 
 const QUEUE_PRIORITY = { now: 0, next: 1, later: 2 };
@@ -82,47 +83,7 @@ export function notificationDisplayText(text) {
   return firstQueueLine(synthetic?.result || result || text) || 'agent notification';
 }
 
-export function promptContentText(content) {
-  if (typeof content === 'string') return content;
-  if (Array.isArray(content)) {
-    return content
-      .map((part) => {
-        if (typeof part === 'string') return part;
-        if (part?.type === 'text') return isAttachmentReference(part) ? attachmentTextForPart(part) : part.text || '';
-        if (part?.type === 'image') return '[Image]';
-        if (part?.type === 'file') return '[File]';
-        return part?.text || '';
-      })
-      .filter(Boolean)
-      .join('\n');
-  }
-  return String(content ?? '');
-}
-
-function timestampMs(value) {
-  if (value == null || value === '') return 0;
-  const n = Number(value);
-  if (Number.isFinite(n) && n > 0) return n;
-  const parsed = Date.parse(String(value));
-  return Number.isFinite(parsed) && parsed > 0 ? parsed : 0;
-}
-
-function hasModelVisibleConversation(session) {
-  const messages = Array.isArray(session?.messages) ? session.messages : [];
-  return messages.some((message) => {
-    const role = message?.role;
-    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
-    const text = promptContentText(message.content).trim();
-    if (role === 'user' && text.startsWith('<system-reminder>')) return false;
-    if (role === 'assistant' && text === '.' && !Array.isArray(message.toolCalls)) return false;
-    return !!text || role === 'assistant' || role === 'tool';
-  });
-}
-
-export function sessionActivityTimestamp(session, fallback = 0) {
-  if (!hasModelVisibleConversation(session)) return 0;
-  return timestampMs(session?.lastUsedAt) || timestampMs(session?.updatedAt) || timestampMs(fallback);
-}
+export { promptContentText, sessionActivityTimestamp };
 
 export function promptDisplayText(content, options = {}) {
   if (typeof options.displayText === 'string' && options.displayText.trim()) return options.displayText;

package/src/tui/session/session-api/integrations.mjs

@@ -138,6 +138,7 @@ export function createSessionIntegrationsApi(bag, { oauthFlows }) {
       (input) => runtime.saveCustomProvider(input),
       (result) => `custom provider saved: ${result.id}`
     ),
+    saveCustomProviderKey: (id, secret) => runtime.saveCustomProviderKey(id, secret),
     updateCustomProviderModel: (id, modelId, patch) => runtime.updateCustomProviderModel(id, modelId, patch),
     setModelPreferences: (provider, changes) => runtime.setModelPreferences(provider, changes),
     removeCustomProvider: async (id) => {

package/src/tui/session/session-api/lifecycle.mjs

@@ -81,6 +81,14 @@ export function createSessionLifecycleApi(bag, { restoreTranscriptItems, oauthFl
     pushNotice,
     removeNotice,
     setProgressHint,
+    // A bot's emoji reactions on a user message (message-reactions.mjs): its
+    // live row shows them at once; false when the live rows do not hold it.
+    setMessageReactions: (messageId, reactions) => {
+      const row = bag
+        .getState()
+        .items.findLast((item) => item?.kind === 'user' && messageId && item.messageId === messageId);
+      return row ? bag.patchItem(row.id, { reactions: Array.isArray(reactions) ? reactions : [] }) : false;
+    },
     ...createSessionResetActions(bag),
     listSessions: (options) => {
       return runtime.listSessions(options);

package/src/tui/session/session-api/routes-agent-definitions.mjs

@@ -2,6 +2,16 @@
  * routes-agent-definitions.mjs — the session route surface's passthroughs to
  * the runtime's agent, workflow-pack, connector and lead-identity services.
  */
+
+/** Mixy's status with `exists`, the one rule (mixy-presence.mjs) the desktop
+ *  answers from (main/mixy-first.ts). null when her routines cannot be read:
+ *  the status still serves readers of her name. */
+async function withMixyExists(status) {
+  if (!status || typeof status !== 'object') return status;
+  const { readMixyExists } = await import('../../../session-runtime/routine-owner.mjs');
+  return { ...status, exists: await readMixyExists(status).catch(() => null) };
+}
+
 export function createAgentDefinitionApi(runtime) {
   return {
     listAgents: () => {
@@ -53,8 +63,10 @@ export function createAgentDefinitionApi(runtime) {
     saveLeadPersona: async (text) => runtime.saveLeadPersona?.(text) ?? '',
     getLeadAgentBody: () => runtime.getLeadAgentBody?.() ?? '',
     saveLeadAgentBody: async (text) => runtime.saveLeadAgentBody?.(text) ?? '',
-    getLeadStatus: () =>
-      runtime.getLeadStatus?.() ?? { created: null, name: '', avatar: null, homeChatted: false, route: null },
+    getLeadStatus: async () =>
+      withMixyExists(
+        runtime.getLeadStatus?.() ?? { created: null, name: '', avatar: null, homeChatted: false, route: null }
+      ),
     getLeadHomeRoute: () => runtime.getLeadHomeRoute?.() ?? null,
     saveLeadIdentity: async (payload) => runtime.saveLeadIdentity?.(payload) ?? null,
     setLeadCreated: async (created, description) => runtime.setLeadCreated?.(created, description) ?? null,

package/src/tui/session/session-api/routes-write.mjs

@@ -54,14 +54,18 @@ const SESSION_ONLY_KEYS = new Set(['provider', 'model', 'effort', 'fast', 'autoE
  * the tuning, or both. Completed here, inside the serialized route write,
  * against the latest selected route — so a Fast-only change keeps the effort a
  * previous write selected. `unchanged` when it asks for nothing the selected
- * route does not already have.
+ * route does not already have and the session itself already runs that model
+ * (a fallback hop moves the session, not the selected route).
  */
 function completeSessionOnlyRequest(request, selected) {
   const named = Boolean(request.provider || request.model);
   const target = named ? request : { ...request, provider: selected.provider, model: selected.model };
   const sameModel = target.provider === selected.provider && target.model === selected.model;
   if (!sameModel) return { request: target, unchanged: false };
+  const sessionOnTarget =
+    !selected.sessionModel || (selected.sessionProvider === target.provider && selected.sessionModel === target.model);
   const unchanged =
+    sessionOnTarget &&
     Object.keys(request).every((key) => SESSION_ONLY_KEYS.has(key)) &&
     (request.effort === undefined || request.effort === selected.effort) &&
     (request.fast === undefined || request.fast === (selected.fast === true)) &&

package/src/tui/session/session-api/routes.mjs

@@ -128,6 +128,7 @@ export function createSessionRouteApi(bag) {
       return result;
     }),
     getOrchestrationMode: () => runtime.getOrchestrationMode(),
+    getConfiguredOrchestrationMode: () => runtime.getConfiguredOrchestrationMode(),
     setOrchestrationMode: withCommandLock(async (mode, options) => {
       const result = await runtime.setOrchestrationMode(mode, options);
       publishSessionSwitches(bag, { orchestrationModeSwitch: result?.orchestrationModeSwitch });

package/src/tui/session/session-api/settings.mjs

@@ -34,8 +34,8 @@ export function createSessionSettingsApi(bag) {
     // refused: another command's lock does not block a selection.
     setModel: async (m) => (await bag.setSessionRoute({ model: m })) !== false,
     setEffort: withCommandLock(
-      async (value) => {
-        await runtime.setEffort(value);
+      async (value, options) => {
+        await runtime.setEffort(value, options);
         set({ ...routeState() });
         return runtime.effort || 'auto';
       },
@@ -112,6 +112,34 @@ export function createSessionSettingsApi(bag) {
     setAiSessionTitles: withCommandLock(async (enabled) => {
       return await runtime.setAiSessionTitles?.(enabled);
     }),
+    getCacheWarmingSettings: () => {
+      return runtime.getCacheWarmingSettings?.() || { enabled: true };
+    },
+    setCacheWarmingEnabled: withCommandLock(async (enabled) => {
+      return await runtime.setCacheWarmingEnabled?.(enabled);
+    }),
+    getHeartbeatSettings: () => {
+      return runtime.getHeartbeatSettings?.() || { heartbeat: true, intervalMinutes: 60 };
+    },
+    setHeartbeatEnabled: withCommandLock(async (enabled) => {
+      return await runtime.setHeartbeatEnabled?.(enabled);
+    }),
+    setHeartbeatInterval: withCommandLock(async (minutes) => {
+      return await runtime.setHeartbeatInterval?.(minutes);
+    }),
+    // The desktop app reports the user's latest in-app input time: Mixy's
+    // heartbeat waits for 30 quiet minutes (mixy-heartbeat.mjs noteUserInput).
+    noteUserInput: async (at) => {
+      const { noteUserInput } = await import('../../../session-runtime/mixy-heartbeat.mjs');
+      noteUserInput(at);
+      return { ok: true };
+    },
+    getReactionSettings: () => {
+      return runtime.getReactionSettings?.() || { reactions: true };
+    },
+    setReactionsEnabled: withCommandLock(async (enabled) => {
+      return await runtime.setReactionsEnabled?.(enabled);
+    }),
     getLeadAppearance: () => {
       return runtime.getLeadAppearance?.() || { avatar: null };
     },

package/src/tui/session/session-flow/auto-clear.mjs

@@ -4,7 +4,7 @@
  * cleared-session UI once the active turn settles.
  */
 import { presentErrorText } from '../../../runtime/shared/err-text.mjs';
-import { sessionActivityTimestamp } from '../queue-helpers.mjs';
+import { idleAutoClearDue, sessionActivityTimestamp } from '../../../runtime/shared/idle-auto-clear-gate.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction-view.mjs';
 
 // Upper bound on the awaited idle compaction. Without a bound a stalled
@@ -17,29 +17,6 @@ import { archiveItemsForCompaction, compactionArchivedRows } from '../compaction
 const AUTO_CLEAR_COMPACT_TIMEOUT_MS = 60_000;
 const LATE_COMPLETION_NOTICE = 'auto-clear completed late; compacted conversation retained';
 
-// A zero is often an unavailable/stale meter field, not an authoritative
-// measurement. Do not let it mask the sibling live estimate.
-function contextUsageBelowThreshold(runtime, minContextPercent) {
-  if (!(minContextPercent > 0)) return false;
-  const status = runtime.contextStatus?.() || null;
-  const usedTokens = Math.max(
-    0,
-    Number(status?.usedTokens) || 0,
-    Number(status?.currentEstimatedTokens) || 0,
-    Number(status?.compaction?.currentEstimatedTokens) || 0
-  );
-  const triggerTokens = Number(
-    status?.compaction?.triggerTokens ||
-      status?.compaction?.autoCompactTokenLimit ||
-      runtime.session?.autoCompactTokenLimit ||
-      0
-  );
-  if (!Number.isFinite(usedTokens) || !Number.isFinite(triggerTokens) || !(usedTokens > 0 && triggerTokens > 0)) {
-    return true;
-  }
-  return (usedTokens / triggerTokens) * 100 < minContextPercent;
-}
-
 export function createAutoClearOps(bag, { reset, kickDrain }) {
   const {
     runtime,
@@ -140,15 +117,9 @@ export function createAutoClearOps(bag, { reset, kickDrain }) {
     const cfg = autoClearState();
     const now = Date.now();
     const activityAt = sessionActivityTimestamp(runtime.session, flags.lastUserActivityAt);
-    const idleMs = activityAt ? now - activityAt : 0;
-    const notIdle =
-      !cfg.enabled ||
-      getState().busy ||
-      (!ignorePending && pending.length > 0) ||
-      flags.autoClearRunning ||
-      flags.autoClearInFlight ||
-      idleMs < cfg.idleMs;
-    if (notIdle || contextUsageBelowThreshold(runtime, Number(cfg.minContextPercent ?? 10))) {
+    const blocked =
+      getState().busy || (!ignorePending && pending.length > 0) || flags.autoClearRunning || flags.autoClearInFlight;
+    if (blocked || !idleAutoClearDue({ cfg, activityAt, at: now, runtime })) {
       if (!activityAt) flags.lastUserActivityAt = now;
       return false;
     }

package/src/tui/session/session-flow/drain-closed-queue.mjs

@@ -0,0 +1,38 @@
+/**
+ * src/tui/session/session-flow/drain-closed-queue.mjs - settling the queue of a
+ * session whose canonical close completed (drain.mjs admission `terminal`).
+ */
+import { dropTuiSteeringPersist } from '../tui-steering-persist.mjs';
+
+export function createClosedQueueSettler({
+  pending,
+  pendingNotificationKeys,
+  clearBlockedDrainRetry,
+  queue,
+  steering,
+  submissions,
+}) {
+  // Canonical close settled: nothing queued can ever run. Every accepted
+  // submission is settled explicitly (rejected), never silently dropped, and
+  // its durable steering mirror is released so a restart cannot resurrect it
+  // into the closed conversation.
+  return function settleClosedQueue() {
+    const entries = pending.splice(0);
+    pendingNotificationKeys.clear();
+    clearBlockedDrainRetry();
+    if (entries.length === 0) return;
+    queue.removeQueuedEntries(entries);
+    const mirrored = entries.filter((entry) => steering.shouldMirrorSteeringEntry(entry) && entry.steeringPersistId);
+    if (mirrored.length > 0) {
+      void Promise.resolve(dropTuiSteeringPersist(steering.leadSessionId(), mirrored)).catch(() => {});
+    }
+    for (const entry of entries) {
+      if (entry.id) submissions.forget(entry.id);
+      try {
+        entry.onSettled?.({ status: 'rejected', reason: 'session-closed', result: null, session: null });
+      } catch {
+        // A throwing callback must not leave the remaining entries unsettled.
+      }
+    }
+  };
+}

package/src/tui/session/session-flow/drain-enqueue.mjs

@@ -0,0 +1,86 @@
+/**
+ * src/tui/session/session-flow/drain-enqueue.mjs - idempotent intake of the
+ * unified prompt queue (drain.mjs): admission fence, duplicate submissions,
+ * notification keys, task-wait wakes and the durable steering mirror.
+ */
+import { isQueuedEntryEditable, isQueuedEntryVisible } from '../queue-helpers.mjs';
+import { appendTuiSteeringPersist } from '../tui-steering-persist.mjs';
+
+export function createEnqueue({
+  admission,
+  tuiDebug,
+  flags,
+  pending,
+  pendingNotificationKeys,
+  getState,
+  set,
+  flushEmitImmediate,
+  getRuntime,
+  queue,
+  steering,
+  submissions,
+  drain,
+}) {
+  return function enqueue(text, options = {}) {
+    // Admission fence. While closing, only user prompts are accepted (retained
+    // so a failed close loses nothing); notification-driven/model-visible
+    // enqueues are refused. A closed session accepts nothing.
+    const state = admission();
+    const mode = options.mode || 'prompt';
+    if (state !== 'open' && (state === 'terminal' || mode !== 'prompt')) {
+      tuiDebug(`enqueue refused: session admission=${state} mode=${mode}`);
+      return false;
+    }
+    const submissionId = String(options.id || '').trim();
+    // Idempotent intake: a transport that re-sent this exact submission (its
+    // first attempt landed but the response was lost) must not double-post.
+    if (submissionId && submissions.has(submissionId)) {
+      tuiDebug(`prompt-duplicate id=${submissionId} ignored`);
+      // This is an idempotent success, not a rejected submit. Returning false
+      // makes Desktop restore and retry a message that is already queued.
+      return true;
+    }
+    const entry = queue.makeQueueEntry(text, options);
+    if (entry.mode === 'task-notification' && entry.key) {
+      if (pendingNotificationKeys.has(entry.key)) return false;
+      pendingNotificationKeys.add(entry.key);
+    }
+    submissions.remember(submissionId);
+    pending.push(entry);
+    // Typed input or a deliverable notification ends a passive task wait or
+    // shell hold so the next boundary hands it to the model now.
+    const wake = steering.taskWaitWakeForEntry(entry);
+    if (wake) {
+      try {
+        getRuntime()?.interruptTaskWait?.(wake, wake === 'notification' ? entry.execution?.id || null : null);
+      } catch {}
+    }
+    const needsDurableSteering =
+      (getState().busy || getState().commandBusy || flags.autoClearRunning || flags.quotaResumePending) &&
+      steering.shouldMirrorSteeringEntry(entry);
+    const persistence = needsDurableSteering ? appendTuiSteeringPersist(steering.leadSessionId(), entry) : null;
+    if (isQueuedEntryVisible(entry)) {
+      set({ queued: [...getState().queued, entry] });
+      if (isQueuedEntryEditable(entry)) flushEmitImmediate?.();
+    }
+    const queueAgeMs = Math.max(0, Date.now() - Number(entry.submittedAt || Date.now()));
+    tuiDebug(`prompt-queued id=${String(entry.id)} busy=${getState().busy ? 1 : 0} ageMs=${queueAgeMs}`);
+    if (getState().busy) tuiDebug(`busy-queue enqueue mode=${entry.mode} pending=${pending.length}`);
+    void drain();
+    if (options.awaitPersistence === true && persistence) {
+      return Promise.resolve(persistence).then((persisted) => {
+        if (persisted !== false) return true;
+        const index = pending.indexOf(entry);
+        // A turn already took the prompt while its durable mirror was being
+        // written: it was delivered, so rejecting it would hand the sender a
+        // copy of a message the model already has.
+        if (index < 0) return true;
+        pending.splice(index, 1);
+        queue.removeQueuedEntries([entry]);
+        if (submissionId) submissions.forget(submissionId);
+        return false;
+      });
+    }
+    return true;
+  };
+}

package/src/tui/session/session-flow/drain-retry.mjs

@@ -0,0 +1,35 @@
+/**
+ * src/tui/session/session-flow/drain-retry.mjs - the re-check timer of a drain
+ * that found a gate closed (drain.mjs). One timer at most, kept on
+ * `flags.blockedDrainRetryTimer`.
+ */
+
+// Re-check cadence for a drain that found a gate closed. A gate is state, not
+// an event: the queue re-reads it instead of trusting that whoever closes it
+// will remember to kick the queue on the way out. Both timers exist only while
+// the queue actually holds work, so an idle session never polls.
+const BLOCKED_DRAIN_RETRY_MS = 50;
+// Session commands (setModel/newSession/resume/auto-clear) release in seconds;
+// an active turn can run for many minutes, so its gate is re-read coarsely.
+export const ACTIVE_TURN_RECHECK_MS = 2_000;
+
+export function createBlockedDrainRetry({ flags, pending, drain }) {
+  function scheduleBlockedDrainRetry(delayMs = BLOCKED_DRAIN_RETRY_MS) {
+    if (pending.length === 0 || flags.disposed) return;
+    if (flags.blockedDrainRetryTimer) return;
+    const timer = setTimeout(() => {
+      flags.blockedDrainRetryTimer = null;
+      if (pending.length > 0) void drain();
+    }, delayMs);
+    if (typeof timer.unref === 'function') timer.unref();
+    flags.blockedDrainRetryTimer = timer;
+  }
+
+  function clearBlockedDrainRetry() {
+    if (!flags.blockedDrainRetryTimer) return;
+    clearTimeout(flags.blockedDrainRetryTimer);
+    flags.blockedDrainRetryTimer = null;
+  }
+
+  return { scheduleBlockedDrainRetry, clearBlockedDrainRetry };
+}