mixdog 1.4.1 → 1.4.3

package/src/session-runtime/workspace/worktree-tool.mjs

@@ -20,6 +20,60 @@ import { assertWorktreeMutationAllowed, worktreeCallerScope } from '../services/
 
 const loadManager = () => import('../../runtime/shared/worktrees/manager.mjs');
 
+async function enter(lane, request) {
+  if (request.branch) {
+    return lane.call('selectBranch', {
+      branch: request.branch,
+      create: request.create === true,
+      confirmLarge: request.confirmLarge === true,
+      txId: request.txId,
+    });
+  }
+  // A valid slug names the worktree; any other text is a hint the slug is made from.
+  const name = typeof request.name === 'string' ? request.name.trim() : '';
+  const slug = name && !worktreeNameError(name) ? name : null;
+  return lane.call('requestWorktree', {
+    provision: true,
+    name: slug,
+    prompt: slug ? '' : name,
+    ...(request.carry ? { carryChanges: request.carry } : {}),
+    confirmLarge: request.confirmLarge === true,
+    txId: request.txId,
+  });
+}
+
+/** Back to the project folder (the branch checked out there); the worktree stays retained. */
+async function back(lane, request) {
+  const menu = await lane.menu();
+  const workspace = menu.workspace;
+  if (!workspace.worktreeId && samePath(workspace.cwd, workspace.projectPath)) {
+    return { revision: workspace.revision, workspace, unchanged: true };
+  }
+  const projectBranch = menu.occupancy.find((row) => row.kind === 'current')?.branch ?? null;
+  if (!projectBranch) {
+    throw worktreeError(
+      'WORKTREE_UNSUPPORTED_REPO',
+      'The project folder has no checked-out branch to return to (detached HEAD).'
+    );
+  }
+  return lane.call('selectBranch', {
+    branch: projectBranch,
+    expectedRevision: workspace.revision,
+    txId: request.txId,
+  });
+}
+
+/** The desktop's "merge": into the confirmed merge target, then the cleanup autoCleanup allows. */
+async function merge(lane) {
+  const { workspace } = await lane.menu();
+  return lane.call('mergeWorkspace', {
+    confirmed: true,
+    target: workspace.mergeTarget ?? null,
+    expectedRevision: workspace.revision,
+    cleanup: true,
+  });
+}
+
 /**
  * @param {object} deps
  * @param {() => any} deps.getSession The Lead session this runtime hosts (its trusted caller scope).
@@ -61,60 +115,6 @@ export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSes
     return { own: false, menu: () => control('getBranchMenu'), call: control };
   }
 
-  async function enter(lane, request) {
-    if (request.branch) {
-      return lane.call('selectBranch', {
-        branch: request.branch,
-        create: request.create === true,
-        confirmLarge: request.confirmLarge === true,
-        txId: request.txId,
-      });
-    }
-    // A valid slug names the worktree; any other text is a hint the slug is made from.
-    const name = typeof request.name === 'string' ? request.name.trim() : '';
-    const slug = name && !worktreeNameError(name) ? name : null;
-    return lane.call('requestWorktree', {
-      provision: true,
-      name: slug,
-      prompt: slug ? '' : name,
-      ...(request.carry ? { carryChanges: request.carry } : {}),
-      confirmLarge: request.confirmLarge === true,
-      txId: request.txId,
-    });
-  }
-
-  /** Back to the project folder (the branch checked out there); the worktree stays retained. */
-  async function back(lane, request) {
-    const menu = await lane.menu();
-    const workspace = menu.workspace;
-    if (!workspace.worktreeId && samePath(workspace.cwd, workspace.projectPath)) {
-      return { revision: workspace.revision, workspace, unchanged: true };
-    }
-    const projectBranch = menu.occupancy.find((row) => row.kind === 'current')?.branch ?? null;
-    if (!projectBranch) {
-      throw worktreeError(
-        'WORKTREE_UNSUPPORTED_REPO',
-        'The project folder has no checked-out branch to return to (detached HEAD).'
-      );
-    }
-    return lane.call('selectBranch', {
-      branch: projectBranch,
-      expectedRevision: workspace.revision,
-      txId: request.txId,
-    });
-  }
-
-  /** The desktop's "merge": into the confirmed merge target, then the cleanup autoCleanup allows. */
-  async function merge(lane) {
-    const { workspace } = await lane.menu();
-    return lane.call('mergeWorkspace', {
-      confirmed: true,
-      target: workspace.mergeTarget ?? null,
-      expectedRevision: workspace.revision,
-      cleanup: true,
-    });
-  }
-
   /**
    * The listed worktree matching `predicate` whose owner is gone and that the
    * list reports removable, or null: no owner lane can remove it.
@@ -147,6 +147,11 @@ export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSes
     }
     const lane = laneFor(entry.ownerSessionId, callerSessionId, scope);
     const menu = await lane.menu();
+    // This session's worktree that it does not work in: removed where it is,
+    // without entering it (its own running workers elsewhere never block that).
+    if (lane.own && menu.workspace?.worktreeId !== entry.id) {
+      return workspaceApi().removeOwnedWorktree({ entryId: entry.id, force: request.force === true });
+    }
     if (menu.retainedWorktree?.id !== entry.id) {
       throw new Error(
         `git worktree remove: ${entry.path} is not the current worktree of session ${entry.ownerSessionId}; enter it (worktree_action enter, branch ${entry.branch}) first, then remove it`
@@ -174,6 +179,17 @@ export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSes
         return merge(lane());
       case 'remove': {
         const force = request.force === true;
+        if (request.branch) {
+          // By branch: the managed worktree of that branch this session owns.
+          const rows = await workspaceApi().listWorktrees();
+          const row = rows.find((item) => item.branch === request.branch && item.ownerSessionId === callerSessionId);
+          if (!row) {
+            throw new Error(
+              `git worktree remove: this session owns no managed worktree of branch ${request.branch}; git worktree list shows them`
+            );
+          }
+          return removePath({ path: row.path, force }, callerSessionId, scope);
+        }
         if (request.sessionId && request.sessionId !== callerSessionId) {
           const gone = await orphan((row) => row.ownerSessionId === request.sessionId);
           if (gone) return workspaceApi().removeOrphanWorktree({ entryId: gone.id, force });

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

@@ -6,7 +6,7 @@
 //
 // Inputs: `getSessionService` / `getSessionRuntimeHost` (both are wired after
 // this control exists — the host takes `execute` as a constructor option), and
-// `cwd`. Output: { canonicalAgentTool, execute }.
+// `cwd`. Output: { canonicalAgentTool, execute, runForeground, dispose }.
 
 export function createCanonicalAgentControl({ getSessionService, getSessionRuntimeHost, cwd }) {
   let canonicalAgentToolPromise = null;
@@ -43,16 +43,33 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
     return canonicalAgentToolPromise;
   }
 
-  async function execute(args = {}, context = {}) {
-    const tool = await canonicalAgentTool();
+  /** `context` rooted at its caller session (agent-tool: the owner is the caller's root). */
+  async function scopeContext(context) {
     const sessionService = getSessionService();
     const parentSessionId = String(context?.callerSessionId || '').trim();
     await sessionService.rehydrateAgentSessions();
-    const scopedContext = {
-      ...context,
-      callerSessionId: parentSessionId || null,
-      ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
+    return {
+      parentSessionId,
+      sessionService,
+      scopedContext: {
+        ...context,
+        callerSessionId: parentSessionId || null,
+        ownerSessionId: sessionService.rootOwnerSessionId(parentSessionId),
+      },
     };
+  }
+
+  /** One agent run to its end for a caller with no session to hand it to
+   *  (routine-executor.mjs): resolves `{ sessionId, content }`. */
+  async function runForeground(args = {}, context = {}, options = {}) {
+    const tool = await canonicalAgentTool();
+    const { scopedContext } = await scopeContext(context);
+    return await tool.runToCompletion(args, scopedContext, options);
+  }
+
+  async function execute(args = {}, context = {}) {
+    const tool = await canonicalAgentTool();
+    const { parentSessionId, sessionService, scopedContext } = await scopeContext(context);
     if (String(args?.type || '') === '__close_all') {
       await tool.closeAll?.(String(args?.reason || 'agent owner closed'), {
         callerSessionId: parentSessionId || null,
@@ -72,5 +89,5 @@ export function createCanonicalAgentControl({ getSessionService, getSessionRunti
     await tool?.disposeAsync?.({ settle: true });
   }
 
-  return { canonicalAgentTool, execute, dispose };
+  return { canonicalAgentTool, execute, runForeground, dispose };
 }

package/src/standalone/daemon-desktop-runtime.mjs

@@ -12,12 +12,13 @@
  *  this daemon's in-memory turn activity (every session runs inline here, so
  *  it is the single source of truth; worker index files only declare work). */
 async function loadSessionStoreWithRuntimeActivity() {
-  const [store, runtime, progress, tasks] = await Promise.all([
+  const [store, runtime, progress, tasks, liveState] = await Promise.all([
     import('../runtime/agent/orchestrator/session/store-summary-reader.mjs'),
     // The import-free leaf holding the runtime map: no session manager graph.
     import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
     import('../runtime/agent/orchestrator/session/agent-pool-progress.mjs'),
     import('../runtime/shared/background-tasks.mjs'),
+    import('../runtime/agent/orchestrator/session/store/live-state.mjs'),
   ]);
   return {
     ...store,
@@ -33,7 +34,10 @@ async function loadSessionStoreWithRuntimeActivity() {
       });
       const awaiting = tasks.activeBackgroundTaskSessionIds({ surface: 'shell', awaitedOnly: true });
       return progress.withTurnProgress(
-        rows,
+        progress.withLiveUsage(
+          progress.withLiveTodo(rows, (sessionId) => liveState._liveSessions.get(sessionId)),
+          (sessionId) => liveState._liveSessions.get(sessionId)
+        ),
         (sessionId) => runtime.runtimeState.get(sessionId),
         runtime.isTurnInFlight,
         (sessionId) => awaiting.has(sessionId)
@@ -66,6 +70,8 @@ export function createDesktopRuntime({ getLocalSessionBridge }) {
     loadDocumentPreview: () => import('../runtime/office/pdf/document-preview.mjs'),
     // The desktop service's git children start on this worker, off the loop.
     loadProcessRunner: () => import('../runtime/shared/process-runner.mjs'),
+    // The desktop app on this PC answers this daemon's per-origin proxy lookups.
+    loadSystemProxy: () => import('../runtime/shared/llm/system-proxy.mjs'),
     async executeCodeGraphTool(name, args, cwd) {
       const graph = await import('../runtime/agent/orchestrator/tools/code-graph/dispatch.mjs');
       return graph.executeCodeGraphTool(name, args, cwd);

package/src/standalone/daemon-lag-profiler.mjs

@@ -15,14 +15,14 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 
 export const LAG_PROFILE_FLAG_FILE = 'lag-profile.on';
-export const LAG_PROFILE_DIR_NAME = 'profiles';
-export const LAG_PROFILE_KEEP = 10;
-export const LAG_PROFILE_TOP = 15;
+const LAG_PROFILE_DIR_NAME = 'profiles';
+const LAG_PROFILE_KEEP = 10;
+const LAG_PROFILE_TOP = 15;
 export const LAG_PROFILE_SAMPLING_US = 1000;
-export const LAG_P99_THRESHOLD_MS = 1000;
+const LAG_P99_THRESHOLD_MS = 1000;
 // The owner lease's stall threshold: any window holding one logged
 // `event loop stalled` line is kept.
-export const LAG_MAX_THRESHOLD_MS = 1000;
+const LAG_MAX_THRESHOLD_MS = 1000;
 
 const PROFILE_FILE_RE = /^daemon-lag-.+\.cpuprofile$/;
 const SRC_ROOT = fileURLToPath(new URL('..', import.meta.url));
@@ -90,12 +90,12 @@ export function summarizeCpuProfile(profile, { limit = LAG_PROFILE_TOP, srcRoot
     .slice(0, limit);
 }
 
-export function formatTopEntries(entries) {
+function formatTopEntries(entries) {
   return entries.map((entry) => `${entry.label}=${Math.round(entry.ms)}ms`).join(',');
 }
 
 /** Keep only the `keep` newest daemon-lag profiles (names sort by timestamp). */
-export async function pruneProfiles(dir, keep = LAG_PROFILE_KEEP) {
+async function pruneProfiles(dir, keep = LAG_PROFILE_KEEP) {
   const names = (await fsp.readdir(dir)).filter((name) => PROFILE_FILE_RE.test(name)).sort();
   const stale = names.slice(0, Math.max(0, names.length - keep));
   for (const name of stale) await fsp.rm(path.join(dir, name), { force: true });

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

@@ -80,6 +80,154 @@ async function storedTitle(sessionId) {
 }
 
 /** Model-facing session operations over the same service used by desktop and TUI. */
+/** `session action=list`: live sessions first, then the filtered catalog scan. */
+async function listSessions({ service, liveWork, readRow }, args, context, limit) {
+  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
+  // 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 = 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 =
+    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));
+}
+
+/** `session action=send`: queue a prompt in another session (a room member, a task session or any session). */
+async function sendToSession({ service, agentTasks }, args, context, sessionId, caller) {
+  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.
+  // Forwarded files ride along as stored attachment parts (workspace-tools.mjs).
+  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 } : {}) };
+  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;
+  if (origin) {
+    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 ? 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 {
+    // New work from this sender: a delegated target acts as the sender does.
+    await rebindDelegation(sessionId, caller);
+    const result = await service.submitSession({
+      sessionId,
+      prompt,
+      options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...chainMeta } },
+    });
+    accepted = result.accepted === true;
+  }
+  return unreportedSendResult(sessionId, addressed, accepted, hop);
+}
+
+/** `session action=status` (and the default read): one session's route, busy state and pending work. */
+async function readSessionStatus({ service, readTitle, pendingWork }, action, sessionId, limit) {
+  const result = await service.readSession({
+    sessionId,
+    transcriptItemLimit: action === 'status' ? 1 : limit,
+    transcriptByteBudget: SESSION_TOOL_OUTPUT_BYTES,
+  });
+  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: 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,
+  };
+}
+
 export function createSessionControl({
   getSessionService,
   agentTasks = createAgentTaskSessions({ getSessionService }),
@@ -108,119 +256,10 @@ export function createSessionControl({
     const service = getSessionService();
     if (!service) throw new Error('session: session service is unavailable');
     if (action === 'list') {
-      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
-      // 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 = 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 =
-        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));
+      return listSessions({ service, liveWork, readRow }, args, context, limit);
     }
     if (action === 'send') {
-      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.
-      // Forwarded files ride along as stored attachment parts (workspace-tools.mjs).
-      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 } : {}) };
-      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;
-      if (origin) {
-        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 ? 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 {
-        // New work from this sender: a delegated target acts as the sender does.
-        await rebindDelegation(sessionId, caller);
-        const result = await service.submitSession({
-          sessionId,
-          prompt,
-          options: { mode: 'prompt', transcriptMeta: { sender: 'lead', ...chainMeta } },
-        });
-        accepted = result.accepted === true;
-      }
-      return unreportedSendResult(sessionId, addressed, accepted, hop);
+      return sendToSession({ service, agentTasks }, args, context, sessionId, caller);
     }
     if (action === 'cancel') {
       // A room's exchange is run by the desktop room host, so its stop (the UI
@@ -240,31 +279,7 @@ export function createSessionControl({
       const result = await service.readSession({ sessionId, transcriptRange: { offset, limit } });
       return sessionReadOutput(sessionId, result.range, { textOffset, itemId: args.item_id });
     }
-    const result = await service.readSession({
-      sessionId,
-      transcriptItemLimit: action === 'status' ? 1 : limit,
-      transcriptByteBudget: SESSION_TOOL_OUTPUT_BYTES,
-    });
-    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: 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,
-    };
+    return readSessionStatus({ service, readTitle, pendingWork }, action, sessionId, limit);
   }
 
   return async function executeSessionControl(args = {}, context = {}) {