mixdog 1.3.4 → 1.4.0

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

@@ -1,42 +1,81 @@
-import { SESSION_ID_PATTERN } from '../runtime/agent/orchestrator/runtime-core/session-id.mjs';
-import { sessionListOutput, sessionReadOutput, SESSION_TOOL_OUTPUT_BYTES } from './session-tool-output.mjs';
-import { createAgentTaskSessions } from '../session-runtime/agent-task-sessions.mjs';
-import { assertWorktreeMutationAllowed } from '../session-runtime/services/worktree-access.mjs';
-import { createBotStatus, scanCatalog, scopedBot, sessionBotOf } from '../session-runtime/bot-status.mjs';
+import {
+  sessionListOutput,
+  sessionReadOutput,
+  SESSION_TITLE_LIMIT,
+  SESSION_TOOL_OUTPUT_BYTES,
+} from './session-tool-output.mjs';
+import { createAgentTaskSessions, taskSessionPendingWork } from '../session-runtime/agent-task-sessions.mjs';
+import { createBotStatus, scanCatalog, scopedBot } 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 { assertBotChainTarget, botChainOf } 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';
-import { agentRoomHost } from '../runtime/shared/agent-room-host.mjs';
+import { roomIdOfSession } from '../runtime/agent/orchestrator/session/agent-room.mjs';
+import { escapeHarnessTags } from '../runtime/shared/shell-output-summary.mjs';
+import { truncateToolText } from '../runtime/shared/tool-primitives.mjs';
+import { requestCaller, targetRequest } from './daemon-session-control/request.mjs';
+import { createWorktreeControl } from './daemon-session-control/worktree-control.mjs';
+import { createRouteControl } from './daemon-session-control/route-control.mjs';
 import {
-  roomIdOfSession,
-  roomMemberOfSession,
-  roomSessionId,
-} from '../runtime/agent/orchestrator/session/agent-room.mjs';
-
-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']);
-// 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';
+  TOP_CURSOR,
+  assertListFlags,
+  listOutputOptions,
+  listRowFilter,
+  listedSessions,
+  liveCandidates,
+  liveRowOverlay,
+  pinnedLiveRows,
+} from './daemon-session-control/list-page.mjs';
+import { roomAddressee, roomSubmitter, stopRoomExchange } from './daemon-session-control/room-host.mjs';
+import {
+  assertSendRequest,
+  chainedHop,
+  chainedOrigin,
+  effortApplier,
+  unreportedSendResult,
+} from './daemon-session-control/send-turn.mjs';
 
-/** The member a send to room log `sessionId` addresses, through the desktop
- *  room host: `{ host, agentId, sessionId, text }`; throws when no desktop is
- *  attached or no member resolves. */
-async function roomAddressee(sessionId, args) {
-  let host;
-  try {
-    host = agentRoomHost();
-  } catch (error) {
-    throw new Error(`session: cannot send to ${sessionId}: ${error.message}`);
+/** Sessions with live work now, from the sources the Agents pool reads:
+ *  `own` (id → its latest sign of work, epoch ms) — a turn in flight in this
+ *  process, or a pool row still running or queued (worker index
+ *  status/stage); `agents` — the Leads such an Agent session works for. */
+async function storedLiveWork() {
+  const [
+    { inFlightSessionActivity },
+    { listStoredAgentWorkersAsync },
+    { hasPendingAgentWork, sessionsWithPendingWork },
+  ] = await Promise.all([
+    import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
+    import('../runtime/agent/orchestrator/session/store-agent-worker-rows.mjs'),
+    import('../runtime/shared/pending-agent-work.mjs'),
+  ]);
+  const { working, agentWorking } = inFlightSessionActivity();
+  const pool = await listStoredAgentWorkersAsync({ runningSessionIds: working });
+  const now = Date.now();
+  const own = new Map([...working].map((id) => [id, now]));
+  for (const row of pool) {
+    const id = String(row?.sessionId || '');
+    if (id && !own.has(id) && hasPendingAgentWork(row)) own.set(id, Date.parse(row.updatedAt) || 0);
   }
-  const member = await host.member(sessionId, { to: args.to, prompt: args.prompt }).catch((error) => {
-    throw new Error(`session: ${error?.message || error}`);
-  });
-  return { host, ...member };
+  return { own, agents: new Set([...agentWorking, ...sessionsWithPendingWork(pool)]) };
+}
+
+/** The catalog row of `sessionId` read by id, or null when the catalog would not list it. */
+async function storedCatalogRow(sessionId) {
+  const { readStoredSessionCatalogRow } = await import(
+    '../runtime/agent/orchestrator/session/store-summary-reader.mjs'
+  );
+  return readStoredSessionCatalogRow(sessionId);
+}
+
+/** The stored title of `sessionId` (its session record), or null. */
+async function storedTitle(sessionId) {
+  const { readStoredSessionTranscript } = await import(
+    '../runtime/agent/orchestrator/session/store-summary-reader.mjs'
+  );
+  return (await readStoredSessionTranscript(sessionId, { metadataOnly: true }))?.title || null;
 }
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
@@ -44,115 +83,86 @@ export function createSessionControl({
   getSessionService,
   agentTasks = createAgentTaskSessions({ getSessionService }),
   botStatus = createBotStatus({ getSessionService }),
+  // Agent work a session handed off and still waits on (agent-task-sessions.mjs).
+  pendingWork = taskSessionPendingWork,
+  liveWork = storedLiveWork,
+  readRow = storedCatalogRow,
+  readTitle = storedTitle,
 }) {
-  /**
-   * Another session's workspace for the git tool's worktree operations
-   * (session-runtime/workspace/worktree-tool.mjs): one workspace method with
-   * one input, through the same configure / read lanes the desktop uses. No
-   * `ownTurn` ever crosses: the target must be idle. A change (anything but
-   * the menu read) needs the caller's trusted scope (`callerScope`, from
-   * worktree-access.mjs worktreeCallerScope) to be an attended conversation.
-   */
-  async function worktreeControl(args, caller, callerScope) {
-    const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
-    if (!SESSION_ID_PATTERN.test(sessionId)) throw new Error('session: session_id is required for action=worktree');
-    if (sessionId === caller) throw new Error('session: worktree control must target another session');
-    if (!WORKTREE_METHODS.has(args.method)) throw new Error(`session: unsupported worktree method "${args.method}"`);
-    if (args.method !== 'getBranchMenu') assertWorktreeMutationAllowed(callerScope, `session: worktree ${args.method}`);
-    const service = getSessionService();
-    if (!service) throw new Error('session: session service is unavailable');
-    if (args.method === 'getBranchMenu') {
-      return (await service.readSession({ sessionId, action: 'getBranchMenu', args: [] })).value;
-    }
-    const result = await service.configureSession(
-      { sessionId, action: args.method, args: [args.input ?? {}] },
-      { revision: 1 }
-    );
-    return result.value;
-  }
+  const worktreeControl = createWorktreeControl(getSessionService);
+  const routeControl = createRouteControl(getSessionService);
 
   return async function executeSessionControl(args = {}, context = {}) {
     const action = args.action;
-    if (
-      action !== 'list' &&
-      action !== 'create' &&
-      action !== 'bots' &&
-      action !== 'worktree' &&
-      !TARGET_ACTIONS.has(action)
-    ) {
-      throw new Error(`session: unsupported remote action "${action}"`);
-    }
-    const caller = context.callerSessionId;
-    if (typeof caller !== 'string' || !SESSION_ID_PATTERN.test(caller)) {
-      throw new Error('session: caller session is required');
-    }
+    const caller = requestCaller(action, context);
     // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
     if (action === 'create') return agentTasks.create(args, context);
     if (action === 'worktree') return worktreeControl(args, caller, context.callerScope);
+    // The setup tool's per-session route actions (authorized by the setup executor).
+    if (action === 'route') return routeControl(args, caller);
     // `callerScope`: the caller's schedule-access scope (workspace-tools.mjs).
     if (action === 'bots') return botStatus(args, context);
-    const sessionId = typeof args.session_id === 'string' ? args.session_id.trim() : '';
-    if (TARGET_ACTIONS.has(action) && !SESSION_ID_PATTERN.test(sessionId)) {
-      throw new Error(`session: session_id is required for action=${action}`);
-    }
-    if (MUTATING_ACTIONS.has(action) && sessionId === caller) {
-      throw new Error(`session: ${action} must target another session`);
-    }
-    const limit = args.limit ?? 25;
-    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
-      throw new Error('session: limit must be an integer from 1 to 100');
-    }
-    const offset = args.offset ?? 0;
-    const textOffset = args.text_offset ?? 0;
-    if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(offset + limit)) {
-      throw new Error('session: offset must be a nonnegative safe integer');
-    }
-    if (!Number.isSafeInteger(textOffset) || textOffset < 0) throw new Error('session: invalid text_offset');
-    if (args.text_offset !== undefined && (args.offset === undefined || limit !== 1 || !args.item_id)) {
-      throw new Error('session: text_offset requires offset, limit:1 and item_id from read');
-    }
+    const { sessionId, limit, offset, textOffset } = targetRequest(args, action, caller);
     const service = getSessionService();
     if (!service) throw new Error('session: session service is unavailable');
     if (action === 'list') {
-      for (const flag of ['include_agents', 'include_archived']) {
-        if (args[flag] !== undefined && typeof args[flag] !== 'boolean') {
-          throw new Error(`session: ${flag} must be a boolean`);
-        }
-      }
+      assertListFlags(args);
       // 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));
+      const keep = listRowFilter(args, archived);
+      // Live work is overlaid on every row: a catalog row keeps the status and
+      // recency of its last settled turn, so a long-running agent read `idle`
+      // and sorted by its first prompt. The first page lists the live rows
+      // first (newest sign of work first); a later page keeps catalog order,
+      // where such a row may show again (never skipped).
+      const live = await liveWork();
+      const withLive = liveRowOverlay(live);
+      // Each live session's row is read by id (wherever it sits in the
+      // catalog), filtered like the listing, and the newest `limit` lead.
+      const candidates = liveCandidates(live);
+      let pinned = [];
+      if (!args.cursor && candidates.length) {
+        pinned = pinnedLiveRows(await Promise.all(candidates.map((id) => readRow(id))), keep, withLive, limit);
+      }
+      const pinnedIds = new Set(pinned.map((row) => row.id));
+      const want = limit - pinned.length;
       // 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 });
+      const scan =
+        want > 0
+          ? await scanCatalog(service, (row) => !pinnedIds.has(row.id) && keep(row), {
+              cursor: args.cursor || null,
+              want,
+              maxRows: 10_000,
+            })
+          : { rows: [], nextCursor: TOP_CURSOR };
+      const sessions = listedSessions(pinned, scan.rows, withLive, archived);
+      return sessionListOutput({ sessions, nextCursor: scan.nextCursor }, limit, listOutputOptions(own, pinnedIds));
     }
     if (action === 'send') {
-      if (typeof args.prompt !== 'string' || !args.prompt.trim()) {
-        throw new Error('session: prompt is required for action=send');
-      }
-      // A room member's session is the room's to drive: a message goes to the
-      // room, naming the member.
-      if (roomMemberOfSession(sessionId)) {
-        throw new Error(
-          `session: ${sessionId} is a group-room member's session; send to its room (session_id ${roomSessionId(roomMemberOfSession(sessionId).roomId)}) with to: <member>`
-        );
-      }
+      assertSendRequest(args, sessionId);
       // A send to a room's log is a message to one member there (`to`, or a
       // leading @name), run by the desktop room host; the member's turn in
       // 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.
@@ -160,42 +170,42 @@ export function createSessionControl({
       const prompt = handoffContent(room ? room.text : args.prompt, context.attachmentParts);
       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.
-      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,
-          })
-        : null;
+      const submit = room ? roomSubmitter(room, sessionId, prompt, from) : 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));
+        applyEffort = effortApplier(service, sessionId, level);
+      }
       // 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.
       const turnHop = Number(context.callerHop) || 0;
-      const chained = (hop) => {
-        if (hop > MAX_BOT_HOPS) throw new Error(BOT_HOP_LIMIT_ERROR);
-        return hop;
-      };
       if (origin) {
-        const hop = chained(origin.target === 'session' ? turnHop + 1 : turnHop);
-        if (hop > 0) origin = { ...origin, hop };
+        const hop = chainedHop(origin.target === 'session' ? turnHop + 1 : turnHop);
+        origin = chainedOrigin(origin, hop, 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;
+      const hop = turnHop > 0 ? chainedHop(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,31 +214,16 @@ 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;
       }
-      return {
-        sessionId,
-        ...addressed,
-        accepted,
-        reportsBack: false,
-        ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
-        ...(hop > 0 ? { hop } : {}),
-      };
+      return unreportedSendResult(sessionId, addressed, accepted, hop);
     }
     if (action === 'cancel') {
       // A room's exchange is run by the desktop room host, so its stop (the UI
       // stop button) ends it; the log is not a session the service can abort.
-      if (roomIdOfSession(sessionId)) {
-        let host;
-        try {
-          host = agentRoomHost();
-        } catch (error) {
-          throw new Error(`session: cannot cancel ${sessionId}: ${error.message}`);
-        }
-        return { sessionId, aborted: host.stop(sessionId) === true };
-      }
+      if (roomIdOfSession(sessionId)) return stopRoomExchange(sessionId);
       const result = await service.abortSession({ sessionId });
       return { sessionId, aborted: result.aborted === true };
     }
@@ -250,13 +245,22 @@ export function createSessionControl({
     });
     const snapshot = result.full;
     if (!snapshot) throw new Error(`session: ${sessionId} is unavailable`);
+    // The snapshot carries no title: it lives on the session record. Quoted
+    // like a listed title.
+    const title = await readTitle(sessionId);
     return {
       sessionId,
-      title: snapshot.title ?? null,
+      title: title ? escapeHarnessTags(truncateToolText(title, SESSION_TITLE_LIMIT)) : null,
       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,
+      // A Lead idle between turns while its agents run is still working:
+      // their results wake it, so `busy` alone would read as stalled.
+      agentsWorking: (await pendingWork(sessionId)) === true,
       quotaResume: snapshot.quotaResume ?? null,
     };
   };

package/src/standalone/daemon.mjs

@@ -77,7 +77,12 @@ import { createStoredSessionViews } from './daemon-stored-session-views.mjs';
 import * as quotaResumeStore from '../runtime/shared/quota-resume-store.mjs';
 import { registerWorktreeCacheCleanups } from '../runtime/shared/worktrees/cache-cleanups.mjs';
 import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
-import { recoverScheduleResults, setAgentHomeLiveSurface } from '../session-runtime/agent-home-delivery.mjs';
+import {
+  postBeforeAgentTurn,
+  recoverScheduleResults,
+  setAgentHomeLiveSurface,
+} from '../session-runtime/agent-home-delivery.mjs';
+import { setSessionTurnPrelude } from '../runtime/shared/session-turn-prelude.mjs';
 import { recoverRoutineDeliveries } from '../session-runtime/owned-automation-run.mjs';
 import { getStandaloneMemoryRuntime } from '../session-runtime/services/memory-runtime-proxy.mjs';
 import { registerTranscriptPurgeHook } from '../session-runtime/session-transcript-purge.mjs';
@@ -1001,6 +1006,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).
@@ -1015,6 +1022,9 @@ async function main() {
         options: {
           mode: 'prompt',
           kickoff: true,
+          // Another bot or agent reported back: the runtime's turn, which the
+          // prompt-cache warmer does not learn from (shared/prompt-origin.mjs).
+          origin: 'agent-report',
           ...(id ? { id } : {}),
           ...(hop > 0 ? { transcriptMeta: { hop } } : {}),
           onSettled: (detail) => settle(String(detail?.status || 'failed')),
@@ -1027,12 +1037,33 @@ async function main() {
       (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
     abort: (sessionId) => sessionService.abortSession({ sessionId }),
   });
+  // A bot's next turn, whatever starts it, first reads the progress updates
+  // queued for its thread (they wake nobody on their own).
+  setSessionTurnPrelude(postBeforeAgentTurn);
+  // Mixy's heartbeat check (user-set interval) (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}`));
   // Agents' sends whose report an earlier process had not queued yet.
   agentTasks.recover().catch((error) => log(`agent task report recovery failed: ${error?.message || error}`));
   recoverRoutineDeliveries().catch((error) => log(`routine delivery recovery failed: ${error?.message || error}`));
+  // Compaction-archive segments an earlier process could not publish.
+  import('../runtime/agent/orchestrator/session/compaction-archive-capture.mjs')
+    .then(({ recoverPendingCompactionArchives }) => recoverPendingCompactionArchives())
+    .then((pending) => pending && log(`compaction archive: publishing pending segments of ${pending} session(s)`))
+    .catch((error) => log(`compaction archive recovery failed: ${error?.message || error}`));
+  // Prompt-cache warms toward routine fires (session/cache-warm.mjs) lived in
+  // the previous process: re-arm them from their durable cache touches (the
+  // re-arm waits for the providers to be registered).
+  import('../runtime/agent/orchestrator/session/cache-warm.mjs')
+    .then(({ rearmCacheWarmsAfterRestart }) => rearmCacheWarmsAfterRestart())
+    .then((armed) => armed && log(`cache warm: re-armed ${armed} session(s)`))
+    .catch((error) => log(`cache warm re-arm failed: ${error?.message || error}`));
   sessionTransport = createSessionTransport({
     // ctx carries the CLIENT token: the session service refcounts views across
     // processes with it, so a terminal exiting cannot destroy the session a
@@ -1088,7 +1119,7 @@ async function main() {
 
   // A pinned channel session outlives the daemon that pinned it. Reactivate the
   // durable intent AFTER the ready handshake (activation itself brings the
-  // messaging bridge up); with no intent on disk this is a no-op and the
+  // channel bridge up); with no intent on disk this is a no-op and the
   // channels graph stays dormant.
   if (transport.remoteIntentSessionId) {
     void transport

package/src/standalone/session-client.mjs

@@ -274,7 +274,9 @@ async function replaceLowerDaemon(discovery, initialHealth, { log, onUpgradeWait
   const notify = (state) => {
     try {
       onUpgradeWait?.({ state, ...info });
-    } catch {}
+    } catch {
+      // A throwing progress callback must not abort the upgrade wait.
+    }
   };
   const done = () => {
     notify('done');
@@ -376,7 +378,8 @@ export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = dae
 }
 
 /** Spawn-or-attach discovery for the machine-global daemon.
- *  `entry` is a test seam; production always forks the real daemon. */
+ *  `entry` and `proveOwner` are test seams; production always forks the real
+ *  daemon and probes the real owner. */
 export async function ensureDaemon({
   cwd = process.cwd(),
   log = () => {},
@@ -384,6 +387,7 @@ export async function ensureDaemon({
   readyTimeoutMs = null,
   onUpgradeWait = null,
   entry = daemonEntry(),
+  proveOwner = proveDaemonOwnerRecord,
 } = {}) {
   const configuredTimeoutMs = Number(process.env.MIXDOG_DAEMON_READY_TIMEOUT_MS);
   let requestedTimeoutMs = DEFAULT_DAEMON_READY_TIMEOUT_MS;
@@ -460,7 +464,7 @@ export async function ensureDaemon({
     // answer with its pid — a crashed daemon leaves its files behind, naming a
     // pid the OS may have reused. A probe cut short by this deadline proves
     // nothing either way.
-    const proof = await proveDaemonOwnerRecord(daemonOwnerPath(), {
+    const proof = await proveOwner(daemonOwnerPath(), {
       discoveryPath: sessionDiscoveryPath(),
       budgetMs: Math.max(1, deadline - Date.now()),
     });

package/src/standalone/session-protocol.mjs

@@ -27,6 +27,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getChannelSettings',
   'getChannelSetup',
   'getChannelWorkerStatus',
+  'getCacheWarmingSettings',
   'getCompactionSettings',
   'getConversationImportJobs',
   'getDeveloperSettings',
@@ -40,6 +41,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
   'getOrchestrationMode',
+  'getConfiguredOrchestrationMode',
   'getProfile',
   'getProviderSetup',
   'getProviderAccounts',
@@ -47,6 +49,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaHistory',
   'getRecapSettings',
   'getSessionTitleSettings',
+  'getHeartbeatSettings',
+  'getReactionSettings',
   'getLeadAppearance',
   'getBotOrder',
   'getWebSearchRoute',
@@ -134,6 +138,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteMediaAssets',
   'deleteSchedule',
   'saveCustomProvider',
+  'saveCustomProviderKey',
   'removeCustomProvider',
   'updateCustomProviderModel',
   'setModelPreferences',
@@ -208,6 +213,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setAgentRoute',
   'setAutoClear',
   'setAutoUpdate',
+  'setCacheWarmingEnabled',
   'setCompactionSettings',
   'setCwd',
   'setDeveloperOption',
@@ -238,6 +244,10 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProgressHint',
   'setRecapEnabled',
   'setAiSessionTitles',
+  'setHeartbeatEnabled',
+  'setHeartbeatInterval',
+  'noteUserInput',
+  '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/agent-tree/agent-child.mjs

@@ -31,6 +31,7 @@ export function createAgentChildFactory({ registry, rehydrateAgentSessions, crea
       sourceName: spec.sourceName || spec.agent || 'agent',
       clientHostPid: spec.clientHostPid || null,
       ...(preset.fallbacks !== undefined ? { routeFallbacks: preset.fallbacks } : {}),
+      ...(preset.fallbackSource ? { routeFallbackSource: preset.fallbackSource } : {}),
     };
     const created = await createSession({
       cwd: spec.cwd || process.cwd(),

package/src/standalone/session-service/quota-resume.mjs

@@ -44,6 +44,9 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
   try {
     usable = await readQuotaUsable(provider, model);
   } catch (error) {
+    // A disconnected PC supplies no quota reading. The scheduler's outer
+    // deferral keeps this reservation without spending an exhaustion attempt.
+    if (error?.code === 'MODEL_PROXY_UNAVAILABLE') throw error;
     log(`quota resume usage reading failed provider=${provider}: ${error?.message || error}`);
   }
   if (!isCurrent(store, entry)) return 'cancelled';