mixdog 1.3.3 → 1.3.5

package/src/session-runtime/boot/begin.mjs

@@ -8,7 +8,7 @@ import { createProviderReadiness } from '../provider-readiness.mjs';
 import { createRoutePreparationGate } from '../route-preparation.mjs';
 import { createRuntimeFeatureGates } from '../runtime-feature-gates.mjs';
 import { createLazyRuntimeModules } from '../runtime-modules.mjs';
-import { normalizeToolProfile } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
+import { sessionToolProfile } from '../../runtime/agent/orchestrator/runtime-core/tool-profile.mjs';
 
 // The boot record: `rt` (shared mutable runtime state, promoted from closure
 // `let`s so extracted modules read/write live values through one reference),
@@ -18,13 +18,14 @@ import { normalizeToolProfile } from '../../runtime/agent/orchestrator/runtime-c
 export function beginBoot(params) {
   const { provider, model, toolMode, cwd, toolProfile, approvalMode, disallowDelegation } = params;
   const rt = {};
-  rt.toolProfile = normalizeToolProfile(toolProfile);
   rt.approvalMode = approvalMode === 'implicit' ? 'implicit' : null;
   rt.disallowDelegation = disallowDelegation === true;
   rt.mcpScopeId = randomUUID();
   rt.desktopSession = params.desktopSession;
   rt.sessionProfile =
     params.sessionProfile && typeof params.sessionProfile === 'object' ? { ...params.sessionProfile } : null;
+  // A heartbeat run's session is fenced to its few tools (tool-profile.mjs).
+  rt.toolProfile = sessionToolProfile({ toolProfile, sessionProfile: rt.sessionProfile });
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
   // Last assistant text handed to the transcript writer (via onAssistantText),
   // so the post-turn final-content append can skip an exact duplicate.

package/src/session-runtime/boot/tools.mjs

@@ -22,6 +22,7 @@ import { TOOL_DEFS as MEDIA_TOOL_DEFS } from '../../runtime/media/tool-defs.mjs'
 import { TOOL_DEFS as TIDY_TOOL_DEFS } from '../../runtime/tidy/tool-defs.mjs';
 import { TOOL_DEFS as VISUALIZE_BRIDGE_TOOL_DEFS } from '../../runtime/visualize-bridge/tool-defs.mjs';
 import { ASK_USER_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/ask-user-tool-defs.mjs';
+import { REACTION_TOOL_DEFS } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
 import { SETUP_TOOL_DEFS } from '../setup-tool/tool-defs.mjs';
 import { createSetupToolExecutor } from '../setup-tool/executor.mjs';
 import { bootProfile } from '../boot-profile.mjs';
@@ -98,6 +99,8 @@ function wireAgent(boot) {
     rt,
     agentTool,
     executeAgentControl: params.executeAgentControl,
+    // Lazy, as above.
+    listProviderModels: (options) => boot.collectProviderModels(options),
   });
   bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
   Object.assign(boot, { agentTool, routedAgentTool, agentStatusState });
@@ -165,6 +168,7 @@ function wireToolSurface(boot) {
     visualizeToolDefs: VISUALIZE_BRIDGE_TOOL_DEFS,
     setupToolDefs: SETUP_TOOL_DEFS,
     askUserToolDefs: ASK_USER_TOOL_DEFS,
+    reactionToolDefs: REACTION_TOOL_DEFS,
     goalTools: goalRuntime.tools,
     agentTools: agentTool.tools,
     skillToolEnabled: !envFlag('MIXDOG_DISABLE_SKILLS'),

package/src/session-runtime/bot-chain.mjs

@@ -0,0 +1,32 @@
+// The bot-to-bot chain a session acts in (bot-hops.mjs botChainOf), from
+// trusted runtime state only: the session's own turn chain (stamped from the
+// submission that started it) and its delegation ancestry (parentSessionId /
+// ownerSessionId), never from tool input.
+import { resolveSessionMode } from '../runtime/agent/orchestrator/session/agent-mode.mjs';
+import { botChainOf, turnBotChainOf } from '../runtime/shared/bot-hops.mjs';
+
+const clean = (value) => String(value ?? '').trim();
+
+/** The agent `session` acts as, by the session-mode resolver: a Lead its
+ *  resolved agent (a coding Lead Mixy), a delegated worker its role. */
+export function actingAgentOf(session, sessionId = '') {
+  const { agentId } = resolveSessionMode({ session, sessionId });
+  return clean(agentId || session?.agent);
+}
+
+/** The chain session `sessionId` acts in, oldest first, ending with the agent
+ *  it acts as (when it has one): walking parentSessionId/ownerSessionId up
+ *  from it, each session contributes its current turn's chain, then the
+ *  agent it acts as. The visited set ends a malformed cycle. */
+export function delegationChainOf(sessionId, getSession = () => null) {
+  const chain = [];
+  const seen = new Set();
+  for (let id = clean(sessionId); id && !seen.has(id); ) {
+    seen.add(id);
+    const session = getSession(id) || null;
+    const acting = actingAgentOf(session, id);
+    chain.unshift(...turnBotChainOf(session), ...(acting ? [acting] : []));
+    id = clean(session?.parentSessionId || session?.ownerSessionId);
+  }
+  return botChainOf(chain);
+}

package/src/session-runtime/bot-status.mjs

@@ -20,7 +20,8 @@
  * — the human's own sessions (Mixy's home, an ordinary Lead session) see every
  * bot; a bot's chat, a room seat or an unattended run (a routine, even one in
  * Mixy's own chat) only its own bot; a background run none. `session list`
- * follows the same scope.
+ * names every session for every scope, but gives previews and bot details
+ * only for the sessions the scope sees here (a background run none).
  *
  * Titles and previews are other bots' words: tag-shaped text is escaped and
  * the answer says they are data, not instructions (UNTRUSTED_NOTE).
@@ -63,8 +64,10 @@ const cut = (text, max) => (text.length > max ? `${text.slice(0, Math.max(0, max
 export const quotedText = (value, max) => cut(escapeHarnessTags(oneLine(value)), max);
 const plural = (count, word) => `${count} ${word}${count === 1 ? '' : 's'}`;
 const outputBytes = (value) => Buffer.byteLength(JSON.stringify(value), 'utf8');
-const isWorking = (row) => row?.working === true || row?.agentWorking === true;
-const activityOf = (row) => Number(row?.lastUsedAt) || Number(row?.updatedAt) || 0;
+/** A catalog row whose session runs a turn now. */
+export const isWorking = (row) => row?.working === true || row?.agentWorking === true;
+/** A catalog row's last activity (epoch ms), 0 when unknown. */
+export const activityOf = (row) => Number(row?.lastUsedAt) || Number(row?.updatedAt) || 0;
 
 /** The bot a catalog row belongs to: its home chat, room seat or task origin; '' for none. */
 export function sessionBotOf(row) {
@@ -309,7 +312,7 @@ export function createBotStatus({
     const parts = [`${quotedText(bot.name, 40)} (${bot.id})`, `chat ${state.homeId}`];
     if (bot.self) parts.push('you');
     parts.push(state.working ? 'working' : 'idle');
-    if (state.flags.length) parts.push(`⚠ ${state.flags.join('; ')}`);
+    if (state.flags.length) parts.push(`attention: ${state.flags.join('; ')}`);
     parts.push(state.lastAt ? `last ${ago(state.lastAt, now)}` : 'no chat yet');
     if (state.running.length) {
       const [first] = state.running;

package/src/session-runtime/channel-config-api.mjs

@@ -3,19 +3,22 @@ import {
   deleteSchedule,
   deleteWebhook,
   getWebhookSecret,
+  renameScheduleHere,
   saveSchedule,
   saveWebhook,
   setScheduleEnabled,
   setWebhookEnabled,
   setWebhookConfigAsync,
   testWebhook,
+  withScheduleRenameReserved,
 } from './services/channel-admin.mjs';
-import { getSchedule, markScheduleFailure, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import { getSchedule, markScheduleFailure, markScheduleSkipped, markScheduleSuccess } from '../runtime/channels/lib/schedules-db.mjs';
+import { scheduleRenameUncertainError } from '../runtime/channels/lib/schedule-errors.mjs';
 import { loadEndpointConfig, readEndpointLastPayload } from '../runtime/channels/lib/webhooks-db.mjs';
 import { webhookEventSummary, webhookRunPrompt } from '../runtime/channels/lib/webhook/session-dispatch.mjs';
 import { runScheduleSession } from './schedule-session-run.mjs';
 import { runWebhookSession } from './webhook-session-run.mjs';
-import { retryRoutineDelivery } from './owned-automation-run.mjs';
+import { beginAutomationRename, retryRoutineDelivery } from './owned-automation-run.mjs';
 
 /** Why a "Run now" did not run: its owner bot is missing, or a run is going. */
 function skippedRunMessage(name, outcome) {
@@ -27,6 +30,36 @@ function skippedRunMessage(name, outcome) {
 // directly here and the runtime injects only the closure-owned callbacks
 // (channel worker handle, soft reload).
 export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAutomationRuntime = () => {} }) {
+  // The channels worker owns the scheduler and the runs it fires, so while it
+  // is up it performs the run check and the row move in one step
+  // (rename_schedule); this process's own runs ("Run now") are reserved around
+  // that call. Without a worker, the check and the move happen here.
+  async function renameSchedule(oldName, def, opts) {
+    if (!channels.status().running) return renameScheduleHere(oldName, def, opts);
+    return withScheduleRenameReserved(oldName, async () => {
+      try {
+        const reply = await channels.execute('rename_schedule', { name: oldName, def, ...opts });
+        const text = reply?.content?.[0]?.text ?? '';
+        if (reply?.isError === true) {
+          // The worker's refusal keeps its structured code and details.
+          throw Object.assign(
+            new Error(text.replace(/^rename_schedule failed: /, '')),
+            typeof reply.code === 'string' ? { code: reply.code } : {},
+            reply.details && typeof reply.details === 'object' ? { details: reply.details } : {}
+          );
+        }
+        return text ? JSON.parse(text) : null;
+      } catch (error) {
+        // Whatever the worker did, have it re-read the schedules.
+        reloadChannelsSoon();
+        // execute() already retried a transport failure (call timeout 120 s,
+        // same callId so the daemon runs the request once); what is left is
+        // an unanswered request.
+        if (error?.daemonTransportError) throw scheduleRenameUncertainError(error.message);
+        throw error;
+      }
+    });
+  }
   return {
     async getChannelSetup() {
       return channelSetup();
@@ -40,7 +73,7 @@ export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAut
       return result;
     },
     async saveSchedule(entry) {
-      const result = await saveSchedule(entry);
+      const result = await saveSchedule(entry, { rename: renameSchedule });
       reloadChannelsSoon();
       // First automation created while the app is already running: the boot-
       // time autostart check has passed, so kick the worker start path now
@@ -86,22 +119,35 @@ export function createChannelConfigApi({ channels, reloadChannelsSoon, ensureAut
     },
     async runScheduleNow(name) {
       const id = String(name || '').trim();
-      const schedule = await getSchedule(id);
-      if (!schedule) throw new Error(`schedule "${id}" does not exist`);
-      // Runs in the engine process as a turn in the owner bot's chat, so it
-      // works even while the channels worker is off.
-      let outcome;
+      // The name is held from the read of the row through the outcome stamps,
+      // so a rename can neither move the row this run read nor slip in before
+      // its stamps are written (they would land on no row).
+      const release = beginAutomationRename('schedule', id);
+      // A run or a rename holding it: not run, recorded as an overlap skip.
+      if (!release) {
+        await markScheduleSkipped(id, new Date()).catch(() => {});
+        throw new Error(skippedRunMessage(id, { reason: 'overlap' }));
+      }
       try {
-        // Asked for by a person: no failure backoff.
-        outcome = await runScheduleSession(schedule, { attended: true });
-      } catch (error) {
-        await markScheduleFailure(schedule.name, new Date()).catch(() => {});
-        throw error;
+        const schedule = await getSchedule(id);
+        if (!schedule) throw new Error(`schedule "${id}" does not exist`);
+        // Runs in the engine process as a turn in the owner bot's chat, so it
+        // works even while the channels worker is off.
+        let outcome;
+        try {
+          // Asked for by a person: no failure backoff.
+          outcome = await runScheduleSession(schedule, { attended: true, reserved: true });
+        } catch (error) {
+          await markScheduleFailure(schedule.name, new Date()).catch(() => {});
+          throw error;
+        }
+        if (outcome.skipped) throw new Error(skippedRunMessage(schedule.name, outcome));
+        // The run's outcome shows as the schedule's last run, like a timed fire.
+        await markScheduleSuccess(schedule.name, new Date()).catch(() => {});
+        return { name: schedule.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
+      } finally {
+        release();
       }
-      if (outcome.skipped) throw new Error(skippedRunMessage(schedule.name, outcome));
-      // The run's outcome shows as the schedule's last run, like a timed fire.
-      await markScheduleSuccess(schedule.name, new Date()).catch(() => {});
-      return { name: schedule.name, ok: true, sessionId: outcome.sessionId, result: outcome.result };
     },
     // Re-runs the endpoint on its latest received payload, with its current
     // instructions, behind the same untrusted-data fence as a live delivery.

package/src/session-runtime/internal-tool-executor/reaction-tool.mjs

@@ -0,0 +1,45 @@
+// react: a bot's emoji reaction on the user's message (message-reactions.mjs).
+// Only a bot's own chat with the user may react: its home chat, where the
+// message is in the chat's own transcript, or its seat in a group room, where
+// the message is the user's row in the room's log. Never a coding session, a
+// delegated worker, or a run nobody attends.
+import { isAgentOwner } from '../../runtime/agent/orchestrator/agent-owner.mjs';
+import { noteReactionTarget, validateReactionArgs } from '../../runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs';
+import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import { roomMemberOfSession, roomSessionId } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+import { reactInSession } from '../../runtime/agent/orchestrator/session/message-reactions.mjs';
+import { agentHomeLiveSurface } from '../agent-home-delivery.mjs';
+import { reactInRoom } from '../agent-room-delivery.mjs';
+import { scheduleCallerScope } from '../services/schedule-access.mjs';
+
+const DONE =
+  'The user sees it under their message. Say nothing about it; reply only if the message also needs an answer.';
+
+export function createReactionToolHandlers({ rt, live = agentHomeLiveSurface, roomReact = reactInRoom }) {
+  return {
+    react: async (args, { callerCtx }) => {
+      const sessionId = callerCtx?.callerSessionId || rt.session?.id || '';
+      const session = rt.session?.id === sessionId ? rt.session : null;
+      const member = roomMemberOfSession(sessionId);
+      const agentId = member?.agentId || agentIdOfHomeSession(sessionId);
+      if (!session || !agentId || isAgentOwner(session)) {
+        throw new Error("react: reactions belong to a bot's own chat with the user");
+      }
+      if (scheduleCallerScope(session).unattended === true) {
+        throw new Error('react: nobody is in this run to see a reaction');
+      }
+      const { emoji, messagesBack } = validateReactionArgs(args);
+      const change = { agentId, emoji, messagesBack };
+      let result;
+      if (member) result = await roomReact(roomSessionId(member.roomId), change);
+      else {
+        result = reactInSession(session, change);
+        // The chat's own turn saves the transcript; its open views show it now.
+        if (result.changed) live()?.react?.(sessionId, result.messageId, result.reactions);
+      }
+      if (!emoji) return result.changed ? 'Removed your reaction.' : 'You had no reaction on that message.';
+      noteReactionTarget(sessionId, callerCtx?.toolCallId, { messageId: result.messageId, room: Boolean(member) });
+      return `Reacted ${emoji}. ${DONE}`;
+    },
+  };
+}

package/src/session-runtime/internal-tool-executor/workspace-tools.mjs

@@ -6,11 +6,17 @@ import { listProjects } from '../../runtime/shared/projects.mjs';
 import { applySessionSidebarChange } from '../../runtime/shared/session-sidebar-host.mjs';
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { AGENT_MODE, resolveSessionMode } from '../../runtime/agent/orchestrator/session/agent-mode.mjs';
-import { agentIdOfHomeSession } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
+import {
+  MIXY_AGENT_ID,
+  agentHomeSessionId,
+  agentIdOfHomeSession,
+} from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { turnHopOf } from '../../runtime/shared/bot-hops.mjs';
+import { isHeartbeatSession } from '../../runtime/shared/routine-trigger.mjs';
 import { scheduleCallerScope } from '../services/schedule-access.mjs';
 import { worktreeCallerScope } from '../services/worktree-access.mjs';
 import { resolveHandoffAttachments, sessionRoots } from '../handoff-attachments.mjs';
+import { delegationChainOf } from '../bot-chain.mjs';
 
 const USER_TITLE_ERROR = 'session: the user already titled this session; the title was not changed';
 
@@ -53,6 +59,14 @@ export function createWorkspaceToolHandlers({
     return rt.session.id;
   };
 
+  // Mixy's hidden heartbeat session (mixy-heartbeat.mjs), by the in-process
+  // mark on the calling session, never by tool input or stored fields.
+  const callerIsHeartbeat = (callerCtx) => isHeartbeatSession(callerCtx?.callerSessionId || rt.session?.id);
+  const HEARTBEAT_NO_HANDOFF =
+    'a heartbeat turn cannot hand work off: its result would reach nobody. Propose it to the user instead (session action suggest).';
+  // What a heartbeat turn does with sessions: read them and the bots, and record proposals.
+  const HEARTBEAT_SESSION_ACTIONS = new Set(['read', 'status', 'list', 'bots', 'suggest']);
+
   const SIDEBAR_ACTIONS = new Set(['favorite', 'archive']);
 
   // Sidebar flags only (the desktop's favorite/archive metadata).
@@ -71,12 +85,26 @@ export function createWorkspaceToolHandlers({
   const session = async (args, { callerCtx, callerCwd }) => {
     const action = clean(args?.action || (args?.path ? 'set-project' : 'status')).toLowerCase();
     const target = clean(args?.session_id);
+    if (callerIsHeartbeat(callerCtx) && !HEARTBEAT_SESSION_ACTIONS.has(action)) {
+      throw new Error(
+        `session: ${
+          action === 'create' || action === 'send'
+            ? HEARTBEAT_NO_HANDOFF
+            : `a heartbeat turn only reads sessions and bots and records proposals; action=${action} is refused`
+        }`
+      );
+    }
     if (
       ['list', 'bots', 'read', 'send', 'cancel', 'delete', 'create'].includes(action) ||
       (action === 'status' && target)
     ) {
       const callerSessionId = assertLead(action, callerCtx);
+      // `callerAgentId`: the bot whose conversation gets results reported
+      // back; `callerBotId`: the bot the caller acts as, attended or not,
+      // for what only a bot's own sessions allow (an effort change).
       const callerAgentId = attendedAgentOf(rt.session);
+      const acting = resolveSessionMode({ session: rt.session });
+      const callerBotId = acting.mode === AGENT_MODE ? acting.agentId : '';
       if (action === 'create' && !callerAgentId) {
         throw new Error(
           'session: create belongs to a bot conversation; delegated workers, agent task sessions and schedule/webhook runs cannot create agent task sessions'
@@ -105,8 +133,24 @@ export function createWorkspaceToolHandlers({
           {
             callerSessionId,
             callerAgentId,
+            callerBotId,
             callerCwd,
-            ...(action === 'send' || action === 'create' ? { callerHop: turnHopOf(rt.session) } : {}),
+            ...(action === 'send' || action === 'create'
+              ? {
+                  callerHop: turnHopOf(rt.session),
+                  // The bot chain this turn acts in (bot-chain.mjs), checked
+                  // against the target and carried to the turn it starts —
+                  // only when the sender is a bot conversation (a bot's chat,
+                  // room seat or run); any other session hands work to any
+                  // bot as before, whatever started its turn (the hop limit
+                  // still bounds a loop).
+                  callerBotChain: callerBotId
+                    ? delegationChainOf(callerSessionId, (id) =>
+                        id === rt.session?.id ? rt.session : getSessionManager()?.getSession?.(id) || null
+                      )
+                    : [],
+                }
+              : {}),
             // Whether a create may provision a worktree (worktree-access.mjs).
             ...(action === 'create' ? { callerScope: worktreeCallerScope(rt.session) } : {}),
             // Which bots and sessions it may see (bot-status.mjs).
@@ -116,6 +160,16 @@ export function createWorkspaceToolHandlers({
         )
       );
     }
+    // Mixy's proposals to the user (mixy-heartbeat.mjs): kept so none repeats.
+    if (action === 'suggest') {
+      const sessionId = assertLead(action, callerCtx);
+      if (sessionId !== agentHomeSessionId(MIXY_AGENT_ID) && !callerIsHeartbeat(callerCtx)) {
+        throw new Error("session: suggest belongs to Mixy's chat");
+      }
+      const { recordSuggestion } = await import('../mixy-heartbeat.mjs');
+      const receipt = recordSuggestion({ key: args?.key, text: args?.title, dismissed: args?.value === false });
+      return JSON.stringify({ action, ...receipt }, null, 2);
+    }
     if (target && target !== assertLead(action, callerCtx)) {
       throw new Error(`session: action=${action} only applies to the current session`);
     }
@@ -184,6 +238,9 @@ export function createWorkspaceToolHandlers({
           project: current?.workspace?.projectPath || current?.desktopSession?.projectPath || currentCwd,
           provider: current?.provider || null,
           model: current?.model || null,
+          effort: current?.effort || null,
+          autoEffort: current?.autoEffort !== false,
+          fast: current?.fast === true,
         },
         null,
         2
@@ -229,12 +286,22 @@ export function createWorkspaceToolHandlers({
 
   return {
     session,
-    goal: async (args, { name, callerCtx }) =>
-      await goalRuntime.executeTool(name, args || {}, {
+    goal: async (args, { name, callerCtx }) => {
+      // A Goal keeps working in its session across turns: a heartbeat's would
+      // run on unseen in the hidden session.
+      if (['create', 'resume'].includes(clean(args?.action).toLowerCase()) && callerIsHeartbeat(callerCtx)) {
+        throw new Error(`goal: ${HEARTBEAT_NO_HANDOFF}`);
+      }
+      return await goalRuntime.executeTool(name, args || {}, {
         callerSessionId: callerCtx?.callerSessionId || rt.session?.id || rt.reservedSessionId || null,
-      }),
+      });
+    },
     agent: async (args, { callerCtx, callerCwd }) => {
       const callerSessionId = callerCtx?.callerSessionId || rt.session?.id || null;
+      // The agent tool's action is `type`, spawn when omitted (agent-tool/execute.mjs).
+      if (['spawn', 'send'].includes((clean(args?.type) || 'spawn').toLowerCase()) && callerIsHeartbeat(callerCtx)) {
+        throw new Error(`agent: ${HEARTBEAT_NO_HANDOFF}`);
+      }
       // `attachmentParts` is never the model's to set: only the resolved
       // `attachments` reach the agent's turn.
       const { attachments, attachmentParts: _ignored, ...rest } = args || {};

package/src/session-runtime/internal-tool-executor.mjs

@@ -10,6 +10,7 @@ import { createAskUserToolHandlers } from './internal-tool-executor/ask-user-too
 import { createBridgeToolHandlers } from './internal-tool-executor/bridge-tools.mjs';
 import { createFeatureToolHandlers } from './internal-tool-executor/feature-tools.mjs';
 import { createKnowledgeToolHandlers } from './internal-tool-executor/knowledge-tools.mjs';
+import { createReactionToolHandlers } from './internal-tool-executor/reaction-tool.mjs';
 import { createWorkspaceToolHandlers } from './internal-tool-executor/workspace-tools.mjs';
 
 export function createInternalToolExecutor({
@@ -40,6 +41,7 @@ export function createInternalToolExecutor({
   const handlers = {
     ...createBridgeToolHandlers({ rt }),
     ...createAskUserToolHandlers({ rt }),
+    ...createReactionToolHandlers({ rt }),
     ...createFeatureToolHandlers({ rt, setupTool, officeToolsEnabled, mediaToolEnabled, tidyToolEnabled }),
     ...createKnowledgeToolHandlers({
       rt,
@@ -80,6 +82,8 @@ export function createInternalToolExecutor({
 
   return async (name, args, callerCtx = {}) => {
     const callerCwd = clean(callerCtx?.callerCwd) || rt.currentCwd;
+    // The Reactions setting gates the tool whoever calls it, not only the model.
+    if (name === 'react' && rt.config?.reactions === false) throw new Error('reactions are turned off in settings');
     if (callerCtx?.invocationSource === 'model-tool') guardModelCall(name);
     if (Object.hasOwn(handlers, name)) return handlers[name](args, { name, callerCtx, callerCwd });
     if (channels.isChannelTool(name)) {

package/src/session-runtime/mcp-glue/server-catalog.mjs

@@ -3,6 +3,7 @@
 // explicit owner metadata), per-server config reads, and the live/failed rollup.
 import { clean } from '../../runtime/agent/orchestrator/runtime-core/session-text.mjs';
 import { connectorOfServer, gmailAppPasswordAccount } from '../../runtime/shared/connector-catalog.mjs';
+import { googleOAuthClient } from '../../runtime/shared/google-oauth-client.mjs';
 import { envFlag } from '../../runtime/shared/env.mjs';
 import { resolveMcpServerCatalog } from './plugin-servers.mjs';
 
@@ -153,6 +154,8 @@ export function createMcpServerCatalog({
       // Gmail connected with an app password: the account it runs as.
       const appPasswordAccount = gmailAppPasswordAccount(cfg);
       if (appPasswordAccount) row.appPassword = { account: appPasswordAccount };
+      // A catalog connector running on the user's own Google client.
+      if (connector && typeof cfg?.oauthClientId === 'string' && cfg.oauthClientId.trim()) row.ownClient = true;
       if (entry.owner) {
         row.owner = entry.owner;
         row.pluginEnabled = entry.pluginEnabled;
@@ -172,7 +175,7 @@ export function createMcpServerCatalog({
 
   function mcpStatus() {
     if (envFlag('MIXDOG_DISABLE_MCP')) {
-      return { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0 };
+      return { servers: [], configuredCount: 0, connectedCount: 0, failedCount: 0, googleClient: Boolean(googleOAuthClient()) };
     }
     const catalog = resolveCatalog();
     const servers = statusRows(catalog);
@@ -186,6 +189,9 @@ export function createMcpServerCatalog({
       failedCount: servers.filter((row) => row.status === 'failed').length,
       warnings: catalog.warnings,
       declarationErrors,
+      // Whether this build carries Mixdog's own Google client (else the
+      // Google sign-ins need the user's own client).
+      googleClient: Boolean(googleOAuthClient()),
     };
   }