mixdog 1.3.3 → 1.3.5

package/src/tui/session/notice-surface.mjs

@@ -35,10 +35,26 @@ export function createNoticeSurface({ getState, set, isDisposed, pushItem, repla
     // A routine result is a finished sentence, never a raw error to polish;
     // a group-room row is someone's words, kept verbatim (a pass has none).
     const value =
-      options.routine || options.room || options.heldRequest ? String(text ?? '').trim() : polishNoticeText(text);
+      options.routine || options.room || options.heldRequest || options.assistant
+        ? String(text ?? '').trim()
+        : polishNoticeText(text);
     if (!value && !options.room) return null;
     const forceTranscript = options.transcript === true;
     if (!forceTranscript) return pushToast(value, tone, options.ttlMs, options);
+    // The agent's own message posted outside a turn (agent-home-delivery.mjs):
+    // its reply row, as the stored message restores.
+    if (options.assistant) {
+      const id = options.messageId || nextId();
+      pushItem({
+        kind: 'assistant',
+        id,
+        text: value,
+        streaming: false,
+        at: Date.now(),
+        ...(options.messageId ? { messageId: options.messageId } : {}),
+      });
+      return id;
+    }
     const userRow = options.room?.kind === 'user';
     // A room user row keeps its message id (the sender's submission id), as a
     // turn's own prompt row keeps its submission id.

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/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,18 @@ export function createSessionSettingsApi(bag) {
     setAiSessionTitles: withCommandLock(async (enabled) => {
       return await runtime.setAiSessionTitles?.(enabled);
     }),
+    getHeartbeatSettings: () => {
+      return runtime.getHeartbeatSettings?.() || { heartbeat: true };
+    },
+    setHeartbeatEnabled: withCommandLock(async (enabled) => {
+      return await runtime.setHeartbeatEnabled?.(enabled);
+    }),
+    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/turn-stream.mjs

@@ -40,6 +40,9 @@ export function createTurnStream(deps) {
     // (`commentary` / `final_answer`), or null; the desktop row carries it.
     phase: null,
     thinkingText: '',
+    // Length of thinkingText when the current provider send began: a
+    // `reasoning` retraction drops only what that send added.
+    thinkingSendMark: 0,
     thinkingStartedAt: 0,
     thinkingSegmentStartedAt: 0,
     accumulatedThinkingMs: 0,
@@ -492,9 +495,20 @@ export function appendReasoningDelta(stream, chunk) {
   scheduleStreamFlush(stream);
 }
 
+// A provider send (one model request of the turn) begins: the thinking so far
+// belongs to earlier sends and survives a retraction of this one.
+export function markThinkingSendStart(stream) {
+  stream.thinkingSendMark = stream.thinkingText.length;
+}
+
 export function resetStreamedText(stream, { chars, reasoning } = {}) {
   const count = Math.max(0, Number(chars) || 0);
-  if (reasoning) endThinkingForText(stream);
+  if (reasoning) {
+    endThinkingForText(stream);
+    // The discarded attempt's thinking must not prefix the next attempt's;
+    // earlier sends' thinking stays.
+    stream.thinkingText = stream.thinkingText.slice(0, stream.thinkingSendMark);
+  }
   if (!count) return reasoning === true;
   flushStreamBatch(stream);
   stream.assistantText = stream.assistantText.slice(0, Math.max(0, stream.assistantText.length - count));
@@ -529,6 +543,8 @@ export function resetStreamedText(stream, { chars, reasoning } = {}) {
 // tool phase (`spinnerMode`: 'task-wait' or 'tool-use').
 export function closeThinkingForToolBatch(stream, spinnerMode) {
   const { getState, set } = stream;
+  // The send that produced this batch is complete; its thinking is kept.
+  markThinkingSendStart(stream);
   if (stream.thinkingText && getState().thinking) {
     const thinkingLastEndedAt = closeThinkingSegment(stream);
     set({

package/src/tui/session/turn.mjs

@@ -23,6 +23,10 @@ import { isRejected429 } from '../../runtime/shared/error-presentation.mjs';
 import { QUOTA_KINDS, providerErrorKind } from '../../runtime/agent/orchestrator/providers/provider-error-kind.mjs';
 import { turnFailureRecord } from '../../runtime/agent/orchestrator/session/turn-failure.mjs';
 import { registerTaskWaitSteeringCheck } from '../../runtime/agent/orchestrator/session/task-wait-control.mjs';
+import {
+  isReactionSuccess,
+  reactionCallIds,
+} from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { promptDisplayText, STEERING_SUPPRESSED_DISPLAY } from './queue-helpers.mjs';
 import { yieldToRenderer } from './render-timing.mjs';
 import { archiveItemsForCompaction, compactionArchivedRows } from './compaction-view.mjs';
@@ -35,6 +39,7 @@ import {
   appendTextDelta,
   appendAssistantText,
   appendReasoningDelta,
+  markThinkingSendStart,
   noteAssistantPhase,
   resetStreamedText,
   applyStageChange,
@@ -152,6 +157,9 @@ function beginTurn({ flags, getState, transcriptRouteMetadata }, options) {
     askResult: null,
     finishedNormally: false,
     transcriptCompacted: false,
+    // Ids of this turn's react calls; `reacted` is set once one succeeds.
+    reactionCallIds: new Set(),
+    reacted: false,
   };
 }
 
@@ -403,10 +411,15 @@ export function toolHandlers(ctx) {
       if (isCurrentTurn()) settleSegmentBeforeToolCall(ctx);
     },
     onToolCall: async (_iter, calls) => {
-      if (isCurrentTurn()) await openToolCalls(ctx, calls);
+      if (!isCurrentTurn()) return;
+      for (const id of reactionCallIds(calls)) ctx.turn.reactionCallIds.add(id);
+      await openToolCalls(ctx, calls);
     },
     onToolResult: (message) => {
       if (!isCurrentTurn()) return;
+      // A reaction that landed on the user's message is this turn's output
+      // even with no reply text; a rejected or failed react call is not.
+      if (isReactionSuccess(message, ctx.turn.reactionCallIds)) ctx.turn.reacted = true;
       try {
         options.onToolResult?.(message);
       } catch {}
@@ -440,7 +453,9 @@ export function streamHandlers(ctx) {
   const { isCurrentTurn, stream } = ctx;
   return {
     onProviderSendStarted: () => {
-      if (isCurrentTurn()) markLiveCallRequestStart(stream);
+      if (!isCurrentTurn()) return;
+      markThinkingSendStart(stream);
+      markLiveCallRequestStart(stream);
     },
     onStageChange: async (stage, detail = null) => {
       if (!isCurrentTurn()) return;
@@ -554,6 +569,9 @@ export function turnDoneItem({ turn, stream, cards, getState, nextId }) {
     outputTokens: finalOutputTokens(stream, getState().spinner?.outputTokens),
     thinkingElapsedMs: stream.thinkingStartedAt ? stream.accumulatedThinkingMs : 0,
     toolCount: cards.toolCards.length,
+    // Its answer may be a reaction alone: readers of the turn's final answer
+    // take it as done with nothing to say (session-final-answer.ts).
+    ...(turn.reacted ? { reacted: true } : {}),
     verb: turn.completionVerb,
     at: Date.now(),
     ...(turn.failureDetail ? { detail: turn.failureDetail } : {}),
@@ -577,9 +595,11 @@ function publishTurnClose(ctx, closingItems) {
   const assistantOutput = (stream.currentAssistantText || stream.assistantText || '').trim();
   // Suppress only true pending-resume no-ops: no transcript items added and
   // no model output; cancelled/error turns and any visible turn stay marked.
+  // A turn whose only output was a reaction ends with its turndone row too.
   const isNoOpTurn =
     turn.finishedNormally &&
     !turn.cancelled &&
+    !turn.reacted &&
     cards.toolCards.length === 0 &&
     !resultContent &&
     !assistantOutput &&

package/src/vendor/statusline/src/gateway/claude-current.mjs

@@ -5,7 +5,6 @@ import { getModelMetadataSync } from '../../../../runtime/shared/llm/model-catal
 import { providerCachedModelsSync } from '../../../../runtime/shared/llm/provider-catalog-cache.mjs';
 
 export const CLAUDE_CURRENT_MODE = 'claude-current';
-export const CLAUDE_CURRENT_CHOICE_ID = 'claude-current';
 
 const DEFAULT_FAMILY_MODEL = Object.freeze({
   opus: 'claude-opus-4-8',
@@ -20,7 +19,6 @@ const EFFORT_BUDGET = Object.freeze({
   xhigh: 32768,
   max: 32768,
 });
-const SNAPSHOT_REFRESH_MS = 30_000;
 
 function cleanString(v) {
   return typeof v === 'string' && v.trim() ? v.trim() : '';
@@ -33,15 +31,6 @@ export function isMixdogModelSelection(value) {
   return cleanString(raw).toLowerCase().startsWith('mixdog/');
 }
 
-export function isClaudeNativeModelSelection(route) {
-  return !!(
-    route &&
-    route.provider === 'anthropic-oauth' &&
-    cleanString(route.model) &&
-    !isMixdogModelSelection(route)
-  );
-}
-
 function num(v, fallback = null) {
   if (v === null || v === undefined || v === '') return fallback;
   const n = Number(v);
@@ -80,23 +69,6 @@ function readFreshJsonFile(file, maxAgeMs) {
   }
 }
 
-function snapshotEquivalent(a, b) {
-  if (!a || !b) return false;
-  const keys = [
-    'mode',
-    'source',
-    'provider',
-    'model',
-    'requestedModel',
-    'modelDisplay',
-    'effort',
-    'fast',
-    'thinkingBudgetTokens',
-    'contextWindow',
-  ];
-  return keys.every(k => (a[k] ?? null) === (b[k] ?? null));
-}
-
 // The newest roster model of a family, by the roster's own release stamps.
 function newestRosterModel(family) {
   const stamp = (row) => Date.parse(row.releaseDate) || (Number(row.created) > 0 ? Number(row.created) : 0);
@@ -298,33 +270,3 @@ export function readClaudeCodeCurrentRoute({ request = null, maxAgeMs = 10 * 60
   if (route.fast === null || route.fast === undefined) route.fast = false;
   return route;
 }
-
-export function writeClaudeCodeCurrentSnapshot(ccJsonInput) {
-  if (!ccJsonInput) return null;
-  let payload = null;
-  try { payload = JSON.parse(String(ccJsonInput)); } catch { return null; }
-  const route = routeFromPayload(payload, 'statusline');
-  if (!route || (!route.model && !route.requestedModel)) return null;
-  const file = path.join(pluginDataDir(), 'claude-current-model.json');
-  try {
-    fs.mkdirSync(path.dirname(file), { recursive: true });
-    const st = fs.existsSync(file) ? fs.statSync(file) : null;
-    const current = st ? readJsonFile(file) : null;
-    if (
-      st &&
-      Date.now() - st.mtimeMs < SNAPSHOT_REFRESH_MS &&
-      snapshotEquivalent(current, route)
-    ) {
-      return route;
-    }
-    fs.writeFileSync(file, JSON.stringify(route, null, 2) + '\n');
-  } catch { /* best-effort statusline cache */ }
-  return route;
-}
-
-export function formatClaudeCurrentChoiceLabel(route = readClaudeCodeCurrentRoute()) {
-  const parts = [`Current selection: ${route.modelDisplay || route.model || 'current model'}`];
-  if (route.effort) parts.push(String(route.effort).toUpperCase());
-  if (route.fast === true) parts.push('fast');
-  return parts.join(' · ');
-}