mixdog 1.4.1 → 1.4.3

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,
@@ -834,6 +841,50 @@ async function startChannelFrontDoor({ channelsRuntime, bootPhases }) {
   return bootPhases.measure('channel-transport-start', () => transport.start());
 }
 
+async function startDaemonMaintenance() {
+  const [schedule, liveness, { IN_FLIGHT_STAGES }] = await Promise.all([
+    import('../runtime/shared/maintenance-schedule.mjs'),
+    import('../runtime/agent/orchestrator/session/manager/runtime-liveness.mjs'),
+    import('../runtime/agent/orchestrator/session/manager/runtime-state.mjs'),
+  ]);
+  const entries = () => [...liveness._runtimeEntries()];
+  schedule.registerMaintenanceIdleProbe(
+    () =>
+      !entries().some(
+        ([, entry]) => (entry?.controller && !entry.controller.signal?.aborted) || IN_FLIGHT_STAGES.has(entry?.stage)
+      )
+  );
+  schedule.registerMaintenanceTask(
+    'worktree-cleanup',
+    async () => {
+      const maintenance = await import('../runtime/shared/worktrees/maintenance.mjs');
+      // Every session with an open runtime entry here counts as live, read
+      // again right before each removal (one that opened meanwhile keeps its folder).
+      const liveSessionIds = () =>
+        entries()
+          .filter(([, entry]) => entry && entry.closed !== true)
+          .map(([id]) => id);
+      const report = await maintenance.runWorktreeCleanup({
+        liveSessionIds: liveSessionIds(),
+        currentLiveSessionIds: liveSessionIds,
+      });
+      const incomplete = report.kept.filter((item) => item.reason === 'incomplete');
+      if (report.removed.length || report.errors.length || incomplete.length) {
+        log(
+          `worktree cleanup: removed ${report.removed.length}, incomplete ${incomplete.length}` +
+            `${incomplete.length ? ` (${incomplete.map((item) => item.id).join(', ')})` : ''}, errors ${report.errors.length}`
+        );
+      }
+    },
+    {
+      intervalMs: 60 * 60_000,
+      initialDelayMs: 3 * 60_000,
+      onError: (error) => log(`worktree cleanup failed: ${error?.message || error}`),
+    }
+  );
+  schedule.startMaintenanceSchedule();
+}
+
 async function main() {
   const startedAt = performance.now();
   const bootPhases = createBootPhaseProfiler({ log, startedAt });
@@ -858,14 +909,19 @@ async function main() {
     .then((maintenance) => maintenance.reconcileWorktreesAtStartup())
     .then((report) => {
       const changed = report.removed.length + report.recovered.length + report.pruned.length;
-      if (changed || report.errors.length) {
+      const incomplete = report.kept.filter((item) => item.reason === 'incomplete').length;
+      if (changed || incomplete || report.errors.length) {
         log(
           `worktree reconcile: removed ${report.removed.length}, recovered ${report.recovered.length}, ` +
-            `pruned ${report.pruned.length}, errors ${report.errors.length}`
+            `pruned ${report.pruned.length}, incomplete ${incomplete}, errors ${report.errors.length}`
         );
       }
     })
     .catch((error) => log(`worktree reconcile failed: ${error?.message || error}`));
+  // Idle-time housekeeping (shared/maintenance-schedule.mjs): the worktree
+  // cleanup's count/age limits and archive rules once the desktop (favorites)
+  // is attached, then hourly while no session is mid-turn.
+  void startDaemonMaintenance().catch((error) => log(`maintenance schedule failed: ${error?.message || error}`));
   // The daemon owns prompt attachments; its census runs off the boot path
   // (first attempt after the store's start delay, then per its interval).
   void import('../runtime/attachments/store.mjs').then((store) => store.startAttachmentGc()).catch(() => {});
@@ -1036,6 +1092,9 @@ async function main() {
     submit: async (sessionId, prompt, options) =>
       (await sessionService.submitSession({ sessionId, prompt, options }))?.accepted === true,
     abort: (sessionId) => sessionService.abortSession({ sessionId }),
+    // A routine's executor sub-agent, run to its end before its bot is woken
+    // (routine-executor.mjs); resolves `{ sessionId, content }`.
+    runAgent: (args, context, options) => agentControl.runForeground(args, context, options),
   });
   // A bot's next turn, whatever starts it, first reads the progress updates
   // queued for its thread (they wake nobody on their own).

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

@@ -17,6 +17,7 @@ import { createToolCardResults } from '../tui/session/tool-card-results.mjs';
 import { createAgentJobFeed } from '../tui/session/agent-job-feed.mjs';
 import { createWorktreeSetupNotices } from '../tui/session/worktree-setup-notice.mjs';
 import { createContextState } from '../tui/session/context-state.mjs';
+import { onTodoChange, todoSnapshot } from '../runtime/agent/orchestrator/runtime-core/todo-list.mjs';
 import { createSessionFlow } from '../tui/session/session-flow.mjs';
 import { createRunTurn } from '../tui/session/turn.mjs';
 import { createQuotaResumeLane } from '../tui/session/quota-resume.mjs';
@@ -39,6 +40,7 @@ import {
   tuiDebug,
   nextId,
   createTranscriptSpillBuffer,
+  spillWarningToStderr,
   sweepStaleTranscriptSpillDirsOnce,
 } from '../tui/session/transcript-spill.mjs';
 import { importInStages } from './staged-import.mjs';
@@ -146,6 +148,9 @@ export function createRuntimePulse({
   const pulse = () => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
+    // A closed conversation has no session to read: republishing would blank
+    // its last todo and Goal for anyone still viewing it.
+    if (flags.admission === 'terminal') return;
     syncContextStats({ allowEstimated: true });
     publishChanged({
       ...routeState(),
@@ -278,7 +283,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 {
@@ -383,6 +389,12 @@ export async function createLocalSessionRuntime({
     displayedExecutionNotificationKeys,
     pushNotice,
     itemIndexById,
+    // The status line's context gauge after an empty session's settings reconcile.
+    refreshContextStats: () => {
+      if (flags.disposed || flags.pendingSessionReset) return;
+      syncContextStats({ allowEstimated: true });
+      set({ stats: { ...getState().stats } });
+    },
   });
   lifecycle.unsubscribeRuntimeNotifications = subscribeRuntimeNotifications();
   if (typeof runtime.onWorktreeSetup === 'function') {
@@ -398,6 +410,12 @@ export async function createLocalSessionRuntime({
     });
   }
 
+  // A todo call republishes the list at once, not on the next 2s pulse.
+  lifecycle.unsubscribeTodo = onTodoChange(({ sessionId }) => {
+    if (flags.disposed || flags.pendingSessionReset || !sessionId || sessionId !== runtime.id) return;
+    set({ todo: todoSnapshot(runtime.session) });
+  });
+
   const { patchToolCardResult, flushToolResults } = createToolCardResults({
     getState,
     set,
@@ -457,6 +475,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

@@ -4,10 +4,13 @@
 // owner that never published, the newest candidate's exit and first stderr
 // error — so the desktop error card's details name the cause, not only the
 // symptom.
-export const DAEMON_UNAVAILABLE_MESSAGE = 'daemon session endpoint is unavailable';
+const DAEMON_UNAVAILABLE_MESSAGE = 'daemon session endpoint is unavailable';
 
 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

@@ -12,10 +12,13 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'agentDefinitionPresence',
   'archivedAgentIdentities',
   'getAgentDefinition',
+  'listInstructionFiles',
+  'getInstructionFile',
   'getAgentAvatarImage',
   'getAgentConnectors',
   'getProjectConnectors',
   'getAgentAlwaysAllowedTools',
+  'getAgentConnectorTools',
   'getAgentPermissions',
   'listConnectors',
   'listConnectorTools',
@@ -81,6 +84,8 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getBranchMenu',
   'getProjectBranchMenu',
   'listWorktrees',
+  'previewWorktreeCleanup',
+  'getSessionWorktreeWork',
   'hooksStatus',
   'inheritancePreflight',
   'listAgents',
@@ -94,6 +99,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'listWebSearchModels',
   'listThemes',
   'listShellJobs',
+  'listStoppableShellJobs',
   'listWorkflows',
   'mcpStatus',
   'pluginsStatus',
@@ -107,6 +113,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
 export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'addHookRule',
   'addMcpServer',
+  'addConnectorAccount',
   'addPlugin',
   'addSkill',
   'agentControl',
@@ -133,6 +140,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'deleteAgentDefinition',
   'restoreAgentDefinition',
   'purgeAgentDefinition',
+  'saveInstructionFile',
+  'resetInstructionFile',
   'deleteHookRule',
   'deleteMediaAsset',
   'deleteMediaAssets',
@@ -146,6 +155,9 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'checkCustomProviderKeyEnv',
   'discoverCustomProviderModels',
   'deleteSession',
+  // The desktop's auto-delete: configureSession routes it through the turn
+  // gate (session-action.mjs deleteIdleSession), never the generic lane.
+  'deleteSessionIfIdle',
   'deleteWebhook',
   'deleteWorkflow',
   'enablePluginMcp',
@@ -269,6 +281,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'startConversationImport',
   'startMediaJob',
   'stopShellJob',
+  'stopShellJobs',
   'releaseShellJob',
   'switchContext',
   'taskControl',
@@ -289,6 +302,8 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'mergeWorkspace',
   'removeWorktree',
   'pruneWorktrees',
+  'deleteWorktree',
+  'setArchivedSessionWorktrees',
 ]);
 
 export const SESSION_READ_ACTION_SET = new Set(SESSION_READ_ACTIONS);

package/src/standalone/session-service/agent-route-follow.mjs

@@ -4,21 +4,13 @@
 // on the model it started on). The latest saved route wins. A thread no
 // runtime hosts keeps its model until it is opened (the desktop refreshes it
 // then, agent-home-sessions.ts).
-import { subscribeAgentRouteChanges } from '../../session-runtime/agent-profile-changes.mjs';
+import {
+  AGENT_ROUTE_KEYS as ROUTE_KEYS,
+  subscribeAgentRouteChanges,
+} from '../../session-runtime/agent-profile-changes.mjs';
 import { agentHomeSessionId } from '../../runtime/agent/orchestrator/session/agent-home.mjs';
 import { roomMemberOfSession } from '../../runtime/agent/orchestrator/session/agent-room.mjs';
 
-const ROUTE_KEYS = [
-  'provider',
-  'model',
-  'effort',
-  'fast',
-  'autoEffort',
-  'modelParameters',
-  'contextPercent',
-  'contextTokens',
-];
-
 /** The pick the session route API takes for a saved route. */
 function sessionRoutePick(route) {
   const pick = { sessionOnly: true };
@@ -41,29 +33,40 @@ export function createAgentRouteFollow({ sessionsById, sessionOwner, advance, pu
         if (step.changed) publishStep(entry, step);
       })
       .catch((error) => {
-        // A route the runtime refuses (provider signed out) leaves the chat on its model.
+        // A route the runtime refuses (provider signed out) leaves the chat on
+        // its model; the publication fails, so a retrying publisher sends it again.
         log(`agent route change not applied to ${sessionId}: ${error?.message || error}`);
+        throw error;
       });
   }
 
   function enqueue(sessionId, pick) {
     const queued = (tails.get(sessionId) || Promise.resolve()).then(() => apply(sessionId, pick));
-    tails.set(sessionId, queued);
-    queued.then(() => {
-      if (tails.get(sessionId) === queued) tails.delete(sessionId);
+    // A refused update never holds back the chat's later ones.
+    const tail = queued.catch(() => {});
+    tails.set(sessionId, tail);
+    tail.then(() => {
+      if (tails.get(sessionId) === tail) tails.delete(sessionId);
     });
     return queued;
   }
 
-  // Every matching chat is queued before the first await: publications queue in order.
-  function follow(agentId, route) {
+  // Every matching chat is queued before the first await: publications queue
+  // in order. Rejects once every chat settled when any refused the route.
+  async function follow(agentId, route) {
     const home = agentHomeSessionId(agentId);
-    if (!home || !route?.provider || !route?.model) return Promise.resolve();
+    if (!home || !route?.provider || !route?.model) return;
     const pick = sessionRoutePick(route);
     const queued = [...sessionsById.keys()]
       .filter((sessionId) => sessionId === home || roomMemberOfSession(sessionId)?.agentId === agentId)
       .map((sessionId) => enqueue(sessionId, pick));
-    return Promise.all(queued);
+    const failures = (await Promise.allSettled(queued)).filter((one) => one.status === 'rejected');
+    if (failures.length) {
+      throw new AggregateError(
+        failures.map((one) => one.reason),
+        `${failures.length} chat(s) of ${agentId} did not take the route`
+      );
+    }
   }
   return subscribeAgentRouteChanges(follow);
 }

package/src/standalone/session-service/agent-tree/agent-turns.mjs

@@ -6,6 +6,7 @@ import { createAgentChildFactory } from './agent-child.mjs';
 import { partialHandoffTextFromSession } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { attachmentsForIntake } from '../../../runtime/attachments/store.mjs';
 import { producedFileLines } from '../../../runtime/shared/handoff-artifacts.mjs';
+import { carryReportOnError, turnReportText } from '../../../runtime/agent/orchestrator/session/loop/turn-report.mjs';
 import {
   collectUnreportedWrites,
   handoffContent,
@@ -79,7 +80,16 @@ export function createAgentTurns({
     return error;
   }
 
-  async function runAgentTurn({ session, prompt, context = null, onToolResult, onTerminalResult } = {}) {
+  async function runAgentTurn({
+    session,
+    prompt,
+    context = null,
+    onToolResult,
+    onTerminalResult,
+    // The trusted skill-selection text of the turn (a routine executor's
+    // instructions); absent selects from the whole prompt, as any turn does.
+    skillSelection,
+  } = {}) {
     await rehydrateAgentSessions();
     const sessionId = String(session?.id || session || '').trim();
     const cancelEpoch = registry.assertAdmission(sessionId);
@@ -116,11 +126,12 @@ export function createAgentTurns({
         priority: 'next',
         context,
         transcriptMeta: agentTurnTranscriptMeta(content),
+        ...(typeof skillSelection === 'string' ? { skillSelection } : {}),
         ...(entry.runtime.isWireSafe === true || typeof onToolResult !== 'function' ? {} : { onToolResult }),
       };
       const detail = await target.call(entry.runtime, content, options);
       if (detail?.status === 'failed') {
-        throw new Error(String(detail.error || 'agent session turn failed'));
+        throw carryReportOnError(new Error(String(detail.error || 'agent session turn failed')), detail.carriedReport);
       }
       if (detail?.status === 'cancelled') {
         const stop = takeWatchdogStop(sessionId) || new Error('agent session turn cancelled');
@@ -134,11 +145,12 @@ export function createAgentTurns({
         const reason = String(detail?.reason || detail?.error || '').trim();
         throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
-      let result = detail?.result || { content: '' };
-      // The files the turn produced reach the owner with its handoff.
-      const report = String(result.content || '');
+      const { reportContent, ...settled } = detail?.result || { content: '' };
+      // The owner gets the turn's whole report (turn-report.mjs), with the
+      // files the turn produced.
+      const report = turnReportText({ ...settled, reportContent });
       const files = await turnArtifactLines(entry.runtime, messageStart, descriptor, report);
-      if (files.length) result = { ...result, content: [report, files.join('\n')].join('\n\n') };
+      const result = { ...settled, content: files.length ? [report, files.join('\n')].join('\n\n') : report };
       descriptor.status = 'idle';
       descriptor.stage = 'idle';
       descriptor.lastHandoff = typeof result?.content === 'string' ? result.content : '';