mixdog 0.9.95 → 0.9.97

package/src/runtime/shared/turn-snapshot.mjs

@@ -83,6 +83,8 @@ function createDiffTracker(meta = {}) {
   return {
     ownerSessionId: clean(meta.ownerSessionId) || null,
     ownerGeneration: Number(meta.ownerGeneration) || 0,
+    worktreeRequest: clean(meta.worktreeRequest),
+    worktreeContended: false,
     valid: true,
     sealed: false,
     revision: 0,
@@ -336,13 +338,31 @@ export async function beginTurnSnapshot(_worktree, sessionId) {
     generation,
     agents: new Map(),
   });
-  const tracker = resetDiffTracker(ownerSessionId);
+  const worktreeRequest = pathKey(_worktree);
+  const tracker = resetDiffTracker(ownerSessionId, { worktreeRequest });
   trimTurnCache();
   if (!tracker) return;
+  for (const [otherSessionId, other] of _diffTrackersBySession) {
+    if (otherSessionId === ownerSessionId || other.sealed) continue;
+    if (!worktreeRequest || other.worktreeRequest !== worktreeRequest) continue;
+    tracker.worktreeContended = true;
+    other.worktreeContended = true;
+  }
   try {
     const snapshot = await createTurnWorktreeSnapshot(_worktree);
     if (_diffTrackersBySession.get(ownerSessionId) === tracker) {
       tracker.worktreeSnapshot = snapshot;
+      if (snapshot?.root) {
+        for (const [otherSessionId, other] of _diffTrackersBySession) {
+          if (otherSessionId === ownerSessionId) continue;
+          if (other.worktreeSnapshot?.root !== snapshot.root) continue;
+          // A whole-worktree baseline cannot attribute concurrent mutations
+          // to either session. Mark both turns permanently contended and fall
+          // back to their exact session-owned mutation trackers.
+          tracker.worktreeContended = true;
+          other.worktreeContended = true;
+        }
+      }
     }
   } catch {
     // Git is optional. Exact apply_patch tracking remains the fallback.
@@ -421,7 +441,7 @@ export function completeAgentTurnReview(handle, patches = []) {
 export async function completeTurnSnapshot(sessionId) {
   const tracker = _diffTrackersBySession.get(clean(sessionId));
   if (!tracker) return false;
-  if (tracker.worktreeSnapshot) {
+  if (tracker.worktreeSnapshot && !tracker.worktreeContended) {
     try { await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot); } catch {}
   }
   tracker.sealed = true;
@@ -429,16 +449,34 @@ export async function completeTurnSnapshot(sessionId) {
   return true;
 }
 
+/** Abandon an aborted Lead turn without waiting for optional Git snapshot IO. */
+export function cancelTurnSnapshot(sessionId) {
+  const ownerSessionId = clean(sessionId);
+  if (!ownerSessionId) return false;
+  let removed = false;
+  for (const [trackedSessionId, tracker] of _diffTrackersBySession) {
+    if (trackedSessionId !== ownerSessionId && tracker.ownerSessionId !== ownerSessionId) continue;
+    releaseDiffTrackerContent(tracker);
+    _diffTrackersBySession.delete(trackedSessionId);
+    removed = true;
+  }
+  if (_turnsBySession.delete(ownerSessionId)) removed = true;
+  return removed;
+}
+
 /** Return the authoritative Lead net diff plus attributed child reviews. */
-export async function getTurnReviewDiff(_worktree, sessionId) {
+export async function getTurnReviewDiff(_worktree, sessionId, options = {}) {
   if (DISABLED) return { supported: false, files: [], patch: '', agents: [] };
   const ownerSessionId = clean(sessionId);
   const turn = _turnsBySession.get(ownerSessionId);
   const tracker = _diffTrackersBySession.get(ownerSessionId);
-  if (tracker?.worktreeSnapshot && !tracker.sealed) {
-    try { await refreshTurnWorktreeSnapshot(tracker.worktreeSnapshot); } catch {}
+  const isolatedWorktreeSnapshot = tracker?.worktreeContended
+    ? null
+    : tracker?.worktreeSnapshot || null;
+  if (isolatedWorktreeSnapshot && !tracker.sealed && options.refresh !== false) {
+    try { await refreshTurnWorktreeSnapshot(isolatedWorktreeSnapshot); } catch {}
   }
-  const snapshot = tracker?.worktreeSnapshot || null;
+  const snapshot = isolatedWorktreeSnapshot;
   return {
     supported: true,
     files: snapshot?.files || [],
@@ -455,6 +493,9 @@ export async function getTurnReviewDiff(_worktree, sessionId) {
 export async function revertTurnReviewFile(_worktree, sessionId, file) {
   const ownerSessionId = clean(sessionId);
   const tracker = _diffTrackersBySession.get(ownerSessionId);
+  if (tracker?.worktreeContended) {
+    throw new Error('turn review revert is unavailable while sessions share a worktree');
+  }
   if (!tracker?.worktreeSnapshot) throw new Error('turn worktree snapshot is unavailable');
   await revertTurnWorktreeFile(tracker.worktreeSnapshot, file);
   return await getTurnReviewDiff(_worktree, ownerSessionId);

package/src/runtime/shared/turn-worktree-snapshot.mjs

@@ -43,15 +43,17 @@ function runGit(args, {
   allowFailure = false,
 } = {}) {
   return new Promise((resolvePromise, rejectPromise) => {
+    const hasInput = (typeof input === 'string' || Buffer.isBuffer(input)) && input.length > 0;
     const child = spawn('git', args, {
       cwd,
       windowsHide: true,
-      stdio: ['pipe', 'pipe', 'pipe'],
+      stdio: [hasInput ? 'pipe' : 'ignore', 'pipe', 'pipe'],
     });
     const stdout = [];
     const stderr = [];
     let stdoutBytes = 0;
     let stderrBytes = 0;
+    let stdinError = null;
     let settled = false;
     const finish = (error, result) => {
       if (settled) return;
@@ -93,9 +95,19 @@ function runGit(args, {
         finish(commandError(args, result.stderr, result.code));
         return;
       }
+      if (stdinError && result.code === 0) {
+        finish(stdinError);
+        return;
+      }
       finish(null, result);
     });
-    child.stdin.end(input);
+    if (child.stdin) {
+      // A short-lived git command can close before Node flushes stdin. Keep
+      // that transport race inside this promise instead of emitting an
+      // unhandled EPIPE that terminates the entire release validator.
+      child.stdin.on('error', (error) => { stdinError = error; });
+      child.stdin.end(input);
+    }
   });
 }
 

package/src/session-runtime/channel-config-api.mjs

@@ -15,10 +15,10 @@ import { runScheduleSession } from '../runtime/shared/schedule-session-run.mjs';
 
 // Channel/webhook/schedule config surface. Extracted verbatim from the runtime
 // API object; the mutating admin helpers are imported directly here and the
-// runtime injects only the closure-owned callbacks (backend flush, channel
+// runtime injects only the closure-owned callbacks (channel provider flush, channel
 // worker handle, soft reload).
 export function createChannelConfigApi({
-  flushBackendSave,
+  flushChannelProviderSave,
   channels,
   reloadChannelsSoon,
   ensureAutomationRuntime = () => {},
@@ -26,10 +26,10 @@ export function createChannelConfigApi({
 }) {
   return {
     async getChannelSetup() {
-      // Flush a pending debounced backend switch first so setup readers
+      // Flush a pending debounced channel provider switch first so setup readers
       // (Settings → Channel Setting, remote toggles) never observe the
-      // previous backend during the 150ms debounce window.
-      try { await flushBackendSave(); } catch {}
+      // previous provider during the 150ms debounce window.
+      try { await flushChannelProviderSave(); } catch {}
       // Bot tokens live in the OS keychain. Reading them before the batch
       // prewarm lands costs one SYNCHRONOUS PowerShell DPAPI decrypt each
       // (measured 971ms + 579ms on a cold desktop boot, blocking the whole

package/src/session-runtime/config-helpers.mjs

@@ -7,11 +7,13 @@ import { routeFastKey, fastPreferenceFor } from './model-capabilities.mjs';
 export const DEFAULT_PROVIDER = 'anthropic-oauth';
 export const DEFAULT_MODEL = '';
 
-// Resolve the provider to use when a route carries no explicit provider.
-// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
+// Resolve a provider-less MAIN selector against the selected Main preset.
+// DEFAULT_PROVIDER is only the unconfigured bootstrap fallback (model remains
+// empty); agent/search override resolution never calls this to synthesize one.
 export function makeResolveDefaultProvider(isKnownProvider) {
   return function resolveDefaultProvider(config) {
-    const configured = clean(config?.defaultProvider);
+    const selectedMain = findPreset(config, config?.default);
+    const configured = clean(selectedMain?.provider);
     if (configured && isKnownProvider(configured)) return configured;
     return DEFAULT_PROVIDER;
   };
@@ -46,16 +48,18 @@ export function makeResolveRoute(resolveDefaultProvider) {
     if (explicitModel && !explicitProvider) {
       const preset = findPreset(config, explicitModel);
       if (preset) {
-        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const p = clean(preset.provider);
         const m = clean(preset.model) || DEFAULT_MODEL;
-        const saved = modelSettingsFor(config, p, m);
-        return {
-          provider: p,
-          model: m,
-          preset,
-          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-        };
+        if (p && m) {
+          const saved = modelSettingsFor(config, p, m);
+          return {
+            provider: p,
+            model: m,
+            preset,
+            effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+            fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+          };
+        }
       }
     }
 
@@ -63,16 +67,18 @@ export function makeResolveRoute(resolveDefaultProvider) {
       const defaultKey = config?.default;
       const preset = findPreset(config, defaultKey);
       if (preset) {
-        const p = clean(preset.provider) || DEFAULT_PROVIDER;
+        const p = clean(preset.provider);
         const m = clean(preset.model) || DEFAULT_MODEL;
-        const saved = modelSettingsFor(config, p, m);
-        return {
-          provider: p,
-          model: m,
-          preset,
-          effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-          fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-        };
+        if (p && m) {
+          const saved = modelSettingsFor(config, p, m);
+          return {
+            provider: p,
+            model: m,
+            preset,
+            effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
+            fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
+          };
+        }
       }
     }
 
@@ -197,14 +203,14 @@ export function resolveAgentTerminalReapMs(config, provider) {
 // fall back to the provider's default; else the global 1h default.
 export function resolveAutoClearIdleMs(config, provider) {
   const raw = config?.autoClear && typeof config.autoClear === 'object' ? config.autoClear : {};
-  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const idleMs = Number(raw.idleMs);
   if (Number.isFinite(idleMs) && idleMs > 0) return Math.max(60_000, Math.round(idleMs));
-  return autoClearIdleMsForProvider(provider, raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers);
+  return autoClearIdleMsForProvider(provider, raw.providerIdleMs);
 }
 
 export function normalizeSystemShellConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
+  const command = clean(raw.command);
   const envCommand = clean(process.env.MIXDOG_SHELL);
   return {
     command,
@@ -227,7 +233,7 @@ export function normalizeSystemShellCommand(value) {
 
 export function normalizeAutoClearConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const idleMs = Number(raw.idleMs);
   const hasExplicitIdle = Number.isFinite(idleMs) && idleMs > 0;
   const rawMinPct = Number(raw.minContextPercent);
   const minContextPercent = Number.isFinite(rawMinPct)
@@ -241,7 +247,7 @@ export function normalizeAutoClearConfig(value = {}) {
     enabled: raw.enabled !== false,
     idleMs: hasExplicitIdle ? Math.max(60_000, Math.round(idleMs)) : null,
     custom: hasExplicitIdle,
-    providerIdleMs: normalizeAutoClearProviderIdleMs(raw.providerIdleMs ?? raw.providerDefaults ?? raw.providers),
+    providerIdleMs: normalizeAutoClearProviderIdleMs(raw.providerIdleMs),
     minContextPercent,
   };
 }
@@ -254,16 +260,15 @@ export function normalizeCompactTypeSetting(value, fallback = 'recall-fasttrack'
   return fallback;
 }
 
-export function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
+export function normalizeCompactionConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
-  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'recall-fasttrack');
-  // Memory is now always-on, so recall-fasttrack no longer downgrades to
-  // semantic. `memoryEnabled` is retained as a param for API compatibility but
-  // is intentionally ignored (fasttrack drains run on-demand regardless of the
-  // recap/background-cycle toggle).
-  void memoryEnabled;
+  const compactType = normalizeCompactTypeSetting(raw.type, 'recall-fasttrack');
+  const next = { ...raw };
+  delete next.compactType;
+  delete next.compact_type;
+  delete next.enabled;
   return {
-    ...raw,
+    ...next,
     auto: raw.auto !== false && raw.enabled !== false,
     type: compactType,
     compactType,
@@ -284,9 +289,6 @@ export function moduleEnabled(configLike, name, fallback = true) {
 export function recapEnabled(configLike, fallback = true) {
   const entry = configLike?.recap;
   if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-  // Legacy fallback: pre-migration configs may still carry modules.memory=false.
-  if (configLike?.modules?.memory === false) return false;
-  if (moduleEnabled(configLike, 'memory', true) === false) return false;
   return fallback !== false;
 }
 

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

@@ -11,7 +11,7 @@
 // same-tick readers see fresh state, and DEBOUNCE the disk write so a burst of
 // toggles collapses into one persist. Three independent debounce channels:
 //   - config save  (cfgMod.saveConfig, agent-section serialize)
-//   - backend save (channel-admin setBackend, file-locked RMW)
+//   - channel provider save (channel-admin setChannelProvider, file-locked RMW)
 //   - outputStyle  (sharedCfgMod.updateConfig whole-root RMW — cfgMod.saveConfig
 //                   only serializes agent-section fields, so a top-level
 //                   outputStyle would never reach disk via that path)
@@ -30,7 +30,7 @@ export function createConfigLifecycle({
   // shared modules / helpers
   cfgMod,
   sharedCfgMod,
-  setBackendAsync,
+  setChannelProviderAsync,
   setConfiguredShell,
   normalizeSystemShellConfig,
   normalizeSearchRouteConfig,
@@ -188,40 +188,40 @@ export function createConfigLifecycle({
     return adopted;
   }
 
-  // --- debounced backend switch ----------------------------------------------
-  let pendingBackendName = null;
-  let backendSaveTimer = null;
-  let backendFlushInFlight = null;
+  // --- debounced channel provider switch ----------------------------------------------
+  let pendingChannelProvider = null;
+  let channelProviderSaveTimer = null;
+  let channelProviderFlushInFlight = null;
 
-  async function runBackendFlushAsync() {
-    while (pendingBackendName !== null) {
-      const name = pendingBackendName;
+  async function runChannelProviderFlushAsync() {
+    while (pendingChannelProvider !== null) {
+      const name = pendingChannelProvider;
       try {
-        await setBackendAsync(name);
+        await setChannelProviderAsync(name);
       } catch (err) {
-        process.stderr.write(`[channels] async setBackend failed: ${err?.message || err}\n`);
-        if (pendingBackendName === name) pendingBackendName = null;
+        process.stderr.write(`[channels] async setChannelProvider failed: ${err?.message || err}\n`);
+        if (pendingChannelProvider === name) pendingChannelProvider = null;
         break;
       }
-      if (pendingBackendName === name) pendingBackendName = null;
+      if (pendingChannelProvider === name) pendingChannelProvider = null;
     }
   }
 
-  function flushBackendSaveAsync() {
-    if (backendSaveTimer) { clearTimeout(backendSaveTimer); backendSaveTimer = null; }
-    const start = () => runBackendFlushAsync();
-    const p = backendFlushInFlight ? backendFlushInFlight.then(start, start) : start();
-    backendFlushInFlight = p;
-    const clear = () => { if (backendFlushInFlight === p) backendFlushInFlight = null; };
+  function flushChannelProviderSaveAsync() {
+    if (channelProviderSaveTimer) { clearTimeout(channelProviderSaveTimer); channelProviderSaveTimer = null; }
+    const start = () => runChannelProviderFlushAsync();
+    const p = channelProviderFlushInFlight ? channelProviderFlushInFlight.then(start, start) : start();
+    channelProviderFlushInFlight = p;
+    const clear = () => { if (channelProviderFlushInFlight === p) channelProviderFlushInFlight = null; };
     p.then(clear, clear);
     return p;
   }
 
-  function scheduleBackendSave(name) {
-    pendingBackendName = name;
-    if (backendSaveTimer) clearTimeout(backendSaveTimer);
-    backendSaveTimer = setTimeout(() => { flushBackendSaveAsync(); }, CONFIG_SAVE_DEBOUNCE_MS);
-    backendSaveTimer.unref?.();
+  function scheduleChannelProviderSave(name) {
+    pendingChannelProvider = name;
+    if (channelProviderSaveTimer) clearTimeout(channelProviderSaveTimer);
+    channelProviderSaveTimer = setTimeout(() => { flushChannelProviderSaveAsync(); }, CONFIG_SAVE_DEBOUNCE_MS);
+    channelProviderSaveTimer.unref?.();
   }
 
   // --- debounced skills.disabled persist -------------------------------------
@@ -326,7 +326,7 @@ export function createConfigLifecycle({
   async function flushAllConfigSavesAsync() {
     await Promise.all([
       flushConfigSaveAsync(),
-      flushBackendSaveAsync(),
+      flushChannelProviderSaveAsync(),
       flushOutputStyleSaveAsync(),
     ]);
     // The shared config layer also tracks writes started directly by channel,
@@ -420,8 +420,8 @@ export function createConfigLifecycle({
     // Every lifecycle flush uses the async lock path. A synchronous waiter on
     // the same lock would block the event loop needed by an in-flight async
     // writer, so callers must await this before a dependent read/start.
-    flushBackendSave: flushBackendSaveAsync,
-    scheduleBackendSave,
+    flushChannelProviderSave: flushChannelProviderSaveAsync,
+    scheduleChannelProviderSave,
     flushSkillsSave,
     scheduleSkillsSave,
     flushOutputStyleSave,

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

@@ -15,6 +15,7 @@ import {
   getStoreDir,
   listSessionHeartbeatMtimes,
 } from '../runtime/agent/orchestrator/session/store/paths-heartbeat.mjs';
+import { SessionClosedError } from '../runtime/agent/orchestrator/session/manager/session-errors.mjs';
 
 export function resolveResumeCwd(session, currentCwd) {
   const desktop = session?.desktopSession;
@@ -52,7 +53,7 @@ export function createLifecycleApi(deps) {
     beginRoutePreparation, clearRoutePreparation,
     pushTranscriptRebind,
     notificationListeners, remoteStateListeners, desktopSession,
-    disposeSessionTitles,
+    disposeSessionTitles, abortActiveTurns, getReservedSessionId,
   } = deps;
   const closeSurfaceSession = (session, reason, options) => {
     if (!session?.id) return false;
@@ -168,6 +169,14 @@ export function createLifecycleApi(deps) {
       // of reaping every session's jobs. CLI exit paths never set this.
       const keepBackgroundWork = options?.keepBackgroundWork === true;
       setCloseRequested(true);
+      const closingTurnId = getSession()?.id || getReservedSessionId?.() || 'pending';
+      try {
+        abortActiveTurns?.(new SessionClosedError(
+          closingTurnId,
+          `runtime close (reason=${reason})`,
+          reason,
+        ));
+      } catch {}
       try { stopSelfUpdateBootCheck?.(); } catch {}
       try { disposeSessionTitles?.(); } catch {}
       // Self-update now stages in the background and swaps on the next clean
@@ -335,8 +344,18 @@ export function createLifecycleApi(deps) {
     },
     abort(reason = 'cli-abort') {
       const session = getSession();
-      if (!session?.id) return false;
-      return mgr.abortSessionTurn(session.id, reason);
+      const sessionId = session?.id || getReservedSessionId?.() || 'pending';
+      const abortError = new SessionClosedError(
+        sessionId,
+        `runtime abort (reason=${reason})`,
+        reason,
+      );
+      let outerAborted = false;
+      try { outerAborted = abortActiveTurns?.(abortError) === true; } catch {}
+      const managerAborted = session?.id
+        ? mgr.abortSessionTurn(session.id, reason)
+        : false;
+      return outerAborted || managerAborted;
     },
     listSessions(options = {}) {
       return listLeadSessions(options);

package/src/session-runtime/memory-runtime-prewarm.mjs

@@ -0,0 +1,15 @@
+// Eager in-process memory initialization for remote sessions. Channel ingest
+// shares the daemon-owned proxy, so readiness is the isolated process/port
+// singleflight returned by getMemoryModule.
+
+export function prewarmMemoryRuntime({ getMemoryModule, bootProfile }) {
+  void (async () => {
+    try {
+      await new Promise((resolve) => setImmediate(resolve))
+      await getMemoryModule()
+      bootProfile('channels:memory-prewarm-ready')
+    } catch (error) {
+      bootProfile('channels:memory-prewarm-failed', { error: error?.message || String(error) })
+    }
+  })()
+}

package/src/session-runtime/model-route-api.mjs

@@ -64,11 +64,13 @@ export function createModelRouteApi(deps) {
       return await collectSearchProviderModels({ force: options.force === true || options.refresh === true });
     },
     async setSearchRoute(next) {
-      const searchRoute = getSearchRouteState();
-      let selectedRoute = normalizeSearchRouteConfig(next);
-      if (!selectedRoute && next?.model && searchRoute?.provider) {
-        selectedRoute = normalizeSearchRouteConfig({ ...next, provider: searchRoute.provider });
-      }
+      let selectedRoute = clean(next?.provider)
+        ? normalizeSearchRouteConfig(next)
+        : normalizeSearchRouteConfig({
+          provider: SEARCH_DEFAULT_PROVIDER,
+          model: SEARCH_DEFAULT_MODEL,
+          ...(next?.toolType ? { toolType: next.toolType } : {}),
+        });
       if (!selectedRoute) throw new Error('search route requires provider and model');
       if (isDefaultSearchRouteConfig(selectedRoute)) {
         await awaitKeychainPrewarm();

package/src/session-runtime/prewarm.mjs

@@ -132,7 +132,7 @@ export function createPrewarmSchedulers({
       if (isCloseRequested()) return;
       // Channels-module and remote toggles gate MESSAGING; automation
       // (enabled schedules/webhooks) keeps the worker boot alive — its
-      // backend runs headless when messaging is off or unconfigured.
+      // channel provider runs headless when messaging is off or unconfigured.
       const automation = await hasActiveAutomation().catch(() => false);
       if (!channelsEnabled() && !automation) {
         bootProfile('channels:start-disabled');

package/src/session-runtime/provider-auth-api.mjs

@@ -193,12 +193,5 @@ export function createProviderAuthApi({
         quick: options.quick === true,
       });
     },
-    async setDefaultProvider(provider) {
-      const requested = clean(provider);
-      if (!requested) throw new Error('provider is required');
-      if (!isKnownProvider(requested)) throw new Error(`unknown provider "${provider}"`);
-      saveConfigAndAdopt({ ...getConfig(), defaultProvider: requested });
-      return requested;
-    },
   };
 }

package/src/session-runtime/provider-models.mjs

@@ -16,7 +16,7 @@ const PROVIDER_MODELS_PROFILE_ENABLED = /^(1|true|yes|on)$/i.test(String(
 ));
 
 // Raw provider model lists are process-global because the provider registry is
-// process-global in the backend daemon. Session runtimes keep only the cheap
+// process-global in the daemon. Session runtimes keep only the cheap
 // hydrated projection (saved effort/fast/current-route ordering). This stops
 // every open pane from repeating the same provider list walk after startup.
 let sharedCatalogRevision = -1;

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

@@ -2,7 +2,7 @@
 // Remote mode is opt-in per session — only a session that turns it on boots the
 // channel worker and contends for the machine-global bridge seat. Extracted
 // from runtime-core, which injects the mutable session/remote state it owns.
-import { startMemoryDaemonEagerly } from './memory-daemon-probe.mjs';
+import { prewarmMemoryRuntime } from './memory-runtime-prewarm.mjs';
 
 export function createRemoteControl({
   getSession,
@@ -16,7 +16,7 @@ export function createRemoteControl({
   channels,
   channelsEnabled,
   hasActiveAutomation,
-  flushBackendSave,
+  flushChannelProviderSave,
   invokeChannelStart,
   createCurrentSession,
   ensureRemoteTranscriptWriter,
@@ -31,9 +31,8 @@ export function createRemoteControl({
   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 });
+    // Warm the daemon-hosted memory module before the first remote ingest.
+    prewarmMemoryRuntime({ getMemoryModule, bootProfile });
     // Publish the session record + transcript file BEFORE the worker's
     // activate-time discovery polls, so forwarding binds to THIS terminal
     // instead of a stale neighbour. A no-op in lazy mode; the turn-start rebind
@@ -54,9 +53,9 @@ export function createRemoteControl({
           bootProfile('channels:start-disabled');
           return isRemoteEnabled();
         }
-        // A backend switch may still be writing; drain it before the worker
+        // A channel provider switch may still be writing; drain it before the worker
         // reads config rather than racing a sync lock wait.
-        try { await flushBackendSave(); } catch { /* best-effort */ }
+        try { await flushChannelProviderSave(); } catch { /* best-effort */ }
         // Yield before the create/transcript/fork chain so Ink's queued render
         // and input handling are not starved by this detached chain.
         await new Promise((resolve) => setImmediate(resolve));