mixdog 1.3.5 → 1.4.1

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

@@ -0,0 +1,60 @@
+import { BOT_HOP_LIMIT_ERROR, MAX_BOT_HOPS } from '../../runtime/shared/bot-hops.mjs';
+import { roomMemberOfSession, roomSessionId } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
+
+// 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';
+
+/** Throws unless a send to `sessionId` carries a prompt and addresses no
+ *  room member's session directly. */
+export function assertSendRequest(args, sessionId) {
+  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>`
+    );
+  }
+}
+
+/** Applies effort `level` (checked) to `sessionId`, just before the prompt is queued. */
+export function effortApplier(service, sessionId, level) {
+  // sessionOnly: the session's route changes, never the user's saved model settings.
+  return 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`);
+    }
+  };
+}
+
+/** `hop`, refused past MAX_BOT_HOPS. */
+export function chainedHop(hop) {
+  if (hop > MAX_BOT_HOPS) throw new Error(BOT_HOP_LIMIT_ERROR);
+  return hop;
+}
+
+/** The report origin with the send's hop and bot chain carried on. */
+export function chainedOrigin(origin, hop, botChain) {
+  let chained = origin;
+  if (hop > 0) chained = { ...chained, hop };
+  if (botChain.length) chained = { ...chained, botChain };
+  return chained;
+}
+
+/** The result of a send that reports nothing back (no report origin). */
+export function unreportedSendResult(sessionId, addressed, accepted, hop) {
+  return {
+    sessionId,
+    ...addressed,
+    accepted,
+    reportsBack: false,
+    ...(accepted ? { reportsBackReason: NOT_BOT_REASON } : {}),
+    ...(hop > 0 ? { hop } : {}),
+  };
+}

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

@@ -0,0 +1,40 @@
+import { SESSION_ID_PATTERN } from '../../runtime/agent/orchestrator/runtime-core/session-id.mjs';
+import { assertWorktreeMutationAllowed } from '../../session-runtime/services/worktree-access.mjs';
+
+// 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',
+]);
+
+/**
+ * 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.
+ */
+export function createWorktreeControl(getSessionService) {
+  return 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;
+  };
+}

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

@@ -1,138 +1,114 @@
-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_TARGET_ACTIONS, isBotShaped, unknownBotError } from '../session-runtime/bot-target.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 { 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. */
 export function createSessionControl({
   getSessionService,
   agentTasks = createAgentTaskSessions({ getSessionService }),
-  botStatus = createBotStatus({ getSessionService }),
+  listBots,
+  botStatus = createBotStatus({ getSessionService, listBots }),
+  // 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 = {}) {
+  async function control(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 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
@@ -143,28 +119,38 @@ export function createSessionControl({
       // out, so a page is never short while more rows match.
       const own = scopedBot(context.callerScope);
       const archived = (await readSessionSidebarState())?.archived ?? {};
-      const keep = (row) =>
-        (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 ? (row) => sessionBotOf(row) === own : 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.
@@ -186,32 +172,7 @@ 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; its bot chain is
-      // recorded under every submission id that turn may take.
-      const submit = room
-        ? 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 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
@@ -228,29 +189,15 @@ export function createSessionControl({
         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`);
-          }
-        };
+        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 };
-        if (botChain.length) origin = { ...origin, botChain };
+        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);
@@ -258,7 +205,7 @@ export function createSessionControl({
         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;
@@ -273,27 +220,12 @@ export function createSessionControl({
         });
         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 };
     }
@@ -315,9 +247,12 @@ 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,
@@ -325,7 +260,24 @@ export function createSessionControl({
       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,
     };
+  }
+
+  return async function executeSessionControl(args = {}, context = {}) {
+    try {
+      return await control(args, context);
+    } catch (error) {
+      // A bot id is resolved to its home chat before this (workspace-tools.mjs),
+      // so a bot-shaped id the session service found no session for is no bot
+      // either: say which ids are.
+      const id = typeof args.session_id === 'string' ? args.session_id.trim() : '';
+      const missing = [`${id} is not available`, `${id} is unavailable`].some((text) => error?.message?.includes(text));
+      if (!BOT_TARGET_ACTIONS.has(args.action) || !isBotShaped(id) || !missing) throw error;
+      throw await unknownBotError(id, listBots, error);
+    }
   };
 }

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';
@@ -1017,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')),
@@ -1029,7 +1037,10 @@ 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.
+  // 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}`) })
@@ -1041,6 +1052,18 @@ async function main() {
   // 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
@@ -1096,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()),
     });