mixdog 1.2.1 → 1.2.3

package/src/standalone/daemon.mjs

@@ -65,7 +65,8 @@ 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 { createDaemonPgStop } from './daemon-pg-stop.mjs';
 import { createChannelSessionRouter } from '../session-runtime/services/channel-session-router.mjs';
 import { createSessionTransport } from './session-transport.mjs';
 import { createSessionService } from './session-service.mjs';
@@ -75,6 +76,7 @@ import * as quotaResumeStore from '../runtime/shared/quota-resume-store.mjs';
 import { registerWorktreeCacheCleanups } from '../runtime/shared/worktrees/cache-cleanups.mjs';
 import { createInlineSessionRuntimeHost } from './session-runtime-inline-host.mjs';
 import { getStandaloneMemoryRuntime } from '../session-runtime/services/memory-runtime-proxy.mjs';
+import { registerTranscriptPurgeHook } from '../session-runtime/session-transcript-purge.mjs';
 import { createBootPhaseProfiler } from './boot-phase-profiler.mjs';
 import { createDaemonBootCoordinator } from './daemon-boot-coordinator.mjs';
 import { createDaemonLog } from './daemon-log.mjs';
@@ -83,11 +85,13 @@ import {
   installDaemonExitRecorder,
   reconcileLostDaemonCaptures,
 } from '../session-runtime/services/daemon-crash-capture/daemon-exit-record.mjs';
-import { createDaemonTelemetry } from './daemon-telemetry.mjs';
+import { createDaemonTelemetry, createStallDescriber } from './daemon-telemetry.mjs';
+import { slowSpans } from '../runtime/shared/slow-span.mjs';
 import { createLagProfiler } from './daemon-lag-profiler.mjs';
 import { createChannelsRuntimeLoader } from './daemon-channels-loader.mjs';
 import { createDesktopRuntime } from './daemon-desktop-runtime.mjs';
 import { createCanonicalAgentControl } from './daemon-agent-control.mjs';
+import { flushAllIndexWrites } from '../session-runtime/services/agent-tool/index-write-queue.mjs';
 import { registerAutomationAgentTool } from '../session-runtime/automation-agents.mjs';
 import {
   compareRuntimeVersions,
@@ -132,7 +136,9 @@ let sessionTransport = null;
 let sessionService = null;
 let sessionRuntimeHost = null;
 let localSessionBridge = null;
+let canonicalAgentControl = null;
 let memoryRuntime = null;
+let transcriptPurgeUnregister = null;
 let agentDispatchBroker = null;
 let remoteSessionState = { enabled: false, sessionId: null };
 let shuttingDown = false;
@@ -161,6 +167,13 @@ function registerMemoryRuntimeLazy() {
   // real memory call (memory/recall tools, the Memory install) starts the
   // singleton; nothing warms it at boot. The PG cluster itself usually starts
   // earlier: the channels schedules/webhooks stores open it at boot.
+  // Deleting a session removes its transcript file here, and its memory ingest
+  // offsets once the memory runtime exists (none when memory is skipped).
+  if (!transcriptPurgeUnregister) {
+    transcriptPurgeUnregister = registerTranscriptPurgeHook({
+      forgetOffsets: (transcriptPaths) => memoryRuntime?.forgetTranscripts(transcriptPaths),
+    });
+  }
   if (process.env.MIXDOG_DAEMON_SKIP_MEMORY === '1') {
     log('memory runtime skipped (MIXDOG_DAEMON_SKIP_MEMORY=1)');
     return;
@@ -201,6 +214,8 @@ function eventLoopStatus() {
 /** Ceiling for the whole teardown sequence, above the slowest individual stop
  *  (channels/memory) so a healthy shutdown always finishes on its own. */
 const SHUTDOWN_BUDGET_MS = 15_000;
+/** Graceful PostgreSQL stop bound inside that budget (pg_ctl stop -m fast). */
+const PG_STOP_TIMEOUT_MS = 6_000;
 
 async function shutdown(reason, code = 0) {
   if (shuttingDown) return;
@@ -221,6 +236,9 @@ async function shutdown(reason, code = 0) {
     process.exit(code);
   }, SHUTDOWN_BUDGET_MS);
   forcedExit.unref?.();
+  // PostgreSQL stops after its users below (durable writes drained first), or
+  // at the fallback point just before the launcher's kill, whichever is first.
+  const pgStop = createDaemonPgStop({ log, stopTimeoutMs: PG_STOP_TIMEOUT_MS });
   try {
     setChannelNotifySink(null);
   } catch {}
@@ -241,6 +259,15 @@ async function shutdown(reason, code = 0) {
   } catch (e) {
     log(`session runtime host stop failed: ${e?.message || e}`);
   }
+  // Every runtime is closed: drain the canonical agent's index writers (and any
+  // other queued index write) before process.exit, whose 'exit' hook cannot
+  // finish async work.
+  try {
+    await canonicalAgentControl?.dispose?.();
+    await flushAllIndexWrites();
+  } catch (e) {
+    log(`agent index drain failed: ${e?.message || e}`);
+  }
   // Host-side Computer Use workers and target claims are reaped only on an
   // explicit release; the runtime's deferred timer is unref'd and never fires
   // once this process exits.
@@ -271,6 +298,11 @@ async function shutdown(reason, code = 0) {
   } catch (e) {
     log(`memory.stop failed: ${e?.message || e}`);
   }
+  // PostgreSQL this daemon started through its stores (schedules, webhooks,
+  // session search) after every user of it above is closed. `pg_ctl start`
+  // daemonizes the postmaster outside this process tree, so without this stop
+  // it outlives the daemon. A cluster another live process owns is left to it.
+  await pgStop.finish();
   try {
     agentDispatchBroker?.close?.(reason);
   } catch (e) {
@@ -309,11 +341,15 @@ function inFlightWork() {
     queuedCalls: (transport?.queuedCount ?? 0) + (sessionTransport?.queuedCount ?? 0),
     busySessions: sessionService?.busyCount ?? 0,
     busyMemoryAgents: agentDispatchBroker?.snapshot?.().inFlight ?? 0,
+    turnBusySessions: sessionService?.turnBusyCount ?? 0,
   };
 }
 
 // Opt-in CPU profiling of lag windows while DATA_DIR/lag-profile.on exists.
 const lagProfiler = createLagProfiler({ dataDir: DATA_DIR, log });
+// Request spans share the heartbeat's performance.now() clock; `[slow-op]` lines
+// and stall attribution come from the same recorder.
+slowSpans.setLog(log);
 
 daemonTelemetry = createDaemonTelemetry({
   log,
@@ -353,11 +389,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 };
@@ -510,6 +541,7 @@ async function claimDaemonOwnership(bootPhases) {
     tickMs: timings.tickMs,
     stallMs: timings.stallMs,
     log,
+    describeStall: createStallDescriber({ spans: slowSpans, getWork: inFlightWork }),
     onBeat: republishMissingDiscovery,
     onSuperseded: (record) => fenceDaemon(`owner claim superseded by pid=${record?.pid}`),
     onFenced: ({ lastRefreshAt, sinceMs }) =>
@@ -700,6 +732,22 @@ function announceDaemonReady({ port, token, startedAt, bootPhases }) {
   });
 }
 
+/** After ready, off every request path: arm the last-chance PostgreSQL stop on
+ *  exit, then open the schedules/webhooks stores. On an existing cluster that
+ *  starts PostgreSQL here, so the first catalog read (the desktop sidebar's
+ *  channel setup) joins this start instead of being the one that runs it; a
+ *  data dir with no cluster yet starts nothing (channel-admin). Loaded after
+ *  the stderr redirect, so the PG layer's logs reach daemon.log. */
+function startPostgresInBackground() {
+  void import('../runtime/memory/lib/pg/adapter.mjs')
+    .then((pg) => {
+      pg.installOwnedPgExitStop();
+      if (shuttingDown) return null;
+      return import('../session-runtime/services/channel-admin.mjs').then((admin) => admin.hasActiveAutomation());
+    })
+    .catch((error) => log(`postgres background start failed: ${error?.message || error}`));
+}
+
 /** The channels front door: pointer-routed calls over HTTP+SSE. Creating the
  *  transport also wires the channels notification sink (session-bound
  *  notifications reach the session service, the rest fan out to channel
@@ -823,7 +871,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({
@@ -848,6 +896,7 @@ async function main() {
     getSessionRuntimeHost: () => sessionRuntimeHost,
     cwd: CWD,
   });
+  canonicalAgentControl = agentControl;
   // Schedules and webhooks run headless here; their sessions reach the same
   // canonical agent control through the automation tool scope.
   registerAutomationAgentTool(agentControl.execute);
@@ -942,6 +991,13 @@ async function main() {
   log(`session front door on 127.0.0.1:${sessionEndpoint.port}`);
 
   announceDaemonReady({ port, token, startedAt, bootPhases });
+  // After ready, off the boot path: load the session-runtime module tree so
+  // the first session.create does not block the loop on synchronous module
+  // compilation. Failures fall back to the lazy import inside create.
+  setImmediate(() => {
+    void sessionRuntimeHost?.warmLocalRuntime?.();
+  });
+  startPostgresInBackground();
 
   // Automation may spawn the shared daemon; keep schedules/webhooks live.
   // A TUI-spawned daemon keeps the historical eager start (its channels client

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

@@ -1,6 +1,7 @@
 import { createRequire } from 'node:module';
 import { fileURLToPath } from 'node:url';
 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';
 
@@ -217,6 +218,10 @@ export class DesktopServiceRegistry {
     const { service } = this.#requireSubscribed(desktopId, ctx);
     const name = String(method || '');
     if (!name) throw new TypeError('desktop service method is required');
+    // `[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] || '') : '';
+    annotateSpan(target ? `${name}:${target}` : name);
     return sanitizeForWire(await service.instance.invoke(name, Array.isArray(args) ? args : [])) ?? null;
   }
 

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

@@ -19,6 +19,7 @@ import { createContextState } from '../tui/session/context-state.mjs';
 import { createSessionFlow } from '../tui/session/session-flow.mjs';
 import { createRunTurn } from '../tui/session/turn.mjs';
 import { createQuotaResumeLane } from '../tui/session/quota-resume.mjs';
+import { createGitHeadWatcher } from '../runtime/shared/worktrees/git-head.mjs';
 import { publicQuotaResume, quotaResumeEntry } from '../runtime/shared/quota-resume-store.mjs';
 import { createSessionApi } from '../tui/session/session-api.mjs';
 import { createSessionDraftStore } from '../tui/session/draft-store.mjs';
@@ -33,18 +34,54 @@ import { formatDoctorReport, runDoctorChecks } from '../tui/app/doctor.mjs';
 // tuiDebug is an opt-in diagnostic trace for the hang chain (runTurn start/end,
 // busy-queue enqueue/drain). Quiet by default so it can never tear through
 // the alternate-screen render; enable with MIXDOG_TUI_DEBUG=1.
-import { tuiDebug, nextId, createTranscriptSpillBuffer } from '../tui/session/transcript-spill.mjs';
+import {
+  tuiDebug,
+  nextId,
+  createTranscriptSpillBuffer,
+  sweepStaleTranscriptSpillDirsOnce,
+} from '../tui/session/transcript-spill.mjs';
 
 const SESSION_RUNTIME_MODULE = '../mixdog-session-runtime.mjs';
 
 // Shared across create calls so concurrent session startups import the
 // runtime graph once.
 let sessionRuntimeModulePromise = null;
+let sessionRuntimeImporter = () => import(SESSION_RUNTIME_MODULE);
 function importSessionRuntimeModule() {
-  sessionRuntimeModulePromise ??= import(SESSION_RUNTIME_MODULE);
+  // A failed import is forgotten so the next caller retries lazily.
+  sessionRuntimeModulePromise ??= Promise.resolve()
+    .then(() => sessionRuntimeImporter())
+    .catch((error) => {
+      sessionRuntimeModulePromise = null;
+      throw error;
+    });
   return sessionRuntimeModulePromise;
 }
 
+/**
+ * Background warm-up for the daemon (scheduled after the ready signal): loads
+ * the session-runtime module tree and runs the one-per-process transcript
+ * spill sweep, so the first session.create pays for neither. Failures are
+ * swallowed — create falls back to the same lazy import.
+ */
+export async function warmLocalSessionRuntime() {
+  try {
+    await importSessionRuntimeModule();
+    // Separate turn: let queued I/O run between the import and the sync sweep.
+    await new Promise((resolve) => setImmediate(resolve));
+    sweepStaleTranscriptSpillDirsOnce();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/** Test seam: replace the dynamic import of the session-runtime module. */
+export function setSessionRuntimeImporterForTest(importer) {
+  sessionRuntimeImporter = importer || (() => import(SESSION_RUNTIME_MODULE));
+  sessionRuntimeModulePromise = null;
+}
+
 const TOOL_APPROVAL_TIMEOUT_MS = (() => {
   const value = Number(process.env.MIXDOG_TOOL_APPROVAL_TIMEOUT_MS);
   return Number.isFinite(value) && value > 0 ? Math.max(1000, Math.round(value)) : 120_000;
@@ -98,7 +135,7 @@ export function createRuntimePulse({
     if (!set(changed)) emit();
     return true;
   };
-  return () => {
+  const pulse = () => {
     if (flags.disposed) return;
     if (flags.pendingSessionReset) return;
     // Attached viewer with a live pipe: the owner's frames are authoritative
@@ -115,6 +152,12 @@ export function createRuntimePulse({
       ...agentStatusState(),
     });
   };
+  /** Publishes just the workspace (a HEAD change): no stats or agent recompute. */
+  pulse.publishWorkspace = () => {
+    if (flags.disposed || flags.pendingSessionReset) return;
+    publishChanged({ workspace: routeState().workspace });
+  };
+  return pulse;
 }
 
 export async function createLocalSessionRuntime({
@@ -277,20 +320,29 @@ export async function createLocalSessionRuntime({
       timeoutMs: TOOL_APPROVAL_TIMEOUT_MS,
     }
   );
-  lifecycle.runtimePulseTimer = setInterval(
-    createRuntimePulse({
-      flags,
-      liveShareMirroring: () => bag.liveShareMirroring?.() === true,
-      getState,
-      getPublishedState,
-      set,
-      emit: store.emit,
-      routeState,
-      agentStatusState,
-      syncContextStats,
-    }),
-    2000
-  );
+  const runtimePulse = createRuntimePulse({
+    flags,
+    liveShareMirroring: () => bag.liveShareMirroring?.() === true,
+    getState,
+    getPublishedState,
+    set,
+    emit: store.emit,
+    routeState,
+    agentStatusState,
+    syncContextStats,
+  });
+  // A `git switch` from any terminal reaches the island within ~a frame; the
+  // pulse retargets the watch when the session's folder moves.
+  const headWatch = createGitHeadWatcher({
+    getCwd: () => runtime.getLiveWorkspace?.()?.cwd || runtime.cwd,
+    onChange: runtimePulse.publishWorkspace,
+  });
+  headWatch.retarget();
+  lifecycle.unsubscribeGitHeadWatch = headWatch.dispose;
+  lifecycle.runtimePulseTimer = setInterval(() => {
+    headWatch.retarget();
+    runtimePulse();
+  }, 2000);
   lifecycle.runtimePulseTimer.unref?.();
 
   const {
@@ -405,8 +457,7 @@ export async function createLocalSessionRuntime({
   Object.assign(bag, createSessionFlow(bag));
   // Runtime-driven completion wakes (no attached surface acked the completion)
   // get the same idle auto-clear as a user submit.
-  lifecycle.unsubscribeCompletionWakeGate =
-    runtime.setCompletionWakeGate?.(() => bag.autoClearBeforeWake()) || null;
+  lifecycle.unsubscribeCompletionWakeGate = runtime.setCompletionWakeGate?.(() => bag.autoClearBeforeWake()) || null;
   Object.assign(
     bag,
     createGoalContinuation({

package/src/standalone/session-client.mjs

@@ -21,6 +21,7 @@ import { withHeapCap } from '../runtime/shared/heap-cap.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';
+import { IN_TREE_DAEMON_STOP_GRACE_MS } from './daemon-stop-budget.mjs';
 import { createAttachmentCalls } from './session-client/attachment-calls.mjs';
 import { daemonUnavailableError } from './session-client/daemon-unavailable.mjs';
 import { createLeaseHeartbeat } from './session-client/lease-heartbeat.mjs';
@@ -324,6 +325,12 @@ async function replaceLowerDaemon(discovery, initialHealth, { log, onUpgradeWait
  *  caller then re-reads discovery and attaches to whoever won. The shared fork
  *  and crash capture live in ./daemon-candidate.mjs.
  *  `entry` is a test seam; production always forks the real daemon. */
+// Daemons this process forked into its own process tree (daemonShouldDetach
+// false: the packaged Windows Desktop). Such a child is killed with its
+// launcher (libuv's kill-on-close job), which skips its whole teardown —
+// 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() }) {
   const t0 = performance.now();
   const at = () => Math.round(performance.now() - t0);
@@ -353,6 +360,10 @@ export function spawnDaemonCandidate({ cwd, log, timeoutMs = 30_000, entry = dae
       const forkMs = at();
       child.once('spawn', () => {
         log(`daemon fork: forkMs=${forkMs} spawnEventMs=${at()}`);
+        if (!detached && child.pid) {
+          inTreeDaemons.set(child.pid, child);
+          child.once('exit', () => inTreeDaemons.delete(child.pid));
+        }
       });
     },
     onReady: () => log(`daemon ready at=${at()}ms`),
@@ -634,6 +645,37 @@ export async function shutdownDaemon(
   return true;
 }
 
+/** Launcher quit: a daemon this process forked into its own tree would die
+ *  with it, so ask the serving one to stop (forced — its work cannot outlive
+ *  this tree anyway) and wait, bounded, for every such child's graceful exit.
+ *  One that already unpublished its endpoint is mid-teardown: only waited on.
+ *  False when no such child is alive (detached, or another launcher's). */
+export async function stopInTreeDaemon({
+  timeoutMs = IN_TREE_DAEMON_STOP_GRACE_MS,
+  discovery = readSessionDiscovery(),
+} = {}) {
+  const pids = [...inTreeDaemons.keys()].filter((pid) => isPidAlive(pid));
+  if (!pids.length) return false;
+  if (discovery?.port && pids.includes(Number(discovery.pid))) {
+    try {
+      await request({
+        port: discovery.port,
+        token: discovery.token,
+        method: 'POST',
+        path: '/stop',
+        body: { force: true },
+        timeoutMs: 3000,
+        control: true,
+      });
+    } catch {
+      // Past its front door already: only the wait remains.
+    }
+  }
+  const deadline = Date.now() + Math.max(1, Number(timeoutMs) || IN_TREE_DAEMON_STOP_GRACE_MS);
+  while (pids.some((pid) => isPidAlive(pid)) && Date.now() < deadline) await delay(50);
+  return !pids.some((pid) => isPidAlive(pid));
+}
+
 export async function shutdownDaemonForRuntimeRoot(root, options = {}) {
   const runtimeRoot = String(root || '').trim();
   if (!runtimeRoot) return false;

package/src/standalone/session-protocol.mjs

@@ -19,6 +19,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getMediaDefault',
   'getMediaJob',
   'getMcpServerConfig',
+  'getMcpOAuthLoginStatus',
   'getOnboardingStatus',
   'getOAuthProviderLoginStatus',
   'getOutputStyle',
@@ -29,6 +30,7 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'getQuotaAutoResume',
   'getQuotaHistory',
   'getRecapSettings',
+  'getSessionTitleSettings',
   'getWebSearchRoute',
   'getSettingsSnapshot',
   'getSystemShell',
@@ -40,9 +42,11 @@ export const SESSION_READ_ACTIONS = Object.freeze([
   'inspectHuggingFaceModel',
   'getLocalProviderModelDetails',
   'getSessionReviewDiff',
+  'getSessionReviewFilePatch',
   'getSessionUsage',
   'getTurnChanges',
   'getTurnReviewDiff',
+  'getTurnReviewFilePatch',
   'getTurnLiveness',
   'getUpdateSettings',
   'getUpdateStatus',
@@ -83,18 +87,23 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'addPlugin',
   'addSkill',
   'agentControl',
+  'askSide',
   'authenticateProvider',
   'beginOAuthProviderLogin',
+  'beginMcpOAuthLogin',
   'updateProviderAccounts',
   'cacheMediaThumbnail',
   'cancelMediaJob',
   'cancelOAuthProviderLogin',
+  'cancelMcpOAuthLogin',
   'cancelConversationImport',
+  'cancelSide',
   'checkForUpdate',
   'clear',
   'compact',
   'completeOnboarding',
   'completeOAuthProviderLogin',
+  'completeMcpOAuthLogin',
   'consumeCodexRateLimitResetCredit',
   'createWorkflow',
   'deleteAgentDefinition',
@@ -106,6 +115,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'removeCustomProvider',
   'updateCustomProviderModel',
   'testCustomProvider',
+  'checkCustomProviderKeyEnv',
   'discoverCustomProviderModels',
   'deleteSession',
   'deleteWebhook',
@@ -118,6 +128,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'memoryControl',
   'openMediaAsset',
   'openMediaFolder',
+  'probeMcpServerAuth',
   'pushNotice',
   'recall',
   'reconnectMcp',
@@ -143,6 +154,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'revertTurnReviewFile',
   'revertTurnChanges',
   'reapplyTurnChanges',
+  'clearSessionChangeHistory',
   'rewindToItem',
   'runDoctor',
   'runScheduleNow',
@@ -188,6 +200,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setProfile',
   'setProgressHint',
   'setRecapEnabled',
+  'setAiSessionTitles',
   'setRoute',
   'setScheduleEnabled',
   'setWebSearchRoute',
@@ -200,6 +213,7 @@ export const SESSION_CONFIGURE_ACTIONS = Object.freeze([
   'setWebhookEnabled',
   'setWorkflow',
   'setOrchestrationMode',
+  'signOutMcpServer',
   'saveStarterGuideState',
   'skipOnboarding',
   'startConversationImport',

package/src/standalone/session-proxy/projection.mjs

@@ -8,6 +8,35 @@
  */
 import { applySessionStatePatch } from '../session-state-patch.mjs';
 
+// Desktop-only live fields: `streamingPartial` is the unfinished streamed
+// line the desktop paints ahead of the line-gated tail. This terminal view
+// keeps the line-gated text, so it never holds the field nor re-renders for it.
+const DESKTOP_ONLY_FIELDS = ['streamingPartial'];
+
+function terminalState(full) {
+  if (!full || typeof full !== 'object' || !DESKTOP_ONLY_FIELDS.some((key) => Object.hasOwn(full, key))) return full;
+  const next = { ...full };
+  for (const key of DESKTOP_ONLY_FIELDS) delete next[key];
+  return next;
+}
+
+/** The patch without desktop-only fields, or null when nothing else moved. */
+function terminalPatch(patch) {
+  const set = patch.set && typeof patch.set === 'object' ? patch.set : {};
+  const remove = Array.isArray(patch.remove) ? patch.remove : [];
+  if (!patch.partialAppend && !DESKTOP_ONLY_FIELDS.some((key) => Object.hasOwn(set, key) || remove.includes(key))) {
+    return patch;
+  }
+  const nextSet = { ...set };
+  for (const key of DESKTOP_ONLY_FIELDS) delete nextSet[key];
+  const nextRemove = remove.filter((key) => !DESKTOP_ONLY_FIELDS.includes(key));
+  if (Object.keys(nextSet).length === 0 && nextRemove.length === 0 && !patch.itemsAppend && !patch.itemsPrepend) {
+    return null;
+  }
+  const { partialAppend: _desktopOnly, ...rest } = patch;
+  return { ...rest, set: nextSet, remove: nextRemove };
+}
+
 export function createProjection({ binding, log }) {
   let state = {};
   let revision = 0;
@@ -40,7 +69,7 @@ export function createProjection({ binding, log }) {
     const incomingRevision = Number(body.revision);
     if (revisionAttachment !== sourceAttachment || revisionSessionId !== binding.sessionId) {
       if (body.full === undefined || body.full === null) return false;
-      state = body.full;
+      state = terminalState(body.full);
       revision = Number.isFinite(incomingRevision) ? incomingRevision : 0;
       revisionAttachment = sourceAttachment;
       revisionSessionId = binding.sessionId;
@@ -49,7 +78,7 @@ export function createProjection({ binding, log }) {
     }
     if (Number.isFinite(incomingRevision) && incomingRevision < revision) return true;
     if (body.full !== undefined && body.full !== null) {
-      state = body.full;
+      state = terminalState(body.full);
       revision = Number.isFinite(incomingRevision) ? incomingRevision : revision;
       emit();
       return true;
@@ -57,8 +86,16 @@ export function createProjection({ binding, log }) {
     if (body.patch) {
       if (Number(body.revision) === revision && Number(body.baseRevision) === revision - 1) return true;
       if (Number(body.baseRevision) !== revision) return false;
-      state = applySessionStatePatch(state, body.patch);
+      const patch = terminalPatch(body.patch);
+      // Only a desktop-only field moved: the terminal view advances silently.
+      if (!patch) {
+        revision = Number(body.revision) || revision;
+        return true;
+      }
+      const patched = applySessionStatePatch(state, patch);
+      if (!patched) return false;
       revision = Number(body.revision) || revision;
+      state = patched;
       emit();
       return true;
     }
@@ -76,7 +113,7 @@ export function createProjection({ binding, log }) {
   return {
     // The create result seeds the projection for the current binding.
     seed(created) {
-      state = created?.full ?? {};
+      state = terminalState(created?.full ?? {});
       revision = Number(created?.revision) || 0;
       revisionAttachment = binding.attachment;
       revisionSessionId = binding.sessionId;

package/src/standalone/session-runtime-inline-host/boot-loaders.mjs

@@ -50,6 +50,20 @@ export function createInlineBootLoaders({
     return localModulePromise;
   }
 
+  // Background warm-up of the session-local module graph. Independent of the
+  // keychain gate (the ESM cache makes the later localModule() import free);
+  // never throws — a failed warm-up leaves create on its lazy path.
+  async function warmLocalRuntime() {
+    if (isClosed()) return false;
+    try {
+      const module = await loadLocalModule();
+      if (isClosed()) return false;
+      return (await module.warmLocalSessionRuntime?.()) !== false;
+    } catch {
+      return false;
+    }
+  }
+
   function agentGraph() {
     agentGraphPromise ??= measured('agent-dispatch-graph-import', () => {
       assertOpen();
@@ -92,5 +106,5 @@ export function createInlineBootLoaders({
     await tracked;
   }
 
-  return { prewarmKeychain, localModule, agentGraph, prepareAgentProviders };
+  return { prewarmKeychain, warmLocalRuntime, localModule, agentGraph, prepareAgentProviders };
 }

package/src/standalone/session-runtime-inline-host.mjs

@@ -74,6 +74,7 @@ export function createInlineSessionRuntimeHost({
   return {
     create,
     prewarmKeychain: loaders.prewarmKeychain,
+    warmLocalRuntime: loaders.warmLocalRuntime,
     agentDispatch: dispatch.agentDispatch,
     async agentControl(args = {}, context = {}) {
       if (closed) throw new Error('session runtime host is closed');