mixdog 0.9.84 → 0.9.86

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

@@ -49,6 +49,7 @@ export function createLifecycleApi(deps) {
     createCurrentSession, refreshRouteEffort,
     invalidateContextStatusCache, invalidatePreSessionToolSurface,
     applyResolvedCwd, resolveRoute, applyDeferredToolSurface, getStandaloneTools,
+    beginRoutePreparation, clearRoutePreparation,
     pushTranscriptRebind,
     notificationListeners, remoteStateListeners, desktopSession,
   } = deps;
@@ -158,6 +159,12 @@ export function createLifecycleApi(deps) {
   return {
     async close(reason = 'cli-exit', options = {}) {
       const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
+      // Desktop multi-engine hosts dispose idle engines while other sessions
+      // keep working in the SAME process. The background-work registries
+      // (shared background tasks, shell jobs, bash sessions) are
+      // process-global, so a non-exit dispose must leave them running instead
+      // of reaping every session's jobs. CLI exit paths never set this.
+      const keepBackgroundWork = options?.keepBackgroundWork === true;
       setCloseRequested(true);
       // Self-update now stages in the background and swaps on the next clean
       // launch (see staged-update.mjs) — nothing installs at shutdown. On a
@@ -218,7 +225,7 @@ export function createLifecycleApi(deps) {
           warmupTimers[timerKey] = null;
         }
       }
-      try { cancelBackgroundTasks({ reason, notify: false }); } catch {}
+      try { if (!keepBackgroundWork) cancelBackgroundTasks({ reason, notify: false }); } catch {}
       const channelStop = channels.stop(reason, detach ? { waitForExit: false } : undefined);
       try { agentTool.closeAll(reason); } catch {}
       let mcpStop = null;
@@ -260,12 +267,12 @@ export function createLifecycleApi(deps) {
       invalidateContextStatusCache();
       notificationListeners?.clear?.();
       remoteStateListeners?.clear?.();
-      const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
+      const shellJobsStop = !keepBackgroundWork && globalThis.__mixdogShellJobsRuntimeLoaded === true
         ? import('../runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
           .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))
           .catch(() => {})
         : null;
-      const bashSessionsStop = globalThis.__mixdogBashSessionRuntimeLoaded === true
+      const bashSessionsStop = !keepBackgroundWork && globalThis.__mixdogBashSessionRuntimeLoaded === true
         ? import('../runtime/agent/orchestrator/tools/bash-session.mjs')
           .then((mod) => mod?.shutdownBashSessions?.(reason))
           .catch(() => {})
@@ -336,7 +343,8 @@ export function createLifecycleApi(deps) {
       pushTranscriptRebind?.();
       return true;
     },
-    async switchContext({ cwd, desktopSession: nextDesktopSession } = {}) {
+    async switchContext({ cwd, desktopSession: nextDesktopSession, forResume = false } = {}) {
+      clearRoutePreparation?.();
       const session = getSession();
       if (session?.id) {
         const cleanupReason = 'desktop-context-switch';
@@ -370,7 +378,7 @@ export function createLifecycleApi(deps) {
       // that session's provider/model. A fresh desktop task or project must
       // return to the configured Lead route instead of inheriting the route
       // of whichever session happened to be open immediately beforehand.
-      if (typeof setRoute === 'function' && typeof getConfig === 'function'
+      if (!forResume && typeof setRoute === 'function' && typeof getConfig === 'function'
         && typeof resolveRoute === 'function') {
         setRoute(resolveRoute(getConfig(), {}));
         await refreshRouteEffort?.();
@@ -400,6 +408,7 @@ export function createLifecycleApi(deps) {
       return mgr.prefetchSession?.(id, toolSpecForMode(getMode())) === true;
     },
     async resume(id) {
+      clearRoutePreparation?.();
       const prev = getSession();
       const previousId = prev?.id || null;
       const previousMessages = prev?.messages || null;
@@ -424,22 +433,44 @@ export function createLifecycleApi(deps) {
       }
       setSession(resumed);
       applyResolvedCwd(resolveResumeCwd(resumed, getCurrentCwd()), { markRefresh: false });
+      // Cwd application is synchronous even though MCP reconnect may continue
+      // in the background. Commit it before returning the resume transcript.
+      resumed.cwd = getCurrentCwd();
       const route = getRoute();
       // The resumed session's OWN effort wins. resolveRoute always returns an
       // effort key, so this used to reinstate the effort of whichever session
       // happened to be open before — a schedule/webhook session opened with a
       // different effort than the one it actually ran with.
       const resumeEffort = resumed.effort || (hasOwn(route, 'effort') ? route.effort : undefined);
-      setRoute(resolveRoute(getConfig(), { provider: resumed.provider, model: resumed.model, effort: resumeEffort }));
-      await refreshRouteEffort();
-      const session = getSession();
-      session.effort = getRoute().effectiveEffort || null;
-      session.cwd = getCurrentCwd();
-      applyDeferredToolSurface(session, deferredSurfaceModeForLead(getMode()), getStandaloneTools(), { provider: getRoute().provider });
+      const resumedRoute = resolveRoute(
+        getConfig(),
+        { provider: resumed.provider, model: resumed.model, effort: resumeEffort },
+      );
+      setRoute(resumedRoute);
+      const finishRoutePreparation = async () => {
+        const preparedRoute = await refreshRouteEffort(null, resumedRoute);
+        // Session or route changed while provider metadata was loading.
+        if (!preparedRoute || getSession() !== resumed || getRoute() !== preparedRoute) return false;
+        const activeSession = getSession();
+        activeSession.effort = getRoute().effectiveEffort || null;
+        activeSession.cwd = getCurrentCwd();
+        applyDeferredToolSurface(
+          activeSession,
+          deferredSurfaceModeForLead(getMode()),
+          getStandaloneTools(),
+          { provider: getRoute().provider },
+        );
+        writeStatuslineRoute(statusRoutes, activeSession, getRoute());
+        return true;
+      };
+      if (typeof beginRoutePreparation === 'function') {
+        beginRoutePreparation(finishRoutePreparation);
+      } else {
+        await finishRoutePreparation();
+      }
       invalidatePreSessionToolSurface();
       invalidateContextStatusCache();
       setSessionNeedsCwdRefresh(false);
-      writeStatuslineRoute(statusRoutes, session, getRoute());
       // Session swapped to the resumed one: repoint the worker to the current
       // transcript instead of waiting for the next inbound steal.
       pushTranscriptRebind?.();

package/src/session-runtime/prewarm.mjs

@@ -91,6 +91,40 @@ export function createPrewarmSchedulers({
     timer.unref?.();
   }
 
+  // Tool-runtime warmup: the per-call cold starts a session's FIRST tool call
+  // would otherwise pay — pwsh standby processes (~300ms each) and the o200k
+  // encoder + token-count worker (~100ms). Each part is independent and
+  // best-effort; failures only mark the boot profile.
+  function scheduleToolRuntimeWarmup(delayMs = 2500) {
+    if (envFlag('MIXDOG_DISABLE_TOOL_PREWARM')) {
+      bootProfile('tool-runtime:prewarm-skipped');
+      return;
+    }
+    const timer = setTimeout(() => void (async () => {
+      if (isCloseRequested()) return;
+      try {
+        const { prewarmShellStandbys } = await import('../runtime/agent/orchestrator/tools/builtin/bash-tool.mjs');
+        bootProfile('tool-runtime:shell-standby', { warmed: prewarmShellStandbys() === true });
+      } catch (error) {
+        bootProfile('tool-runtime:shell-standby-failed', { error: error?.message || String(error) });
+      }
+      try {
+        const { prewarmTokenEstimator } = await import('../runtime/agent/orchestrator/session/context-utils.mjs');
+        bootProfile('tool-runtime:token-estimator', { warmed: prewarmTokenEstimator() === true });
+      } catch (error) {
+        bootProfile('tool-runtime:token-estimator-failed', { error: error?.message || String(error) });
+      }
+      try {
+        const { prewarmAgentShard } = await import('../standalone/agent-shard/shard-pool.mjs');
+        const warmed = await prewarmAgentShard();
+        if (warmed) bootProfile('tool-runtime:agent-shard', { warmed: true });
+      } catch (error) {
+        bootProfile('tool-runtime:agent-shard-failed', { error: error?.message || String(error) });
+      }
+    })(), delayMs);
+    timer.unref?.();
+  }
+
   function invokeChannelStart() {
     if (state.channelStartPromise) return state.channelStartPromise;
     const startedAt = performance.now();
@@ -142,6 +176,7 @@ export function createPrewarmSchedulers({
   return {
     scheduleCodeGraphPrewarm,
     scheduleLeadSessionPrewarm,
+    scheduleToolRuntimeWarmup,
     invokeChannelStart,
     scheduleChannelStart,
   };

package/src/session-runtime/remote-control.mjs

@@ -10,8 +10,6 @@ export function createRemoteControl({
   setRemoteEnabled,
   getRemoteSessionId,
   setRemoteSessionId,
-  setRemoteClaimPending,
-  isRemoteClaimPending,
   isCloseRequested,
   clearChannelStartTimer,
   remoteTransitions,
@@ -28,22 +26,11 @@ export function createRemoteControl({
   bootProfile,
   envFlag,
 }) {
-  // FORCE-TAKEOVER for an explicit claim: it always (re)claims the seat and
-  // rebinds forwarding to this session, even when the worker already runs
-  // (`/remote` re-issued after another session took the seat).
-  function startRemote(options = {}) {
-    const intent = options?.intent === 'auto' ? 'auto' : 'explicit';
-    if (intent === 'auto') {
-      // Auto-start attempts a claim-if-vacant: remoteEnabled flips only when the
-      // worker reports it actually acquired the seat, so a live owner elsewhere
-      // leaves this session non-remote.
-      setRemoteClaimPending(true);
-    } else {
-      setRemoteEnabled(true);
-      // Explicit toggle: the CURRENT session owns the relay (lazy create adopts
-      // inside ensureRemoteTranscriptWriter when no session exists yet).
-      setRemoteSessionId(getSession()?.id || null);
-    }
+  // Manual ON always targets the current session and explicitly overrides any
+  // previous manual owner. There is no auto/claim-if-vacant path.
+  function startRemote() {
+    setRemoteEnabled(true);
+    setRemoteSessionId(getSession()?.id || null);
     // The worker forwards transcript ingests to the memory service, so its port
     // must be live before the first ingest.
     startMemoryDaemonEagerly({ getMemoryModule, bootProfile });
@@ -65,7 +52,6 @@ export function createRemoteControl({
         // boots the worker, which runs headless when messaging is off.
         if (!channelsEnabled() && !(await hasActiveAutomation().catch(() => false))) {
           bootProfile('channels:start-disabled');
-          setRemoteClaimPending(false);
           return isRemoteEnabled();
         }
         // A backend switch may still be writing; drain it before the worker
@@ -83,39 +69,16 @@ export function createRemoteControl({
         ensureRemoteTranscriptWriter();
         // Re-check after the awaits: stop/supersede or runtime close may have
         // landed mid-chain — never boot for a session that turned remote off.
-        if ((!isRemoteEnabled() && !isRemoteClaimPending()) || isCloseRequested()) {
-          setRemoteClaimPending(false);
-          return false;
-        }
-        // The fork reads process.env synchronously, so set the inherited intent
-        // immediately before it and restore right after: the pollution window is
-        // this fork instead of the whole boot chain.
-        const previousIntent = process.env.MIXDOG_REMOTE_INTENT;
-        try {
-          process.env.MIXDOG_REMOTE_INTENT = intent;
-          await invokeChannelStart();
-        } finally {
-          if (previousIntent === undefined) delete process.env.MIXDOG_REMOTE_INTENT;
-          else process.env.MIXDOG_REMOTE_INTENT = previousIntent;
-        }
-        if ((!isRemoteEnabled() && !isRemoteClaimPending()) || isCloseRequested()) {
-          setRemoteClaimPending(false);
-          return false;
-        }
-        // Explicit claims are unconditional; auto-start dispatches the same
-        // activation as claim-if-vacant so it promotes an automation-only daemon
-        // without stealing a live remote owner.
+        if (!isRemoteEnabled() || isCloseRequested()) return false;
+        await invokeChannelStart();
+        if (!isRemoteEnabled() || isCloseRequested()) return false;
         await channels.execute('activate_channel_bridge', {
           active: true,
-          claimIfVacant: intent === 'auto',
           sessionId: getSession()?.id || getRemoteSessionId() || null,
           transcriptPath: getTranscriptPath(),
         });
-        // The worker's acquire/supersede notification now owns the transition.
-        setRemoteClaimPending(false);
         return isRemoteEnabled();
       } catch (error) {
-        setRemoteClaimPending(false);
         if (isRemoteEnabled()) {
           setRemoteEnabled(false);
           setRemoteSessionId(null);
@@ -135,7 +98,6 @@ export function createRemoteControl({
     const releasingSessionId = getRemoteSessionId() || getSession()?.id || null;
     setRemoteEnabled(false);
     setRemoteSessionId(null);
-    setRemoteClaimPending(false);
     clearChannelStartTimer();
     return remoteTransitions.run(async () => {
       try {
@@ -156,7 +118,6 @@ export function createRemoteControl({
   function stopRemote(reason) {
     setRemoteEnabled(false);
     setRemoteSessionId(null);
-    setRemoteClaimPending(false);
     clearChannelStartTimer();
     channels.stop(reason || 'remote-disabled').catch(() => {});
     return true;

package/src/session-runtime/remote-transcript.mjs

@@ -17,7 +17,6 @@ export function createRemoteTranscript({
   isCloseRequested,
   channelsEnabled,
   channels,
-  mgr,
   bootProfile,
 }) {
   let writer = null;
@@ -36,9 +35,8 @@ export function createRemoteTranscript({
     flushPendingTranscriptRebind,
   };
 
-  // Bind (or refresh) the writer for the CURRENT session+cwd. The owner gate
-  // covers lazy create: an unset owner adopts this session, a LIVE owner blocks
-  // every other session, and a dead owner hands the relay over.
+  // Bind (or refresh) only the manually selected session. Session creation,
+  // close, or liveness never transfers Remote ownership.
   function ensureRemoteTranscriptWriter() {
     const session = getSession();
     if (!isRemoteEnabled() || !session?.id) return false;
@@ -46,9 +44,7 @@ export function createRemoteTranscript({
     if (!owner) {
       setRemoteSessionId(session.id);
     } else if (session.id !== owner) {
-      const ownerSession = mgr.getSession(owner);
-      if (ownerSession && ownerSession.closed !== true && ownerSession.status !== 'closed') return false;
-      setRemoteSessionId(session.id);
+      return false;
     }
     const cwd = getCwd();
     const key = `${session.id}\u0000${cwd}`;

package/src/session-runtime/route-preparation.mjs

@@ -0,0 +1,24 @@
+// One background route preparation can be associated with the currently
+// resumed session. Resume/navigation reads do not wait for it; the next real
+// turn does. Clearing replaces the visible gate without attempting to cancel
+// provider initialization that may already be shared elsewhere.
+export function createRoutePreparationGate({ onError } = {}) {
+  let pending = Promise.resolve();
+
+  return {
+    clear() {
+      pending = Promise.resolve();
+    },
+    start(task) {
+      const operation = Promise.resolve().then(task);
+      pending = operation;
+      // Keep the original rejecting promise for waiters while still marking a
+      // background failure as observed until a submit reaches the same gate.
+      void operation.catch((error) => onError?.(error));
+      return operation;
+    },
+    wait() {
+      return pending;
+    },
+  };
+}

package/src/session-runtime/runtime-core.mjs

@@ -246,6 +246,7 @@ import { createToolSurface } from './tool-surface.mjs';
 import { readRuntimeTunables } from './runtime-tunables.mjs';
 import { createSessionTurnApi } from './session-turn-api.mjs';
 import { providerInitCacheKey } from './provider-init-key.mjs';
+import { createRoutePreparationGate } from './route-preparation.mjs';
 import {
   RUNTIME,
   SEARCH_RUNTIME,
@@ -322,17 +323,8 @@ export async function createMixdogSessionRuntime({
   let desktopSession = initialDesktopSession;
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
   let remoteEnabled = remote === true;
-  // Transient marker: an AUTO start (config/delayed autoStart) has forked the
-  // worker to ATTEMPT a claim-if-vacant but has NOT asserted remote for this
-  // session yet. remoteEnabled flips only if the worker reports it acquired the
-  // seat (the 'acquired' notification). Lets the deferred start chain proceed
-  // past its remoteEnabled guards without prematurely showing this session as
-  // remote (single-holder: a live owner must not be stolen by autoStart).
-  let remoteClaimPending = false;
-  // SESSION-SCOPED remote (user decision): the session that toggled remote
-  // OWNS the channel relay. Other sessions' turns never rebind or relay; a
-  // dead/replaced owner (clear, delete) hands the seat to the next current
-  // session that asks.
+  // SESSION-SCOPED Remote is manual-only. Explicit ON selects/overrides; no
+  // registration, turn, session death, or process death transfers ownership.
   let remoteSessionId = null;
   // Desktop/TUI Remote toggles are desired-state transitions. Serialize the
   // daemon deactivate/detach and reconnect/activate chains so an OFF that is
@@ -371,6 +363,11 @@ export async function createMixdogSessionRuntime({
     })();
     return keychainPrewarmWaitPromise;
   }
+  const routePreparation = createRoutePreparationGate({
+    onError: (error) => bootProfile('route-preparation:failed', {
+      error: error?.message || String(error),
+    }),
+  });
 
   const importsStartedAt = performance.now();
   const [
@@ -744,28 +741,10 @@ export async function createMixdogSessionRuntime({
       // newer remote session. Drop remote mode entirely on this session (no
       // handover, no retry) and tell UI listeners so the indicator updates.
       if (msg?.method === 'notifications/mixdog/remote') {
-        // Any acquire/supersede verdict resolves an in-flight auto claim attempt.
-        remoteClaimPending = false;
         if (msg?.params?.state === 'superseded' && remoteEnabled) {
           stopRemote('superseded-by-newer-remote-session');
           emitRemoteStateChange(false, 'superseded');
         }
-        // Symmetric acquire: the worker took the bridge seat (boot make-before-
-        // break or activate). Flip remote ON via the same side-state a user
-        // /remote toggles — remoteEnabled + transcript writer — but WITHOUT
-        // re-invoking channel start (the worker is already running; startRemote
-        // would re-fork/activate). Idempotent: no-op when already enabled.
-        if (msg?.params?.state === 'acquired' && !remoteEnabled) {
-          remoteEnabled = true;
-          if (!remoteSessionId) remoteSessionId = session?.id || null;
-          ensureRemoteTranscriptWriter();
-          // Auto-acquire: the worker restored yesterday's transcript from
-          // persisted status and we just created the CURRENT writer. Push the
-          // repoint now instead of waiting for the next inbound parent-chain
-          // steal, so outbound forwarding never tails a stale transcript.
-          pushTranscriptRebind();
-          emitRemoteStateChange(true, 'acquired');
-        }
         return;
       }
       if (msg?.method !== 'notifications/claude/channel') return;
@@ -845,7 +824,11 @@ export async function createMixdogSessionRuntime({
       if (name === 'recall' || name === 'memory' || name === 'search_memories') {
         const memoryMod = await getMemoryModule();
         if (!memoryMod?.handleToolCall) throw new Error('memory runtime is not available');
-        return await memoryMod.handleToolCall(name, memoryToolArgsForCaller(args, callerCwd));
+        return await memoryMod.handleToolCall(
+          name,
+          memoryToolArgsForCaller(args, callerCwd),
+          callerCtx?.signal || session?.controller?.signal || null,
+        );
       }
       if (name === 'code_graph') {
         const codeGraphMod = await getCodeGraphModule();
@@ -1170,12 +1153,18 @@ export async function createMixdogSessionRuntime({
     return route;
   }
 
-  async function refreshRouteEffort(modelMetaOverride = null) {
-    await ensureProvidersReady(ensureProviderEnabled(config, route.provider));
-    const modelMeta = modelMetaOverride || await lookupModelMeta(route.provider, route.model);
-    const requested = hasOwn(route, 'effort') ? route.effort : (route.preset?.effort || null);
-    const effectiveEffort = coerceEffortFor(route.provider, modelMeta, requested);
-    const fastCapable = fastCapableFor(route.provider, modelMeta);
+  async function refreshRouteEffort(modelMetaOverride = null, expectedRoute = null) {
+    const targetRoute = expectedRoute || route;
+    await ensureProvidersReady(ensureProviderEnabled(config, targetRoute.provider));
+    const modelMeta = modelMetaOverride || await lookupModelMeta(targetRoute.provider, targetRoute.model);
+    // A rapid second resume/model change can replace the route while provider
+    // metadata is loading. Never let the older completion overwrite it.
+    if (expectedRoute && route !== expectedRoute) return null;
+    const requested = hasOwn(targetRoute, 'effort')
+      ? targetRoute.effort
+      : (targetRoute.preset?.effort || null);
+    const effectiveEffort = coerceEffortFor(targetRoute.provider, modelMeta, requested);
+    const fastCapable = fastCapableFor(targetRoute.provider, modelMeta);
     // Carry the catalog display name onto the route so the statusline shows a
     // human label (e.g. "Claude Fable 5") for preset-less direct models instead
     // of the raw id. `name` is only trusted when it differs from the raw model
@@ -1183,11 +1172,11 @@ export async function createMixdogSessionRuntime({
     // already-resolved label. Falls back to existing route.modelDisplay, then unset.
     const metaName = clean(modelMeta?.name);
     const modelDisplay = clean(modelMeta?.display) || clean(modelMeta?.displayName)
-      || (metaName && metaName !== clean(route.model) ? metaName : '')
-      || clean(route.modelDisplay);
+      || (metaName && metaName !== clean(targetRoute.model) ? metaName : '')
+      || clean(targetRoute.modelDisplay);
     route = {
-      ...route,
-      fast: fastCapable ? route.fast === true : false,
+      ...targetRoute,
+      fast: fastCapable ? targetRoute.fast === true : false,
       fastCapable,
       effectiveEffort,
       effortOptions: effortItemsFor(route.provider, modelMeta, effectiveEffort),
@@ -1393,6 +1382,7 @@ export async function createMixdogSessionRuntime({
   const {
     scheduleCodeGraphPrewarm,
     scheduleLeadSessionPrewarm,
+    scheduleToolRuntimeWarmup,
     invokeChannelStart,
     scheduleChannelStart,
   } = createPrewarmSchedulers({
@@ -1435,7 +1425,6 @@ export async function createMixdogSessionRuntime({
     isCloseRequested: () => closeRequested,
     channelsEnabled,
     channels,
-    mgr,
     bootProfile,
   });
   const ensureRemoteTranscriptWriter = () => remoteTranscript.ensureRemoteTranscriptWriter();
@@ -1450,8 +1439,6 @@ export async function createMixdogSessionRuntime({
     setRemoteEnabled: (next) => { remoteEnabled = next; },
     getRemoteSessionId: () => remoteSessionId,
     setRemoteSessionId: (next) => { remoteSessionId = next; },
-    isRemoteClaimPending: () => remoteClaimPending,
-    setRemoteClaimPending: (next) => { remoteClaimPending = next; },
     isCloseRequested: () => closeRequested,
     clearChannelStartTimer: () => {
       if (prewarmTimers.channelStartTimer) {
@@ -1500,6 +1487,7 @@ export async function createMixdogSessionRuntime({
     codeGraphPrewarm: codeGraphPrewarmEnabled,
   });
   scheduleLeadSessionPrewarm();
+  scheduleToolRuntimeWarmup();
   // Lazy mode (default): skip the startup prewarm entirely; the first turn
   // triggers it instead (see ask()). Eager mode keeps the old startup schedule.
   if (!codeGraphPrewarmLazy) {
@@ -1519,32 +1507,7 @@ export async function createMixdogSessionRuntime({
   // Channels are opt-in: only boot the worker when this session started in (or
   // was toggled into) remote mode. Non-remote sessions never contend for the
   // channel; see startRemote()/stopRemote() and the `/remote` toggle.
-  // `remote.autoStart` in mixdog-config.json makes terminal sessions attempt a
-  // remote claim at boot. Desktop sessions are explicit-only: opening the app
-  // must never claim or spawn the channel bridge until its Remote button is
-  // pressed, while the shared owner-state watcher still reflects a terminal
-  // that already owns it.
-  // The flag lives in the TOP-LEVEL `remote` section of mixdog-config.json
-  // (sibling of agent/ui/channels), not inside the agent section that
-  // cfgMod.loadConfig returns — read it via the shared whole-file reader.
-  // `config?.remote?.autoStart` is kept for back-compat with agent-section
-  // placement.
-  // `remote` (from `mixdog --remote`) is EXPLICIT force-takeover. Config
-  // `remote.autoStart` is AUTO: it must claim the seat ONLY if no live owner
-  // exists (claim-if-vacant) and back off silently otherwise — so it does NOT
-  // set remoteEnabled up front (that would assert remote before the claim is
-  // known to have won). Track it as a separate deferred auto request; the
-  // worker's acquire notification flips remoteEnabled if/when it wins the seat.
-  let remoteAutoStartRequested = false;
-  if (!remoteEnabled && !desktopSession) {
-    try {
-      if (config?.remote?.autoStart === true
-        || sharedCfgMod?.readSection?.('remote')?.autoStart === true) {
-        remoteAutoStartRequested = true;
-      }
-    } catch { /* unreadable config never blocks boot */ }
-  }
-  // Boot-time remote start (autoStart or --remote) is DEFERRED past the TUI's
+  // A manual `mixdog --remote` request is deferred past the TUI's
   // first frame. startRemote() front-loads heavy work — memory daemon fork
   // (PG + forced ONNX embed warmup in the child), eager session create, and
   // the channel-worker fork — and running it inline here interleaves that
@@ -1553,22 +1516,18 @@ export async function createMixdogSessionRuntime({
   // early /remote (startRemote clears it), stopRemote(), and close() all
   // cancel it through the existing clearTimeout paths. Runtime /remote calls
   // still start immediately (user-initiated, UI already painted).
-  if (remoteEnabled || remoteAutoStartRequested) {
-    const remoteStartIntent = remoteEnabled ? 'explicit' : 'auto';
-    bootProfile('channels:autostart-deferred', { delayMs: remoteAutoStartDelayMs, intent: remoteStartIntent });
+  if (remoteEnabled) {
+    bootProfile('channels:manual-start-deferred', { delayMs: remoteAutoStartDelayMs });
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
-      if (closeRequested) return;
-      // Explicit: a /remote-off before the timer clears remoteEnabled — skip.
-      // Auto: always attempt (claim-if-vacant is safe when a live owner exists).
-      if (remoteStartIntent === 'explicit' && !remoteEnabled) return;
-      startRemote({ intent: remoteStartIntent });
+      if (closeRequested || !remoteEnabled) return;
+      startRemote();
     }, remoteAutoStartDelayMs);
     prewarmTimers.channelStartTimer.unref?.();
   } else {
     // Automation decoupling (user decision): enabled schedules/webhooks boot
     // the worker on their own — no remote flag, no remote.autoStart, and no
-    // messaging backend. A later explicit/auto Remote claim promotes the same
+    // messaging backend. A later explicit Remote ON promotes the same
     // daemon without restarting schedules or webhooks.
     prewarmTimers.channelStartTimer = setTimeout(() => {
       prewarmTimers.channelStartTimer = null;
@@ -1703,6 +1662,8 @@ export async function createMixdogSessionRuntime({
     applyResolvedCwd,
     resolveRoute,
     applyDeferredToolSurface,
+    beginRoutePreparation: (task) => routePreparation.start(task),
+    clearRoutePreparation: () => routePreparation.clear(),
     // Live getter: cwd-refresh session rebuilds must re-evaluate the
     // workflow's agent-tool gate, not reuse the boot-time array.
     getStandaloneTools: modelStandaloneTools,
@@ -1842,6 +1803,7 @@ export async function createMixdogSessionRuntime({
     notificationListeners,
     remoteStateListeners,
     awaitInitialMcpConnect,
+    awaitRoutePreparation: () => routePreparation.wait(),
   });
 
   return {
@@ -1940,15 +1902,9 @@ export async function createMixdogSessionRuntime({
     getRemoteSessionId() {
       return remoteSessionId;
     },
-    // Move the relay seat to the CURRENT session (last-wins within this
-    // engine): rebind the transcript writer + forwarder without restarting
-    // the worker. No-op when remote is off or no session exists.
+    // Back-compat alias for an explicit manual ON in the current session.
     claimRemoteForCurrentSession() {
-      if (!remoteEnabled || !session?.id) return false;
-      remoteSessionId = session.id;
-      ensureRemoteTranscriptWriter();
-      pushTranscriptRebind();
-      return true;
+      return startRemote();
     },
     // Subscribe to non-user-initiated remote flips (seat superseded). Returns
     // an unsubscribe function. TUI uses this to sync its Remote indicator and

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

@@ -43,7 +43,7 @@ export function createSessionTurnApi(deps) {
     scheduleProviderWarmup, scheduleProviderModelWarmup, invalidateContextStatusCache,
     agentTool, recreateCurrentSessionIfReady, invalidatePreSessionToolSurface,
     activeToolSurface, applyResolvedCwd, resolveCwdPath, agentStatusState, notificationListeners,
-    awaitInitialMcpConnect,
+    awaitInitialMcpConnect, awaitRoutePreparation,
   } = deps;
   const enqueueRemoteAttachedPrompt = (prompt) => {
     const attachedSession = getSession();
@@ -84,6 +84,10 @@ export function createSessionTurnApi(deps) {
           session: attachedSession,
         };
       }
+      // Historical-session resume publishes its transcript immediately while
+      // provider/model metadata initializes in the background. Only the next
+      // actual turn waits, guaranteeing that it cannot run on a stale route.
+      await awaitRoutePreparation?.();
       setActiveTurnCount(getActiveTurnCount() + 1);
       // Lazy code-graph prewarm: kick off the build ONCE, on the first real
       // turn, so a likely code lookup hits a warm cache.
@@ -115,7 +119,10 @@ export function createSessionTurnApi(deps) {
             void invokeChannelStart()
               .then(() => {
                 if (!getRemoteEnabled() || getCloseRequested()) return undefined;
-                return channels.execute('activate_channel_bridge', { active: true });
+                // A turn may refresh the current owner's transcript, but it
+                // must never acquire/override Remote implicitly.
+                pushTranscriptRebind();
+                return undefined;
               })
               .catch((error) => bootProfile('channels:turn-rebind-failed', { error: error?.message || String(error) }));
           }

package/src/session-runtime/workflow-agents-api.mjs

@@ -165,6 +165,9 @@ export function createWorkflowAgentsApi(deps) {
         description: workflow.description,
         source: workflow.source,
         active: workflow.id === active,
+        // Distinguishes "agents: (empty) = Lead only" from "no agents key =
+        // all fixed agents" for surfaces that render the pack's agent set.
+        agentsConfigured: workflow.agentsConfigured === true,
         agents: workflow.agents,
       }));
     },