mixdog 1.3.4 → 1.3.5

package/src/standalone/daemon-session-control.mjs

@@ -4,7 +4,15 @@ import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.
 import { assertWorktreeMutationAllowed } from '../session-runtime/services/worktree-access.mjs';
 import { createBotStatus, scanCatalog, scopedBot, sessionBotOf } from '../session-runtime/bot-status.mjs';
 import { handoffContent } from '../session-runtime/handoff-attachments.mjs';
-import { BOT_HOP_LIMIT_ERROR, MAX_BOT_HOPS } from '../runtime/shared/bot-hops.mjs';
+import { checkEffort, readModelCatalog } from '../session-runtime/task-session-route.mjs';
+import {
+  BOT_HOP_LIMIT_ERROR,
+  MAX_BOT_HOPS,
+  assertBotChainTarget,
+  botChainOf,
+  rememberSubmissionBotChain,
+} from '../runtime/shared/bot-hops.mjs';
+import { agentIdOfHomeSession } from '../runtime/agent/orchestrator/session/agent-home.mjs';
 import { rebindDelegation } from '../runtime/agent/orchestrator/session/human-gate/delegation.mjs';
 import { isAgentOnlySession } from '../runtime/agent/orchestrator/session/store-summary-visibility.mjs';
 import { readSessionSidebarState } from '../runtime/shared/session-sidebar-host.mjs';
@@ -19,7 +27,13 @@ const TARGET_ACTIONS = new Set(['status', 'read', 'send', 'cancel', 'delete']);
 const MUTATING_ACTIONS = new Set(['send', 'cancel', 'delete']);
 // The workspace methods `worktree` reaches on another session (all on the
 // session protocol's read/configure allowlists).
-const WORKTREE_METHODS = new Set(['getBranchMenu', 'requestWorktree', 'selectBranch', 'mergeWorkspace', 'removeWorktree']);
+const WORKTREE_METHODS = new Set([
+  'getBranchMenu',
+  'requestWorktree',
+  'selectBranch',
+  'mergeWorkspace',
+  'removeWorktree',
+]);
 // Why a send from a conversation that is no bot's reports nothing back.
 const NOT_BOT_REASON = 'only a bot conversation gets session results reported back; check that session for the result';
 
@@ -120,22 +134,25 @@ export function createSessionControl({
         }
       }
       // Scoped like bots (`callerScope`, bot-status.mjs): the human's sessions
-      // list everything, a bot (or its unattended run) only its own sessions,
-      // anything else the plain rows without previews. Sub-agent sessions (a
+      // list everything with previews, a bot (or its unattended run) lists the
+      // same rows (so it can find a session to send to) but only its own carry
+      // the bot, activity, preview and working state, anything else the plain
+      // rows without previews. Sub-agent sessions (a
       // parent finds its own through the agent tool) and archived ones (the
       // desktop's flag) only on request; the scan pages past the rows left
       // out, so a page is never short while more rows match.
       const own = scopedBot(context.callerScope);
       const archived = (await readSessionSidebarState())?.archived ?? {};
       const keep = (row) =>
-        (!own || sessionBotOf(row) === own) &&
         (args.include_agents === true || !isAgentOnlySession(row)) &&
         (args.include_archived === true || !Object.hasOwn(archived, row.id));
       // Bounded: past 10000 rows scanned with fewer than `limit` matching, the
       // page ends (possibly empty) with a nextCursor to continue from.
       const scan = await scanCatalog(service, keep, { cursor: args.cursor || null, want: limit, maxRows: 10_000 });
       const sessions = scan.rows.map((row) => (Object.hasOwn(archived, row.id) ? { ...row, archived: true } : row));
-      return sessionListOutput({ sessions, nextCursor: scan.nextCursor }, limit, { rich: own !== null });
+      return sessionListOutput({ sessions, nextCursor: scan.nextCursor }, limit, {
+        rich: own ? (row) => sessionBotOf(row) === own : own !== null,
+      });
     }
     if (action === 'send') {
       if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
@@ -153,6 +170,15 @@ export function createSessionControl({
       // its member session is the turn that answers and reports.
       const room = roomIdOfSession(sessionId) ? await roomAddressee(sessionId, args) : null;
       if (room?.sessionId === caller) throw new Error('session: send must target another session');
+      // Work goes on to a bot (a room seat's, or a bot's home) only outside
+      // the caller's bot chain (`callerBotChain`, bot-chain.mjs), never back
+      // to the caller's own bot; the turn it starts carries that chain on.
+      const botChain = botChainOf(context.callerBotChain);
+      assertBotChainTarget(
+        room ? room.agentId : agentIdOfHomeSession(sessionId),
+        { chain: botChain, self: context.callerBotId || context.callerAgentId || '' },
+        'session'
+      );
       // An agent conversation's send reports its turn back to the agent's
       // home: a task session it created by its stored origin, any other
       // session by an origin for this send only.
@@ -161,23 +187,58 @@ export function createSessionControl({
       const turnSessionId = room ? room.sessionId : sessionId;
       const from = { sessionId: caller, ...(context.callerAgentId ? { agentId: context.callerAgentId } : {}) };
       // The member's turn carries the send's hop (`transcriptMeta.hop`), so a
-      // chain through the room counts on toward MAX_BOT_HOPS.
+      // chain through the room counts on toward MAX_BOT_HOPS; its bot chain is
+      // recorded under every submission id that turn may take.
       const submit = room
-        ? async ({ id, onSettled, follow, transcriptMeta } = {}) => ({
-            accepted:
-              (await room.host.ask(sessionId, {
-                agentId: room.agentId,
-                prompt,
-                from,
-                ...(id ? { id } : {}),
-                ...(transcriptMeta?.hop > 0 ? { hop: transcriptMeta.hop } : {}),
-                ...(onSettled ? { onSettled } : {}),
-                ...(follow ? { follow } : {}),
-              })) === true,
-          })
+        ? async ({ id, onSettled, follow, transcriptMeta } = {}) => {
+            rememberSubmissionBotChain(id, transcriptMeta?.botChain);
+            const followed = follow
+              ? (submissionId) => {
+                  rememberSubmissionBotChain(submissionId, transcriptMeta?.botChain);
+                  return follow(submissionId);
+                }
+              : null;
+            return {
+              accepted:
+                (await room.host.ask(sessionId, {
+                  agentId: room.agentId,
+                  prompt,
+                  from,
+                  ...(id ? { id } : {}),
+                  ...(transcriptMeta?.hop > 0 ? { hop: transcriptMeta.hop } : {}),
+                  ...(onSettled ? { onSettled } : {}),
+                  ...(followed ? { follow: followed } : {}),
+                })) === true,
+            };
+          }
         : null;
       const addressed = room ? { to: room.agentId } : {};
       let origin = await agentTasks.reportOrigin(turnSessionId, context.callerAgentId, caller);
+      // `effort` is the menu's effort pick on the target: checked now against the
+      // levels of its model, applied just before the prompt is queued.
+      let applyEffort = async () => {};
+      if (args.effort !== undefined) {
+        if (room) throw new Error('session: effort applies to a session, not a group room');
+        // Any bot, attended or not (`callerBotId`), changes only the task
+        // sessions it created; reports go only to a bot conversation.
+        const botId = context.callerBotId || context.callerAgentId || '';
+        if (botId && (await agentTasks.reportOrigin(sessionId, botId, caller))?.target === 'session') {
+          throw new Error('session: a bot may set the effort only of the task sessions it created');
+        }
+        const target = (await service.readSession({ sessionId, transcriptItemLimit: 1 })).full;
+        if (!target) throw new Error(`session: ${sessionId} is unavailable`);
+        const level = checkEffort(args.effort, target, await readModelCatalog(service, caller));
+        // sessionOnly: the session's route changes, never the user's saved model settings.
+        applyEffort = async () => {
+          const applied = await service.configureSession(
+            { sessionId, action: 'setEffort', args: [level, { sessionOnly: true }] },
+            { revision: 1 }
+          );
+          if (applied?.value === false) {
+            throw new Error(`session: ${sessionId} is busy with another command; effort not changed`);
+          }
+        };
+      }
       // A send made in a bot-descended turn (`callerHop` > 0), or by a bot to
       // another session, extends the chain by one; a bot's own task session
       // only continues it. Refused past the limit, whatever the target.
@@ -189,13 +250,17 @@ export function createSessionControl({
       if (origin) {
         const hop = chained(origin.target === 'session' ? turnHop + 1 : turnHop);
         if (hop > 0) origin = { ...origin, hop };
+        if (botChain.length) origin = { ...origin, botChain };
         // The task session a bot created acts as the sending conversation does
         // from now on (attended chat or run); another's session keeps its own.
         if (origin.target !== 'session') await rebindDelegation(sessionId, caller);
+        await applyEffort();
         const sent = await agentTasks.send(turnSessionId, prompt, origin, submit);
         return { sessionId, ...addressed, ...sent, ...(hop > 0 ? { hop } : {}) };
       }
       const hop = turnHop > 0 ? chained(turnHop + 1) : 0;
+      await applyEffort();
+      const chainMeta = { ...(hop > 0 ? { hop } : {}), ...(botChain.length ? { botChain } : {}) };
       let accepted;
       if (submit) accepted = (await submit(hop > 0 ? { transcriptMeta: { hop } } : {})).accepted;
       else {
@@ -204,7 +269,7 @@ export function createSessionControl({
         const result = await service.submitSession({
           sessionId,
           prompt,
-          options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...(hop > 0 ? { hop } : {}) } },
+          options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...chainMeta } },
         });
         accepted = result.accepted === true;
       }
@@ -256,6 +321,9 @@ export function createSessionControl({
       cwd: snapshot.cwd ?? null,
       provider: snapshot.provider ?? null,
       model: snapshot.model ?? null,
+      effort: snapshot.effort ?? null,
+      autoEffort: snapshot.autoEffort ?? null,
+      fast: snapshot.fast ?? null,
       busy: snapshot.busy === true,
       quotaResume: snapshot.quotaResume ?? null,
     };

package/src/standalone/daemon.mjs

@@ -1001,6 +1001,8 @@ async function main() {
   setAgentHomeLiveSurface({
     busy: (sessionId) => sessionService.liveSessionBusy(sessionId),
     notice: (sessionId, notice) => sessionService.pushLiveSessionNotice(sessionId, notice),
+    // A bot's emoji reaction on a user message (message-reactions.mjs).
+    react: (sessionId, messageId, reactions) => sessionService.setLiveMessageReactions(sessionId, messageId, reactions),
     // A task session's result (session create): the agent relays it in one
     // turn. Resolves false when the turn was refused, else `{ settled }`, the
     // turn's end status ('done' when it finished).
@@ -1027,6 +1029,12 @@ async function main() {
       (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
     abort: (sessionId) => sessionService.abortSession({ sessionId }),
   });
+  // Mixy's 30-minute heartbeat check (mixy-heartbeat.mjs), on an unref'd timer.
+  import('../session-runtime/mixy-heartbeat.mjs')
+    .then(({ startMixyHeartbeat }) =>
+      startMixyHeartbeat({ getSessionService: () => sessionService, log: (line) => log(`heartbeat: ${line}`) })
+    )
+    .catch((error) => log(`heartbeat start failed: ${error?.message || error}`));
   // Results queued before a restart are posted now; results a finished run
   // could not queue (kept on its routine's record) are queued again.
   recoverScheduleResults().catch((error) => log(`routine results recovery failed: ${error?.message || error}`));

package/src/standalone/session-protocol.mjs

@@ -47,6 +47,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaHistory',
   'getRecapSettings',
   'getSessionTitleSettings',
+  'getHeartbeatSettings',
+  'getReactionSettings',
   'getLeadAppearance',
   'getBotOrder',
   'getWebSearchRoute',
@@ -134,6 +136,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteMediaAssets',
   'deleteSchedule',
   'saveCustomProvider',
+  'saveCustomProviderKey',
   'removeCustomProvider',
   'updateCustomProviderModel',
   'setModelPreferences',
@@ -238,6 +241,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProgressHint',
   'setRecapEnabled',
   'setAiSessionTitles',
+  'setHeartbeatEnabled',
+  'setReactionsEnabled',
   'setLeadAppearance',
   'setBotOrder',
   'setRoute',

package/src/standalone/session-service/agent-tree/agent-cancel.mjs

@@ -64,9 +64,10 @@ export function createAgentCancellation({
         if (typeof closeCanonical !== 'function') {
           throw new TypeError('session runtime must implement closeCanonicalSession');
         }
+        const wasRunning = descriptor.status === 'running';
         // The close clears the transcript: capture a running turn's transcript
         // first so the cancelled turn still hands off its partial output.
-        if (descriptor.status === 'running') {
+        if (wasRunning) {
           try {
             const { messages } = await entry.runtime.readModelMessages(0);
             rememberCancelTranscript(id, messages);
@@ -77,7 +78,10 @@ export function createAgentCancellation({
         const closed = await closeCanonical.call(entry.runtime, reason, { tombstone: options.tombstone === true });
         if (closed !== true) throw new Error(`agent session ${id} could not be durably closed`);
         descriptor.closed = options.tombstone === true;
-        descriptor.status = descriptor.closed ? 'closed' : 'cancelled';
+        // Only a close that stopped a running turn is a cancellation; closing a
+        // finished agent (cleanup after its handoff) keeps its last status.
+        if (descriptor.closed) descriptor.status = 'closed';
+        else if (wasRunning) descriptor.status = 'cancelled';
         descriptor.stage = descriptor.status;
         descriptor.updatedAt = Date.now();
         return true;

package/src/standalone/session-service/session-calls/session-turns.mjs

@@ -128,6 +128,12 @@ export function createSessionTurnCalls(ctx) {
     const accepted = await Promise.resolve(target.call(entry.runtime, intake.prompt, submissionOptions));
     if (accepted === true) {
       entry.reservedOnly = false;
+      if (isUserTurn(submissionOptions)) {
+        // The user is active: Mixy's due heartbeat check waits for quiet.
+        void import('../../../session-runtime/mixy-heartbeat.mjs')
+          .then(({ noteUserTurn }) => noteUserTurn())
+          .catch((error) => log(`heartbeat activity note failed: ${error?.message || error}`));
+      }
       if (isAgentHomeSessionId(id) && isUserTurn(submissionOptions)) {
         // The user spoke in this agent's home: its round trips with other
         // sessions count from zero again, so a capped thread wakes again.

package/src/standalone/session-service.mjs

@@ -274,6 +274,18 @@ export function createSessionService({
     return true;
   }
 
+  /** Show the reactions now on message `messageId` in the hosted runtime of
+   *  `sessionId` and publish them to its views; false when no runtime hosts
+   *  it or its live rows do not hold that message. */
+  function setLiveMessageReactions(sessionId, messageId, reactions) {
+    const owner = projection.sessionOwner(sessionId);
+    if (typeof owner?.runtime?.setMessageReactions !== 'function') return false;
+    if (!owner.runtime.setMessageReactions(messageId, reactions)) return false;
+    const step = projection.advance(owner);
+    if (step.changed) projection.publishStep(owner, step);
+    return true;
+  }
+
   function getStatus() {
     const busy = retention.liveBusyCount();
     let watched = 0;
@@ -322,6 +334,7 @@ export function createSessionService({
       liveSessionBusy,
       liveSessionAwaitingApproval,
       pushLiveSessionNotice,
+      setLiveMessageReactions,
       stop,
       startQuotaResume: () => quotaResume?.start(),
       runDueQuotaResumes: () => quotaResume?.tick() ?? Promise.resolve(),

package/src/standalone/session-tool-output.mjs

@@ -13,20 +13,23 @@ const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
 
 /** Keep catalog paging authoritative even when the output budget shortens a page.
  *  `rich` adds the owning bot, last activity, latest line and working state
- *  (never for a background caller: bot-status.mjs scopedBot). */
+ *  (never for a background caller: bot-status.mjs scopedBot). `rich` may be a
+ *  per-row predicate: a bot gets them only for its own sessions. */
 export function sessionListOutput(page, limit, { rich = true } = {}) {
   const raw = page.sessions;
   const sessions = raw.slice(0, limit).map((row) => {
+    // Decided first: a session that is not the caller's carries its real
+    // title only, never a preview standing in for it.
+    const own = typeof rich === 'function' ? rich(row) : rich;
+    const title = own ? row.title || row.preview : row.title;
     const base = {
       id: row.id,
-      ...(row.title || row.preview
-        ? { title: escapeHarnessTags(truncateToolText(row.title || row.preview, 160)) }
-        : {}),
+      ...(title ? { title: escapeHarnessTags(truncateToolText(title, 160)) } : {}),
       ...(row.status ? { status: row.status } : {}),
       ...(row.cwd ? { cwd: row.cwd } : {}),
       ...(row.archived === true ? { archived: true } : {}),
     };
-    if (!rich) return base;
+    if (!own) return base;
     // The bot it belongs to: its chat, room seat or the task's creator.
     const bot = sessionBotOf(row);
     const lastUsedAt = Number(row.lastUsedAt) || 0;

package/src/tui/app/model-options.mjs

@@ -173,6 +173,7 @@ const PROVIDER_DISPLAY_NAMES = new Map([
   ['command-code-oauth', 'Command Code'],
   ['mimo-oauth', 'MiMo'],
   ['cursor-oauth', 'Cursor OAuth'],
+  ['devin-oauth', 'Devin'],
   ['antigravity-oauth', 'Antigravity OAuth'],
   ['openai', 'OpenAI API'],
   ['openai-api', 'OpenAI API'],
@@ -279,6 +280,7 @@ const PROVIDER_DISPLAY_RANKS = {
   'mimo-oauth': 34,
   'antigravity-oauth': 31,
   'cursor-oauth': 32,
+  'devin-oauth': 32.5,
   'opencode-go-oauth': 34.5,
   openai: 40,
   'openai-api': 40,

package/src/tui/dist/index.mjs

@@ -51347,6 +51347,7 @@ var PROVIDER_CATALOGS = Object.freeze({
     rosterLimitsAuthoritative: true
   },
   "cursor-oauth": { relay: true },
+  "devin-oauth": { relay: true },
   "cursor-api": { relay: true },
   // The models.dev listing id of the Go gateway: a relay catalog, not a
   // selectable provider (the model lookup needs it flagged as a relay).
@@ -59670,6 +59671,7 @@ var PROVIDER_DISPLAY_NAMES = /* @__PURE__ */ new Map([
   ["command-code-oauth", "Command Code"],
   ["mimo-oauth", "MiMo"],
   ["cursor-oauth", "Cursor OAuth"],
+  ["devin-oauth", "Devin"],
   ["antigravity-oauth", "Antigravity OAuth"],
   ["openai", "OpenAI API"],
   ["openai-api", "OpenAI API"],
@@ -59754,6 +59756,7 @@ var PROVIDER_DISPLAY_RANKS = {
   "mimo-oauth": 34,
   "antigravity-oauth": 31,
   "cursor-oauth": 32,
+  "devin-oauth": 32.5,
   "opencode-go-oauth": 34.5,
   openai: 40,
   "openai-api": 40,
@@ -62131,12 +62134,30 @@ function markUserDataInitialized(dataDir2) {
 }
 var ensuredDataDirs = /* @__PURE__ */ new Set();
 function ensureUserDataInitialized(dataDir2) {
-  if (!dataDir2) return;
+  if (!dataDir2 || skipBackups()) return;
   const key = normalizeDataDir(dataDir2);
   if (ensuredDataDirs.has(key)) return;
-  if (!hasUserDataInitMarker(dataDir2)) backupUserData(dataDir2, "initial-snapshot");
+  if (!hasPublishedBackup(dataDir2)) {
+    backupUserData(dataDir2, "initial-snapshot");
+    if (!hasPublishedBackup(dataDir2)) return;
+  }
   ensuredDataDirs.add(key);
 }
+function hasPublishedBackup(dataDir2) {
+  const instanceId = readInitInstanceId(dataDir2);
+  if (!instanceId) return false;
+  const key = normalizeDataDir(dataDir2);
+  const scopeDir = scopeDirFor(dataDir2);
+  return listBackupDirsNewestFirst(scopeDir).some((name) => {
+    try {
+      const manifest = JSON.parse(readFileSync10(manifestPath(scopeDir, name), "utf8"));
+      return typeof manifest?.dataDir === "string" && normalizeDataDir(manifest.dataDir) === key && manifest.instanceId === instanceId;
+    } catch (error) {
+      if (isAbsentBackupError(error)) return false;
+      throw error;
+    }
+  });
+}
 function skipBackups() {
   return process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "1" || process.env.MIXDOG_SKIP_USER_DATA_BACKUP === "true";
 }
@@ -62270,6 +62291,7 @@ var {
   setSecret: _setSecret,
   deleteSecret: _deleteSecret,
   hasSecret: _hasSecret,
+  hasFallbackSecret: _hasFallbackSecret,
   setSecretAsync: _setSecretAsyncImpl,
   deleteSecretAsync: _deleteSecretAsyncImpl,
   keychainStatus: _keychainStatus,

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 &&