mixdog 1.3.3 → 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,