mixdog 1.2.0 → 1.2.2

package/src/session-runtime/webhook-session-run.mjs

@@ -35,6 +35,10 @@ export async function runWebhookSession({
   workflow = null,
   attachments = null,
   signal = null,
+  // Endpoint-authored instructions: the run's ONLY skill-selection input.
+  // `prompt` also carries the fenced external payload, which must never
+  // select a skill; absent means nothing selects.
+  skillSelection = '',
 }) {
   const endpoint = String(name || '').trim();
   const body = String(prompt || '').trim();
@@ -63,9 +67,17 @@ export async function runWebhookSession({
   // askOpts.signal is the parent-abort link: it is cascaded onto the turn
   // controller, so aborting it stops the in-flight provider/tool work instead
   // of leaving a timed-out delivery's session running with live side effects.
-  const ask = (turnContent) =>
-    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, signal ? { signal } : {});
-  // Agents the run delegates to report back; each result is the next turn.
-  const result = await runAutomationTurns(session.id, () => ask(content), ask);
+  const ask = (turnContent, askOpts) =>
+    askSession(session.id, turnContent, null, null, projectCwd || undefined, undefined, {
+      ...askOpts,
+      ...(signal ? { signal } : {}),
+    });
+  // Agents the run delegates to report back; each result is the next turn
+  // (runAutomationTurns marks those turns as task notifications).
+  const result = await runAutomationTurns(
+    session.id,
+    () => ask(content, { skillSelection: String(skillSelection ?? '') }),
+    ask
+  );
   return { sessionId: session.id, result: String(result?.content || '') };
 }

package/src/skill-script-entry.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+// Entry the skill-script launcher runs (src/runtime/shared/skill-script-runtime.mjs):
+//   <runtime executable> skill-script-entry.mjs <script.mjs> [args...]
+// The script then sees itself as the main module, exactly as under
+// `node <script.mjs> [args...]`, and its exit code is the process's.
+
+// Before anything can import sharp: Electron on Linux must use its wasm build.
+await import('./runtime/shared/sharp-electron-linux.mjs');
+// Node mode belongs to this process only; whatever the script starts is a
+// normal child again.
+delete process.env.ELECTRON_RUN_AS_NODE;
+
+const { pathToFileURL } = await import('node:url');
+const { canonicalSkillScriptPath, decodeSkillArgv, SKILL_ARGV_ENV } = await import(
+  './runtime/shared/skill-script-runtime.mjs'
+);
+
+// The PowerShell `mixdog-skill-node` function passes its arguments in the
+// environment (see renderPowerShellSkillFunction); the script never sees them.
+const envArgv = process.argv.length === 2 ? decodeSkillArgv(process.env[SKILL_ARGV_ENV]) : null;
+delete process.env[SKILL_ARGV_ENV];
+const [execPath, , target, ...args] = envArgv ? [process.argv[0], process.argv[1], ...envArgv] : process.argv;
+if (!target) {
+  console.error('Usage: <skill launcher> <script.mjs> [args...]');
+  process.exitCode = 2;
+} else {
+  const script = canonicalSkillScriptPath(target);
+  // The scripts' main check compares import.meta.url with argv[1].
+  process.argv = [execPath, script, ...args];
+  try {
+    await import(pathToFileURL(script).href);
+  } catch (error) {
+    console.error(error?.stack || String(error));
+    process.exitCode = 1;
+  }
+}

package/src/standalone/daemon-drain-policy.mjs

@@ -1,3 +1,11 @@
+/** Whether an idle GC sweep may start: no service call and no running turn
+ *  (provider stream / tool call). Background-task-only sessions and memory
+ *  agents do not block it — unlike drainDeferral, which guards shutdown. */
+export function idleGcEligible(work) {
+  const { activeCalls = 0, queuedCalls = 0, turnBusySessions = 0 } = work || {};
+  return !(activeCalls > 0 || queuedCalls > 0 || turnBusySessions > 0);
+}
+
 /** Whether self-shutdown must wait for in-flight work. A forced replacement
  *  never waits: shutdown() aborts busy sessions, service calls and agent runs. */
 export function drainDeferral(work, { force = false } = {}) {

package/src/standalone/daemon-stored-session-views.mjs

@@ -78,9 +78,17 @@ export function createStoredSessionViews({ desktopRuntime, dataDir }) {
         });
       }
       const store = await desktopRuntime.loadSessionStore();
-      return store.listStoredSessionSummaries({
-        refreshFromStorage: options.refreshFromStorage === true,
-      });
+      const refreshFromStorage = options.refreshFromStorage === true;
+      // Paged ordinary catalog ({ sessions, nextCursor }) only on the explicit
+      // `page: { limit, cursor }` option (`limit` alone keeps its old meaning:
+      // ignored, full array). An authoritative refresh is never paged.
+      const page = options.page && typeof options.page === 'object' ? options.page : null;
+      if (page && !refreshFromStorage && store.listStoredSessionSummaryPage) {
+        return store.listStoredSessionSummaryPage({ limit: page.limit, cursor: page.cursor });
+      }
+      // The async listing may answer from the session catalog DB.
+      if (store.listStoredSessionSummariesAsync) return store.listStoredSessionSummariesAsync({ refreshFromStorage });
+      return store.listStoredSessionSummaries({ refreshFromStorage });
     },
   };
 }

package/src/standalone/daemon-telemetry.mjs

@@ -93,6 +93,52 @@ export function collectDaemonTelemetry({
   };
 }
 
+/**
+ * Tracks the smallest heapUsed observed right after a major GC (mark-sweep-
+ * compact) — the retained-set size, which heapUsed at an arbitrary instant
+ * hides. Sampled per telemetry interval; no per-GC logging. Returns null when
+ * PerformanceObserver is unavailable.
+ */
+export function createPostGcHeapTracker({
+  heapUsed = () => v8.getHeapStatistics().used_heap_size,
+  observe = (onGc) => {
+    const obs = new PerformanceObserver((list) => {
+      for (const entry of list.getEntries()) onGc(entry);
+    });
+    obs.observe({ entryTypes: ['gc'] });
+    return () => obs.disconnect();
+  },
+} = {}) {
+  let min = -1;
+  let disconnect = null;
+  try {
+    disconnect = observe((entry) => {
+      // NODE_PERFORMANCE_GC_MAJOR = 4 (older Node: entry.kind); newer: entry.detail.kind.
+      const kind = entry?.detail?.kind ?? entry?.kind;
+      if (kind !== 4) return;
+      const used = byteCount(heapUsed());
+      if (used >= 0 && (min < 0 || used < min)) min = used;
+    });
+  } catch {
+    return null;
+  }
+  return {
+    /** Min post-major-GC heap since the last take; -1 when none ran. */
+    take() {
+      const value = min;
+      min = -1;
+      return value;
+    },
+    stop() {
+      try {
+        disconnect?.();
+      } catch {
+        /* already gone */
+      }
+    },
+  };
+}
+
 export function formatDaemonTelemetry(record, reason = 'periodic') {
   const row = record && typeof record === 'object' ? record : collectDaemonTelemetry();
   return [
@@ -110,6 +156,8 @@ export function formatDaemonTelemetry(record, reason = 'periodic') {
     `queuedCalls=${row.queuedCalls}`,
     `busySessions=${row.busySessions}`,
     `busyMemoryAgents=${row.busyMemoryAgents}`,
+    // Present only when a major GC ran since the previous line.
+    ...(byteCount(row.postGcHeapMinBytes) >= 0 ? [`postGcHeapMinBytes=${row.postGcHeapMinBytes}`] : []),
   ].join(' ');
 }
 
@@ -123,8 +171,10 @@ export function createDaemonTelemetry({
   heapStatistics,
   setIntervalFn = setInterval,
   clearIntervalFn = clearInterval,
+  createGcTracker = createPostGcHeapTracker,
 } = {}) {
   let timer = null;
+  let gcTracker = null;
 
   function emit(reason = 'periodic') {
     try {
@@ -141,6 +191,8 @@ export function createDaemonTelemetry({
         heapStatistics,
         work,
       });
+      const postGc = gcTracker?.take() ?? -1;
+      if (postGc >= 0) record.postGcHeapMinBytes = postGc;
       log(formatDaemonTelemetry(record, reason));
       return record;
     } catch {
@@ -159,6 +211,7 @@ export function createDaemonTelemetry({
 
   function start(intervalMs = DAEMON_TELEMETRY_INTERVAL_MS) {
     if (timer) return timer;
+    gcTracker ??= createGcTracker();
     const delay = Number(intervalMs);
     const ms = Number.isFinite(delay) && delay > 0 ? delay : DAEMON_TELEMETRY_INTERVAL_MS;
     const handle = setIntervalFn(() => {
@@ -174,6 +227,8 @@ export function createDaemonTelemetry({
     if (!timer) return;
     clearIntervalFn(timer);
     timer = null;
+    gcTracker?.stop();
+    gcTracker = null;
   }
 
   return { emit, start, stop };

package/src/standalone/daemon.mjs

@@ -49,6 +49,7 @@ import {
   startOwnerLivenessListener,
 } from './daemon-owner.mjs';
 import { remoteIntentPath } from '../runtime/shared/remote-intent.mjs';
+import { modelProxyClientMode } from '../runtime/shared/model-proxy-mode.mjs';
 import { setChannelNotifySink } from '../runtime/channels/lib/parent-bridge.mjs';
 import { setOwnerContext } from '../runtime/channels/lib/runtime-paths.mjs';
 import { safeIpcSend } from '../runtime/shared/safe-ipc-send.mjs';
@@ -64,7 +65,7 @@ import {
 } from '../runtime/agent/orchestrator/providers/stream-json-pool.mjs';
 import { createAgentDispatchBroker } from './agent-dispatch-broker.mjs';
 import { createChannelTransport } from './channel-transport.mjs';
-import { drainDeferral } from './daemon-drain-policy.mjs';
+import { drainDeferral, idleGcEligible } from './daemon-drain-policy.mjs';
 import { createChannelSessionRouter } from '../session-runtime/services/channel-session-router.mjs';
 import { createSessionTransport } from './session-transport.mjs';
 import { createSessionService } from './session-service.mjs';
@@ -144,6 +145,11 @@ let ownerLiveness = null;
 // The endpoints daemon.json carries once published; a heartbeat re-publishes
 // them when the file goes missing (TEMP cleanup).
 let publishedEndpoints = null;
+// Remote mode only: the loopback relay that lets headless runs started from
+// model shells (skill scripts) reach the PC behind this daemon's model proxy
+// channel (providers/model-proxy-bridge.mjs), and its running-call count.
+let modelProxyBridge = null;
+let modelProxyBridgeActive = 0;
 const eventLoopDelay = monitorEventLoopDelay({ resolution: 20 });
 eventLoopDelay.enable();
 let idleGc = null;
@@ -218,6 +224,13 @@ async function shutdown(reason, code = 0) {
   try {
     setChannelNotifySink(null);
   } catch {}
+  // Abort every relayed model call, close the bridge sockets and wait for the
+  // calls to settle before anything they depend on goes away.
+  try {
+    await modelProxyBridge?.close(`daemon shutdown: ${reason}`);
+  } catch (e) {
+    log(`model proxy bridge stop failed: ${e?.message || e}`);
+  }
   try {
     await sessionService?.stop?.(reason);
   } catch (e) {
@@ -292,10 +305,11 @@ async function shutdown(reason, code = 0) {
  *  asks whether this process may exit; idle GC asks whether a pause is safe. */
 function inFlightWork() {
   return {
-    activeCalls: (transport?.activeCount ?? 0) + (sessionTransport?.activeCount ?? 0),
+    activeCalls: (transport?.activeCount ?? 0) + (sessionTransport?.activeCount ?? 0) + modelProxyBridgeActive,
     queuedCalls: (transport?.queuedCount ?? 0) + (sessionTransport?.queuedCount ?? 0),
     busySessions: sessionService?.busyCount ?? 0,
     busyMemoryAgents: agentDispatchBroker?.snapshot?.().inFlight ?? 0,
+    turnBusySessions: sessionService?.turnBusyCount ?? 0,
   };
 }
 
@@ -340,11 +354,6 @@ daemonTelemetry = createDaemonTelemetry({
   },
 });
 
-function daemonHasWorkInFlight() {
-  const work = inFlightWork();
-  return work.activeCalls > 0 || work.queuedCalls > 0 || work.busySessions > 0 || work.busyMemoryAgents > 0;
-}
-
 /** One process, two front doors (channels + sessions): an idle side must never
  *  evict a busy one, so every self-shutdown trigger checks BOTH registries. */
 let _lastDeferredLog = { key: '', at: 0, suppressed: 0 };
@@ -562,9 +571,9 @@ function daemonStatusSnapshot() {
 
 /** The file every attacher reads to find this daemon: wire identity plus both
  *  loopback endpoints and their privileged tokens. */
-function publishDaemonDiscovery({ channel, session }) {
+function publishDaemonDiscovery({ channel, session, modelProxy = null }) {
   // A re-publish keeps the first publication's startedAt.
-  publishedEndpoints = { channel, session, startedAt: publishedEndpoints?.startedAt ?? Date.now() };
+  publishedEndpoints = { channel, session, modelProxy, startedAt: publishedEndpoints?.startedAt ?? Date.now() };
   writeJsonAtomicSync(
     DAEMON_DISCOVERY_PATH,
     {
@@ -577,12 +586,34 @@ function publishDaemonDiscovery({ channel, session }) {
       endpoints: {
         channel: { port: channel.port, token: channel.token },
         session: { port: session.port, token: session.token },
+        ...(modelProxy ? { modelProxy: { port: modelProxy.port, token: modelProxy.token } } : {}),
       },
     },
     { compact: true, secret: true }
   );
 }
 
+/** Remote mode only: the model proxy bridge endpoint to publish, or null. */
+async function startModelProxyBridge(bootPhases) {
+  if (!modelProxyClientMode()) return null;
+  const [{ createModelProxyBridgeServer }, { getModelProxyChannel }] = await Promise.all([
+    import('../runtime/agent/orchestrator/providers/model-proxy-bridge.mjs'),
+    import('../runtime/agent/orchestrator/providers/model-proxy-channel.mjs'),
+  ]);
+  modelProxyBridge = createModelProxyBridgeServer({
+    channel: getModelProxyChannel(),
+    // Fenced or shutting down: no new relayed call.
+    admit: () => !shuttingDown && admitOwnerWork(),
+    trackWork: (active) => {
+      modelProxyBridgeActive = active;
+    },
+    log,
+  });
+  const endpoint = await bootPhases.measure('model-proxy-bridge-start', () => modelProxyBridge.start());
+  log(`model proxy bridge on 127.0.0.1:${endpoint.port}`);
+  return endpoint;
+}
+
 /** Asked by both front doors before every register/call: an expired lease
  *  fences here (answered 503), and after an event-loop stall nothing is
  *  served until the record is re-verified as ours. */
@@ -598,6 +629,7 @@ function fenceDaemon(reason) {
   log(`${reason} — refusing new work and stopping so only one daemon serves`);
   sessionTransport?.commitDrain?.(reason);
   transport?.commitDrain?.(reason);
+  modelProxyBridge?.abortAll(reason);
   try {
     if (discoveryPid(DAEMON_DISCOVERY_PATH) === process.pid) rmSync(DAEMON_DISCOVERY_PATH, { force: true });
   } catch (e) {
@@ -787,7 +819,7 @@ async function main() {
   // Reclaim deferred garbage while nothing is in flight. V8 keeps a long-lived
   // daemon's dead transcripts resident for as long as the heap limit stays out
   // of sight; a measured sweep on this daemon returned 140MB in 98ms.
-  idleGc = createIdleGc({ isBusy: daemonHasWorkInFlight, log });
+  idleGc = createIdleGc({ isBusy: () => !idleGcEligible(inFlightWork()), log });
   if (idleGc.arm()) log('idle gc armed');
 
   const channelsRuntime = createChannelsRuntimeLoader({
@@ -890,6 +922,7 @@ async function main() {
     admitWork: admitOwnerWork,
   });
   const sessionEndpoint = await bootPhases.measure('session-transport-start', () => sessionTransport.start());
+  const modelProxyEndpoint = await startModelProxyBridge(bootPhases);
   // A boot whose holder stopped answering may have been superseded by a
   // contender between beats; never publish over the winner's endpoint. An
   // unreadable record (an antivirus lock) is not a takeover.
@@ -900,7 +933,7 @@ async function main() {
     exitRecorder.setReason(`owner claim superseded by pid=${ownerPid} before publish`, 0);
     process.exit(0);
   }
-  publishDaemonDiscovery({ channel: { port, token }, session: sessionEndpoint });
+  publishDaemonDiscovery({ channel: { port, token }, session: sessionEndpoint, modelProxy: modelProxyEndpoint });
   bootPhases.mark('discovery-published');
   log(`session front door on 127.0.0.1:${sessionEndpoint.port}`);
 

package/src/standalone/session-protocol.mjs

@@ -13,11 +13,13 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getChannelSetup',
   'getChannelWorkerStatus',
   'getCompactionSettings',
+  'getConversationImportJobs',
   'getDeveloperSettings',
   'getDisabledSkills',
   'getMediaDefault',
   'getMediaJob',
   'getMcpServerConfig',
+  'getMcpOAuthLoginStatus',
   'getOnboardingStatus',
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
@@ -57,6 +59,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'hooksStatus',
   'inheritancePreflight',
   'listAgents',
+  'listImportableConversations',
   'listMediaAssets',
   'listMediaLanes',
   'listOutputStyles',
@@ -83,15 +86,19 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'agentControl',
   'authenticateProvider',
   'beginOAuthProviderLogin',
+  'beginMcpOAuthLogin',
   'updateProviderAccounts',
   'cacheMediaThumbnail',
   'cancelMediaJob',
   'cancelOAuthProviderLogin',
+  'cancelMcpOAuthLogin',
+  'cancelConversationImport',
   'checkForUpdate',
   'clear',
   'compact',
   'completeOnboarding',
   'completeOAuthProviderLogin',
+  'completeMcpOAuthLogin',
   'consumeCodexRateLimitResetCredit',
   'createWorkflow',
   'deleteAgentDefinition',
@@ -115,9 +122,11 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'memoryControl',
   'openMediaAsset',
   'openMediaFolder',
+  'probeMcpServerAuth',
   'pushNotice',
   'recall',
   'reconnectMcp',
+  'registerConversationImportFile',
   'reloadPlugins',
   'reloadSkills',
   'rememberPromptHistory',
@@ -139,6 +148,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'revertTurnReviewFile',
   'revertTurnChanges',
   'reapplyTurnChanges',
+  'clearSessionChangeHistory',
   'rewindToItem',
   'runDoctor',
   'runScheduleNow',
@@ -196,8 +206,10 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setWebhookEnabled',
   'setWorkflow',
   'setOrchestrationMode',
+  'signOutMcpServer',
   'saveStarterGuideState',
   'skipOnboarding',
+  'startConversationImport',
   'startMediaJob',
   'stopShellJob',
   'switchContext',

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

@@ -1,9 +1,29 @@
 // agent-tree/agent-cancel.mjs
 // Cancelling an agent subtree: descendants first, then a durable canonical
 // close of the session itself. Concurrent cancels of one id share a run.
-import { cancelBackgroundTasks } from '../../../runtime/shared/background-tasks.mjs';
+import {
+  cancelBackgroundTask,
+  cancelBackgroundTasks,
+  listBackgroundTasks,
+} from '../../../runtime/shared/background-tasks.mjs';
 
-export function createAgentCancellation({ registry, rehydrateAgentSessions, sessionOwner, entryForSession, log }) {
+// Cancel the running Agent task(s) bound to this session itself (owned by its
+// parent) BEFORE the session closes, so the owner hears `cancelled` with the
+// turn's partial output instead of the closed turn failing the task.
+function cancelOwnAgentTasks(sessionId, reason) {
+  for (const row of listBackgroundTasks({ surface: 'agent' })) {
+    if (row.status === 'running' && row.sessionId === sessionId) cancelBackgroundTask(row.task_id, reason);
+  }
+}
+
+export function createAgentCancellation({
+  registry,
+  rehydrateAgentSessions,
+  sessionOwner,
+  entryForSession,
+  log,
+  rememberCancelTranscript,
+}) {
   const agentCancelRuns = new Map();
 
   /** The runtime entry that can close this descriptor: the live owner, else a
@@ -39,6 +59,7 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       });
       const children = registry.childrenOf(id);
       await Promise.all(children.map((childId) => cancelAgentTree(childId, reason)));
+      cancelOwnAgentTasks(id, reason);
       const descriptor = registry.get(id);
       if (!descriptor) return children.length > 0;
       if (descriptor.closed) return true;
@@ -47,6 +68,16 @@ export function createAgentCancellation({ registry, rehydrateAgentSessions, sess
       if (typeof closeCanonical !== 'function') {
         throw new TypeError('session runtime must implement closeCanonicalSession');
       }
+      // The close clears the transcript: capture a running turn's transcript
+      // first so the cancelled turn still hands off its partial output.
+      if (descriptor.status === 'running') {
+        try {
+          const { messages } = await entry.runtime.readModelMessages(0);
+          rememberCancelTranscript(id, messages);
+        } catch (error) {
+          log(`agent cancel transcript read failed session=${id}: ${error?.message || error}`);
+        }
+      }
       const closed = await closeCanonical.call(entry.runtime, reason);
       if (closed !== true) throw new Error(`agent session ${id} could not be durably closed`);
       descriptor.closed = true;

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

@@ -12,16 +12,23 @@ export function createAgentTurns({
   retainUnwatched,
   createSession,
   takeWatchdogStop,
+  takeCancelTranscript,
 }) {
   const createAgentChild = createAgentChildFactory({ registry, rehydrateAgentSessions, createSession });
 
-  // The progress watchdog stopped the turn: rethrow its stall error carrying
-  // the assistant text the turn produced, so the owner still gets a partial
-  // result.
-  async function watchdogStopError(runtime, error, messageStart) {
-    const { messages } = await runtime.readModelMessages(messageStart);
-    const partial = partialHandoffTextFromSession({ messages });
-    if (partial) error.partialHandoff = partial;
+  // The turn was stopped (progress watchdog or cancellation): rethrow its error
+  // carrying the assistant text the turn produced, so the owner still gets a
+  // partial result. A cancel that closed the session captured the transcript
+  // before the close cleared it.
+  async function withPartialHandoff(runtime, sessionId, error, messageStart) {
+    try {
+      const captured = takeCancelTranscript(sessionId);
+      const messages = captured
+        ? captured.slice(messageStart)
+        : (await runtime.readModelMessages(messageStart)).messages;
+      const partial = partialHandoffTextFromSession({ messages });
+      if (partial) error.partialHandoff = partial;
+    } catch {}
     return error;
   }
 
@@ -44,6 +51,7 @@ export function createAgentTurns({
     }
     // A stop left over from an earlier turn must not relabel this one.
     takeWatchdogStop(sessionId);
+    takeCancelTranscript(sessionId);
     // Transcript length before this turn: where a watchdog stop's partial
     // output starts.
     const { messageCount: messageStart } = await entry.runtime.readModelMessages(Number.MAX_SAFE_INTEGER);
@@ -64,9 +72,16 @@ export function createAgentTurns({
         throw new Error(String(detail.error || 'agent session turn failed'));
       }
       if (detail?.status === 'cancelled') {
-        const watchdogStop = takeWatchdogStop(sessionId);
-        if (watchdogStop) throw await watchdogStopError(entry.runtime, watchdogStop, messageStart);
-        throw new Error('agent session turn cancelled');
+        const stop = takeWatchdogStop(sessionId) || new Error('agent session turn cancelled');
+        throw await withPartialHandoff(entry.runtime, sessionId, stop, messageStart);
+      }
+      // Only a completed turn has a result; a rejected submission (session
+      // closing/terminal, steering persist failure) or any unknown status is a
+      // failure, never an empty completion.
+      if (detail?.status !== 'done' && detail?.status !== 'completed') {
+        const status = String(detail?.status || 'unknown');
+        const reason = String(detail?.reason || detail?.error || '').trim();
+        throw new Error(`agent turn ${status}${reason ? `: ${reason}` : ''}`);
       }
       const result = detail?.result || { content: '' };
       descriptor.status = 'idle';
@@ -81,6 +96,7 @@ export function createAgentTurns({
       descriptor.stage = descriptor.status;
       throw error;
     } finally {
+      takeCancelTranscript(sessionId);
       descriptor.updatedAt = Date.now();
       retainUnwatched(entry, 'agent child idle');
     }

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

@@ -37,6 +37,16 @@ export function createAgentTree({
     watchdogStops.delete(sessionId);
     return error;
   };
+  // Transcripts of running turns captured by a cancel just before it closes
+  // (and clears) the session, so the cancelled turn still reports the output
+  // it produced.
+  const cancelTranscripts = new Map();
+  const rememberCancelTranscript = (sessionId, messages) => cancelTranscripts.set(sessionId, messages);
+  const takeCancelTranscript = (sessionId) => {
+    const messages = cancelTranscripts.get(sessionId) || null;
+    cancelTranscripts.delete(sessionId);
+    return messages;
+  };
   function getSessionProgressSnapshot(sessionId) {
     const runtime = sessionOwner(sessionId)?.runtime;
     if (typeof runtime?.getTurnLiveness !== 'function') return null;
@@ -58,6 +68,7 @@ export function createAgentTree({
     retainUnwatched,
     createSession,
     takeWatchdogStop,
+    takeCancelTranscript,
   });
   const { cancelAgentTree, cancelAgentDescendants } = createAgentCancellation({
     registry,
@@ -65,6 +76,7 @@ export function createAgentTree({
     sessionOwner,
     entryForSession,
     log,
+    rememberCancelTranscript,
   });
 
   /** The descriptor as callers see it: status from the live runtime when one

package/src/standalone/session-service/quota-resume.mjs

@@ -8,6 +8,8 @@
 // again, and the session's own lane runs the retry under the entry's
 // generation. Overdue entries run as soon as the scheduler starts.
 
+import { isAgentOnlySession } from '../../runtime/shared/quota-resume-store.mjs';
+
 /** A still-exhausted reading is re-taken once, this much later. */
 export const QUOTA_RESUME_RETRY_MS = 5 * 60_000;
 /** A busy session is re-checked this much later, without spending an attempt. */
@@ -30,6 +32,12 @@ async function resumeDueEntry(entry, { store, materializeSession, readQuotaUsabl
     return 'unavailable';
   }
   if (!isCurrent(store, entry)) return 'cancelled';
+  // A delegated agent child never owns a resume (the Lead decides retries), so
+  // an entry persisted for one never fires, whatever wrote it.
+  if (isAgentOnlySession({ id: sessionId, ...runtime?.session })) {
+    store.cancelQuotaResumeEntry(sessionId, { generation });
+    return 'agent-session';
+  }
   let usable = false;
   try {
     usable = await readQuotaUsable(entry.provider, entry.model);

package/src/standalone/session-service/retention/busy.mjs

@@ -28,6 +28,12 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     // reaches a terminal state and its completion can be delivered back into
     // this session.
     if (sessionId && hasActiveBackgroundTasks({ callerSessionId: sessionId })) return true;
+    return sessionTurnBusy(entry);
+  }
+
+  // A turn is running (provider stream / tool call / queued input). Background
+  // tasks are deliberately not counted: they run outside the heap-churning turn.
+  function sessionTurnBusy(entry) {
     if (typeof entry?.busy === 'boolean') return entry.busy;
     try {
       return updateEntryBusy(entry, entry.runtime.getState?.() || {});
@@ -46,5 +52,13 @@ export function createBusyTracker({ sessions, currentSessionId }) {
     return count;
   }
 
-  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount };
+  function liveTurnBusyCount() {
+    let count = 0;
+    for (const entry of sessions) {
+      if (sessionTurnBusy(entry)) count += 1;
+    }
+    return count;
+  }
+
+  return { stateBusy, updateEntryBusy, sessionBusy, liveBusyCount, liveTurnBusyCount };
 }

package/src/standalone/session-service/session-calls/session-action.mjs

@@ -101,15 +101,20 @@ export function createSessionActionCalls(ctx) {
     if (typeof listSessions !== 'function') {
       throw new Error('session catalog is unavailable');
     }
-    const sessions = await listSessions({
+    const listed = await listSessions({
       ...(options || {}),
       // Agent-only records are an internal ancestry/reuse source, never part
       // of the ordinary session catalog returned over the public transport.
       includeAgentOnly: false,
     });
+    // A `page: { limit, cursor }` request answers one page: { sessions, nextCursor }.
+    const page = listed && !Array.isArray(listed) && Array.isArray(listed.sessions) ? listed : null;
+    const sessions = page ? page.sessions : listed;
     const remoteSession = typeof getRemoteSessionState === 'function' ? await getRemoteSessionState() : null;
+    const nextCursor = typeof page?.nextCursor === 'string' ? page.nextCursor : null;
     return {
       sessions: sanitizeForWire(Array.isArray(sessions) ? sessions : []),
+      ...(page ? { nextCursor } : {}),
       remoteSession: sanitizeForWire(remoteSession) ?? null,
     };
   }

package/src/standalone/session-service-api.mjs

@@ -29,6 +29,7 @@ export function createSessionServiceApi({
   methods,
   getSize,
   getBusyCount,
+  getTurnBusyCount,
   getStatus,
   getExternalClientCount,
 }) {
@@ -46,6 +47,10 @@ export function createSessionServiceApi({
     get busyCount() {
       return getBusyCount();
     },
+    /** Sessions with a running turn; background-task-only sessions excluded. */
+    get turnBusyCount() {
+      return getTurnBusyCount();
+    },
     get status() {
       return getStatus();
     },