mixdog 1.3.4 → 1.3.5

package/src/runtime/agent/orchestrator/runtime-core/reaction-tool-defs.mjs

@@ -0,0 +1,133 @@
+// react: a bot's emoji reaction on the user's message, shown under the user's
+// bubble the way a messenger shows one. Offered only in a bot's own chat with
+// the user (its home chat or its seat in a group room) while the Reactions
+// setting is on (session-tool-surface.mjs, builtin-features.mjs).
+export const REACTION_TOOL_NAME = 'react';
+
+/** The reactions a bot can leave, in the order the schema lists them. */
+export const REACTION_EMOJI = Object.freeze(['❤️', '👍', '✔️', '😆', '😮', '😢', '🙏']);
+const MESSAGES_BACK_MAX = 20;
+
+export const REACTION_TOOL_DEFS = Object.freeze([
+  {
+    name: REACTION_TOOL_NAME,
+    title: 'React',
+    trigger: "Leave one emoji reaction on the user's message, as a chat app shows one under it.",
+    description:
+      "Leave one emoji reaction under the user's message. Two uses only. Instead of a reply: when the message needs no words back (ok, got it, agreement, thanks, a done update), react alone with no reply text, when the reaction fully answers, instead of a filler reply like 'sounds good'. As emphasis: on clear good or sad news or something truly funny, react and still reply as the message needs; keep this rare, about once per 5-10 exchanges. Otherwise none: never react to questions or requests needing real content, never on two messages in a row, never as a status signal, and never mention or explain a reaction. ❤️ warmth or good news, 👍 agreement or ok, ✔️ done or noted, 😆 funny, 😮 surprising, 😢 sad, 🙏 thanks. In a group room, react only to messages for you, never repeating one another member left. Reacting again replaces yours.",
+    annotations: {
+      title: 'React',
+      readOnlyHint: false,
+      destructiveHint: false,
+      idempotentHint: true,
+      openWorldHint: false,
+      agentHidden: true,
+    },
+    inputSchema: {
+      type: 'object',
+      properties: {
+        emoji: { type: 'string', description: `One of ${REACTION_EMOJI.join(' ')}.` },
+        messages_back: {
+          type: 'integer',
+          minimum: 0,
+          maximum: MESSAGES_BACK_MAX,
+          description: "0 or omitted: the user's latest message; 1: the one before it, and so on.",
+        },
+        remove: { type: 'boolean', description: 'Remove your reaction instead.' },
+      },
+      additionalProperties: false,
+    },
+  },
+]);
+
+const bare = (text) => text.replace(/\uFE0F/g, '');
+
+/** The reaction `value` names (a missing or extra U+FE0F tolerated), or ''. */
+export function reactionEmoji(value) {
+  const text = typeof value === 'string' ? bare(value.trim()) : '';
+  return (text && REACTION_EMOJI.find((emoji) => bare(emoji) === text)) || '';
+}
+
+/** `{ emoji, messagesBack }` of a react call (`emoji` '' removes); throws on
+ *  anything else. */
+export function validateReactionArgs(args) {
+  const input = args && typeof args === 'object' ? args : {};
+  const back = input.messages_back ?? 0;
+  if (!Number.isInteger(back) || back < 0 || back > MESSAGES_BACK_MAX) {
+    throw new Error(`react: messages_back is a whole number from 0 to ${MESSAGES_BACK_MAX}`);
+  }
+  if (input.remove === true) return { emoji: '', messagesBack: back };
+  const emoji = reactionEmoji(input.emoji);
+  if (!emoji) throw new Error(`react: emoji must be exactly one of ${REACTION_EMOJI.join(' ')}`);
+  return { emoji, messagesBack: back };
+}
+
+/** Whether a provider tool call (direct, or bridged through call_tool) is a react call. */
+function isReactionToolCall(call) {
+  const name = call?.name ?? call?.function?.name;
+  if (name === REACTION_TOOL_NAME) return true;
+  return name === 'call_tool' && call?.arguments?.name === REACTION_TOOL_NAME;
+}
+
+/** The ids of a batch's react calls. */
+export function reactionCallIds(calls) {
+  return new Set(
+    (calls || [])
+      .filter(isReactionToolCall)
+      .map((call) => call?.id)
+      .filter(Boolean)
+  );
+}
+
+// What each successful react call actually hit, keyed by session and tool
+// call id: the tool result reaches the loop as plain text (internal-tools.mjs
+// normalizes every handler return to a string), so this is the result's
+// metadata side channel. `{ messageId, room }`: the id of the message
+// reactToMessage reacted on, and whether that log is a group room's (a
+// separate transcript from the worker's own).
+//
+// A record belongs to the loop of its session: the batch that ran the call
+// consumes it (takeReactionTarget), agentLoop clears the session's leftovers
+// whenever it ends, success or not (clearReactionTargets), and the cap bounds
+// the map even if neither ever ran.
+const REACTION_TARGET_CAP = 256;
+const reactionTargets = new Map();
+const targetKey = (sessionId, toolCallId) => `${sessionId}\u0000${toolCallId}`;
+
+/** Records the message a successful react call landed on. */
+export function noteReactionTarget(sessionId, toolCallId, target) {
+  if (!sessionId || !toolCallId || !target?.messageId) return;
+  reactionTargets.set(targetKey(sessionId, toolCallId), target);
+  if (reactionTargets.size > REACTION_TARGET_CAP) reactionTargets.delete(reactionTargets.keys().next().value);
+}
+
+/** Drops every record of `sessionId`: its loop has ended. */
+export function clearReactionTargets(sessionId) {
+  const prefix = `${sessionId}\u0000`;
+  for (const key of reactionTargets.keys()) if (key.startsWith(prefix)) reactionTargets.delete(key);
+}
+
+/** How many records are held (tests). */
+export function reactionTargetCount() {
+  return reactionTargets.size;
+}
+
+/** The recorded target of a react call, consumed; null when it recorded none. */
+export function takeReactionTarget(sessionId, toolCallId) {
+  const key = targetKey(sessionId, toolCallId);
+  const target = reactionTargets.get(key) ?? null;
+  reactionTargets.delete(key);
+  return target;
+}
+
+/** Whether a tool result reports one of `ids` (reactionCallIds) as executed
+ *  and succeeded: a rejected, denied, skipped or failed call is not a reaction,
+ *  and neither is an early UI-only notify that precedes the real result. */
+export function isReactionSuccess(message, ids) {
+  return (
+    message?.role === 'tool' &&
+    message.__earlyNotify !== true &&
+    message.toolKind === 'normal' &&
+    ids.has(message.toolCallId)
+  );
+}

package/src/runtime/agent/orchestrator/runtime-core/tool-catalog-data.mjs

@@ -77,6 +77,9 @@ export const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
   // Always on the Lead surface (native and bridge alike): a question is an
   // optional move the model skips when it costs a load or call_tool hop.
   'ask_user',
+  // A bot's reaction, likewise: only a bot's chat with the user has it at all
+  // (session-tool-surface.mjs reactionDisabled).
+  'react',
   'Skill',
   'load_tool',
 ]);

package/src/runtime/agent/orchestrator/runtime-core/tool-defs.mjs

@@ -73,7 +73,8 @@ export const SESSION_TOOL = {
     openWorldHint: false,
     agentHidden: true,
   },
-  trigger: 'Session lookup/control, bot status, agent task sessions and their initial location, title, compact, fork, Project.',
+  trigger:
+    'Session lookup/control, bot status, agent task sessions and their initial location, title, compact, fork, Project.',
   description:
     'Inspect sessions or control another by exact ID, never a guessed one. send acknowledges queue intake, not completion: promise a report of it only when its result has reportsBack: true. create returns status: started — started, not done yet; it reports its final answer, after the agents it started finish, unless its result says reportsBack: false. reportsBack: false carries reportsBackReason, the reason to tell the user. Cancel/delete require the user’s request. Other actions affect only the current session. A new session’s initial location (Project folder branch or its own worktree) is set here, with create’s worktree; worktree operations on existing sessions (enter, return, merge, remove, list, prune) use the git tool’s action:"worktree". Pass files on with attachments; a reported turn returns the files it produced as attachments.',
   inputSchema: {
@@ -97,11 +98,20 @@ export const SESSION_TOOL = {
           'list-projects',
           'favorite',
           'archive',
+          'suggest',
         ],
         description:
-          'status defaults to current; list pages sessions, without sub-agent or archived ones unless include_agents/include_archived; bots shows each bot’s activity, work, approvals, routines and attention flags, or with session_id (a bot id or its chat) its routines and recent sessions; read returns latest items; send queues prompt (reportsBack: the turn result reports back here); cancel stops the turn; delete removes the session. create (bot conversations) starts a visible agent task session from brief (started, not done yet); unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching.',
+          'status defaults to current; list pages sessions, without sub-agent or archived ones unless include_agents/include_archived; bots shows each bot’s activity, work, approvals, routines and attention flags, or with session_id (a bot id or its chat) its routines and recent sessions; read returns latest items; send queues prompt (reportsBack: the turn result reports back here); cancel stops the turn; delete removes the session. create (bot conversations) starts a visible agent task session from brief (started, not done yet); unknown Project: list-projects first, still ambiguous: ask the user. compact runs after this turn; fork copies it without switching. suggest (Mixy’s chat only) records a proposal made to the user under key; value false records that the user declined it.',
+      },
+      title: {
+        type: 'string',
+        description: 'rename: new current-session title; create: task title; suggest: the proposal in one line.',
+      },
+      key: {
+        type: 'string',
+        description:
+          'suggest: stable action:target key, e.g. pause-routine:daily-news; the same key refreshes its proposal.',
       },
-      title: { type: 'string', description: 'rename: new current-session title; create: task title.' },
       session_id: {
         type: 'string',
         description:
@@ -150,7 +160,7 @@ export const SESSION_TOOL = {
           'Existing directory; implies set-project. Resolve names with list-projects first. Shell cd does not switch Project.',
       },
       compact: { type: 'boolean', description: 'fork: compact the copy.' },
-      value: { type: 'boolean', description: 'favorite/archive: on or off.' },
+      value: { type: 'boolean', description: 'favorite/archive: on or off; suggest: false = the user declined it.' },
       brief: { type: 'string', description: 'create: self-contained instruction, the first message.' },
       project: { type: 'string', description: 'create: registered Project name or existing directory.' },
       worktree: {
@@ -171,7 +181,13 @@ export const SESSION_TOOL = {
       },
       model: {
         type: 'string',
-        description: 'create: provider/model or preset; default is the Lead model (else the last-used one).',
+        description:
+          'create: provider/model, preset, or a model menu display name (e.g. "Claude Opus 5.5", case-insensitive; a trailing effort word is read as effort); default is the Lead model (else the last-used one).',
+      },
+      effort: {
+        type: 'string',
+        description:
+          'create/send: reasoning effort setting of the session (auto, or a level its model supports, e.g. low, medium, high, xhigh, max); wins over one in model. send: bots may change only task sessions they created. status shows effort and fast.',
       },
       notify: { type: 'boolean', description: 'create: report results back, default true.' },
       attachments: {
@@ -248,6 +264,7 @@ export function collectStandaloneToolDefs({
   visualizeToolDefs = [],
   setupToolDefs = [],
   askUserToolDefs = [],
+  reactionToolDefs = [],
   goalTools = [],
   agentTools = [],
   skillToolEnabled = true,
@@ -269,6 +286,7 @@ export function collectStandaloneToolDefs({
     ...admitted(visualizeToolDefs, VISUALIZE_RUNTIME_TOOLS),
     ...setupToolDefs,
     ...askUserToolDefs,
+    ...reactionToolDefs,
     ...goalTools,
     ...agentTools,
   ];

package/src/runtime/agent/orchestrator/runtime-core/tool-profile.mjs

@@ -1,5 +1,11 @@
+import { HEARTBEAT_SOURCE } from '../../../shared/routine-trigger.mjs';
+
 const INTERACTIVE_TOOL_PROFILE = 'interactive';
 export const HEADLESS_TOOL_PROFILE = 'headless';
+// Mixy's hidden heartbeat session (session-runtime/mixy-heartbeat.mjs): it
+// judges a reviewed digest, so it reads sessions and bots, records proposals
+// (session) and pauses or reruns a routine (setup); nothing else.
+export const HEARTBEAT_TOOL_PROFILE = 'heartbeat';
 
 export const HEADLESS_MODEL_TOOL_NAMES = Object.freeze([
   'find',
@@ -21,23 +27,42 @@ export const HEADLESS_MODEL_TOOL_NAMES = Object.freeze([
   'tidy',
 ]);
 
-const HEADLESS_MODEL_TOOL_SET = new Set(HEADLESS_MODEL_TOOL_NAMES.map((name) => name.toLowerCase()));
+// load_tool loads the two deferred tools' schemas.
+export const HEARTBEAT_MODEL_TOOL_NAMES = Object.freeze(['session', 'setup', 'load_tool']);
+
+// The model tools each narrowed profile allows; the interactive profile has no list.
+const PROFILE_TOOL_NAMES = new Map([
+  [HEADLESS_TOOL_PROFILE, HEADLESS_MODEL_TOOL_NAMES],
+  [HEARTBEAT_TOOL_PROFILE, HEARTBEAT_MODEL_TOOL_NAMES],
+]);
+const PROFILE_TOOL_SETS = new Map(
+  [...PROFILE_TOOL_NAMES].map(([profile, names]) => [profile, new Set(names.map((name) => name.toLowerCase()))])
+);
 
 export function normalizeToolProfile(value) {
-  return String(value || '')
+  const profile = String(value || '')
     .trim()
-    .toLowerCase() === HEADLESS_TOOL_PROFILE
-    ? HEADLESS_TOOL_PROFILE
-    : INTERACTIVE_TOOL_PROFILE;
+    .toLowerCase();
+  return PROFILE_TOOL_NAMES.has(profile) ? profile : INTERACTIVE_TOOL_PROFILE;
+}
+
+/** The profile a session runtime runs under: a session created as a heartbeat
+ *  run (source `heartbeat`) is fenced to the heartbeat tools whatever profile
+ *  was asked for. The source only ever narrows, so a forged one costs nothing. */
+export function sessionToolProfile({ toolProfile, sessionProfile } = {}) {
+  if (String(sessionProfile?.sourceName || '').trim() === HEARTBEAT_SOURCE) return HEARTBEAT_TOOL_PROFILE;
+  return normalizeToolProfile(toolProfile);
 }
 
 export function modelToolSchemaAllowlist(profile) {
-  return normalizeToolProfile(profile) === HEADLESS_TOOL_PROFILE ? [...HEADLESS_MODEL_TOOL_NAMES] : null;
+  const names = PROFILE_TOOL_NAMES.get(normalizeToolProfile(profile));
+  return names ? [...names] : null;
 }
 
 export function modelToolAllowedForProfile(name, profile) {
-  if (normalizeToolProfile(profile) !== HEADLESS_TOOL_PROFILE) return true;
-  return HEADLESS_MODEL_TOOL_SET.has(
+  const allowed = PROFILE_TOOL_SETS.get(normalizeToolProfile(profile));
+  if (!allowed) return true;
+  return allowed.has(
     String(name || '')
       .trim()
       .toLowerCase()
@@ -46,12 +71,12 @@ export function modelToolAllowedForProfile(name, profile) {
 
 export function filterModelToolsForProfile(tools, profile) {
   const rows = Array.isArray(tools) ? tools : [];
-  if (normalizeToolProfile(profile) !== HEADLESS_TOOL_PROFILE) return rows;
+  if (!PROFILE_TOOL_SETS.has(normalizeToolProfile(profile))) return rows;
   return rows.filter((tool) => modelToolAllowedForProfile(tool?.name, profile));
 }
 
 export function disallowedModelToolNamesForProfile(tools, profile) {
-  if (normalizeToolProfile(profile) !== HEADLESS_TOOL_PROFILE) return [];
+  if (!PROFILE_TOOL_SETS.has(normalizeToolProfile(profile))) return [];
   return [
     ...new Set(
       (Array.isArray(tools) ? tools : [])

package/src/runtime/agent/orchestrator/runtime-core/workflow/agents.mjs

@@ -3,9 +3,10 @@
 // shipped starter after the user deletes it, so package updates do not
 // silently resurrect the role.
 import { join } from 'node:path';
-import { existsSync } from 'node:fs';
+import { existsSync, statSync } from 'node:fs';
 import { clean } from '../session-text.mjs';
-import { defaultDirResolver, readJsonSafe, readTextSafe } from '../fs-utils.mjs';
+import { parseJsonText } from '../../../../shared/atomic-file.mjs';
+import { defaultDirResolver, readTextSafe } from '../fs-utils.mjs';
 import { SHARED_SCAN_REVALIDATE_MS, createSharedScanCache } from './shared-scan-cache.mjs';
 import { isHiddenAgent } from '../../internal-agents.mjs';
 import { isAgentDisabled } from '../../../../shared/agent-route-config.mjs';
@@ -30,6 +31,27 @@ import {
   setAgentDefinitionCache,
 } from '../workflow-ids.mjs';
 
+/** The entry file name an agent folder's manifest names (default AGENT.md). */
+export const agentEntryFile = (manifest) => clean(manifest?.entry) || 'AGENT.md';
+
+/** The entry file path of the agent folder `dir` for `manifest`, exactly as the
+ *  loader reads it. The one resolver the loader, discovery, presence and the
+ *  editor's revision share. */
+export const agentEntryPath = (dir, manifest) => join(dir, agentEntryFile(manifest));
+
+/** The agent.json object in `text` (a leading BOM tolerated), or null when it
+ *  is not a JSON object. The one manifest parser: loader, discovery, editor. */
+export function parseManifestText(text) {
+  try {
+    const value = parseJsonText(String(text));
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+
+const manifestOfText = (text) => parseManifestText(text) || {};
+
 // Yields its fs requests; see shared-scan-cache.mjs. With the bot store
 // active, bots/ is scanned too and the agents/ originals of the ids the split
 // copied are skipped (agent-store.mjs).
@@ -69,6 +91,21 @@ function* scanCustomAgentIds(userRoot, shippedRoot, botsRoot = null, migrated =
 export const AGENT_LIST_REVALIDATE_MS = SHARED_SCAN_REVALIDATE_MS;
 const agentListCache = createSharedScanCache();
 
+// mtime+size of each file ("-" when absent). loadAgentDefinition runs per
+// agent on every status pulse and prompt build; a handful of stats is cheap.
+function fileSignature(files) {
+  return files
+    .map((file) => {
+      try {
+        const st = statSync(file);
+        return `${st.mtimeMs}:${st.size}`;
+      } catch {
+        return '-';
+      }
+    })
+    .join('|');
+}
+
 export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, normalizeAgentPermissionOrNone }) {
   const defaultDir = defaultDirResolver(dataDir);
   function agentSourceDirs(dir, id) {
@@ -111,12 +148,24 @@ export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, n
     const agentId = normalizeAgentId(id) || normalizeWorkflowId(id);
     if (!agentId) return null;
     const cacheKey = `${dir || defaultDir()}\n${agentId}`;
-    if (agentDefinitionCache.has(cacheKey)) return agentDefinitionCache.get(cacheKey);
+    const cached = agentDefinitionCache.get(cacheKey);
+    // A hit is trusted only while the files it was built from are unchanged,
+    // so a direct edit of AGENT.md/agent.json/PERSONA.md shows without a restart.
+    if (cached && fileSignature(cached.files) === cached.signature) return cached.definition;
     const slot = FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId);
+    const files = [];
+    const remember = (definition) => {
+      setAgentDefinitionCache(cacheKey, { definition, files, signature: fileSignature(files) });
+      return definition;
+    };
     for (const d of agentSourceDirs(dir, agentId)) {
-      const manifest = readJsonSafe(join(d, 'agent.json')) || {};
-      const entry = clean(manifest.entry) || 'AGENT.md';
-      const doc = readMarkdownDocument(readTextSafe(join(d, entry)));
+      const manifest = manifestOfText(readTextSafe(join(d, 'agent.json')));
+      const entry = agentEntryPath(d, manifest);
+      // Shipped files change only with an install update (a restart).
+      if (d !== join(rootDir, 'agents', agentId)) {
+        files.push(join(d, 'agent.json'), entry, join(d, 'PERSONA.md'), join(d, AGENT_DELETED_MARKER));
+      }
+      const doc = readMarkdownDocument(readTextSafe(entry));
       const body = doc.body;
       if (!body) continue;
       const definition = {
@@ -136,13 +185,11 @@ export function createWorkflowAgents({ rootDir, dataDir, readMarkdownDocument, n
         // Optional PERSONA.md beside AGENT.md (same dir, same cache entry).
         persona: (readTextSafe(join(d, 'PERSONA.md')) || '').trim(),
       };
-      setAgentDefinitionCache(cacheKey, definition);
-      return definition;
+      return remember(definition);
     }
     // Every shipped and user role lives at agents/<id>/AGENT.md; there is no
     // flat agents/<id>.md layout left to fall back to.
-    setAgentDefinitionCache(cacheKey, null);
-    return null;
+    return remember(null);
   }
 
   return { listCustomAgentIds, delegatableAgentIds, loadAgentDefinition };

package/src/runtime/agent/orchestrator/runtime-core/workflow/context.mjs

@@ -59,13 +59,13 @@ export function createWorkflowContext({ packs, agents }) {
   // - coding: the orchestration mode block and the full agent catalog;
   // - agent mode: the fixed delegation block (no per-agent setting) and the
   //   sub-agent catalog — identical for every agent, so their prompts share
-  //   it — plus, for Mixy only, the contact-agent catalog.
-  function leadPromptParts(config, dir, { agentMode = false, mixy = false } = {}) {
+  //   it — plus the contact-agent catalog: every bot but `agentId` itself.
+  function leadPromptParts(config, dir, { agentMode = false, agentId = '' } = {}) {
     const mode = configuredOrchestrationMode(config);
     const ids = agents.delegatableAgentIds(config, dir);
     const isContact = (id) => isContactAgentId(id, agents.loadAgentDefinition(dir, id)?.kind);
     if (!agentMode) {
-      // Bots are never a coding Lead's agents: only Mixy hands them work.
+      // Bots are never a coding Lead's agents: only agent-mode Leads hand them work.
       const workflowIds = ids.filter((id) => !isContact(id));
       const catalog = agentCatalog(dir, workflowIds);
       return {
@@ -79,7 +79,10 @@ export function createWorkflowContext({ packs, agents }) {
       dir,
       ids.filter((id) => !isContact(id))
     );
-    const contacts = mixy ? agentCatalog(dir, ids.filter(isContact)) : '';
+    const contacts = agentCatalog(
+      dir,
+      ids.filter((id) => isContact(id) && id !== agentId)
+    );
     return {
       // An agent-mode Lead without agents has no one to delegate to at all.
       orchestrationContext: subAgents || contacts ? AGENT_MODE_DELEGATION : '',
@@ -110,8 +113,8 @@ export function createWorkflowContext({ packs, agents }) {
       // orchestration instructions / agent catalog.
       packContext,
       context: [packContext, orchestrationContextBlock(config, dir)].filter(Boolean).join('\n\n'),
-      // A Lead's BP3 slices beside the pack: `{ agentMode, mixy }` picks the
-      // coding, agent or Mixy variant (session/agent-mode.mjs).
+      // A Lead's BP3 slices beside the pack: `{ agentMode, agentId }` picks the
+      // coding variant, or the agent variant of the agent `agentId` (session/agent-mode.mjs).
       leadPromptParts: (options) => leadPromptParts(config, dir, options),
     };
   }

package/src/runtime/agent/orchestrator/runtime-core/workflow-ids.mjs

@@ -15,7 +15,7 @@ export const BUILTIN_SLOT_AGENT_IDS = new Set(
   FIXED_AGENT_SLOTS.filter((agent) => agent.workflowSlot).map((agent) => agent.id)
 );
 export const STARTER_AGENT_ORDER = new Map(DEFAULT_DISABLED_AGENT_IDS.map((id, index) => [id, index]));
-// Only Mixy delegates to contacts (agent-route-config.mjs isContactAgentId).
+// Only agent-mode Leads (Mixy and the bots) delegate to contacts (agent-route-config.mjs isContactAgentId).
 export { isContactAgentId } from '../../../shared/agent-route-config.mjs';
 export const DEFAULT_WORKFLOW_ID = 'default';
 

package/src/runtime/agent/orchestrator/session/agent-loop.mjs

@@ -10,8 +10,10 @@ import {
 import { repairTranscriptBeforeProviderSend } from './loop/transcript-repair.mjs';
 import { resetAccountProbePacing } from '../providers/account-pool.mjs';
 import { createLoopState, finishLoop } from './loop/loop-state.mjs';
+import { clearReactionTargets } from '../runtime-core/reaction-tool-defs.mjs';
 import { applyRetryAction, beginIteration, sendProviderRequest, settleSendResult } from './loop/send-phase.mjs';
 import { runToolPhase } from './loop/tool-phase.mjs';
+import { endedWithoutReply } from './loop/turn-limits.mjs';
 
 // Facade re-exports: these symbols live in ./loop/ modules and are part of
 // loop.mjs's public surface (imported by scripts/tests and other runtime
@@ -44,6 +46,16 @@ export {
  * ./loop/tool-phase.mjs.
  */
 export async function agentLoop(provider, messages, model, tools, onToolCall, cwd, sendOpts) {
+  try {
+    return await runAgentLoop(provider, messages, model, tools, onToolCall, cwd, sendOpts);
+  } finally {
+    // A react call's recorded target belongs to this loop: whatever the batch
+    // did not consume (cancelled or failed turn) ends with it.
+    if (sendOpts?.sessionId) clearReactionTargets(sendOpts.sessionId);
+  }
+}
+
+async function runAgentLoop(provider, messages, model, tools, onToolCall, cwd, sendOpts) {
   // An explicit request asks for a current answer. Let the account pool
   // re-measure quota it recorded as exhausted instead of refusing from the old
   // reading — once per loop entry, not per provider round inside the turn.
@@ -67,6 +79,12 @@ export async function agentLoop(provider, messages, model, tools, onToolCall, cw
       break;
     }
     await runToolPhase(state, round, sent, onToolCall);
+    // A capped turn that kept calling tools after it was told to reply ends
+    // here with no reply (./loop/turn-limits.mjs).
+    if (state.turnLimitEnded) {
+      state.response = endedWithoutReply(state.response);
+      break;
+    }
   }
   return finishLoop(state);
 }

package/src/runtime/agent/orchestrator/session/agent-room.d.mts

@@ -84,15 +84,12 @@ export const ROOM_LIMITS: Readonly<
   Record<'maxRounds' | 'maxMessages', Readonly<{ min: number; max: number; default: number }>>
 >;
 export const ROOM_INSTRUCTION_LIMIT: number;
-export const ROOM_PASS_REPLY: string;
 export const ROOM_ROW_SOURCE: string;
-export function isRoomId(value: unknown): value is string;
 export function roomSessionId(roomId: unknown): string;
 export function roomIdOfSession(sessionId: unknown): string;
 export function roomMemberSessionId(roomId: unknown, agentId: unknown): string;
 export function roomMemberOfSession(sessionId: unknown): { roomId: string; agentId: string } | null;
 export function isRoomThreadSessionId(sessionId: unknown): boolean;
-export function clampRoomLimit(kind: 'maxRounds' | 'maxMessages', value: unknown): number;
 export function normalizeRoomConfig(value?: Partial<RoomConfig> & Record<string, unknown>): RoomConfig;
 export function parseRoomAsk(
   text: unknown,

package/src/runtime/agent/orchestrator/session/agent-room.mjs

@@ -11,7 +11,11 @@
 // session-runtime/handoff-attachments.mjs): stored references, handed as
 // content to the members the row reaches, once each.
 import { escapeHarnessTags } from '../../../shared/shell-output-summary.mjs';
-import { normalizeMessageAttachments, transcriptAttachmentFields } from '../../../shared/transcript-metadata.mjs';
+import {
+  normalizeMessageAttachments,
+  transcriptAttachmentFields,
+  transcriptReactionsField,
+} from '../../../shared/transcript-metadata.mjs';
 import { AGENT_MESSAGE_NOTE } from '../../../shared/agent-message-envelope.mjs';
 import { agentHomeSessionId } from './agent-home.mjs';
 
@@ -29,7 +33,7 @@ export const ROOM_LIMITS = Object.freeze({
 /** The longest supervisor note a member's turn carries. */
 export const ROOM_INSTRUCTION_LIMIT = 200;
 /** A member's reply that says it has nothing to add. */
-export const ROOM_PASS_REPLY = '(pass)';
+const ROOM_PASS_REPLY = '(pass)';
 /** `meta.source` of every row stored in a room's log. */
 export const ROOM_ROW_SOURCE = 'agent-room';
 /** First-time members see at most this many earlier rows. */
@@ -44,7 +48,7 @@ const PART_TYPES = new Set(['image', 'file', 'text']);
 const ATTACHMENT_LIMIT = 64;
 const SENDER_SESSION = /^[A-Za-z0-9_.:-]{1,200}$/;
 
-export function isRoomId(value) {
+function isRoomId(value) {
   return typeof value === 'string' && ROOM_ID.test(value);
 }
 
@@ -86,7 +90,7 @@ export function isRoomThreadSessionId(sessionId) {
 }
 
 /** `value` as a whole number inside the `kind` limit's bounds. */
-export function clampRoomLimit(kind, value) {
+function clampRoomLimit(kind, value) {
   const bounds = ROOM_LIMITS[kind];
   const number = Math.round(Number(value));
   if (!Number.isFinite(number)) return bounds.default;
@@ -776,6 +780,8 @@ export function roomRowItem(message, id) {
     // A user row's (or member speech's) files, in the fields a chat prompt's row draws them from.
     ...(room.kind === 'user' || room.kind === 'speech' ? transcriptAttachmentFields(message.meta.transcript) : {}),
     ...(room.kind === 'user' && Array.isArray(images) && images.length ? { images } : {}),
+    // The members' emoji reactions on a user row (message-reactions.mjs).
+    ...(room.kind === 'user' ? transcriptReactionsField(message.meta.transcript) : {}),
     ...roomRowSender(room),
   };
 }

package/src/runtime/agent/orchestrator/session/compact/runner.mjs

@@ -90,14 +90,24 @@ function splitFreshSource(messages) {
   };
 }
 
+// A cut at `end` that would split a surrogate pair (an emoji) moves back one
+// unit: a lone surrogate serializes as an escape providers reject as invalid
+// JSON, failing every Compact of the session.
+function codePointEnd(text, end) {
+  const code = text.charCodeAt(end - 1);
+  return end < text.length && code >= 0xd800 && code <= 0xdbff ? end - 1 : end;
+}
+
 function chunkConversationMessage(role, content, source = {}) {
   const text = String(content || '');
   const out = [];
-  for (let offset = 0; offset < text.length; offset += HANDOFF_SOURCE_CHUNK_CHARS) {
+  for (let offset = 0; offset < text.length; ) {
+    const end = codePointEnd(text, offset + HANDOFF_SOURCE_CHUNK_CHARS);
     const next = {
       role,
-      content: text.slice(offset, offset + HANDOFF_SOURCE_CHUNK_CHARS),
+      content: text.slice(offset, end),
     };
+    offset = end;
     if (Object.hasOwn(source, 'ts')) next.ts = source.ts;
     if (Object.hasOwn(source, 'timestamp')) next.timestamp = source.timestamp;
     out.push(next);
@@ -113,7 +123,9 @@ const SUMMARY_TOOL_ARGS_CHARS = 200;
 const SUMMARY_TOOL_OUTCOME_CHARS = 300;
 
 function boundedSummaryText(text, limit) {
-  return text.length > limit ? `${text.slice(0, limit)}… [${text.length - limit} more chars]` : text;
+  if (text.length <= limit) return text;
+  const end = codePointEnd(text, limit);
+  return `${text.slice(0, end)}… [${text.length - end} more chars]`;
 }
 
 function toolCallSummaryLine(call, result) {

package/src/runtime/agent/orchestrator/session/eager-dispatch.mjs

@@ -11,6 +11,7 @@ import { createEagerEntry, runEagerEntry } from './eager-dispatch/entry.mjs';
 import { executeTool } from './loop/tool-exec.mjs';
 import { isParallelDispatchable } from './loop/tool-helpers.mjs';
 import { resolveExecutionToolCall } from './loop/tool-call-resolution.mjs';
+import { turnLimitsOf } from './loop/turn-limits.mjs';
 
 export function createEagerDispatcher({
   tools,
@@ -37,6 +38,9 @@ export function createEagerDispatcher({
     repeatFailLimit,
   });
   const barriers = createEagerBarriers({ cwd });
+  // A capped turn runs its calls in order, so none past its cap starts early
+  // (loop/turn-limits.mjs).
+  const capped = turnLimitsOf(opts) !== null;
   const execute = (call, entry) =>
     executeToolFn(call.name, call.arguments, cwd, sessionId, sessionRef, {
       toolCallId: call.id,
@@ -52,6 +56,7 @@ export function createEagerDispatcher({
   const startEagerTool = (wireCall) => {
     // Streamed call_tool requests are admitted, ordered and executed as their
     // targets; a projection error is answered by the serial batch instead.
+    if (capped) return null;
     const call = resolveExecutionToolCall(wireCall, sessionRef);
     if (!call?.id || pending.has(call.id) || !isParallelDispatchable(call.name)) return null;
     const admitted = admission.admit(call);