mixdog 1.4.1 → 1.4.2

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 = {}) {

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(),

package/src/standalone/session-frame-stream.mjs

@@ -1,6 +1,8 @@
-// Session snapshots are latest-wins under backpressure; terminal byte streams
-// concatenate instead. Keep socket ownership and bounded backlog policy here.
+// Session snapshots are latest-wins under backpressure; a session patch chains
+// onto the queued frame it builds on, and terminal byte streams concatenate.
+// Keep socket ownership and bounded backlog policy here.
 const TERMINAL_BACKLOG_MAX_CHARS = 256 * 1024;
+const KEEPALIVE_MS = 15_000;
 
 function terminalDataFrame(frame) {
   return frame?.type === 'desktop-event' &&
@@ -26,13 +28,28 @@ function mergePendingFrame(existing, frame, json) {
 }
 
 function pendingEntry(frame, json, queuedAt) {
-  return { frame, json, bytes: Buffer.byteLength(json) + 8, queuedAt };
+  const sse = `data: ${json}\n\n`;
+  return { frame, sse, bytes: Buffer.byteLength(sse), queuedAt };
 }
 
 function isResyncMarker(frame) {
   return frame?.resyncRequired === true || frame?.message?.resyncRequired === true;
 }
 
+// A patch builds on the frame queued before it for the same key. Replacing
+// that frame hands the receiver a lane it cannot decode, and the resync it
+// asks for re-sends the full snapshot into the same backlog.
+function isPatchFrame(frame) {
+  if (isResyncMarker(frame)) return false;
+  if (frame?.type === 'session-state') return Boolean(frame.patch) && Number.isSafeInteger(frame.baseRevision);
+  const wire = frame?.type === 'desktop-event' && frame.message?.kind === 'session-state' ? frame.message.wire : null;
+  return Boolean(wire?.__itemsPatch);
+}
+
+function readTraceIdOf(frame) {
+  return frame?.readTraceId ?? frame?.message?.readTraceId;
+}
+
 function resyncEntry(frame) {
   if (frame?.type === 'desktop-event' && frame.message?.kind === 'session-state' && frame.message.sessionId) {
     // The desktop decoder cannot apply a patch against base -2, so it resets
@@ -116,13 +133,39 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     } catch {}
   }
 
+  function pause(client) {
+    if (!client.paused) client.pausedAt = nowMs();
+    client.paused = true;
+  }
+
+  // A stream paused across a keepalive period: bytes still buffered mean the
+  // consumer stopped reading; none buffered means a drain that never fired.
+  function reportStall(client, res) {
+    if (typeof onDiagnostic !== 'function') return;
+    const atMs = nowMs();
+    if (atMs - client.pausedAt < KEEPALIVE_MS) return;
+    try {
+      onDiagnostic({
+        stage: 'stream-stalled',
+        atMs,
+        pausedMs: atMs - client.pausedAt,
+        bufferedBytes: res.writableLength,
+        needDrain: res.writableNeedDrain,
+        pendingBytes: client.pendingBytes || 0,
+        maxPendingBytes,
+      });
+    } catch {
+      /* A diagnostic failure cannot change backpressure. */
+    }
+  }
+
   function flushPending(client) {
     while (client.sse && !client.paused && client.pending.size > 0) {
       const [key, entry] = client.pending.entries().next().value;
       client.pending.delete(key);
       client.pendingBytes = Math.max(0, client.pendingBytes - (entry.bytes || 0));
       try {
-        if (client.sse.write(`data: ${entry.json}\n\n`) === false) client.paused = true;
+        if (client.sse.write(entry.sse) === false) pause(client);
         traceFrame(client, entry.frame, 'stream-write', entry);
       } catch {
         traceFrame(client, entry.frame, 'stream-write-failed', entry, true);
@@ -144,13 +187,18 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     client.pending.set(key, entry);
     client.pendingBytes += entry.bytes || 0;
     traceFrame(client, entry.frame, 'stream-queued', entry);
+    boundPending(client, key);
+  }
+
+  function boundPending(client, key) {
     // The cap bounds accumulated backlog: older entries collapse to resync
     // markers or drop, oldest first. The newest frame is always admitted, so a
     // snapshot larger than the cap still reaches a client with no backlog, and
     // markers are kept so a receiver always learns what it missed.
     for (const [oldestKey, oldest] of client.pending) {
       if (client.pendingBytes <= maxPendingBytes) break;
-      if (oldestKey === key || isResyncMarker(oldest.frame)) continue;
+      // Only a single newest frame is exempt: a patch chain is backlog too.
+      if ((oldestKey === key && !oldest.chained) || isResyncMarker(oldest.frame)) continue;
       const marker = resyncEntry(oldest.frame);
       if (marker && marker.bytes < oldest.bytes) {
         traceFrame(client, oldest.frame, 'stream-resync-marker', oldest, true);
@@ -166,7 +214,26 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
   }
 
   function queueFrame(client, key, frame, json) {
-    const merged = mergePendingFrame(client.pending.get(key), frame, json);
+    const existing = client.pending.get(key);
+    if (existing && isPatchFrame(frame)) {
+      // A queued marker already makes the receiver fetch a fresh full
+      // snapshot, which supersedes every patch issued before it.
+      if (isResyncMarker(existing.frame)) return;
+      const next = pendingEntry(frame, json, nowMs());
+      // Map.set on a present key keeps its place: the chain leaves with its base.
+      client.pending.set(key, {
+        frame: readTraceIdOf(existing.frame) ? existing.frame : frame,
+        sse: existing.sse + next.sse,
+        bytes: existing.bytes + next.bytes,
+        queuedAt: existing.queuedAt,
+        chained: true,
+      });
+      client.pendingBytes += next.bytes;
+      traceFrame(client, frame, 'stream-queued', next);
+      boundPending(client, key);
+      return;
+    }
+    const merged = mergePendingFrame(existing, frame, json);
     setPending(client, key, pendingEntry(merged.frame, merged.json, nowMs()));
   }
 
@@ -177,7 +244,7 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
       return;
     }
     try {
-      if (client.sse.write(`data: ${json}\n\n`) === false) client.paused = true;
+      if (client.sse.write(`data: ${json}\n\n`) === false) pause(client);
       traceFrame(client, frame, 'stream-write');
     } catch {
       traceFrame(client, frame, 'stream-write-failed', {}, true);
@@ -221,7 +288,8 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     const paused = res.write(': attached\n\n') === false;
     const previous = client.sse;
     client.sse = res;
-    client.paused = paused;
+    client.paused = false;
+    if (paused) pause(client);
     client.lastSeen = nowMs();
     // Replacement transfers ownership before closing the old stream, so its
     // close/error callbacks cannot detach the new response.
@@ -252,13 +320,17 @@ export function createSessionFrameStream({ clients, maxPendingBytes, nowMs, onAt
     res.on('close', cleanup);
     res.on('error', cleanup);
     keepAlive = setInterval(() => {
-      if (client.sse !== res || client.paused) return;
+      if (client.sse !== res) return;
+      if (client.paused) {
+        reportStall(client, res);
+        return;
+      }
       try {
-        if (res.write(': ka\n\n') === false) client.paused = true;
+        if (res.write(': ka\n\n') === false) pause(client);
       } catch {
         retireStream(res);
       }
-    }, 15_000);
+    }, KEEPALIVE_MS);
     keepAlive.unref?.();
     flushPending(client);
     return true;

package/src/standalone/session-protocol.mjs

@@ -16,6 +16,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getAgentConnectors',
   'getProjectConnectors',
   'getAgentAlwaysAllowedTools',
+  'getAgentConnectorTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
@@ -94,6 +95,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'listWebSearchModels',
   'listThemes',
   'listShellJobs',
+  'listStoppableShellJobs',
   'listWorkflows',
   'mcpStatus',
   'pluginsStatus',
@@ -107,6 +109,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
 export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'addHookRule',
   'addMcpServer',
+  'addConnectorAccount',
   'addPlugin',
   'addSkill',
   'agentControl',
@@ -269,6 +272,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'startConversationImport',
   'startMediaJob',
   'stopShellJob',
+  'stopShellJobs',
   'releaseShellJob',
   'switchContext',
   'taskControl',