mixdog 1.4.0 → 1.4.2

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).
@@ -27,12 +81,7 @@ const loadManager = () => import('../../runtime/shared/worktrees/manager.mjs');
  * @param {((args: object, context: object) => Promise<any>)|null} [deps.executeSessionControl] Cross-session lane.
  * @param {object|null} [deps.manager] Managed-worktree backend override (tests).
  */
-export function createWorktreeToolHost({
-  getSession,
-  getWorkspaceApi,
-  executeSessionControl = null,
-  manager = null,
-}) {
+export function createWorktreeToolHost({ getSession, getWorkspaceApi, executeSessionControl = null, manager = null }) {
   const backend = () => (manager ? Promise.resolve(manager) : loadManager());
 
   function workspaceApi() {
@@ -66,54 +115,13 @@ export function createWorktreeToolHost({
     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.
+   */
+  async function orphan(predicate) {
+    const rows = await workspaceApi().listWorktrees();
+    return rows.find((row) => predicate(row) && row.ownerLive === false && row.removable === true) ?? null;
   }
 
   /**
@@ -129,6 +137,9 @@ export function createWorktreeToolHost({
       );
     }
     if (entry.kind === 'snapshot') return workspaceApi().removeSnapshot({ path: entry.path, force: request.force });
+    if (entry.ownerSessionId !== callerSessionId && (await orphan((row) => row.id === entry.id))) {
+      return workspaceApi().removeOrphanWorktree({ entryId: entry.id, force: request.force === true });
+    }
     if (!entry.ownerSessionId) {
       throw new Error(
         `git worktree remove: no session retains ${entry.path}; git worktree prune removes it once it is clean and merged`
@@ -161,8 +172,14 @@ export function createWorktreeToolHost({
         return back(lane(), request);
       case 'merge':
         return merge(lane());
-      case 'remove':
-        return lane().call('removeWorktree', { force: request.force === true });
+      case 'remove': {
+        const force = request.force === true;
+        if (request.sessionId && request.sessionId !== callerSessionId) {
+          const gone = await orphan((row) => row.ownerSessionId === request.sessionId);
+          if (gone) return workspaceApi().removeOrphanWorktree({ entryId: gone.id, force });
+        }
+        return lane().call('removeWorktree', { force });
+      }
       case 'list':
         return workspaceApi().listWorktrees({ includeSnapshots: true });
       case 'prune':

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

@@ -66,6 +66,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-session-control.mjs

@@ -7,6 +7,7 @@ import {
 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 { assertBotChainTarget, botChainOf } from '../runtime/shared/bot-hops.mjs';
 import { agentIdOfHomeSession } from '../runtime/agent/orchestrator/session/agent-home.mjs';
@@ -79,10 +80,159 @@ 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 }),
-  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,
@@ -92,7 +242,7 @@ export function createSessionControl({
   const worktreeControl = createWorktreeControl(getSessionService);
   const routeControl = createRouteControl(getSessionService);
 
-  return async function executeSessionControl(args = {}, context = {}) {
+  async function control(args = {}, context = {}) {
     const action = args.action;
     const caller = requestCaller(action, context);
     // `callerAgentId`: set only for an attended agent conversation (workspace-tools.mjs).
@@ -106,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
@@ -238,30 +279,20 @@ 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 = {}) {
+    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

@@ -22,6 +22,13 @@ process.env.MIXDOG_DAEMON_HOST = '1';
 await import('../runtime/shared/uv-threadpool-boot.mjs');
 // Before anything can import sharp: Electron on Linux must use its wasm build.
 await import('../runtime/shared/sharp-electron-linux.mjs');
+// Proxy variables (the user's, or the desktop's system proxy): fetch goes
+// through the proxy while local and LAN hosts stay direct. The system proxy
+// (handed over by the CLI or desktop that started this daemon, or read on
+// Windows when started alone) is applied to this process's fetch only; its
+// handoff variable is removed here so no child inherits it.
+(await import('../runtime/shared/llm/system-proxy.mjs')).adoptSystemProxy();
+(await import('../runtime/shared/llm/http-agent.mjs')).adoptEnvProxy();
 
 // No V8 compile cache here, on purpose. Measured on this runtime: a cache hit
 // saves nothing (spawn→ready 316-347ms with the cache vs 318-323ms without,

package/src/standalone/desktop-service-registry.mjs

@@ -4,6 +4,7 @@ import { sanitizeForWire } from './session-wire-values.mjs';
 import { annotateSpan } from '../runtime/shared/slow-span.mjs';
 import { modelProxyClientMode } from '../runtime/shared/model-proxy-mode.mjs';
 import { getModelProxyChannel } from '../runtime/agent/orchestrator/providers/model-proxy-channel.mjs';
+import { SYSTEM_PROXY_REQUEST_EVENT } from '../runtime/shared/llm/system-proxy.mjs';
 
 const requireDesktopModule = createRequire(import.meta.url);
 
@@ -40,6 +41,8 @@ function desktopEventKey(desktopId, message) {
     let terminalId = '';
     if (name === 'terminal-data') terminalId = String(message?.value?.id || '');
     else if (name === 'session-runtime-released') terminalId = String(message?.value?.sessionId || '');
+    // Each lookup waits for its own answer: a backed-up stream must not drop one.
+    else if (name === SYSTEM_PROXY_REQUEST_EVENT) terminalId = String(message?.value?.id || '');
     return `desktop-event:${desktopId}:${kind}:${name}${terminalId ? `:${terminalId}` : ''}`;
   }
   return `desktop-event:${desktopId}:${kind}`;
@@ -236,6 +239,12 @@ export class DesktopServiceRegistry {
       }
       callArgs = [callArgs[0], callArgs[1], epoch];
     }
+    // The resolver stays attached while this client is: its epoch is released with it.
+    if (name === 'invokeDesktopOperation' && callArgs[0] === 'systemProxyAttach') {
+      const epoch = token ? service.visibilityEpochs.get(token) : undefined;
+      if (epoch === undefined) throw new Error('desktop service client is not initialized');
+      callArgs = ['systemProxyAttach', [epoch]];
+    }
     // `[slow-op] desktop.invoke` names the call it timed: a desktop operation
     // (Git reads) or a session capability, not only the generic route.
     const target = name === 'invokeDesktopOperation' || name === 'invokeCapability' ? String(args?.[0] || '') : '';

package/src/standalone/local-session-runtime.mjs

@@ -39,6 +39,7 @@ import {
   tuiDebug,
   nextId,
   createTranscriptSpillBuffer,
+  spillWarningToStderr,
   sweepStaleTranscriptSpillDirsOnce,
 } from '../tui/session/transcript-spill.mjs';
 import { importInStages } from './staged-import.mjs';
@@ -278,7 +279,8 @@ export async function createLocalSessionRuntime({
   const { getState, getPublishedState, set, flushEmit, flushEmitImmediate } = store;
 
   const itemIndexById = new Map();
-  const transcriptSpill = createTranscriptSpillBuffer();
+  // stderr is daemon.log in the daemon: a pinned spill must not stay silent.
+  const transcriptSpill = createTranscriptSpillBuffer({ onWarning: spillWarningToStderr });
   const { markToolCallActive, markToolCallDone, clearActiveToolSummary, resetActiveToolCalls } =
     createActiveToolTracker({ getState, set });
   const {
@@ -457,6 +459,8 @@ export async function createLocalSessionRuntime({
     snapshotTranscriptSpill: () => transcriptSpill.snapshot(),
     restoreTranscriptSpill: (snapshot) => transcriptSpill.restoreSnapshot(snapshot),
     releaseTranscriptSpill: (snapshot) => transcriptSpill.releaseSnapshot(snapshot),
+    // Paged views read the rows spilled out of memory (transcript-window.mjs).
+    readSpilledTranscript: (range) => transcriptSpill.readSpilled(range),
     presentNextToolApproval,
     finishToolApproval,
     denyAllToolApprovals,

package/src/standalone/session-client/daemon-unavailable.mjs

@@ -8,6 +8,9 @@ export const DAEMON_UNAVAILABLE_MESSAGE = 'daemon session endpoint is unavailabl
 
 function exitCodeText(code) {
   // Windows reports NTSTATUS crash codes as large unsigned values.
+  // 0xE0000008 is Chromium's kOomExceptionCode; 134 is a V8 fatal error (abort).
+  if (code === 0xe0000008 || code === -536870904) return `${code === -536870904 ? code : '0xE0000008'} (out of memory)`;
+  if (code === 134) return '134 (V8 fatal error (JavaScript heap out of memory))';
   return Number.isSafeInteger(code) && code > 0x7fffffff ? `0x${code.toString(16).toUpperCase()}` : String(code);
 }
 

package/src/standalone/session-client.mjs

@@ -18,6 +18,7 @@ import { readSingletonOwner } from '../runtime/shared/singleton-owner.mjs';
 import { isPidAlive } from '../runtime/shared/pid-liveness.mjs';
 import { resolveRuntimeRoot } from '../runtime/shared/runtime-root.mjs';
 import { withHeapCap } from '../runtime/shared/heap-cap.mjs';
+import { systemProxyHandoffEnv } from '../runtime/shared/llm/system-proxy.mjs';
 import { daemonCrashCaptureDir, daemonDataDir } from '../session-runtime/services/daemon-crash-capture.mjs';
 import { forkDaemonCandidate } from '../session-runtime/services/daemon-candidate.mjs';
 import { daemonOwnerIsStale, proveDaemonOwnerRecord } from './daemon-owner.mjs';
@@ -338,7 +339,7 @@ async function replaceLowerDaemon(discovery, initialHealth, { log, onUpgradeWait
 // PostgreSQL stop included — so the launcher's quit stops it first.
 const inTreeDaemons = new Map();
 
-export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = daemonEntry() }) {
+export async function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = daemonEntry() }) {
   const t0 = performance.now();
   const at = () => Math.round(performance.now() - t0);
   const detached = daemonShouldDetach();
@@ -353,6 +354,9 @@ export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = dae
     detached,
     env: {
       ...process.env,
+      // The fallback system proxy this launcher settled (the CLI), not as
+      // standard proxy env; a desktop is asked per origin once attached.
+      ...systemProxyHandoffEnv(),
       ELECTRON_RUN_AS_NODE: '1',
       MIXDOG_DAEMON_HOST: '1',
       MIXDOG_RUNTIME_ROOT: resolveRuntimeRoot(),