mixdog 1.3.4 → 1.4.0

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),
   };
 }