mixdog 1.2.1 → 1.2.2

package/src/session-runtime/resource-mcp-api.mjs

@@ -7,8 +7,20 @@ import {
   mergeMcpServerConfig,
   MCP_TIMEOUT_FIELD_GROUPS,
 } from '../runtime/agent/orchestrator/runtime-core/plugin-mcp.mjs';
+import { resolveMcpOAuthUrl } from '../runtime/agent/orchestrator/mcp/client-config.mjs';
 import { withAdoptedCopies, withPinnedCollisionNames, withPluginServerIntent } from './mcp-glue/plugin-servers.mjs';
 import { findRegisteredPlugin } from './resource-plugins-api.mjs';
+import { createMcpOAuthLogins } from './mcp-oauth-login.mjs';
+
+/** The URL a server's OAuth credentials are stored under, or null. */
+function oauthUrlOf(cfg) {
+  try {
+    return resolveMcpOAuthUrl(cfg);
+  } catch {
+    // No valid remote URL: such a server never logged in.
+    return null;
+  }
+}
 
 /** The `mcpServers` map of a config as a fresh object (never the live one). */
 function mcpServersOf(config) {
@@ -59,14 +71,45 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
     mcpStatus,
     getMcpServerConfig,
     connectConfiguredMcp,
+    clearMcpServerOAuth,
     reloadFullConfig,
     awaitKeychainPrewarm,
     pluginsStatus,
-    resolveMcpCatalog = () => ({ adoption: null, plugins: {}, entries: {} }),
+    resolveMcpCatalog = () => ({ servers: {}, adoption: null, plugins: {}, entries: {} }),
+    resolveConfiguredMcpCatalog = resolveMcpCatalog,
     pluginMcpServer = () => null,
     flushSkillsSave,
+    cancelMcpLogin = () => {},
+    completeMcpLogin,
+    getMcpServerOAuthState = () => null,
+    probeMcpServerAuth,
   } = deps;
 
+  // Explicit OAuth sign-in: the one interactive MCP connect. On success the
+  // other runtimes reconnect the server non-interactively with the new tokens.
+  const oauthLogins = createMcpOAuthLogins({
+    async connect(name, openBrowser) {
+      const status = await connectConfiguredMcp({ only: name, enabled: true, login: { openBrowser } });
+      const row = status?.servers?.find((server) => server.name === name);
+      return { connected: row?.connected === true, error: row?.error || null };
+    },
+    cancel: (name) => cancelMcpLogin(name),
+    completeCallback: completeMcpLogin,
+    onComplete: (name) => sync.announce('mcp', { detail: { mcpChanges: [{ name, enabled: true }] } }),
+  });
+  /** The effective config of a server that signs in with MCP OAuth (HTTP/SSE
+   *  without configured authentication). */
+  const oauthServerConfig = async (name) => {
+    const serverName = clean(name);
+    if (!serverName) throw new Error('MCP server name is required');
+    await awaitKeychainPrewarm();
+    reloadFullConfig();
+    const cfg = resolveMcpCatalog().servers[serverName];
+    if (!cfg) throw new Error(`MCP server not configured: ${serverName}`);
+    if (!getMcpServerOAuthState(cfg)) throw new Error(`MCP server "${serverName}" does not use OAuth sign-in`);
+    return { serverName, cfg };
+  };
+
   /** The config with any adoptable plugin server copies already adopted, so
    *  every write also persists the adoption and never re-adds a copy. */
   const adoptedConfig = () => withAdoptedCopies(getConfig(), resolveMcpCatalog().adoption);
@@ -115,6 +158,49 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
       const { enabled } = getMcpServerConfig(serverName);
       return sync.reconnectMcpAndAnnounce({ only: serverName, enabled });
     },
+    /** `{ flowId, state: 'pending', url }` once the browser login starts
+     *  (`options.openBrowser === false` leaves opening `url` to the caller), or
+     *  `{ flowId, state: 'complete' }` when stored credentials sufficed. */
+    async beginMcpOAuthLogin(name, options = {}) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      if (cfg.enabled === false) throw new Error(`MCP server is disabled: ${serverName}`);
+      return oauthLogins.begin(serverName, options);
+    },
+    /** `{ flowId, state: 'pending' | 'complete' | 'failed' | 'cancelled', error? }` */
+    getMcpOAuthLoginStatus(flowId) {
+      return oauthLogins.status(flowId);
+    },
+    cancelMcpOAuthLogin(flowId) {
+      return oauthLogins.cancel(flowId);
+    },
+    /** Remote / headless sign-in: complete the pending flow with the redirect
+     *  URL pasted from the browser. `{ flowId, state: 'complete' | 'failed',
+     *  error? }`; an invalid paste throws a fixed message and stays pending. */
+    completeMcpOAuthLogin(flowId, callbackUrl) {
+      return oauthLogins.complete(flowId, callbackUrl);
+    },
+    /** Forget the server's stored OAuth credentials (shared by every server
+     *  with the same exact URL) and reconnect without a login, here and on
+     *  peers, so it reports sign-in required. */
+    async signOutMcpServer(name) {
+      const { serverName, cfg } = await oauthServerConfig(name);
+      // A begin issued meanwhile waits until the credentials are gone.
+      return oauthLogins.cancelServer(serverName, async () => {
+        await clearMcpServerOAuth(cfg);
+        return sync.reconnectMcpAndAnnounce({ only: serverName, enabled: cfg.enabled !== false });
+      });
+    },
+    /** `{ auth: 'oauth' | 'none' | 'configured' | 'unreachable', error? }` for an
+     *  HTTP/SSE config, without credentials or a browser. */
+    probeMcpServerAuth(cfg) {
+      if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) throw new TypeError('MCP server config is required');
+      const probe = {};
+      for (const key of ['type', 'url', 'headers', 'bearer_token_env_var', 'env_http_headers']) {
+        if (cfg[key] !== undefined) probe[key] = cfg[key];
+      }
+      if (probe.type !== 'http' && probe.type !== 'sse') throw new TypeError("type must be 'http' or 'sse'");
+      return probeMcpServerAuth(probe);
+    },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
       const servers = userServers();
@@ -162,9 +248,19 @@ export function createMcpResourceApi({ deps, sync, decorate }) {
         refusePluginServer(serverName);
         throw new Error(`MCP server not configured: ${serverName}`);
       }
+      const removed = servers[serverName];
       delete servers[serverName];
       saveServers(servers);
-      return sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      const status = await sync.reconnectMcpAndAnnounce({ drop: [serverName] });
+      // A removed server keeps no OAuth tokens or client registration, unless
+      // another configured server (plugin or disabled ones included, even
+      // with MCP disabled for this runtime) still uses them through the same
+      // exact URL.
+      const url = oauthUrlOf(removed);
+      if (url && !Object.values(resolveConfiguredMcpCatalog().servers).some((cfg) => oauthUrlOf(cfg) === url)) {
+        await clearMcpServerOAuth(removed);
+      }
+      return status;
     },
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);

package/src/session-runtime/runtime-review-api.mjs

@@ -1,6 +1,7 @@
 import { registerCacheInvalidationListener } from '../runtime/agent/orchestrator/tools/builtin/cache-layers.mjs';
 import { turnReviewReply } from '../runtime/shared/turn-review-reply.mjs';
 import {
+  clearSessionChangeHistory,
   getSessionReviewDiff,
   getTurnChanges,
   getTurnReviewDiff,
@@ -10,6 +11,17 @@ import {
   revertTurnReviewFile,
 } from '../runtime/shared/turn-snapshot.mjs';
 import { noteTurnWorktreeChange } from '../runtime/shared/turn-worktree-snapshot.mjs';
+import { forgetSessionChangeHistoryMarker } from '../runtime/shared/turn-snapshot-store.mjs';
+import { forgetSessionBaselines } from '../runtime/shared/session-baseline-store.mjs';
+import { registerSessionPurgeHook } from '../runtime/agent/orchestrator/session/store.mjs';
+
+// A deleted history stays deleted for as long as its session exists; the
+// session's own deletion takes the marker — and its stored first-seen file
+// contents — with it.
+registerSessionPurgeHook((sessionId) => {
+  void forgetSessionChangeHistoryMarker(sessionId);
+  void forgetSessionBaselines(sessionId);
+});
 
 // Tool writes (apply_patch, mutating shell commands, git, watcher events)
 // reach the live review snapshot as its change signal: a review poll right
@@ -31,5 +43,6 @@ export function createRuntimeReviewApi({ getCwd, getSessionId }) {
       revertTurnChanges(getSessionId(), checkpointId, file, revision),
     reapplyTurnChanges: (checkpointId, file, revision) =>
       reapplyTurnChanges(getSessionId(), checkpointId, file, revision),
+    clearSessionChangeHistory: () => clearSessionChangeHistory(getSessionId()),
   };
 }

package/src/session-runtime/services/agent-tool/job-task-reconcile.mjs

@@ -19,7 +19,7 @@
 // Every call is idempotent (the first terminal state wins, so the outer reject
 // path cannot double-notify) and absorbs its own errors, so reporting on a
 // turn can never break the turn.
-import { reconcileBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
+import { reconcileBackgroundTask, settleCancelledBackgroundTask } from '../../../runtime/shared/background-tasks.mjs';
 
 function reconcileJobTerminalResult(job, value) {
   if (!job?.taskId) return;
@@ -50,6 +50,8 @@ export function terminalResultHook({ job, turnReview, completionValue, notifyEar
     turnReview.complete();
     const value = completionValue(terminalResult);
     job._terminalResultValue = value;
+    // A cancelled job reports once, as `cancelled`, when its turn settles.
+    if (job.status === 'cancelled') return;
     notifyEarly(job, value, notifyContext || {});
     reconcileJobTerminalResult(job, value);
   };
@@ -67,6 +69,16 @@ export function reconcileJobWatchdogPartial(job, value) {
   } catch {}
 }
 
+/** The cancelled turn stopped: deliver the owner's single `cancelled`
+ *  notification, carrying the output the turn produced before it stopped
+ *  (header-only when it produced none). */
+export function reconcileJobCancelled(job, value) {
+  if (!job?.taskId) return;
+  try {
+    settleCancelledBackgroundTask(job.taskId, value?.content ? { result: value } : {});
+  } catch {}
+}
+
 export function reconcileJobStreamStalled(job, error) {
   if (!job?.taskId || job._terminalResultValue !== undefined) return;
   try {

package/src/session-runtime/services/agent-tool/job-views/agent-list.mjs

@@ -5,6 +5,8 @@ import { ACTIVE_STAGES } from '../tool-def.mjs';
 import { isTerminalWorkerStatus } from '../worker-rows.mjs';
 import { sessionUsageTotals } from '../../../../runtime/shared/session-usage-totals.mjs';
 
+const CANCELLED_WORKER_STATUS = /^(?:cancelled|canceled|killed|cancel[-_\s]?(?:unconfirmed|pending))$/;
+
 // Idle, closed, errored and reaped/unknown rows are history and stay reachable
 // through the task section (status/read keep their terminal result).
 export function isActiveWorkerRow(row = {}) {
@@ -14,8 +16,11 @@ export function isActiveWorkerRow(row = {}) {
   const status = String(row.status ?? '')
     .trim()
     .toLowerCase();
-  if (ACTIVE_STAGES.has(stage) || ACTIVE_STAGES.has(status)) return true;
-  const effective = stage || status;
+  // `status` decides; the stage is the runtime phase and only stands in for a
+  // row with no status. A cancel in either field is not work.
+  if (CANCELLED_WORKER_STATUS.test(stage) || CANCELLED_WORKER_STATUS.test(status)) return false;
+  const effective = status || stage;
+  if (ACTIVE_STAGES.has(effective)) return true;
   if (!effective || effective === 'unknown') return false;
   return !isTerminalWorkerStatus(effective);
 }

package/src/session-runtime/services/agent-tool/send-flow.mjs

@@ -1,12 +1,14 @@
 import {
   resolveAgentWatchdogPolicy,
   resolveHandoffMessageStartIndex,
+  turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { clean, normalizeAgentName, resolvePrompt } from './helpers.mjs';
 import { abnormalEmptyFinishError, renderResult } from './render.mjs';
 import {
+  reconcileJobCancelled,
   reconcileJobFinally,
   reconcileJobStreamStalled,
   reconcileJobWatchdogPartial,
@@ -93,6 +95,18 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       turnStartedAt: new Date().toISOString(),
     });
     let handoffMsgStart = 0;
+    // A cancelled turn reports the output it produced before it stopped.
+    const settleCancelled = (error, result = null) => {
+      finalStatus = 'cancelled';
+      reconcileJobCancelled(job, {
+        tag,
+        sessionId,
+        agent: session.agent || null,
+        provider: session.provider,
+        model: session.model,
+        content: turnPartialHandoff(error, mgr.getSession(sessionId), handoffMsgStart) || result?.content || '',
+      });
+    };
     try {
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(sessionId));
       const turnHooks = buildTurnHooks({ sessionId, notifyContext, job, turnReview, completionValue });
@@ -100,6 +114,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       // Early preview no longer suppresses the canonical body notification;
       // notifyTaskCompletion fires once with output via resolve/reconcile.
       const finalValue = completionValue(result);
+      if (job?.status === 'cancelled') {
+        settleCancelled(null, result);
+        return finalValue;
+      }
       if (finalValue.error) {
         finalStatus = 'error';
         if (job) job._terminalResultValue = finalValue;
@@ -107,6 +125,10 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
       }
       return finalValue;
     } catch (error) {
+      if (job?.status === 'cancelled') {
+        settleCancelled(error);
+        throw error;
+      }
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(sessionId), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -123,10 +145,6 @@ export function createSendFlow({ mgr, defaultCwd, sessionSurface, canUseSessionS
         reconcileJobWatchdogPartial(job, value);
         return value;
       }
-      if (job?.status === 'cancelled') {
-        finalStatus = 'cancelled';
-        throw error;
-      }
       finalStatus = 'error';
       reconcileJobStreamStalled(job, error);
       throw error;

package/src/session-runtime/services/agent-tool/spawn-flow/job-start.mjs

@@ -44,6 +44,8 @@ export function createJobStarter({ mgr, notifyStatusChange, notifySessionComplet
       meta: jobMeta,
       resultType: 'agent_task_result',
       renderResult: (result) => renderResult(result),
+      // Cancellation reaches the owner once, with the worker's partial output.
+      notifyOnCancel: true,
       cancel: () => {
         try {
           admissionController.abort(new Error('agent task cancelled before resource admission'));

package/src/session-runtime/services/agent-tool/spawn-flow/spawn-run.mjs

@@ -6,6 +6,7 @@
  */
 import { createNotify } from '../notify.mjs';
 import {
+  reconcileJobCancelled,
   reconcileJobFinally,
   reconcileJobStreamStalled,
   reconcileJobWatchdogPartial,
@@ -15,11 +16,13 @@ import { abnormalEmptyFinishError } from '../render.mjs';
 import { createProgressWatchdogRegistry } from '../../agent-watchdog-registry.mjs';
 import {
   resolveHandoffMessageStartIndex,
+  turnPartialHandoff,
   watchdogPartialHandoffFromError,
   watchdogStoppedHandoff,
 } from '../../../../runtime/agent/orchestrator/agent-runtime/agent-progress-watchdog.mjs';
 import { saveSessionAsync } from '../../../../runtime/agent/orchestrator/session/store.mjs';
 import { presetDescriptor } from './spawn-prep.mjs';
+import { workerStageForStatus } from '../worker-rows.mjs';
 
 // Mid-turn worker persistence cadence. The watchdog sweep runs every second;
 // a transcript save is far more expensive than a bookkeeping stamp, so the
@@ -68,7 +71,7 @@ export function createSpawnRunner({
       const messages = Number(progress?.messages) || 0;
       upsertWorkerSessionDeferred(session, tag, {
         status: 'running',
-        stage: progress.stage || 'running',
+        stage: workerStageForStatus('running', progress.stage),
         ...(messages > 0 ? { messages } : {}),
       });
       // The canonical runtime owns persistence; this session is only its descriptor.
@@ -135,6 +138,16 @@ export function createSpawnRunner({
     });
     notifyStatusChange();
     let handoffMsgStart = 0;
+    // A cancelled turn reports the output it produced before it stopped.
+    const settleCancelled = (error, result = null) => {
+      finalStatus = 'cancelled';
+      reconcileJobCancelled(job, {
+        tag,
+        sessionId: session.id,
+        ...presetDescriptor(agent, preset, presetName),
+        content: turnPartialHandoff(error, mgr.getSession(session.id), handoffMsgStart) || result?.content || '',
+      });
+    };
     try {
       handoffMsgStart = resolveHandoffMessageStartIndex(mgr.getSession(session.id));
       const turnHooks = {
@@ -157,6 +170,10 @@ export function createSpawnRunner({
       // notifyTaskCompletion is left to fire exactly once with output via the
       // resolve/reconcile/finally path.
       const finalValue = completionValue(result);
+      if (job?.status === 'cancelled') {
+        settleCancelled(null, result);
+        return finalValue;
+      }
       // Non-job return path (or job path where the terminal-result reconcile
       // already ran): if the finish was abnormal-empty, surface it as a thrown
       // error so finalStatus becomes 'error' and the caller's error path (and
@@ -168,6 +185,10 @@ export function createSpawnRunner({
       }
       return finalValue;
     } catch (error) {
+      if (job?.status === 'cancelled') {
+        settleCancelled(error);
+        throw error;
+      }
       const partial = watchdogPartialHandoffFromError(error, mgr.getSession(session.id), handoffMsgStart);
       if (partial) {
         finalStatus = 'idle';
@@ -182,10 +203,6 @@ export function createSpawnRunner({
         reconcileJobWatchdogPartial(job, value);
         return value;
       }
-      if (job?.status === 'cancelled') {
-        finalStatus = 'cancelled';
-        throw error;
-      }
       finalStatus = 'error';
       reconcileJobStreamStalled(job, error);
       throw error;

package/src/session-runtime/services/agent-tool/worker-index/row-liveness.mjs

@@ -11,8 +11,15 @@ const ACTIVE_WORKER_STATUS =
   /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
 const WORKER_POOL_FRESH_MS = 2 * 60 * 1000;
 
+const CANCELLED_WORKER_STATUS = /^(?:cancelled|canceled|killed|cancel[-_\s]?(?:unconfirmed|pending))$/i;
+
+/** `status` decides; `stage` is the runtime phase copied in by the progress
+ *  sweep and only decides for a row with no status. A cancel in either field
+ *  is not work (bare `cancelling` still is). */
 export const isActiveWorkerRow = (row) =>
-  ACTIVE_WORKER_STATUS.test(clean(row?.status)) || ACTIVE_WORKER_STATUS.test(clean(row?.stage));
+  !CANCELLED_WORKER_STATUS.test(clean(row?.status)) &&
+  !CANCELLED_WORKER_STATUS.test(clean(row?.stage)) &&
+  ACTIVE_WORKER_STATUS.test(clean(row?.status) || clean(row?.stage));
 
 /** A persisted approval wait whose runtime is gone: the in-memory wait died
  *  with that process (daemon restart), so the flag must not stick. */

package/src/session-runtime/services/agent-tool/worker-index/row-shape.mjs

@@ -2,7 +2,7 @@
 // The one row shape of the worker index: coercing whatever a stored file or a
 // caller hands in, and projecting a live session into a row.
 import { agentTagOf, clean, positiveInt } from '../helpers.mjs';
-import { isLeadPoolAgent } from '../worker-rows.mjs';
+import { isLeadPoolAgent, workerStageForStatus } from '../worker-rows.mjs';
 
 /** An explicit boolean wins; otherwise the session's own fast flag (true) or unknown. */
 function fastFlag(explicit, sessionFast) {
@@ -72,7 +72,7 @@ export function workerRowFromSession(session, fallbackTag = '', extra = {}, getS
   if (!tag || !sessionId) return null;
   const runtime = getSessionRuntime(sessionId);
   const status = clean(extra.status) || (session?.closed === true ? 'closed' : clean(session?.status) || 'idle');
-  const stage = clean(extra.stage) || clean(runtime?.stage) || status;
+  const stage = clean(extra.stage) || workerStageForStatus(status, runtime?.stage);
   const nowIso = new Date().toISOString();
   return {
     tag,

package/src/session-runtime/services/agent-tool/worker-rows.mjs

@@ -1,4 +1,5 @@
 import { agentTagOf, clean, positiveInt, stampMs } from './helpers.mjs';
+import { ACTIVE_STAGES } from './tool-def.mjs';
 
 import { TAG_TOMBSTONE_TTL_MS, tagTombstoneKey } from '../../../runtime/shared/agent-reap-state.mjs';
 export { TAG_TOMBSTONE_TTL_MS, tagTombstoneKey };
@@ -27,6 +28,22 @@ export function isTerminalWorkerStatus(status) {
   );
 }
 
+const WORKING_WORKER_STATUS =
+  /^(?:connecting|requesting|streaming|tool[-_\s]?running|running|queued|pending|starting|cancelling)$/i;
+const WORKING_WORKER_STAGES = new Set([...ACTIVE_STAGES, 'resource_wait']);
+
+/** The `stage` to store beside a worker `status`, from a stage read off the
+ *  live runtime. That stage is the runtime's own phase, so mid-work it can say
+ *  `idle`/`done`/`error` (a fresh or just-settled runtime entry) while the
+ *  worker is still running. Stored next to a working status it made a mixed
+ *  row that readers classified as finished, so a working status keeps a
+ *  working stage and falls back to the status itself. */
+export function workerStageForStatus(status, runtimeStage) {
+  const stage = clean(runtimeStage);
+  if (!WORKING_WORKER_STATUS.test(clean(status))) return stage || clean(status);
+  return WORKING_WORKER_STAGES.has(stage.toLowerCase()) ? stage : clean(status);
+}
+
 export function recoverTagTombstoneOwner(row, sessions) {
   if (clean(row.parentSessionId || row.ownerSessionId)) return row;
   const pid = positiveInt(row.clientHostPid);

package/src/session-runtime/settings-compaction-api.mjs

@@ -82,6 +82,7 @@ export function createCompactionSettings({
       const next = { ...current };
       if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
       if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
+      if (hasOwn(input, 'onModelChange')) next.onModelChange = input.onModelChange !== false;
       // Legacy Compact type fields are intentionally ignored. There is one
       // fresh-context Compact contract for every session.
       // A new budget representation replaces the previous one. Otherwise a

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-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

@@ -65,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';
@@ -309,6 +309,7 @@ function inFlightWork() {
     queuedCalls: (transport?.queuedCount ?? 0) + (sessionTransport?.queuedCount ?? 0),
     busySessions: sessionService?.busyCount ?? 0,
     busyMemoryAgents: agentDispatchBroker?.snapshot?.().inFlight ?? 0,
+    turnBusySessions: sessionService?.turnBusyCount ?? 0,
   };
 }
 
@@ -353,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 };
@@ -823,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({

package/src/standalone/session-protocol.mjs

@@ -19,6 +19,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getMediaDefault',
   'getMediaJob',
   'getMcpServerConfig',
+  'getMcpOAuthLoginStatus',
   'getOnboardingStatus',
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
@@ -85,16 +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',
@@ -118,6 +122,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'memoryControl',
   'openMediaAsset',
   'openMediaFolder',
+  'probeMcpServerAuth',
   'pushNotice',
   'recall',
   'reconnectMcp',
@@ -143,6 +148,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'revertTurnReviewFile',
   'revertTurnChanges',
   'reapplyTurnChanges',
+  'clearSessionChangeHistory',
   'rewindToItem',
   'runDoctor',
   'runScheduleNow',
@@ -200,6 +206,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setWebhookEnabled',
   'setWorkflow',
   'setOrchestrationMode',
+  'signOutMcpServer',
   'saveStarterGuideState',
   'skipOnboarding',
   'startConversationImport',