mixdog 0.9.3 → 0.9.4

package/src/mixdog-session-runtime.mjs

@@ -28,8 +28,8 @@ import {
   readMarkdownDocument,
 } from './runtime/shared/markdown-frontmatter.mjs';
 import { setConfiguredShell } from './runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs';
+import { hasUserConversationMessage } from './runtime/agent/orchestrator/session/manager/prompt-utils.mjs';
 import {
-  PROVIDER_STATUS_TOOL,
   beginOAuthProviderLogin,
   forgetProviderAuth,
   isKnownProvider,
@@ -60,7 +60,6 @@ import {
   forgetDiscordToken,
   forgetTelegramToken,
   forgetWebhookAuthtoken,
-  renderChannelStatus,
   saveChannel,
   saveDiscordToken,
   saveTelegramToken,
@@ -137,9 +136,13 @@ import {
   normalizeSystemShellConfig,
   normalizeSystemShellCommand,
   normalizeAutoClearConfig,
+  resolveAutoClearIdleMs,
+  autoClearIdleMsForProvider,
   normalizeCompactionConfig,
   moduleEnabled,
   setModuleEnabledInConfig,
+  recapEnabled,
+  setRecapEnabledInConfig,
   formatDurationMs,
   parseDurationMs,
   modelMetaLooksResolved,
@@ -208,6 +211,36 @@ import {
 // Re-exported for external consumers (scripts/tool-smoke.mjs) that imported
 // these from this module before the tool-catalog extraction.
 export { defaultDeferredToolNames, compactToolSearchDescription } from './session-runtime/tool-catalog.mjs';
+import {
+  TOOL_SEARCH_TOOL,
+  CWD_TOOL,
+  SKILL_TOOL,
+  LEAD_DISALLOWED_TOOLS,
+  applyStandaloneToolDefaults,
+} from './session-runtime/tool-defs.mjs';
+import { ONBOARDING_VERSION, QUICK_SEARCH_MODELS } from './session-runtime/quick-search-models.mjs';
+import {
+  sortProviderModels as sortProviderModelsRaw,
+  providerModelCacheRow as providerModelCacheRowRaw,
+} from './session-runtime/model-recency.mjs';
+import { createNativeSearch } from './session-runtime/native-search.mjs';
+import { createConfigLifecycle } from './session-runtime/config-lifecycle.mjs';
+import { attachSessionHooks } from './session-runtime/session-hooks.mjs';
+import { createQuickModelRows } from './session-runtime/quick-model-rows.mjs';
+import { createWarmupSchedulers } from './session-runtime/warmup-schedulers.mjs';
+import { createPrewarmSchedulers } from './session-runtime/prewarm.mjs';
+import { createMcpGlue } from './session-runtime/mcp-glue.mjs';
+import { createCwdPlugins } from './session-runtime/cwd-plugins.mjs';
+import { createSettingsApi } from './session-runtime/settings-api.mjs';
+import { createProviderModels } from './session-runtime/provider-models.mjs';
+import { createProviderUsage } from './session-runtime/provider-usage.mjs';
+// Re-exported for external consumers (scripts/tool-smoke.mjs) that imported
+// these from this module before the tool-defs extraction.
+export { TOOL_SEARCH_TOOL, SKILL_TOOL };
+// Back-compat test alias; delegates to the extracted helper.
+export function __applyStandaloneToolDefaultsForTest(tool) {
+  return applyStandaloneToolDefaults(tool);
+}
 
 const RUNTIME = './runtime/agent/orchestrator';
 const SEARCH_RUNTIME = './runtime/search/index.mjs';
@@ -276,146 +309,7 @@ async function profiledImport(label, spec, { optional = false } = {}) {
     throw error;
   }
 }
-export const TOOL_SEARCH_TOOL = {
-  name: 'tool_search',
-  title: 'Tool Search',
-  annotations: {
-    title: 'Tool Search',
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false,
-    agentHidden: true,
-  },
-  description: 'Search deferred tools; confident queries load matches.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      query: { type: 'string', description: 'Search text; confident hits load. select:a,b forces exact names.' },
-      select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Force exact tool names.' },
-      limit: { type: 'number', description: 'Max matches.' },
-    },
-    additionalProperties: false,
-  },
-};
-
-const CHANNEL_STATUS_TOOL = {
-  name: 'channel_status',
-  title: 'Channel Status',
-  annotations: {
-    title: 'Channel Status',
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false,
-    agentHidden: true,
-  },
-  description: 'List channel/schedule/webhook status. No secrets.',
-  inputSchema: { type: 'object', properties: {}, additionalProperties: false },
-};
-
-const CWD_TOOL = {
-  name: 'cwd',
-  title: 'Work Project',
-  annotations: {
-    title: 'Work Project',
-    readOnlyHint: false,
-    destructiveHint: false,
-    idempotentHint: false,
-    openWorldHint: false,
-    agentHidden: true,
-  },
-  description: 'Show or set the session work project for tool execution.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: { type: 'string', enum: ['get', 'set'], description: 'Default get.' },
-      path: { type: 'string', description: 'Project directory for set.' },
-    },
-    additionalProperties: false,
-  },
-};
-
-export const SKILL_TOOL = {
-  name: 'Skill',
-  title: 'Skill',
-  annotations: {
-    title: 'Skill',
-    readOnlyHint: true,
-    destructiveHint: false,
-    idempotentHint: true,
-    openWorldHint: false,
-    agentHidden: false,
-  },
-  description: 'Load a named SKILL.md into context.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      name: { type: 'string', description: 'Skill name.' },
-    },
-    required: ['name'],
-    additionalProperties: false,
-  },
-};
-
-const LEAD_DISALLOWED_TOOLS = Object.freeze(['diagnostics', 'open_config']);
-const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
-
-export function __applyStandaloneToolDefaultsForTest(tool) {
-  if (!tool || !AGENT_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;
-  return {
-    ...tool,
-    annotations: {
-      ...(tool.annotations || {}),
-      agentHidden: true,
-    },
-  };
-}
-const applyStandaloneToolDefaults = __applyStandaloneToolDefaultsForTest;
 const outputStyleStatus = (dataDir = STANDALONE_DATA_DIR) => outputStyleStatusRaw(STANDALONE_ROOT, dataDir || STANDALONE_DATA_DIR);
-
-const ONBOARDING_VERSION = 1;
-const QUICK_SEARCH_MODELS = Object.freeze({
-  'openai-oauth': [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
-    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
-  ],
-  openai: [
-    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
-    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
-    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
-    { id: 'gpt-4o', display: 'GPT-4o', contextWindow: 128000 },
-  ],
-  'grok-oauth': [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
-    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
-    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
-  ],
-  xai: [
-    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
-    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
-    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
-  ],
-  gemini: [
-    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true, contextWindow: 1000000 },
-    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro', contextWindow: 1000000 },
-    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash', contextWindow: 1000000 },
-    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash', contextWindow: 1000000 },
-  ],
-  'anthropic-oauth': [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
-  ],
-  anthropic: [
-    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
-    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
-    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
-  ],
-});
 // Workflow/agent pack loaders bound to this runtime's root/data layout.
 const {
   listWorkflowPacks,
@@ -445,15 +339,6 @@ export function __saveModelSettingsForTest(cfgMod, route, options = {}) {
   return saveModelSettings(cfgMod, route, options);
 }
 
-function resolveCwdPath(currentCwd, value) {
-  const raw = clean(value);
-  if (!raw) throw new Error('cwd: path is required for action=set');
-  const next = resolve(currentCwd || process.cwd(), raw);
-  const stat = statSync(next);
-  if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${next}`);
-  return next;
-}
-
 export async function createMixdogSessionRuntime({
   provider,
   model,
@@ -516,37 +401,16 @@ export async function createMixdogSessionRuntime({
   let memoryModPromise = null;
   let searchModPromise = null;
   let codeGraphModPromise = null;
-  let outputStyleStatusCache = null;
-  let outputStyleStatusCacheAt = 0;
-  let outputStyleStatusCacheDir = '';
 
-  const memoryEnabled = () => moduleEnabled(config, 'memory', true);
+  // Memory module is always-on. `memoryEnabled()` is kept as a thin alias that
+  // now always returns true (callers/compaction helpers still reference it);
+  // the user-facing toggle is `recap` (background cycles only), read via
+  // recapEnabled(config).
+  const memoryEnabled = () => true;
+  const recapEnabledFn = () => recapEnabled(config, true);
   const channelsEnabled = () => moduleEnabled(config, 'channels', true);
-  const getOutputStyleStatusCached = ({ fresh = false } = {}) => {
-    const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-    const cacheDir = resolve(dataDir);
-    const now = performance.now();
-    if (
-      !fresh
-      && outputStyleStatusCache
-      && outputStyleStatusCacheDir === cacheDir
-      && now - outputStyleStatusCacheAt < 2500
-    ) {
-      return outputStyleStatusCache;
-    }
-    outputStyleStatusCache = outputStyleStatus(dataDir);
-    outputStyleStatusCacheAt = now;
-    outputStyleStatusCacheDir = cacheDir;
-    return outputStyleStatusCache;
-  };
-  const invalidateOutputStyleStatusCache = () => {
-    outputStyleStatusCache = null;
-    outputStyleStatusCacheAt = 0;
-    outputStyleStatusCacheDir = '';
-  };
 
   async function getMemoryModule() {
-    if (!memoryEnabled()) throw new Error('memory is disabled in settings');
     const startedAt = performance.now();
     memoryModPromise ??= Promise.resolve(memoryRuntime);
     const mod = await memoryModPromise;
@@ -565,211 +429,6 @@ export async function createMixdogSessionRuntime({
     return mod;
   }
 
-  function normalizeSearchAllowedDomain(site) {
-    const raw = clean(site);
-    if (!raw) return '';
-    try {
-      return new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`).hostname.toLowerCase();
-    } catch {
-      return raw.replace(/^https?:\/\//i, '').split('/')[0].toLowerCase();
-    }
-  }
-
-  function nativeSearchUserLocation(locale) {
-    if (!locale || typeof locale !== 'object' || Array.isArray(locale)) return null;
-    const location = { type: 'approximate' };
-    for (const key of ['country', 'region', 'city', 'timezone']) {
-      const value = clean(locale[key]);
-      if (value) location[key] = value;
-    }
-    return Object.keys(location).length > 1 ? location : null;
-  }
-
-  function nativeSearchTool(args = {}, toolType = 'web_search', providerId = '') {
-    const providerName = normalizeSearchProviderId(providerId);
-    const domain = normalizeSearchAllowedDomain(args.site);
-    const type = clean(toolType) || 'web_search';
-    const location = nativeSearchUserLocation(args.locale);
-    if (providerName === 'gemini') {
-      return { type: type || 'google_search' };
-    }
-    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') {
-      const tool = {
-        type: 'web_search_20250305',
-        name: 'web_search',
-        max_uses: Math.max(1, Math.min(10, Number(args.maxResults) || 5)),
-      };
-      if (domain) tool.allowed_domains = [domain];
-      if (location) tool.user_location = location;
-      return tool;
-    }
-    if (providerName === 'grok-oauth' || providerName === 'xai') {
-      const tool = { type };
-      if (domain) tool.filters = { allowed_domains: [domain] };
-      return tool;
-    }
-    const tool = {
-      type,
-    };
-    if (type === 'web_search') {
-      tool.search_context_size = clean(args.contextSize) || 'low';
-      if (domain) tool.filters = { allowed_domains: [domain] };
-      if (location) tool.user_location = location;
-    }
-    return tool;
-  }
-
-  function nativeSearchToolTypes(routeLike = {}) {
-    const envToolType = clean(process.env.MIXDOG_NATIVE_SEARCH_TOOL_TYPE);
-    if (envToolType) return [envToolType];
-    const configured = clean(routeLike.toolType);
-    if (configured) return [configured];
-    const providerName = normalizeSearchProviderId(routeLike.provider);
-    if (providerName === 'gemini') return ['google_search'];
-    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') return ['web_search'];
-    if (providerName === 'grok-oauth' || providerName === 'xai') return ['web_search'];
-    return ['web_search', 'web_search_preview'];
-  }
-
-  function currentMainSearchModelMeta() {
-    if (!route?.provider || !route?.model) return null;
-    return { ...route, id: route.model, display: route.model, name: route.model };
-  }
-
-  function nativeSearchRoutes() {
-    const cfg = ensureFullConfig();
-    searchRoute = normalizeSearchRouteConfig(cfg.searchRoute) || normalizeSearchRouteConfig(searchRoute);
-    if (!searchRoute) return [];
-    if (isDefaultSearchRouteConfig(searchRoute)) {
-      const mainModel = currentMainSearchModelMeta();
-      if (!mainModel || !searchCapableFor(route.provider, mainModel)) return [];
-      return [{
-        key: `default\n${route.provider}\n${route.model}`,
-        provider: normalizeSearchProviderId(route.provider),
-        model: route.model,
-        source: 'default-search-route',
-        effort: route.effectiveEffort || route.effort || null,
-        fast: route.fast === true,
-        toolType: searchRoute.toolType || null,
-      }];
-    }
-    const providerName = normalizeSearchProviderId(searchRoute.provider);
-    if (!isSearchCapableProvider(providerName)) return [];
-    return [{
-      key: `${providerName}\n${searchRoute.model}`,
-      provider: providerName,
-      model: searchRoute.model,
-      source: 'search-route',
-      effort: searchRoute.effort || null,
-      fast: searchRoute.fast === true,
-      toolType: searchRoute.toolType || null,
-    }];
-  }
-
-  function nativeSearchMessages(searchArgs = {}) {
-    const prompt = searchArgs.prompt || '';
-    return [
-      {
-        role: 'system',
-        content: [
-          'You are Mixdog native web search.',
-          'Use the hosted web_search tool for current or external facts.',
-          'Answer concisely, cite source URLs, and do not request local tools or file edits.',
-        ].join('\n'),
-      },
-      { role: 'user', content: prompt },
-    ];
-  }
-
-  function flattenNativeSearchSources(result = {}) {
-    const out = [];
-    const add = (source, fallbackTitle = '') => {
-      if (!source || typeof source !== 'object') return;
-      const url = clean(source.url || source.uri || source.href || source.source_url);
-      if (!url) return;
-      out.push({
-        title: clean(source.title || source.query || source.name || fallbackTitle || url),
-        url,
-        snippet: clean(source.snippet || source.text || source.description),
-        source: source.source || 'native-web-search',
-        provider: source.provider || 'native-web-search',
-      });
-    };
-    for (const citation of Array.isArray(result.citations) ? result.citations : []) add(citation);
-    for (const call of Array.isArray(result.webSearchCalls) ? result.webSearchCalls : []) {
-      const action = call?.action || {};
-      for (const source of Array.isArray(action.sources) ? action.sources : []) add(source, action.query || '');
-      if (action.url) add({ url: action.url, title: action.query || '' });
-      for (const url of Array.isArray(action.urls) ? action.urls : []) add({ url, title: action.query || '' });
-    }
-    const seen = new Set();
-    return out.filter((item) => {
-      const key = item.url || `${item.title}\n${item.snippet}`;
-      if (!key || seen.has(key)) return false;
-      seen.add(key);
-      return true;
-    });
-  }
-
-  async function runNativeWebSearch(searchArgs = {}, { signal } = {}) {
-    const candidates = nativeSearchRoutes();
-    if (!candidates.length) {
-      if (isDefaultSearchRouteConfig(searchRoute)) {
-        throw new Error(`default search route requires the current main model to support native web search (${route?.provider || 'unknown'}/${route?.model || 'unknown'})`);
-      }
-      throw new Error('search route is not configured; open /search to choose a search provider/model');
-    }
-    const errors = [];
-    for (const candidate of candidates) {
-      for (const toolType of nativeSearchToolTypes(candidate)) {
-        try {
-          await ensureProvidersReady(ensureProviderEnabled(config, candidate.provider));
-          const providerImpl = reg.getProvider(candidate.provider);
-          if (!providerImpl || typeof providerImpl.send !== 'function') {
-            throw new Error(`provider "${candidate.provider}" is not ready`);
-          }
-          const model = candidate.model;
-          const searchTool = nativeSearchTool(searchArgs, toolType, candidate.provider);
-          const startedAt = Date.now();
-          const result = await providerImpl.send(
-            nativeSearchMessages(searchArgs),
-            model,
-            undefined,
-            {
-              signal,
-              role: 'web-search',
-              sessionId: `${session?.id || 'search'}:native-search:${Date.now().toString(36)}`,
-              sourceType: 'native-search',
-              sourceName: 'search',
-              nativeTools: [searchTool],
-              nativeInclude: candidate.provider === 'openai' || candidate.provider === 'openai-oauth'
-                ? ['web_search_call.action.sources']
-                : [],
-              toolChoice: candidate.provider === 'gemini' ? 'auto' : 'required',
-              ...(candidate.effort ? { effort: candidate.effort } : {}),
-              fast: candidate.fast === true,
-              onStageChange: () => {},
-              onStreamDelta: () => {},
-            },
-          );
-          const sources = flattenNativeSearchSources(result);
-          return {
-            content: String(result?.content || '').trim(),
-            provider: candidate.provider,
-            model: result?.model || candidate.model || null,
-            usage: result?.usage || null,
-            citations: sources,
-            webSearchCalls: result?.webSearchCalls || [],
-            durationMs: Date.now() - startedAt,
-          };
-        } catch (err) {
-          errors.push(`${candidate.provider}${candidate.model ? `/${candidate.model}` : ''}/${toolType}: ${err?.message || String(err)}`);
-        }
-      }
-    }
-    throw new Error(`native web search failed: ${errors.join(' | ')}`);
-  }
-
   async function getCodeGraphModule() {
     const startedAt = performance.now();
     codeGraphModPromise ??= import(CODE_GRAPH_RUNTIME);
@@ -808,60 +467,6 @@ export async function createMixdogSessionRuntime({
     }
   }
 
-  function formatCoreMemoryLines(payload = {}) {
-    const seen = new Set();
-    const lines = [];
-    for (const value of [
-      ...(Array.isArray(payload.userLines) ? payload.userLines : []),
-      ...(Array.isArray(payload.dbLines) ? payload.dbLines : []),
-    ]) {
-      const text = clean(value).replace(/\s+/g, ' ');
-      if (!text) continue;
-      const key = text.toLowerCase();
-      if (seen.has(key)) continue;
-      seen.add(key);
-      lines.push(`- ${text}`);
-      if (lines.length >= 40) break;
-    }
-    const out = lines.join('\n');
-    const maxChars = 6000;
-    return out.length > maxChars ? `${out.slice(0, maxChars).replace(/\s+\S*$/, '')}\n- ...` : out;
-  }
-
-  async function loadCoreMemoryContext() {
-    // Boot should not pay for memory/PG startup unless explicitly requested.
-    // Recall and memory tools still initialize the memory service on first use.
-    if (!memoryEnabled()) {
-      bootProfile('core-memory:disabled');
-      return '';
-    }
-    if (process.env.MIXDOG_BOOT_CORE_MEMORY !== '1') {
-      bootProfile('core-memory:skipped');
-      return '';
-    }
-    const startedAt = performance.now();
-    let timer = null;
-    const timeout = new Promise((resolve) => {
-      timer = setTimeout(() => resolve(''), 2000);
-      timer.unref?.();
-    });
-    try {
-      return await Promise.race([
-        (async () => {
-          const memoryMod = await getMemoryModule();
-          if (typeof memoryMod?.buildSessionCoreMemoryPayload !== 'function') return '';
-          return formatCoreMemoryLines(await memoryMod.buildSessionCoreMemoryPayload(currentCwd));
-        })(),
-        timeout,
-      ]);
-    } catch {
-      return '';
-    } finally {
-      if (timer) clearTimeout(timer);
-      bootProfile('core-memory:done', { ms: (performance.now() - startedAt).toFixed(1) });
-    }
-  }
-
   const configStartedAt = performance.now();
   let config = cfgMod.loadConfig({ secrets: false });
   setConfiguredShell(normalizeSystemShellConfig(config.shell).command);
@@ -875,17 +480,26 @@ export async function createMixdogSessionRuntime({
   let currentCwd = cwd;
   let sessionNeedsCwdRefresh = false;
   let closeRequested = false;
-  let channelStartTimer = null;
-  let channelStartPromise = null;
-  let providerSetupWarmupTimer = null;
-  let providerWarmupTimer = null;
-  let providerModelWarmupTimer = null;
-  let modelCatalogWarmupTimer = null;
-  let codeGraphPrewarmTimer = null;
-  let codeGraphPrewarmInFlight = false;
-  let codeGraphPrewarmQueuedCwd = '';
-  let statuslineUsageWarmupTimer = null;
-  let statuslineUsageRefreshTimer = null;
+  const warmupTimers = {
+    providerSetupWarmupTimer: null,
+    providerWarmupTimer: null,
+    providerModelWarmupTimer: null,
+    modelCatalogWarmupTimer: null,
+    statuslineUsageWarmupTimer: null,
+    statuslineUsageRefreshTimer: null,
+  };
+  // Prewarm/channel-start timer handles + async state, owned here so the
+  // teardown clearTimeout sweep still sees them; the prewarm scheduler factory
+  // mutates these objects in place (see createPrewarmSchedulers).
+  const prewarmTimers = {
+    codeGraphPrewarmTimer: null,
+    channelStartTimer: null,
+  };
+  const prewarmState = {
+    codeGraphPrewarmInFlight: false,
+    codeGraphPrewarmQueuedCwd: '',
+    channelStartPromise: null,
+  };
   let activeTurnCount = 0;
   let firstTurnCompleted = false;
   function hookTranscriptPath(sessionId) {
@@ -955,20 +569,50 @@ export async function createMixdogSessionRuntime({
   let codeGraphFirstTurnPrewarmDone = false;
   const modelMetaByRoute = new Map();
   const notificationListeners = new Set();
-  let providerModelsCache = { models: null, at: 0 };
-  let providerModelsPromise = null;
-  let providerModelsLoadSeq = 0;
-  let searchProviderModelsCache = { models: null, at: 0 };
-  let usageDashboardCache = { dashboard: null, at: 0 };
-  let usageDashboardPromise = null;
-  let providerSetupCache = { setup: null, at: 0 };
-  let providerSetupQuickCache = { setup: null, at: 0 };
-  let providerSetupPromise = null;
+  // Remote seat listeners (TUI): fired when remote mode flips outside a direct
+  // user action — currently only the superseded (seat stolen) path.
+  const remoteStateListeners = new Set();
+  function emitRemoteStateChange(enabled, reason = '') {
+    for (const listener of [...remoteStateListeners]) {
+      try { listener({ enabled: enabled === true, reason: String(reason || '') }); } catch {}
+    }
+  }
+  const providerModelCaches = {
+    providerModelsCache: { models: null, at: 0 },
+    providerModelsPromise: null,
+    providerModelsLoadSeq: 0,
+    searchProviderModelsCache: { models: null, at: 0 },
+  };
+  const providerUsageCaches = {
+    usageDashboardCache: { dashboard: null, at: 0 },
+    usageDashboardPromise: null,
+    providerSetupCache: { setup: null, at: 0 },
+    providerSetupQuickCache: { setup: null, at: 0 },
+    providerSetupPromise: null,
+  };
   let providerInitPromise = null;
-  let mcpFailures = [];
   let lastProjectMcpKey = null;
-  let mcpConnectGeneration = 0;
-  let mcpConnectInFlight = null;
+  // MCP connect state, owned here so teardown/reconnect paths still observe it;
+  // the mcp-glue factory mutates this object in place (see createMcpGlue).
+  const mcpState = {
+    mcpFailures: [],
+    mcpConnectGeneration: 0,
+    mcpConnectInFlight: null,
+  };
+  // MCP glue factory — config/currentCwd live-bound; connect state shared via
+  // the caller-owned mcpState object above.
+  const {
+    mcpTransportLabel,
+    resolveEffectiveMcpServers,
+    mcpStatus,
+    connectConfiguredMcp,
+    normalizeMcpServerInput,
+  } = createMcpGlue({
+    mcpClient,
+    getConfig: () => config,
+    getCurrentCwd: () => currentCwd,
+    state: mcpState,
+  });
   let preSessionToolSurface = null;
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
@@ -1041,9 +685,12 @@ export async function createMixdogSessionRuntime({
   // the user opts in via setAutoUpdate(true)); a failed check or install is
   // swallowed — getUpdateStatus()/getUpdateSettings() are the only surfaces,
   // there is no push notice channel from runtime -> TUI today.
+  // force:true — always hit the registry at boot (the 24h disk cache went
+  // stale-visible: it kept reporting an older "latest" than the installed
+  // version). checkLatestVersion() still falls back to the cache offline.
   const updateBootTimer = setTimeout(() => {
     void (async () => {
-      await checkForUpdateInternal({ force: false });
+      await checkForUpdateInternal({ force: true });
       if (autoUpdateEnabled() && updateCheckState.updateAvailable) {
         await runUpdateNowInternal();
       }
@@ -1051,15 +698,6 @@ export async function createMixdogSessionRuntime({
   }, 0);
   updateBootTimer.unref?.();
 
-  function mcpTransportLabel(cfg = {}) {
-    if (cfg.autoDetect) return `autoDetect:${cfg.autoDetect}`;
-    try {
-      return mcpClient.resolveMcpTransportKind(cfg);
-    } catch {
-      return 'unknown';
-    }
-  }
-
   function emitRuntimeNotification(content, meta = {}) {
     const text = String(content || '').trim();
     if (!text) return false;
@@ -1101,40 +739,6 @@ export async function createMixdogSessionRuntime({
     };
   }
 
-  function mcpStatus() {
-    const { servers: configured, sources } = resolveEffectiveMcpServers();
-    const connected = new Map((mcpClient.getMcpServerStatus?.() || []).map((row) => [row.name, row]));
-    const failures = new Map((mcpFailures || []).map((row) => [row.name, row]));
-    const servers = [];
-    for (const [name, cfg] of Object.entries(configured)) {
-      const live = connected.get(name);
-      const fail = failures.get(name);
-      servers.push({
-        name,
-        configured: true,
-        enabled: cfg?.enabled !== false,
-        connected: Boolean(live),
-        status: cfg?.enabled === false ? 'disabled' : live ? 'connected' : fail ? 'failed' : 'disconnected',
-        transport: mcpTransportLabel(cfg),
-        toolCount: live?.toolCount || 0,
-        tools: live?.tools || [],
-        error: fail?.msg || null,
-        source: sources[name] || 'config',
-      });
-      connected.delete(name);
-    }
-    for (const live of connected.values()) {
-      servers.push({ ...live, configured: false, status: 'connected' });
-    }
-    servers.sort((a, b) => String(a.name).localeCompare(String(b.name)));
-    return {
-      servers,
-      configuredCount: Object.keys(configured).length,
-      connectedCount: servers.filter((row) => row.connected).length,
-      failedCount: servers.filter((row) => row.status === 'failed').length,
-    };
-  }
-
   function skillsStatus() {
     const skills = typeof contextMod.collectSkillsCached === 'function'
       ? contextMod.collectSkillsCached(currentCwd)
@@ -1158,113 +762,51 @@ export async function createMixdogSessionRuntime({
     };
   }
 
-  function scheduleCodeGraphPrewarm(delayMs = codeGraphPrewarmDelayMs, reason = 'cwd') {
-    if (!codeGraphPrewarmEnabled) {
-      bootProfile('code-graph:prewarm-skipped', { reason: 'disabled' });
-      return;
-    }
-    if (closeRequested) return;
-    codeGraphPrewarmQueuedCwd = currentCwd;
-    if (codeGraphPrewarmTimer) return;
-    codeGraphPrewarmTimer = setTimeout(() => {
-      codeGraphPrewarmTimer = null;
-      if (closeRequested) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('code-graph:prewarm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'busy');
-        return;
-      }
-      if (codeGraphPrewarmInFlight) {
-        bootProfile('code-graph:prewarm-deferred', { reason: 'in-flight' });
-        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'in-flight');
-        return;
-      }
-      const prewarmCwd = codeGraphPrewarmQueuedCwd || currentCwd;
-      codeGraphPrewarmQueuedCwd = '';
-      codeGraphPrewarmInFlight = true;
-      const startedAt = performance.now();
-      bootProfile('code-graph:prewarm:start', { cwd: prewarmCwd, reason });
-      void getCodeGraphModule()
-        .then((mod) => {
-          if (typeof mod?.prewarmCodeGraphIfProject !== 'function') return false;
-          return mod.prewarmCodeGraphIfProject(prewarmCwd);
-        })
-        .then((scheduled) => bootProfile(scheduled ? 'code-graph:prewarm:scheduled' : 'code-graph:prewarm:no-project', {
-          cwd: prewarmCwd,
-          ms: (performance.now() - startedAt).toFixed(1),
-        }))
-        .catch((error) => bootProfile('code-graph:prewarm:failed', {
-          cwd: prewarmCwd,
-          ms: (performance.now() - startedAt).toFixed(1),
-          error: error?.message || String(error),
-        }))
-        .finally(() => {
-          codeGraphPrewarmInFlight = false;
-          if (codeGraphPrewarmQueuedCwd && !closeRequested) {
-            scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'queued');
-          }
-        });
-    }, delayMs);
-    codeGraphPrewarmTimer.unref?.();
-  }
-
-  function applyResolvedCwd(nextCwd, { markRefresh = true } = {}) {
-    const resolved = resolve(nextCwd);
-    const stat = statSync(resolved);
-    if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
-    const changed = resolve(currentCwd) !== resolved;
-    currentCwd = resolved;
-    process.env.MIXDOG_SESSION_CWD = currentCwd;
-    writeLastSessionCwd(currentCwd);
-    if (session) session.cwd = currentCwd;
-    // cwd changes NEVER recreate the session: a mid-conversation cwd switch must
-    // preserve the full message history (and the BP1–BP3 prompt cache). We only
-    // retarget the live session's cwd in place; tool execution already reads the
-    // current cwd per turn. `cwd` is intentionally absent from the prompt
-    // context (see composeSystemPrompt), so there is nothing prompt-side to
-    // refresh either. `markRefresh`/`changed` are kept only for signature
-    // compatibility with existing callers.
-    void markRefresh;
-    // Lazy mode: before the first turn (e.g. the initial project-selection
-    // cwd set), do NOT prewarm — that is exactly the post-first-frame freeze
-    // we are avoiding. Once a turn has run, an in-session cwd switch DOES
-    // prewarm the new dir, since a lookup there is now likely.
-    if (codeGraphPrewarmLazy && !codeGraphFirstTurnPrewarmDone) {
-      bootProfile('code-graph:prewarm-lazy', { reason: 'cwd-deferred-to-first-turn' });
-    } else {
-      scheduleCodeGraphPrewarm(changed ? 0 : codeGraphPrewarmDelayMs, changed ? 'cwd-change' : 'cwd');
-    }
-    // Project-local `.mcp.json` follows the cwd: when the effective project MCP
-    // set changes, reconnect in the background (never await — this stays sync,
-    // and the session is preserved). Guarded so a no-op cwd change does not
-    // churn connections.
-    if (changed) {
-      try {
-        const nextKey = resolved + '\u0000' + JSON.stringify(readProjectMcpServers(resolved));
-        if (nextKey !== lastProjectMcpKey) {
-          lastProjectMcpKey = nextKey;
-          void connectConfiguredMcp({ reset: true })
-            .then(() => invalidatePreSessionToolSurface())
-            .catch(() => {});
-        }
-      } catch {}
-    }
-    // CwdChanged: bridge an effective cwd switch to the standard hook bus.
-    // No matcher event — payload is minimal { cwd }. Fire-and-forget.
-    if (changed) {
-      try { void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd })); } catch {}
-    }
-    return currentCwd;
-  }
-
-  async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {
-    // No-op: cwd changes are applied in place by applyResolvedCwd and never
-    // tear down the session. Retained as a stable hook for ask()'s pre-turn
-    // call so the surrounding turn flow is unchanged.
-    void reason;
-    sessionNeedsCwdRefresh = false;
-    return session;
-  }
+  // cwd resolution/apply + plugins-status + core-memory context. Extracted to
+  // session-runtime/cwd-plugins.mjs; the facade keeps ownership of the mutable
+  // currentCwd/session/config/lastProjectMcpKey locals via getter/setter
+  // injection and passes the later-defined callbacks (prewarm/tool-surface/
+  // memory) as closures.
+  const {
+    resolveCwdPath,
+    applyResolvedCwd,
+    refreshSessionForCwdIfNeeded,
+    pluginsStatus,
+    loadCoreMemoryContext,
+  } = createCwdPlugins({
+    getCurrentCwd: () => currentCwd,
+    setCurrentCwd: (next) => { currentCwd = next; },
+    getConfig: () => config,
+    getSession: () => session,
+    getRoute: () => route,
+    getLastProjectMcpKey: () => lastProjectMcpKey,
+    setLastProjectMcpKey: (next) => { lastProjectMcpKey = next; },
+    isCodeGraphPrewarmLazy: () => codeGraphPrewarmLazy,
+    isCodeGraphFirstTurnPrewarmDone: () => codeGraphFirstTurnPrewarmDone,
+    getCodeGraphPrewarmDelayMs: () => codeGraphPrewarmDelayMs,
+    setSessionNeedsCwdRefresh: (next) => { sessionNeedsCwdRefresh = next; },
+    connectConfiguredMcp,
+    invalidatePreSessionToolSurface: (...a) => invalidatePreSessionToolSurface(...a),
+    scheduleCodeGraphPrewarm: (...a) => scheduleCodeGraphPrewarm(...a),
+    hooks,
+    hookCommonPayload: (...a) => hookCommonPayload(...a),
+    bootProfile,
+    getMemoryModule: (...a) => getMemoryModule(...a),
+    listRegisteredPlugins,
+    pluginAdminStatus,
+    pluginManifest,
+    pluginMcpServerName,
+    mcpScriptForPlugin,
+    countSkillFiles,
+    readProjectMcpServers,
+    writeLastSessionCwd,
+    clean,
+    resolve,
+    statSync,
+    existsSync,
+    cfgMod,
+    STANDALONE_DATA_DIR,
+  });
 
   function skillContent(name) {
     const res = typeof contextMod.loadSkillResource === 'function'
@@ -1308,166 +850,6 @@ export async function createMixdogSessionRuntime({
     return { name, filePath };
   }
 
-  function pluginsStatus() {
-    const dataDir = cfgMod.getPluginData?.();
-    const configuredMcp = config?.mcpServers && typeof config.mcpServers === 'object'
-      ? config.mcpServers
-      : {};
-    const plugins = [];
-    const addRegisteredPlugin = (entry) => {
-      const root = clean(entry.root);
-      if (!root || !existsSync(root)) return;
-      const manifest = pluginManifest(root);
-      const name = clean(manifest.name) || clean(manifest.id) || clean(entry.name) || root.split(/[\\/]/).pop() || root;
-      const plugin = {
-        id: clean(entry.id) || name,
-        name,
-        title: clean(manifest.title) || clean(manifest.displayName) || clean(entry.title) || name,
-        version: clean(manifest.version) || clean(entry.version) || null,
-        description: clean(manifest.description) || clean(entry.description),
-        marketplace: null,
-        source: clean(entry.sourceType) === 'local' ? 'local' : 'registry',
-        sourceUrl: clean(entry.source),
-        sourceType: clean(entry.sourceType) || 'git',
-        managed: entry.managed !== false,
-        root,
-        installedAt: entry.installedAt || null,
-        updatedAt: entry.updatedAt || null,
-        skillCount: countSkillFiles(root),
-        mcpScript: mcpScriptForPlugin(root),
-      };
-      plugin.mcpServerName = pluginMcpServerName(plugin);
-      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName)
-        || Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
-      plugins.push(plugin);
-    };
-
-    for (const entry of listRegisteredPlugins({ dataDir })) addRegisteredPlugin(entry);
-
-    plugins.sort((a, b) => {
-      if (a.source !== b.source) return a.source.localeCompare(b.source);
-      return a.name.localeCompare(b.name);
-    });
-    const admin = pluginAdminStatus({ dataDir });
-    return {
-      count: plugins.length,
-      plugins,
-      roots: {
-        registry: admin.registryPath,
-        installed: admin.installRoot,
-      },
-    };
-  }
-
-  // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
-  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
-  // precedence: project > user config). `sources[name]` records each server's
-  // origin ('config' | 'project') for status reporting.
-  function resolveEffectiveMcpServers() {
-    const configured = config?.mcpServers && typeof config.mcpServers === 'object'
-      ? config.mcpServers
-      : {};
-    const project = readProjectMcpServers(currentCwd);
-    const servers = { ...configured, ...project };
-    const sources = {};
-    for (const name of Object.keys(configured)) sources[name] = 'config';
-    for (const name of Object.keys(project)) sources[name] = 'project';
-    return { servers, sources };
-  }
-
-  async function connectConfiguredMcp({ reset = false } = {}) {
-    // Serialize reconnects: boot connect, cwd-change reset, and rapid cwd
-    // switches must never interleave their disconnect/connect phases, or an
-    // older run finishing after a newer reset could re-add stale servers into
-    // the shared client registry. Approach: a generation token + a single
-    // in-flight promise. Each call bumps the generation, waits for any prior
-    // run to finish, then bails if a newer call has superseded it — leaving the
-    // latest requested effective-server-set in the registry.
-    const gen = ++mcpConnectGeneration;
-    if (mcpConnectInFlight) {
-      try { await mcpConnectInFlight; } catch { /* prior run's failures already captured */ }
-    }
-    if (gen !== mcpConnectGeneration) return mcpStatus();
-    const run = (async () => {
-      if (reset) await mcpClient.disconnectAll?.();
-      mcpFailures = [];
-      const { servers } = resolveEffectiveMcpServers();
-      if (Object.keys(servers).length === 0) return;
-      try {
-        await mcpClient.connectMcpServers(servers);
-      } catch (error) {
-        mcpFailures = Array.isArray(error?.failures)
-          ? error.failures
-          : [{ name: 'mcp', msg: error?.message || String(error) }];
-      }
-    })();
-    mcpConnectInFlight = run;
-    try {
-      await run;
-    } finally {
-      if (mcpConnectInFlight === run) mcpConnectInFlight = null;
-    }
-    return mcpStatus();
-  }
-
-  function normalizeMcpServerInput(input = {}) {
-    const name = clean(input.name).toLowerCase().replace(/[^a-z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
-    if (!name) throw new Error('MCP server name is required');
-    const coerceStringRecord = (value) => {
-      if (!value || typeof value !== 'object' || Array.isArray(value)) return null;
-      const out = {};
-      for (const [key, val] of Object.entries(value)) {
-        if (val === undefined || val === null) continue;
-        out[String(key)] = String(val);
-      }
-      return Object.keys(out).length > 0 ? out : null;
-    };
-    const withOptionalHeaders = (config) => {
-      const headers = coerceStringRecord(input.headers);
-      if (headers) config.headers = headers;
-      return config;
-    };
-    const url = clean(input.url);
-    const type = clean(input.type).toLowerCase();
-    if (url) {
-      if (type === 'sse') {
-        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
-        return { name, config: withOptionalHeaders({ type: 'sse', url }) };
-      }
-      if (type === 'ws') {
-        if (!/^(?:wss?|https?):\/\//i.test(url)) {
-          throw new Error('MCP WebSocket URL must start with ws://, wss://, http://, or https://');
-        }
-        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
-      }
-      if (type === 'http' || type === 'streamable-http') {
-        if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
-        return { name, config: withOptionalHeaders({ type: 'http', url }) };
-      }
-      if (/^wss?:\/\//i.test(url)) {
-        return { name, config: withOptionalHeaders({ type: 'ws', url }) };
-      }
-      if (!/^https?:\/\//i.test(url)) throw new Error('MCP URL must start with http:// or https://');
-      return { name, config: withOptionalHeaders({ type: 'http', url }) };
-    }
-    const command = clean(input.command);
-    if (!command) throw new Error('MCP server command or URL is required');
-    const args = Array.isArray(input.args)
-      ? input.args.map((v) => String(v)).filter(Boolean)
-      : clean(input.args).split(/\s+/).filter(Boolean);
-    const requestedCwd = clean(input.cwd);
-    const cwdForServer = requestedCwd ? resolve(currentCwd, requestedCwd) : currentCwd;
-    const root = resolve(currentCwd);
-    const resolvedCwd = resolve(cwdForServer);
-    if (resolvedCwd !== root && !resolvedCwd.startsWith(`${root}\\`) && !resolvedCwd.startsWith(`${root}/`)) {
-      throw new Error('MCP server cwd must stay under the current project');
-    }
-    const config = { type: 'stdio', command, args, cwd: resolvedCwd };
-    const env = coerceStringRecord(input.env);
-    if (env) config.env = env;
-    return { name, config };
-  }
-
   const agentToolStartedAt = performance.now();
   const agentTool = createStandaloneAgent({
     cfgMod,
@@ -1508,6 +890,16 @@ export async function createMixdogSessionRuntime({
     dataDir: cfgMod.getPluginData(),
     cwd,
     onNotify: (msg) => {
+      // Single-holder remote: the worker reports it lost the bridge seat to a
+      // 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') {
+        if (msg?.params?.state === 'superseded' && remoteEnabled) {
+          stopRemote('superseded-by-newer-remote-session');
+          emitRemoteStateChange(false, 'superseded');
+        }
+        return;
+      }
       if (msg?.method !== 'notifications/claude/channel') return;
       const params = msg?.params && typeof msg.params === 'object' ? msg.params : {};
       const meta = params.meta && typeof params.meta === 'object' ? params.meta : {};
@@ -1531,8 +923,6 @@ export async function createMixdogSessionRuntime({
     ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => channels.isChannelTool(tool?.name)),
     ...(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS || []).filter((tool) => tool?.name === 'code_graph'),
     ...agentTool.tools,
-    PROVIDER_STATUS_TOOL,
-    CHANNEL_STATUS_TOOL,
   ].map(applyStandaloneToolDefaults);
   bootProfile('tools:ready', { ms: (performance.now() - toolsStartedAt).toFixed(1), count: standaloneTools.length });
 
@@ -1607,7 +997,7 @@ export async function createMixdogSessionRuntime({
       if (name === 'explore') {
         const callerSessionId = callerCtx?.callerSessionId || session?.id || null;
         return await runExplore(args || {}, {
-          callerCwd: args?.cwd ? resolveCwdPath(currentCwd, args.cwd) : callerCwd,
+          callerCwd: args?.cwd ? resolveCwdPath(args.cwd) : callerCwd,
           callerSessionId,
           routingSessionId: callerSessionId,
           clientHostPid: callerCtx?.clientHostPid || session?.clientHostPid || process.pid,
@@ -1617,7 +1007,7 @@ export async function createMixdogSessionRuntime({
       if (name === 'cwd') {
         const action = clean(args?.action || (args?.path ? 'set' : 'get')).toLowerCase();
         if (action === 'set') {
-          applyResolvedCwd(resolveCwdPath(currentCwd, args?.path));
+          applyResolvedCwd(resolveCwdPath(args?.path));
         } else if (action !== 'get') {
           throw new Error(`cwd: unknown action "${action}"`);
         }
@@ -1637,8 +1027,6 @@ export async function createMixdogSessionRuntime({
           notifyFn: notifyFnForSession(callerSessionId),
         });
       }
-      if (name === 'provider_status') return renderProviderStatus(displayConfig());
-      if (name === 'channel_status') return renderChannelStatus();
       if (channels.isChannelTool(name)) {
         if (!channelsEnabled()) throw new Error('channels are disabled in settings');
         return await channels.execute(name, args || {});
@@ -1660,159 +1048,58 @@ export async function createMixdogSessionRuntime({
   }
 
   function invalidateProviderCaches() {
-    providerModelsCache = { models: null, at: 0 };
-    providerModelsPromise = null;
-    providerModelsLoadSeq += 1;
-    searchProviderModelsCache = { models: null, at: 0 };
-    usageDashboardCache = { dashboard: null, at: 0 };
-    usageDashboardPromise = null;
-    providerSetupCache = { setup: null, at: 0 };
-    providerSetupQuickCache = { setup: null, at: 0 };
-    providerSetupPromise = null;
+    providerModelCaches.providerModelsCache = { models: null, at: 0 };
+    providerModelCaches.providerModelsPromise = null;
+    providerModelCaches.providerModelsLoadSeq += 1;
+    providerModelCaches.searchProviderModelsCache = { models: null, at: 0 };
+    providerUsageCaches.usageDashboardCache = { dashboard: null, at: 0 };
+    providerUsageCaches.usageDashboardPromise = null;
+    providerUsageCaches.providerSetupCache = { setup: null, at: 0 };
+    providerUsageCaches.providerSetupQuickCache = { setup: null, at: 0 };
+    providerUsageCaches.providerSetupPromise = null;
     providerInitPromise = null;
     modelMetaByRoute.clear();
   }
 
-  function adoptConfig(nextConfig, { hasSecrets = configHasSecrets } = {}) {
-    config = nextConfig;
-    configHasSecrets = hasSecrets === true;
-    setConfiguredShell(normalizeSystemShellConfig(config.shell).command);
-    searchRoute = normalizeSearchRouteConfig(config.searchRoute) || normalizeSearchRouteConfig(searchRoute);
-    return config;
-  }
-
-  // Persisting mixdog-config.json is heavy: it takes a cross-process file
-  // lock, does an atomic temp+rename, and on win32 shells out to icacls
-  // (an external process, multiple times per write) to enforce an owner-only
-  // ACL. Doing that synchronously on EVERY option toggle froze the TUI main
-  // thread, so adjusting a picker felt laggy and unresponsive. We split the
-  // two concerns: adopt the new config in-memory IMMEDIATELY (so getProfile/
-  // getAutoClear/etc. and the UI read fresh values on the same tick), and
-  // DEBOUNCE the actual disk write so a burst of toggles collapses into a
-  // single persist after input settles. The security model is unchanged —
-  // cfgMod.saveConfig still strips apiKey (keychain-only) and still applies
-  // the owner-only ACL; we only changed WHEN it runs, never HOW.
-  let pendingConfigToSave = null;
-  let configSaveTimer = null;
-  const CONFIG_SAVE_DEBOUNCE_MS = 150;
-  // Same debounce pattern as saveConfigAndAdopt below, but for the channels-
-  // section backend switch: channel-admin's setBackend() does a synchronous
-  // file-locked read-modify-write (updateChannelsSection), which is a
-  // secondary hitch source on the settings-toggle key handler. Coalesce
-  // rapid toggles and move the write off the key-handler tick.
-  let pendingBackendName = null;
-  let backendSaveTimer = null;
-  function flushBackendSave() {
-    if (backendSaveTimer) {
-      clearTimeout(backendSaveTimer);
-      backendSaveTimer = null;
-    }
-    if (pendingBackendName === null) return;
-    const name = pendingBackendName;
-    pendingBackendName = null;
-    try {
-      setBackend(name);
-    } catch (err) {
-      process.stderr.write(`[channels] debounced setBackend failed: ${err?.message || err}\n`);
-    }
-  }
-  // Debounced persist for the top-level `outputStyle` config key. This CANNOT
-  // ride saveConfigAndAdopt/flushConfigSave: cfgMod.saveConfig() serializes
-  // ONLY the agent-section fields (see orchestrator config.mjs saveConfig),
-  // so a top-level outputStyle adopted in memory would never reach disk and
-  // would silently revert on the next fresh catalog read/restart. Persist it
-  // through sharedCfgMod.updateConfig (whole-root RMW under the same file
-  // lock), debounced off the key-handler tick like the backend switch above.
-  let pendingOutputStyleId = null;
-  let outputStyleSaveTimer = null;
-  function flushOutputStyleSave() {
-    if (outputStyleSaveTimer) {
-      clearTimeout(outputStyleSaveTimer);
-      outputStyleSaveTimer = null;
-    }
-    if (pendingOutputStyleId === null) return;
-    const styleId = pendingOutputStyleId;
-    pendingOutputStyleId = null;
-    try {
-      sharedCfgMod.updateConfig((root) => {
-        const next = { ...(root || {}), outputStyle: styleId };
-        if (next.agent && typeof next.agent === 'object' && !Array.isArray(next.agent)) {
-          const agent = { ...next.agent };
-          delete agent.outputStyle;
-          next.agent = agent;
-        }
-        return next;
-      });
-    } catch (err) {
-      process.stderr.write(`[config] debounced outputStyle save failed: ${err?.message || err}\n`);
-    }
-  }
-  function flushConfigSave() {
-    if (configSaveTimer) {
-      clearTimeout(configSaveTimer);
-      configSaveTimer = null;
-    }
-    if (pendingConfigToSave === null) return;
-    const snapshot = pendingConfigToSave;
-    pendingConfigToSave = null;
-    try {
-      cfgMod.saveConfig(snapshot);
-    } catch (err) {
-      process.stderr.write(`[config] debounced saveConfig failed: ${err?.message || err}\n`);
-    }
-  }
-  function saveConfigAndAdopt(nextConfig, { hasSecrets = configHasSecrets } = {}) {
-    // In-memory adopt is synchronous and first so callers that read back the
-    // value immediately (e.g. setProfile -> getProfile) see the new state.
-    const adopted = adoptConfig(nextConfig, { hasSecrets });
-    // Persist the adopted object; coalesce rapid successive changes into one
-    // disk write after CONFIG_SAVE_DEBOUNCE_MS of quiet.
-    pendingConfigToSave = config;
-    if (configSaveTimer) clearTimeout(configSaveTimer);
-    configSaveTimer = setTimeout(flushConfigSave, CONFIG_SAVE_DEBOUNCE_MS);
-    configSaveTimer.unref?.();
-    return adopted;
-  }
-
-  function reloadFullConfig() {
-    // A pending debounced write holds the only copy of the latest change.
-    // Flush it before re-reading from disk so loadConfig() observes (and the
-    // subsequent adopt preserves) that change instead of reverting to a stale
-    // on-disk snapshot.
-    flushConfigSave();
-    return adoptConfig(cfgMod.loadConfig(), { hasSecrets: true });
-  }
-
-  function ensureFullConfig() {
-    if (configHasSecrets) return config;
-    return reloadFullConfig();
-  }
-
-  function displayConfig() {
-    return config;
-  }
-
-  function ensureConfigForRouteProvider() {
-    const providerId = clean(route.provider);
-    const providerCfg = config?.providers?.[providerId];
-    if (configHasSecrets || LAZY_SECRET_PROVIDERS.has(providerId) || providerCfg?.apiKey) {
-      return config;
-    }
-    return ensureFullConfig();
-  }
-
-  function refreshStatuslineUsageSnapshot(routeLike = {}) {
-    const providerId = clean(routeLike.provider);
-    const modelId = clean(routeLike.model);
-    if (!providerId || !providerId.includes('oauth')) return;
-    const providerObj = reg.getProvider(providerId);
-    if (!providerObj) return;
-    void fetchOAuthUsageSnapshot({ provider: providerId, model: modelId }, providerObj, (message) => {
-      if (process.env.MIXDOG_STATUSLINE_TRACE) {
-        try { process.stderr.write(`[statusline] ${message}\n`); } catch {}
-      }
-    }).catch(() => {});
-  }
+  // Config reload/save/adopt family + output-style status cache. Extracted to
+  // session-runtime/config-lifecycle.mjs; the facade retains ownership of the
+  // config/searchRoute/configHasSecrets mutable locals via getter/setter
+  // injection (the proven mutable-state pattern).
+  const {
+    getOutputStyleStatusCached,
+    invalidateOutputStyleStatusCache,
+    seedOutputStyleStatusCache,
+    adoptConfig,
+    saveConfigAndAdopt,
+    flushConfigSave,
+    flushBackendSave,
+    scheduleBackendSave,
+    flushOutputStyleSave,
+    scheduleOutputStyleSave,
+    reloadFullConfig,
+    ensureFullConfig,
+    displayConfig,
+    ensureConfigForRouteProvider,
+  } = createConfigLifecycle({
+    getConfig: () => config,
+    setConfig: (next) => { config = next; },
+    getSearchRoute: () => searchRoute,
+    setSearchRoute: (next) => { searchRoute = next; },
+    getConfigHasSecrets: () => configHasSecrets,
+    setConfigHasSecrets: (next) => { configHasSecrets = next; },
+    getRoute: () => route,
+    cfgMod,
+    sharedCfgMod,
+    setBackend,
+    setConfiguredShell,
+    normalizeSystemShellConfig,
+    normalizeSearchRouteConfig,
+    outputStyleStatus,
+    LAZY_SECRET_PROVIDERS,
+    clean,
+    resolve,
+    STANDALONE_DATA_DIR,
+  });
 
   async function ensureProvidersReady(providerConfig = config.providers || {}) {
     if (providerInitPromise) return await providerInitPromise;
@@ -1823,499 +1110,113 @@ export async function createMixdogSessionRuntime({
     return await providerInitPromise;
   }
 
-  async function cachedProviderSetup({ force = false, quick = false } = {}) {
-    if (!force && providerSetupCache.setup) {
-      return providerSetupCache.setup;
-    }
-    if (quick) {
-      if (!force && providerSetupQuickCache.setup) {
-        return providerSetupQuickCache.setup;
-      }
-      const setup = await providerSetup(displayConfig(), { detectLocal: false, checkSecrets: false });
-      providerSetupQuickCache = { setup, at: Date.now() };
-      if (!providerSetupPromise && !providerSetupWarmupTimer && !closeRequested) {
-        scheduleProviderSetupWarmup(0);
-      }
-      return setup;
-    }
-    if (providerSetupPromise) return await providerSetupPromise;
-    providerSetupPromise = providerSetup(displayConfig(), { detectLocal: true })
-      .then((setup) => {
-        providerSetupCache = { setup, at: Date.now() };
-        return setup;
-      })
-      .finally(() => {
-        providerSetupPromise = null;
-      });
-    return await providerSetupPromise;
-  }
-
-  function modelMetaKey(providerId, modelId) {
-    return `${clean(providerId)}\n${clean(modelId)}`;
-  }
-
-  async function lookupModelMeta(providerId, modelId, { allowFetch = false } = {}) {
-    const key = modelMetaKey(providerId, modelId);
-    if (modelMetaByRoute.has(key)) return modelMetaByRoute.get(key);
-    const providerImpl = reg.getProvider(providerId);
-    if (!providerImpl || typeof providerImpl.listModels !== 'function') {
-      const fallback = { id: modelId, provider: providerId };
-      modelMetaByRoute.set(key, fallback);
-      return fallback;
-    }
-    if (typeof providerImpl.getCachedModelInfo === 'function') {
-      const cached = providerImpl.getCachedModelInfo(modelId);
-      if (cached) {
-        const meta = { ...cached, id: cached.id || modelId, provider: providerId };
-        modelMetaByRoute.set(key, meta);
-        return meta;
-      }
-    }
-    if (!allowFetch) {
-      const fallback = { id: modelId, provider: providerId };
-      modelMetaByRoute.set(key, fallback);
-      scheduleProviderModelWarmup();
-      return fallback;
-    }
-    try {
-      const models = await providerImpl.listModels();
-      const found = Array.isArray(models) ? models.find((m) => m?.id === modelId) : null;
-      const meta = found || { id: modelId, provider: providerId };
-      modelMetaByRoute.set(key, meta);
-      return meta;
-    } catch {
-      const fallback = { id: modelId, provider: providerId };
-      modelMetaByRoute.set(key, fallback);
-      return fallback;
-    }
-  }
-
-function parsedProviderModelVersion(id) {
-    const text = clean(id).toLowerCase();
-    const claude = text.match(/^claude-[a-z]+-(\d+)(?:[-.](\d+))?/);
-    if (claude) return [Number(claude[1]) || 0, Number(claude[2]) || 0];
-    const compact = text.match(/(?:^|[-_])(?:o|gpt|grok|qwen|llama|mistral|gemma|phi|glm)(\d+)(?:\.(\d+))?(?:\.(\d{1,3}))?/);
-    if (compact) return compact.slice(1).filter((v) => v != null).map((v) => Number(v) || 0);
-    const generic = text.match(/(?:^|[-_v])(\d+)(?:\.(\d+))?(?:\.(\d{1,3}))?/);
-    return generic ? generic.slice(1).filter((v) => v != null).map((v) => Number(v) || 0) : [];
-  }
-
-  function compareProviderModelVersion(a, b) {
-    const va = parsedProviderModelVersion(a.id || a.display || a.name);
-    const vb = parsedProviderModelVersion(b.id || b.display || b.name);
-    if (va.length === 0 && vb.length === 0) return 0;
-    if (va.length === 0) return 1;
-    if (vb.length === 0) return -1;
-    for (let i = 0; i < Math.max(va.length, vb.length); i += 1) {
-      const delta = (vb[i] || 0) - (va[i] || 0);
-      if (delta) return delta;
-    }
-    return 0;
-  }
-
-  function providerModelReleaseTime(model) {
-    if (model?.releaseDate) {
-      const t = Date.parse(model.releaseDate);
-      if (Number.isFinite(t)) return t;
-    }
-    const created = Number(model?.created);
-    if (Number.isFinite(created) && created > 0) {
-      return created < 1_000_000_000_000 ? created * 1000 : created;
-    }
-    const dated = clean(model?.id).match(/(?:^|-)(\d{4})(\d{2})(\d{2})(?:$|-)/);
-    return dated ? (Date.parse(`${dated[1]}-${dated[2]}-${dated[3]}`) || 0) : 0;
-  }
-
-  function isClaudeProviderModel(model) {
-    return clean(model?.provider).toLowerCase().includes('anthropic')
-      && /^claude-[a-z]+-/.test(clean(model?.id).toLowerCase());
-  }
-
-  function compareProviderModelRecency(a, b) {
-    if (isClaudeProviderModel(a) && isClaudeProviderModel(b)) {
-      if (a.latest !== b.latest) return a.latest ? -1 : 1;
-      const versionDelta = compareProviderModelVersion(a, b);
-      if (versionDelta) return versionDelta;
-      const ta = providerModelReleaseTime(a);
-      const tb = providerModelReleaseTime(b);
-      if (ta !== tb) return tb - ta;
-      return clean(a.display || a.id).localeCompare(clean(b.display || b.id));
-    }
-    const ta = providerModelReleaseTime(a);
-    const tb = providerModelReleaseTime(b);
-    if (ta !== tb) return tb - ta;
-    if (a.latest !== b.latest) return a.latest ? -1 : 1;
-    const versionDelta = compareProviderModelVersion(a, b);
-    if (versionDelta) return versionDelta;
-    return clean(a.display || a.id).localeCompare(clean(b.display || b.id));
-  }
-
-  function sortProviderModels(models) {
-    return (models || []).sort((a, b) => {
-      const ar = a.provider === route.provider ? 0 : 1;
-      const br = b.provider === route.provider ? 0 : 1;
-      if (ar !== br) return ar - br;
-      if (a.provider !== b.provider) return a.provider.localeCompare(b.provider);
-      return compareProviderModelRecency(a, b);
-    });
-  }
-
-  function isSelectableLlmModel(model) {
-    const id = clean(model?.id).toLowerCase();
-    const display = clean(model?.display || model?.name).toLowerCase();
-    const mode = clean(model?.mode).toLowerCase();
-    const text = `${id} ${display}`;
-    if (!id) return false;
-    if (mode && !['chat', 'completion', 'responses', 'messages'].includes(mode)) return false;
-    if (/(^|[-_\s])(image|images|video|videos|audio|tts|stt|speech|embedding|embeddings|rerank|moderation|imagine)([-_\s]|$)/i.test(text)) return false;
-    if (/(^|[-_\s])(dall[-_\s]?e|sora|imagen)([-_\s]|$)/i.test(text)) return false;
-    return true;
-  }
-
-  function providerModelCacheRow(name, m) {
-    return {
-      id: m.id,
-      provider: name,
-      display: m.display || m.name || m.id,
-      created: typeof m.created === 'number' ? m.created : null,
-      releaseDate: m.releaseDate || null,
-      contextWindow: m.contextWindow,
-      outputTokens: m.outputTokens || null,
-      family: m.family || null,
-      tier: m.tier || null,
-      latest: m.latest === true,
-      description: m.description || '',
-      supportsVision: m.supportsVision === true,
-      supportsFunctionCalling: m.supportsFunctionCalling === true,
-      supportsWebSearch: searchCapableFor(name, m),
-      supportsPromptCaching: m.supportsPromptCaching === true,
-      supportsReasoning: m.supportsReasoning === true,
-      reasoningLevels: Array.isArray(m.reasoningLevels) ? m.reasoningLevels : undefined,
-      reasoningOptions: Array.isArray(m.reasoningOptions) ? m.reasoningOptions : [],
-      reasoningContentField: m.reasoningContentField || null,
-      mode: m.mode || null,
-    };
-  }
-
-  function hydrateProviderModelRow(row) {
-    return {
-      ...row,
-      effortOptions: effortItemsFor(row.provider, row, null),
-      fastCapable: fastCapableFor(row.provider, row),
-      fastPreferred: fastPreferenceFor(config, row.provider, row.id),
-      savedEffort: modelSettingsFor(config, row.provider, row.id).effort || null,
-      savedFast: modelSettingsFor(config, row.provider, row.id).fast === true,
-    };
-  }
-
-  function providerModelsFromCacheRows(rows) {
-    return sortProviderModels((rows || []).map(hydrateProviderModelRow));
-  }
-
-  function quickProviderModelRows() {
-    const pickerConfig = displayConfig();
-    const rows = [];
-    const seen = new Set();
-    const addRoute = (routeLike = {}) => {
-      const provider = clean(routeLike.provider);
-      const model = clean(routeLike.model);
-      if (!provider || !model) return;
-      const key = `${provider}:${model}`;
-      if (seen.has(key)) return;
-      seen.add(key);
-      const row = providerModelCacheRow(provider, {
-        id: model,
-        name: routeLike.modelDisplay || routeLike.display || model,
-        display: routeLike.modelDisplay || routeLike.display || model,
-        latest: routeLike.latest === true,
-        supportsReasoning: !!routeLike.effort,
-        mode: 'chat',
-      });
-      rows.push(row);
-      modelMetaByRoute.set(modelMetaKey(provider, model), row);
-    };
-
-    addRoute(route);
-    for (const preset of pickerConfig.presets || []) addRoute(preset);
-    for (const workflowRoute of Object.values(pickerConfig.workflowRoutes || {})) addRoute(workflowRoute);
-    for (const agentRoute of Object.values(pickerConfig.agents || {})) addRoute(agentRoute);
-    return providerModelsFromCacheRows(rows);
-  }
-
-  function addQuickSearchModel(rows, seen, provider, model) {
-    const providerName = normalizeSearchProviderId(provider);
-    const modelId = clean(model?.id || model);
-    if (!providerName || !modelId || !isSearchCapableProvider(providerName)) return;
-    const key = `${providerName}:${modelId}`;
-    if (seen.has(key)) return;
-    const row = providerModelCacheRow(providerName, {
-      id: modelId,
-      name: model?.name || model?.display || modelId,
-      display: model?.display || model?.name || modelId,
-      contextWindow: model?.contextWindow || null,
-      outputTokens: model?.outputTokens || null,
-      latest: model?.latest === true,
-      supportsWebSearch: true,
-      supportsFunctionCalling: model?.supportsFunctionCalling === true,
-      supportsPromptCaching: model?.supportsPromptCaching === true,
-      supportsReasoning: model?.supportsReasoning === true,
-      reasoningLevels: Array.isArray(model?.reasoningLevels) ? model.reasoningLevels : undefined,
-      reasoningOptions: Array.isArray(model?.reasoningOptions) ? model.reasoningOptions : [],
-      mode: 'chat',
-    });
-    if (row.supportsWebSearch !== true) return;
-    seen.add(key);
-    rows.push({
-      ...row,
-      provider: providerName,
-      searchCapable: true,
-      searchToolType: row.searchToolType || 'web_search',
-    });
-  }
-
-  function addDefaultSearchModel(rows, seen = new Set()) {
-    const mainModel = currentMainSearchModelMeta();
-    if (!mainModel || !searchCapableFor(route.provider, mainModel)) return;
-    const key = `${SEARCH_DEFAULT_PROVIDER}:${SEARCH_DEFAULT_MODEL}`;
-    if (seen.has(key)) return;
-    seen.add(key);
-    rows.push({
-      id: SEARCH_DEFAULT_MODEL,
-      provider: SEARCH_DEFAULT_PROVIDER,
-      display: 'Default',
-      name: 'Default',
-      description: `Use current main model: ${route.provider}/${route.model}`,
-      supportsWebSearch: true,
-      searchCapable: true,
-      searchToolType: 'web_search',
-      mode: 'chat',
-    });
-  }
-
-  function quickSearchProviderModelRows() {
-    const pickerConfig = displayConfig();
-    const rows = [];
-    const seen = new Set();
-    addDefaultSearchModel(rows, seen);
-    for (const [name, providerConfig] of Object.entries(pickerConfig.providers || {})) {
-      const providerName = normalizeSearchProviderId(name);
-      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
-      for (const model of QUICK_SEARCH_MODELS[providerName] || []) {
-        addQuickSearchModel(rows, seen, providerName, model);
-      }
-    }
-    const configuredSearch = normalizeSearchRouteConfig(pickerConfig.searchRoute) || normalizeSearchRouteConfig(searchRoute);
-    if (configuredSearch?.provider && configuredSearch?.model) {
-      addQuickSearchModel(rows, seen, configuredSearch.provider, {
-        id: configuredSearch.model,
-        display: configuredSearch.model,
-      });
-    }
-    const mainModel = currentMainSearchModelMeta();
-    if (mainModel && searchCapableFor(route.provider, mainModel)) {
-      addQuickSearchModel(rows, seen, route.provider, {
-        id: route.model,
-        display: route.model,
-      });
-    }
-    return searchModelsFromRows(rows);
-  }
-
-  function searchModelsFromRows(rows) {
-    return sortProviderModels((rows || [])
-      .filter((row) => row.supportsWebSearch === true)
-      .map((row) => ({
-        ...row,
-        provider: normalizeSearchProviderId(row.provider),
-        searchCapable: true,
-        searchToolType: row.searchToolType || 'web_search',
-      })));
-  }
-
-  function searchRowsWithDefault(rows = []) {
-    const out = [];
-    const seen = new Set();
-    addDefaultSearchModel(out, seen);
-    for (const row of rows || []) {
-      const providerName = normalizeSearchProviderId(row?.provider);
-      const modelId = clean(row?.id || row?.model);
-      if (providerName === SEARCH_DEFAULT_PROVIDER && modelId.toLowerCase() === SEARCH_DEFAULT_MODEL) continue;
-      const key = `${providerName}:${modelId}`;
-      if (!providerName || !modelId || seen.has(key)) continue;
-      seen.add(key);
-      out.push(row);
-    }
-    return out;
-  }
-
-  async function collectSearchProviderModels({ force = false } = {}) {
-    if (!force && Array.isArray(searchProviderModelsCache.models)) {
-      return providerModelsFromCacheRows(searchRowsWithDefault(searchProviderModelsCache.models));
-    }
-    if (!force && Array.isArray(providerModelsCache.models)) {
-      const rows = searchRowsWithDefault(searchModelsFromRows(providerModelsCache.models));
-      searchProviderModelsCache = { models: rows, at: Date.now() };
-      return providerModelsFromCacheRows(rows);
-    }
-    if (!force) {
-      const rows = searchRowsWithDefault(quickSearchProviderModelRows());
-      searchProviderModelsCache = { models: rows, at: Date.now() };
-      return providerModelsFromCacheRows(rows);
-    }
-    if (force) {
-      const models = await loadSearchProviderModelsFresh({ forceRefresh: true });
-      searchProviderModelsCache = { models, at: Date.now() };
-      return providerModelsFromCacheRows(models);
-    }
-  }
-
-  function enabledSearchProviderConfig() {
-    ensureFullConfig();
-    const out = {};
-    for (const [name, providerConfig] of Object.entries(config.providers || {})) {
-      const providerName = normalizeSearchProviderId(name);
-      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
-      out[providerName] = { ...providerConfig, enabled: true };
-    }
-    return out;
-  }
-
-  async function loadSearchProviderModelsFresh({ forceRefresh = false } = {}) {
-    const searchProviders = enabledSearchProviderConfig();
-    const providerNames = Object.keys(searchProviders);
-    if (!providerNames.length) return [];
-    await ensureProvidersReady(config.providers || {});
-    const providerResults = await Promise.all(providerNames.map(async (name) => {
-      const provider = reg.getProvider(name);
-      if (typeof provider?.listModels !== 'function') return [];
-      try {
-        let models = null;
-        if (forceRefresh && typeof provider._refreshModelCache === 'function') {
-          models = await provider._refreshModelCache();
-        }
-        if (!Array.isArray(models)) {
-          models = await provider.listModels();
-        }
-        if (!Array.isArray(models)) return [];
-        const rows = [];
-        for (const m of models) {
-          if (!m?.id || !isSelectableLlmModel(m)) continue;
-          const row = providerModelCacheRow(name, m);
-          if (row.supportsWebSearch !== true) continue;
-          rows.push({
-            ...row,
-            provider: normalizeSearchProviderId(row.provider),
-            searchCapable: true,
-            searchToolType: row.searchToolType || 'web_search',
-          });
-          modelMetaByRoute.set(modelMetaKey(name, m.id), row);
-        }
-        return rows;
-      } catch {
-        // Keep the picker responsive if one search-capable provider has a
-        // transient catalog/auth failure.
-        return [];
-      }
-    }));
-    const results = [];
-    const seen = new Set();
-    addDefaultSearchModel(results, seen);
-    for (const row of providerResults.flat()) {
-      const key = `${normalizeSearchProviderId(row.provider)}:${row.id}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      results.push(row);
-    }
-    return results;
-  }
+  const {
+    currentMainSearchModelMeta,
+    runNativeWebSearch,
+  } = createNativeSearch({
+    getRoute: () => route,
+    getSearchRoute: () => searchRoute,
+    setSearchRoute: (next) => { searchRoute = next; },
+    getConfig: () => config,
+    getSession: () => session,
+    getReg: () => reg,
+    ensureFullConfig,
+    ensureProvidersReady,
+    ensureProviderEnabled,
+    normalizeSearchProviderId,
+    normalizeSearchRouteConfig,
+    isDefaultSearchRouteConfig,
+    isSearchCapableProvider,
+    searchCapableFor,
+  });
 
-  async function loadProviderModelsFresh({ forceRefresh = false } = {}) {
-    ensureFullConfig();
-    await ensureProvidersReady(config.providers || {});
-    const allProviders = [...reg.getAllProviders()];
-    const providerResults = await Promise.all(allProviders.map(async ([name, provider]) => {
-      if (typeof provider?.listModels !== 'function') return [];
-      try {
-        let models = null;
-        if (forceRefresh && typeof provider._refreshModelCache === 'function') {
-          models = await provider._refreshModelCache();
-        }
-        if (!Array.isArray(models)) {
-          models = await provider.listModels();
-        }
-        if (!Array.isArray(models)) return [];
-        const rows = [];
-        for (const m of models) {
-          if (!m?.id) continue;
-          if (!isSelectableLlmModel(m)) continue;
-          rows.push(providerModelCacheRow(name, m));
-        }
-        return rows;
-      } catch {
-        // Ignore per-provider catalog failures so one bad credential or
-        // transient /models error does not hide other authenticated models.
-        return [];
-      }
-    }));
-    const results = [];
-    const seen = new Set();
-    for (const row of providerResults.flat()) {
-      const key = `${row.provider}:${row.id}`;
-      if (seen.has(key)) continue;
-      seen.add(key);
-      results.push(row);
-      modelMetaByRoute.set(modelMetaKey(row.provider, row.id), row);
-    }
-    return results;
-  }
+  // Late-bound: createWarmupSchedulers is constructed after this factory, but
+  // cachedProviderSetup(quick) may nudge scheduleProviderSetupWarmup on a cold
+  // quick-cache fill. Thread it by reference so the scheduler is reachable once
+  // it exists (a pre-scheduler quick fill simply skips the warmup nudge).
+  let scheduleProviderSetupWarmupRef = () => {};
+  const {
+    refreshStatuslineUsageSnapshot,
+    cachedProviderSetup,
+    getUsageDashboard,
+  } = createProviderUsage({
+    caches: providerUsageCaches,
+    getConfig: () => config,
+    getReg: () => reg,
+    displayConfig,
+    providerSetup,
+    createUsageDashboard,
+    fetchOAuthUsageSnapshot,
+    isCloseRequested: () => closeRequested,
+    getProviderSetupWarmupTimer: () => warmupTimers.providerSetupWarmupTimer,
+    scheduleProviderSetupWarmup: (delayMs) => scheduleProviderSetupWarmupRef(delayMs),
+  });
 
-  async function collectProviderModels({ force = false, quick = false } = {}) {
-    if (!force && Array.isArray(providerModelsCache.models)) {
-      return providerModelsFromCacheRows(providerModelsCache.models);
-    }
-    if (!force && quick) {
-      warmProviderModelCache();
-      return quickProviderModelRows();
-    }
-    if (force) {
-      const seq = ++providerModelsLoadSeq;
-      const models = await loadProviderModelsFresh({ forceRefresh: true });
-      if (seq === providerModelsLoadSeq) providerModelsCache = { models, at: Date.now() };
-      return providerModelsFromCacheRows(models);
-    }
-    if (!providerModelsPromise) {
-      const seq = ++providerModelsLoadSeq;
-      providerModelsPromise = loadProviderModelsFresh()
-        .then((models) => {
-          if (seq === providerModelsLoadSeq) providerModelsCache = { models, at: Date.now() };
-          return models;
-        })
-        .finally(() => {
-          providerModelsPromise = null;
-        });
-    }
-    return providerModelsFromCacheRows(await providerModelsPromise);
-  }
+  // Holder filled after createQuickModelRows resolves; provider-models and
+  // quick-model-rows are mutually dependent (rows need cache-row helpers, the
+  // model factory needs quick fallbacks) so we thread the quick surface in by
+  // reference after both are constructed.
+  const providerModelQuickHelpers = {};
+  // Late-bound: createWarmupSchedulers is constructed after this factory, but
+  // lookupModelMeta may fire scheduleProviderModelWarmup on a cache miss. Thread
+  // it by reference so the scheduler is called once it exists (miss handling is
+  // best-effort; a pre-scheduler miss simply skips the warmup nudge).
+  let scheduleProviderModelWarmupRef = () => {};
+  const {
+    modelMetaKey,
+    lookupModelMeta,
+    sortProviderModels,
+    providerModelCacheRow,
+    providerModelsFromCacheRows,
+    collectSearchProviderModels,
+    collectProviderModels,
+    warmProviderModelCache,
+  } = createProviderModels({
+    caches: providerModelCaches,
+    modelMetaByRoute,
+    getRoute: () => route,
+    getConfig: () => config,
+    getReg: () => reg,
+    searchCapableFor,
+    sortProviderModelsRaw,
+    providerModelCacheRowRaw,
+    normalizeSearchProviderId,
+    isSearchCapableProvider,
+    ensureFullConfig,
+    ensureProvidersReady,
+    bootProfile,
+    scheduleProviderModelWarmup: () => scheduleProviderModelWarmupRef(),
+    quickHelpers: providerModelQuickHelpers,
+  });
 
-  function warmProviderModelCache() {
-    if (Array.isArray(providerModelsCache.models) || providerModelsPromise) return providerModelsPromise;
-    const seq = ++providerModelsLoadSeq;
-    providerModelsPromise = loadProviderModelsFresh()
-      .then((models) => {
-        if (seq === providerModelsLoadSeq) providerModelsCache = { models, at: Date.now() };
-        bootProfile('provider-models:warm-ready', { count: models.length });
-        return models;
-      })
-      .catch((err) => {
-        const msg = err instanceof Error ? err.message : String(err);
-        bootProfile('provider-models:warm-failed', { error: msg });
-        return [];
-      })
-      .finally(() => {
-        providerModelsPromise = null;
-      });
-    return providerModelsPromise;
-  }
+  const {
+    quickProviderModelRows,
+    addDefaultSearchModel,
+    quickSearchProviderModelRows,
+    searchModelsFromRows,
+    searchRowsWithDefault,
+  } = createQuickModelRows({
+    getRoute: () => route,
+    getSearchRoute: () => searchRoute,
+    displayConfig,
+    providerModelCacheRow,
+    providerModelsFromCacheRows,
+    sortProviderModels,
+    modelMetaByRoute,
+    modelMetaKey,
+    normalizeSearchProviderId,
+    normalizeSearchRouteConfig,
+    isSearchCapableProvider,
+    searchCapableFor,
+    currentMainSearchModelMeta,
+  });
+  Object.assign(providerModelQuickHelpers, {
+    quickProviderModelRows,
+    addDefaultSearchModel,
+    quickSearchProviderModelRows,
+    searchModelsFromRows,
+    searchRowsWithDefault,
+  });
 
   async function resolveMissingRouteModelForFirstTurn() {
     if (routeHasModel()) return route;
@@ -2432,85 +1333,7 @@ function parsedProviderModelVersion(id) {
       }
       session = mgr.createSession(sessionOpts);
       sessionNeedsCwdRefresh = false;
-      Object.defineProperty(session, 'beforeToolHook', {
-        value: (input) => hooks.beforeTool(hookCommonPayload({
-          ...input,
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          tool_name: input?.name || input?.tool_name,
-          tool_input: input?.args || input?.tool_input,
-          tool_use_id: input?.toolCallId || input?.tool_use_id,
-          cwd: input?.cwd || currentCwd,
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
-      // PostToolUse: bridge runtime tool completions to the standard hook bus.
-      // dispatch() returns a promise; the loop's afterToolHook caller already
-      // try/catches, so a rejection cannot escape the tool loop.
-      Object.defineProperty(session, 'afterToolHook', {
-        value: (input) => hooks.dispatch('PostToolUse', hookCommonPayload({
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          cwd: input?.cwd || currentCwd,
-          tool_name: input?.name,
-          tool_input: input?.args,
-          tool_use_id: input?.toolCallId || input?.tool_use_id,
-          tool_response: input?.result,
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
-      // PostToolUseFailure: dispatched by loop.mjs only when a tool execution
-      // resolved to a failure (thrown-error path or an is_error result). Same
-      // shape as afterToolHook; `result` carries the error text. Best-effort.
-      Object.defineProperty(session, 'afterToolFailureHook', {
-        value: (input) => hooks.dispatch('PostToolUseFailure', hookCommonPayload({
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          cwd: input?.cwd || currentCwd,
-          tool_name: input?.name,
-          tool_input: input?.args,
-          tool_use_id: input?.toolCallId || input?.tool_use_id,
-          tool_response: input?.result,
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
-      // PostToolBatch: dispatched by loop.mjs after a full parallel batch of
-      // tool calls resolves and before the next model call. No matcher event.
-      Object.defineProperty(session, 'afterToolBatchHook', {
-        value: (input) => hooks.dispatch('PostToolBatch', hookCommonPayload({
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          cwd: input?.cwd || currentCwd,
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
-      // PreCompact / PostCompact: dispatched by manager.mjs/loop.mjs compaction
-      // flow via these session-property hooks (manager has no hooks bus access).
-      // payload { trigger: 'auto' | 'manual' }. Best-effort.
-      Object.defineProperty(session, 'preCompactHook', {
-        value: (input) => hooks.dispatch('PreCompact', hookCommonPayload({
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          cwd: input?.cwd || currentCwd,
-          trigger: input?.trigger || 'auto',
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
-      Object.defineProperty(session, 'postCompactHook', {
-        value: (input) => hooks.dispatch('PostCompact', hookCommonPayload({
-          session_id: input?.sessionId || input?.session_id || session?.id,
-          cwd: input?.cwd || currentCwd,
-          trigger: input?.trigger || 'auto',
-        })),
-        enumerable: false,
-        configurable: true,
-        writable: true,
-      });
+      attachSessionHooks(session, { hooks, hookCommonPayload, getCwd: () => currentCwd });
       applyDeferredToolSurface(session, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
       applyPreSessionToolSelection();
       writeStatuslineRoute(statusRoutes, session, route);
@@ -2549,212 +1372,133 @@ function parsedProviderModelVersion(id) {
     }
   }
 
-  function scheduleLeadSessionPrewarm() {
-    if (!sessionPrewarmEnabled) {
-      bootProfile('session:prewarm-skipped');
-      return;
-    }
-    const timer = setTimeout(() => {
-      if (closeRequested || session?.id || sessionCreatePromise || activeTurnCount > 0) return;
-      void createCurrentSession('prewarm')
-        .then(() => bootProfile('session:prewarm:ready'))
-        .catch((error) => bootProfile('session:prewarm:failed', { error: error?.message || String(error) }));
-    }, sessionPrewarmDelayMs);
-    timer.unref?.();
-  }
-
-  function scheduleProviderWarmup(delayMs = providerWarmupDelayMs) {
-    if (!providerWarmupEnabled) {
-      bootProfile('providers:warm-skipped');
-      return;
-    }
-    if (providerWarmupTimer || closeRequested) return;
-    providerWarmupTimer = setTimeout(() => {
-      providerWarmupTimer = null;
-      if (closeRequested) return;
-      if (!firstTurnCompleted && !envFlag('MIXDOG_PROVIDER_WARMUP_BEFORE_FIRST_TURN')) {
-        bootProfile('providers:warm-deferred', { reason: 'first-turn-pending' });
-        return;
-      }
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('providers:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleProviderWarmup(backgroundBusyRetryMs);
-        return;
-      }
-      const providersStartedAt = performance.now();
-      try {
-        reloadFullConfig();
-      } catch (error) {
-        bootProfile('config:full-failed', { error: error?.message || String(error) });
-      }
-      void ensureProvidersReady(config.providers || {})
-        .then(() => {
-          bootProfile('providers:init:ready', { ms: (performance.now() - providersStartedAt).toFixed(1) });
-          if (closeRequested) return null;
-          return true;
-        })
-        .catch((error) => bootProfile('providers:warm-failed', { error: error?.message || String(error) }));
-    }, delayMs);
-    providerWarmupTimer.unref?.();
-  }
-
-  function scheduleProviderSetupWarmup(delayMs = providerSetupWarmupDelayMs) {
-    if (providerSetupWarmupTimer || closeRequested) return;
-    providerSetupWarmupTimer = setTimeout(() => {
-      providerSetupWarmupTimer = null;
-      if (closeRequested) return;
-      void cachedProviderSetup()
-        .then(() => bootProfile('provider-setup:warm-ready'))
-        .catch((error) => bootProfile('provider-setup:warm-failed', { error: error?.message || String(error) }));
-    }, delayMs);
-    providerSetupWarmupTimer.unref?.();
-  }
-
-  function scheduleProviderModelWarmup(delayMs = providerModelWarmupDelayMs) {
-    if (!modelPrefetchEnabled) return;
-    if (providerModelWarmupTimer || closeRequested) return;
-    providerModelWarmupTimer = setTimeout(() => {
-      providerModelWarmupTimer = null;
-      if (closeRequested || Array.isArray(providerModelsCache.models) || providerModelsPromise) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('provider-models:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleProviderModelWarmup(backgroundBusyRetryMs);
-        return;
-      }
-      warmProviderModelCache();
-    }, delayMs);
-    providerModelWarmupTimer.unref?.();
-  }
-
-  function scheduleModelCatalogWarmup(delayMs = modelCatalogWarmupDelayMs) {
-    if (!modelCatalogWarmupEnabled) {
-      bootProfile('model-catalog:warm-skipped', { reason: 'disabled' });
-      return;
-    }
-    if (modelCatalogWarmupTimer || closeRequested) return;
-    modelCatalogWarmupTimer = setTimeout(() => {
-      modelCatalogWarmupTimer = null;
-      if (closeRequested) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('model-catalog:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleModelCatalogWarmup(backgroundBusyRetryMs);
-        return;
-      }
-      void warmCatalogsInBackground()
-        .then(() => bootProfile('model-catalog:warm-ready'))
-        .catch((error) => bootProfile('model-catalog:warm-failed', { error: error?.message || String(error) }));
-    }, delayMs);
-    modelCatalogWarmupTimer.unref?.();
-  }
+  const {
+    scheduleProviderWarmup,
+    scheduleProviderSetupWarmup,
+    scheduleProviderModelWarmup,
+    scheduleModelCatalogWarmup,
+    scheduleStatuslineUsageWarmup,
+    scheduleStatuslineUsageRefresh,
+  } = createWarmupSchedulers({
+    timers: warmupTimers,
+    bootProfile,
+    getRoute: () => route,
+    getConfig: () => config,
+    isCloseRequested: () => closeRequested,
+    getActiveTurnCount: () => activeTurnCount,
+    getSessionCreatePromise: () => sessionCreatePromise,
+    getProviderModelsCache: () => providerModelCaches.providerModelsCache,
+    getProviderModelsPromise: () => providerModelCaches.providerModelsPromise,
+    reloadFullConfig,
+    ensureConfigForRouteProvider,
+    ensureProvidersReady,
+    ensureProviderEnabled,
+    refreshStatuslineUsageSnapshot,
+    warmProviderModelCache,
+    cachedProviderSetup,
+    warmCatalogsInBackground,
+    isFirstTurnCompleted: () => firstTurnCompleted,
+    envFlag,
+    delays: {
+      providerWarmupDelayMs,
+      providerSetupWarmupDelayMs,
+      providerModelWarmupDelayMs,
+      modelCatalogWarmupDelayMs,
+      statuslineUsageWarmupDelayMs,
+      statuslineUsageRefreshDelayMs,
+      backgroundBusyRetryMs,
+    },
+    flags: {
+      providerWarmupEnabled,
+      modelPrefetchEnabled,
+      modelCatalogWarmupEnabled,
+    },
+  });
+  scheduleProviderModelWarmupRef = scheduleProviderModelWarmup;
+  scheduleProviderSetupWarmupRef = scheduleProviderSetupWarmup;
+
+  const {
+    scheduleCodeGraphPrewarm,
+    scheduleLeadSessionPrewarm,
+    invokeChannelStart,
+    scheduleChannelStart,
+  } = createPrewarmSchedulers({
+    timers: prewarmTimers,
+    bootProfile,
+    getCurrentCwd: () => currentCwd,
+    isCloseRequested: () => closeRequested,
+    getActiveTurnCount: () => activeTurnCount,
+    getSessionCreatePromise: () => sessionCreatePromise,
+    getSession: () => session,
+    isRemoteEnabled: () => remoteEnabled,
+    channelsEnabled,
+    getCodeGraphModule,
+    createCurrentSession,
+    channels,
+    envFlag,
+    delays: {
+      codeGraphPrewarmDelayMs,
+      channelStartDelayMs,
+      sessionPrewarmDelayMs,
+      backgroundBusyRetryMs,
+    },
+    flags: {
+      codeGraphPrewarmEnabled,
+      sessionPrewarmEnabled,
+    },
+    state: prewarmState,
+  });
 
-  function scheduleStatuslineUsageWarmup(delayMs = statuslineUsageWarmupDelayMs) {
-    const providerId = clean(route?.provider);
-    if (!providerId || !providerId.includes('oauth')) {
-      bootProfile('statusline-usage:warm-skipped', { provider: providerId || null });
-      return;
-    }
-    if (statuslineUsageWarmupTimer || closeRequested) return;
-    statuslineUsageWarmupTimer = setTimeout(async () => {
-      statuslineUsageWarmupTimer = null;
-      if (closeRequested) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('statusline-usage:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleStatuslineUsageWarmup(backgroundBusyRetryMs);
-        return;
-      }
+  // Eagerly create/refresh the remote transcript writer for the CURRENT
+  // session + cwd, publish the session record, and ensure the transcript
+  // file exists on disk. Called from startRemote() (so the channel worker's
+  // activate-time discovery finds THIS session immediately instead of
+  // waiting for the first turn) and from ask() at turn start. Returns true
+  // when a writer is bound.
+  function ensureRemoteTranscriptWriter() {
+    if (!remoteEnabled || !session?.id) return false;
+    const twKey = `${session.id}\u0000${currentCwd}`;
+    if (_twKey !== twKey) {
       try {
-        ensureConfigForRouteProvider();
-        await ensureProvidersReady(ensureProviderEnabled(config, route.provider));
-        if (closeRequested) return;
-        refreshStatuslineUsageSnapshot(route);
-        bootProfile('statusline-usage:warm-ready', { provider: clean(route?.provider) });
+        _transcriptWriter = createTranscriptWriter({
+          mixdogHome: mixdogHome(),
+          sessionId: session.id,
+          cwd: currentCwd,
+          pid: process.pid,
+        });
+        _transcriptWriter.writeSessionRecord();
+        _twKey = twKey;
       } catch (error) {
-        bootProfile('statusline-usage:warm-failed', { error: error?.message || String(error) });
-      } finally {
-        scheduleStatuslineUsageRefresh();
-      }
-    }, delayMs);
-    statuslineUsageWarmupTimer.unref?.();
-  }
-
-  // Idle keep-alive loop: periodically re-fetch the OAuth usage snapshot so its
-  // cachedAt stays "live-fresh" and the statusline usage segment does not vanish
-  // after LIVE_USAGE_SNAPSHOT_MAX_AGE_MS while the session is idle. Turn-driven
-  // refreshes (recordStandaloneStatusTelemetry) already cover active sessions.
-  function scheduleStatuslineUsageRefresh(delayMs = statuslineUsageRefreshDelayMs) {
-    const providerId = clean(route?.provider);
-    if (!providerId || !providerId.includes('oauth')) return;
-    if (statuslineUsageRefreshTimer || closeRequested) return;
-    statuslineUsageRefreshTimer = setTimeout(async () => {
-      statuslineUsageRefreshTimer = null;
-      if (closeRequested) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        // Active turns refresh usage on their own; just re-arm the idle loop.
-        scheduleStatuslineUsageRefresh();
-        return;
-      }
-      try {
-        ensureConfigForRouteProvider();
-        await ensureProvidersReady(ensureProviderEnabled(config, route.provider));
-        if (closeRequested) return;
-        refreshStatuslineUsageSnapshot(route);
-      } catch {
-        // Usage display must never affect the session runtime.
-      } finally {
-        scheduleStatuslineUsageRefresh();
+        process.stderr.write(`mixdog: transcript-writer: init failed: ${error?.message || error}\n`);
+        _transcriptWriter = null;
+        _twKey = '';
+        return false;
       }
-    }, delayMs);
-    statuslineUsageRefreshTimer.unref?.();
-  }
-
-  function invokeChannelStart() {
-    if (channelStartPromise) return channelStartPromise;
-    const startedAt = performance.now();
-    bootProfile('channels:start:begin');
-    channelStartPromise = channels.start()
-      .then(() => bootProfile('channels:start:ready', { ms: (performance.now() - startedAt).toFixed(1) }))
-      .catch((error) => bootProfile('channels:start:failed', {
-        ms: (performance.now() - startedAt).toFixed(1),
-        error: error?.message || String(error),
-      }))
-      .finally(() => {
-        channelStartPromise = null;
-      });
-    return channelStartPromise;
-  }
-
-  function scheduleChannelStart(delayMs = channelStartDelayMs) {
-    if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
-      bootProfile('channels:start-skipped');
-      return;
-    }
-    if (!channelsEnabled()) {
-      bootProfile('channels:start-disabled');
-      return;
+    } else {
+      // Same binding — refresh updatedAt so worker-side discovery keeps
+      // ranking this session as the live parent-chain candidate.
+      try { _transcriptWriter?.writeSessionRecord(); } catch {}
     }
-    if (channelStartTimer || channelStartPromise || closeRequested) return;
-    bootProfile('channels:start-scheduled', { delayMs });
-    channelStartTimer = setTimeout(() => {
-      channelStartTimer = null;
-      if (closeRequested) return;
-      // A deferred start may straddle a stopRemote(); re-check before booting so
-      // a turned-off session neither starts channels nor keeps rescheduling.
-      if (!remoteEnabled) return;
-      if (activeTurnCount > 0 || sessionCreatePromise) {
-        bootProfile('channels:start-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-        scheduleChannelStart(backgroundBusyRetryMs);
-        return;
-      }
-      void invokeChannelStart();
-    }, delayMs);
-    channelStartTimer.unref?.();
+    try { _transcriptWriter?.ensureTranscriptFile(); }
+    catch (error) { process.stderr.write(`mixdog: transcript-writer: ensureTranscriptFile failed: ${error?.message || error}\n`); }
+    return _transcriptWriter != null;
   }
 
   // Remote (Discord channel) mode is opt-in per session. Only a session that
   // explicitly enables remote — via `mixdog --remote` or the runtime toggle —
   // boots the channel worker and contends for channel ownership.
+  // startRemote() is FORCE-TAKEOVER: it always (re)claims the bridge seat and
+  // rebinds output forwarding to this session, even when the worker is
+  // already running (e.g. `/remote` re-issued after another session took the
+  // seat, or to re-pin forwarding onto the current transcript).
   function startRemote() {
     remoteEnabled = true;
+    // Publish this session's record + transcript file BEFORE the worker's
+    // activate-time discovery polls, so output forwarding binds to this
+    // terminal session immediately instead of waiting for the first turn.
+    // No-op when the session has not been created yet (lazy mode); that
+    // case is covered by the turn-start rebind in ask().
+    ensureRemoteTranscriptWriter();
     // A backend switch may still be sitting in its debounce window; flush it
     // so the channel worker boots against the backend the user just chose,
     // not the previous on-disk value.
@@ -2768,19 +1512,43 @@ function parsedProviderModelVersion(id) {
       return true;
     }
     if (closeRequested) return true;
-    if (channelStartTimer) {
-      clearTimeout(channelStartTimer);
-      channelStartTimer = null;
+    if (prewarmTimers.channelStartTimer) {
+      clearTimeout(prewarmTimers.channelStartTimer);
+      prewarmTimers.channelStartTimer = null;
     }
     bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
-    void invokeChannelStart();
+    void (async () => {
+      // Immediate-occupancy guarantee: make sure a session + transcript
+      // exist BEFORE the worker boots — a freshly-forked worker claims and
+      // runs transcript discovery inside its own start(), so publishing the
+      // session record/file first lets that very first discovery pass bind
+      // output forwarding to THIS terminal instead of a persisted/stale
+      // neighbour. Lazy mode means the session may not exist yet at /remote
+      // time; create it here (idempotent — reuses a live session, joins an
+      // in-flight create). On create failure we still claim: that matches
+      // the pre-eager behavior (bind resolves on the first turn's rebind).
+      try { await createCurrentSession('remote-start'); }
+      catch (error) { bootProfile('channels:remote-session-create-failed', { error: error?.message || String(error) }); }
+      ensureRemoteTranscriptWriter();
+      // Re-check after the awaits above: stopRemote()/superseded or runtime
+      // close may have landed mid-chain — do not boot/claim for a session
+      // that already turned remote off.
+      if (!remoteEnabled || closeRequested) return;
+      await invokeChannelStart();
+      if (!remoteEnabled || closeRequested) return;
+      // Unconditional claim + forwarder rebind. A freshly-forked worker
+      // already claims in its own start(), so this is idempotent there; the
+      // already-running case is where it matters (last-wins seat overwrite +
+      // transcript rebind onto this session).
+      await channels.execute('activate_channel_bridge', { active: true });
+    })().catch((error) => bootProfile('channels:claim-failed', { error: error?.message || String(error) }));
     return true;
   }
 
   function stopRemote(reason) {
     remoteEnabled = false;
     // Cancel any pending deferred start so it can't fire after remote is off.
-    if (channelStartTimer) { clearTimeout(channelStartTimer); channelStartTimer = null; }
+    if (prewarmTimers.channelStartTimer) { clearTimeout(prewarmTimers.channelStartTimer); prewarmTimers.channelStartTimer = null; }
     channels.stop(reason || 'remote-disabled', { waitForExit: false }).catch(() => {});
     return true;
   }
@@ -2879,7 +1647,63 @@ function parsedProviderModelVersion(id) {
     return true;
   }
 
+  // Pure settings-delegate methods (onboarding status/skip, autoClear, profile,
+  // compaction, recap/memory, channels, systemShell, update settings, channel
+  // token save/forget, setBackend). Extracted to session-runtime/settings-api.mjs
+  // and SPREAD into the API object below so the external surface is unchanged.
+  const settingsApi = createSettingsApi({
+    getConfig: () => config,
+    getRoute: () => route,
+    getSession: () => session,
+    getRemoteEnabled: () => remoteEnabled,
+    saveConfigAndAdopt,
+    scheduleBackendSave,
+    cfgMod,
+    hasOwn,
+    normalizeAutoClearConfig,
+    autoClearIdleMsForProvider,
+    normalizeCompactionConfig,
+    normalizeCompactTypeSetting,
+    normalizeSystemShellConfig,
+    normalizeSystemShellCommand,
+    setConfiguredShell,
+    setRecapEnabledInConfig,
+    setModuleEnabledInConfig,
+    summarizeWorkflowRoutes,
+    parseDurationMs,
+    formatDurationMs,
+    localPackageVersion,
+    memoryEnabled,
+    recapEnabledFn,
+    channelsEnabled,
+    autoUpdateEnabled,
+    getUpdateCheckState: () => updateCheckState,
+    getUpdateProcessState: () => updateProcessState,
+    invalidateContextStatusCache: (...a) => invalidateContextStatusCache(...a),
+    invalidatePreSessionToolSurface: (...a) => invalidatePreSessionToolSurface(...a),
+    scheduleChannelStart: (...a) => scheduleChannelStart(...a),
+    channels,
+    clearChannelStartTimer: () => {
+      if (prewarmTimers.channelStartTimer) {
+        clearTimeout(prewarmTimers.channelStartTimer);
+        prewarmTimers.channelStartTimer = null;
+      }
+    },
+    checkForUpdateInternal: (...a) => checkForUpdateInternal(...a),
+    runUpdateNowInternal: (...a) => runUpdateNowInternal(...a),
+    reloadChannelsSoon: (...a) => reloadChannelsSoon(...a),
+    ONBOARDING_VERSION,
+    saveDiscordToken,
+    forgetDiscordToken,
+    saveTelegramToken,
+    forgetTelegramToken,
+    saveWebhookAuthtoken,
+    forgetWebhookAuthtoken,
+    setBackend,
+  });
+
   return {
+    ...settingsApi,
     get id() {
       return session?.id || null;
     },
@@ -2914,7 +1738,7 @@ function parsedProviderModelVersion(id) {
       return mode;
     },
     get autoClear() {
-      return normalizeAutoClearConfig(config.autoClear);
+      return this.getAutoClear();
     },
     get systemShell() {
       return normalizeSystemShellConfig(config.shell);
@@ -3046,244 +1870,7 @@ function parsedProviderModelVersion(id) {
       return await cachedProviderSetup();
     },
     async getUsageDashboard(options = {}) {
-      const forceSetup = options?.force === true || options?.refresh === true;
-      if (!forceSetup && usageDashboardCache.dashboard) {
-        const cached = {
-          ...usageDashboardCache.dashboard,
-          refresh: false,
-          checking: false,
-          cached: true,
-          cachedAt: usageDashboardCache.at,
-        };
-        if (typeof options?.onUpdate === 'function') {
-          try { options.onUpdate(cached); } catch {}
-        }
-        return cached;
-      }
-      if (!forceSetup && usageDashboardPromise) return await usageDashboardPromise;
-      const quickSetup = options?.quickSetup !== false;
-      const getProvider = (providerId) => reg.getProvider(providerId);
-      const log = (message) => {
-        if (process.env.MIXDOG_USAGE_TRACE) {
-          try { process.stderr.write(`[usage] ${message}\n`); } catch {}
-        }
-      };
-      if (quickSetup && typeof options?.onUpdate === 'function') {
-        const previewConfig = displayConfig();
-        const previewSetup = await cachedProviderSetup({ force: false, quick: true });
-        await createUsageDashboard(previewConfig, {
-          ...(options || {}),
-          preview: true,
-          setup: previewSetup,
-          getProvider,
-          log,
-        });
-      }
-      const buildDashboard = async () => {
-        const dashboard = await createUsageDashboard(displayConfig(), {
-          ...(options || {}),
-          setup: await cachedProviderSetup({ force: forceSetup, quick: false }),
-          getProvider,
-          log,
-        });
-        usageDashboardCache = { dashboard, at: Date.now() };
-        return dashboard;
-      };
-      if (forceSetup) return await buildDashboard();
-      usageDashboardPromise = buildDashboard()
-        .finally(() => {
-          usageDashboardPromise = null;
-        });
-      return await usageDashboardPromise;
-    },
-    getOnboardingStatus() {
-      const nextConfig = displayConfig();
-      return {
-        completed: nextConfig?.onboarding?.completed === true,
-        version: nextConfig?.onboarding?.version || 0,
-        default: nextConfig?.default || null,
-        workflowRoutes: summarizeWorkflowRoutes(nextConfig),
-      };
-    },
-    // Mark onboarding as done WITHOUT touching routes/agents/provider. Used by
-    // the TUI "skip" (Esc) path so the wizard doesn't reappear next launch,
-    // while leaving any existing config routes untouched.
-    skipOnboarding() {
-      const nextConfig = { ...config };
-      nextConfig.onboarding = {
-        ...(nextConfig.onboarding || {}),
-        completed: true,
-        version: ONBOARDING_VERSION,
-        completedAt: new Date().toISOString(),
-        skipped: true,
-      };
-      saveConfigAndAdopt(nextConfig);
-      return this.getOnboardingStatus();
-    },
-    getAutoClear() {
-      return normalizeAutoClearConfig(config.autoClear);
-    },
-    // --- User profile (/profile statusline command) ---------------------
-    // getProfile returns the normalized { title, language } plus the resolved
-    // language catalog entry and the full language list for the picker UI.
-    getProfile() {
-      const profile = cfgMod.normalizeProfileConfig(config.profile);
-      return {
-        ...profile,
-        languageEntry: cfgMod.profileLanguageEntry(profile.language),
-        languages: cfgMod.PROFILE_LANGUAGES,
-      };
-    },
-    // setProfile patches title and/or language and persists. Unknown language
-    // ids normalize back to 'system'. Prompt-side injection is wired separately
-    // (composeSystemPrompt) — this only owns the stored value.
-    setProfile(input = {}) {
-      const current = cfgMod.normalizeProfileConfig(config.profile);
-      const next = { ...current };
-      if (hasOwn(input, 'title') || hasOwn(input, 'name')) {
-        next.title = input.title ?? input.name ?? '';
-      }
-      if (hasOwn(input, 'language') || hasOwn(input, 'lang')) {
-        next.language = input.language ?? input.lang ?? 'system';
-      }
-      const normalized = cfgMod.normalizeProfileConfig(next);
-      saveConfigAndAdopt({ ...config, profile: normalized });
-      return this.getProfile();
-    },
-    getCompactionSettings() {
-      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
-    },
-    setCompactionSettings(input = {}) {
-      const current = normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
-      const next = { ...current };
-      if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
-      if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
-      if (hasOwn(input, 'type') || hasOwn(input, 'compactType') || hasOwn(input, 'compact_type')) {
-        const requestedType = input.type ?? input.compactType ?? input.compact_type;
-        const compactType = normalizeCompactTypeSetting(requestedType, current.compactType || current.type || 'semantic');
-        if (compactType === 'recall-fasttrack' && !memoryEnabled()) {
-          throw new Error('recall-fasttrack compact requires memory to be enabled');
-        }
-        next.type = compactType;
-        next.compactType = compactType;
-      }
-      const nextConfig = { ...config };
-      nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
-      saveConfigAndAdopt(nextConfig);
-      if (session) {
-        session.compaction = {
-          ...(session.compaction || {}),
-          ...normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() }),
-        };
-      }
-      invalidateContextStatusCache();
-      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
-    },
-    getMemorySettings() {
-      return {
-        enabled: memoryEnabled(),
-        compactFastTrackAvailable: memoryEnabled(),
-      };
-    },
-    async setMemoryEnabled(enabled) {
-      const nextConfig = setModuleEnabledInConfig({ ...config }, 'memory', enabled !== false);
-      if (enabled === false) {
-        nextConfig.compaction = normalizeCompactionConfig(nextConfig.compaction, { memoryEnabled: false });
-      }
-      saveConfigAndAdopt(nextConfig);
-      if (!memoryEnabled() && memoryModPromise) {
-        await memoryModPromise.then((mod) => mod?.stop?.()).catch(() => {});
-        memoryModPromise = null;
-      }
-      if (session && config.compaction) {
-        session.compaction = {
-          ...(session.compaction || {}),
-          ...normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() }),
-        };
-      }
-      invalidatePreSessionToolSurface();
-      invalidateContextStatusCache();
-      return this.getMemorySettings();
-    },
-    getChannelSettings(options = {}) {
-      return {
-        enabled: channelsEnabled(),
-        ...(options?.includeStatus === false ? {} : { status: channels.status() }),
-      };
-    },
-    async setChannelsEnabled(enabled) {
-      const nextConfig = setModuleEnabledInConfig({ ...config }, 'channels', enabled !== false);
-      saveConfigAndAdopt(nextConfig);
-      if (!channelsEnabled()) {
-        if (channelStartTimer) {
-          clearTimeout(channelStartTimer);
-          channelStartTimer = null;
-        }
-        await channels.stop('settings-disabled', { waitForExit: false }).catch(() => {});
-      } else {
-        // Enabling channels in settings only boots the worker when this session
-        // is in remote mode; otherwise the toggle just persists config.
-        if (remoteEnabled) scheduleChannelStart(0);
-      }
-      invalidatePreSessionToolSurface();
-      return this.getChannelSettings();
-    },
-    getSystemShell() {
-      return normalizeSystemShellConfig(config.shell);
-    },
-    setSystemShell(input = {}) {
-      const command = normalizeSystemShellCommand(typeof input === 'string' ? input : input?.command);
-      saveConfigAndAdopt({
-        ...config,
-        shell: command ? { ...(config.shell || {}), command } : {},
-      });
-      setConfiguredShell(command);
-      return normalizeSystemShellConfig(config.shell);
-    },
-    setAutoClear(input = {}) {
-      const current = normalizeAutoClearConfig(config.autoClear);
-      const next = { ...current };
-      if (hasOwn(input, 'enabled')) next.enabled = input.enabled !== false;
-      if (hasOwn(input, 'idleMs')) {
-        const idleMs = Number(input.idleMs);
-        if (!Number.isFinite(idleMs) || idleMs <= 0) throw new Error('autoclear idleMs must be a positive number');
-        next.idleMs = Math.max(60_000, Math.round(idleMs));
-      }
-      if (hasOwn(input, 'duration')) {
-        const idleMs = parseDurationMs(input.duration);
-        if (!idleMs) throw new Error('usage: /autoclear [on|off|status|<minutes|1h|90m>]');
-        next.idleMs = idleMs;
-        if (!hasOwn(input, 'enabled')) next.enabled = true;
-      }
-      saveConfigAndAdopt({ ...config, autoClear: next });
-      return { ...normalizeAutoClearConfig(config.autoClear), label: formatDurationMs(normalizeAutoClearConfig(config.autoClear).idleMs) };
-    },
-    getUpdateSettings() {
-      return {
-        autoUpdate: autoUpdateEnabled(),
-        currentVersion: updateCheckState.currentVersion || localPackageVersion(),
-        latestVersion: updateCheckState.latestVersion,
-        updateAvailable: updateCheckState.updateAvailable,
-        lastCheckedAt: updateCheckState.lastCheckedAt,
-      };
-    },
-    setAutoUpdate(enabled) {
-      saveConfigAndAdopt({
-        ...config,
-        update: { ...(config.update || {}), auto: enabled === true },
-      });
-      return this.getUpdateSettings();
-    },
-    async checkForUpdate(options = {}) {
-      await checkForUpdateInternal({ force: options?.force === true });
-      return this.getUpdateSettings();
-    },
-    async runUpdateNow() {
-      const state = await runUpdateNowInternal();
-      return { ok: state.phase === 'installed', ...state };
-    },
-    getUpdateStatus() {
-      return { ...updateProcessState };
+      return await getUsageDashboard(options);
     },
     async completeOnboarding(payload = {}) {
       // Only fall back to the live runtime route when the caller actually sent a
@@ -3408,52 +1995,13 @@ function parsedProviderModelVersion(id) {
     isRemoteEnabled() {
       return isRemoteEnabled();
     },
-    saveDiscordToken(token) {
-      const result = saveDiscordToken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetDiscordToken() {
-      const result = forgetDiscordToken();
-      reloadChannelsSoon();
-      return result;
-    },
-    saveTelegramToken(token) {
-      const result = saveTelegramToken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetTelegramToken() {
-      const result = forgetTelegramToken();
-      reloadChannelsSoon();
-      return result;
-    },
-    setBackend(name) {
-      // Validate synchronously (same contract as before: bad input throws on
-      // this call so the TUI's try/catch can react immediately). The actual
-      // channels-section file read-modify-write is the hitch source on the
-      // settings-toggle key handler, so defer it through the same debounce
-      // pattern as saveConfigAndAdopt/flushConfigSave instead of writing to
-      // disk synchronously inside the key handler.
-      const value = String(name || '').trim();
-      if (value !== 'discord' && value !== 'telegram') {
-        throw new Error('backend must be discord or telegram');
-      }
-      pendingBackendName = value;
-      if (backendSaveTimer) clearTimeout(backendSaveTimer);
-      backendSaveTimer = setTimeout(flushBackendSave, CONFIG_SAVE_DEBOUNCE_MS);
-      backendSaveTimer.unref?.();
-      return { ok: true, backend: value };
-    },
-    saveWebhookAuthtoken(token) {
-      const result = saveWebhookAuthtoken(token);
-      reloadChannelsSoon();
-      return result;
-    },
-    forgetWebhookAuthtoken() {
-      const result = forgetWebhookAuthtoken();
-      reloadChannelsSoon();
-      return result;
+    // Subscribe to non-user-initiated remote flips (seat superseded). Returns
+    // an unsubscribe function. TUI uses this to sync its Remote indicator and
+    // show a "remote taken over" notice.
+    onRemoteStateChange(listener) {
+      if (typeof listener !== 'function') return () => {};
+      remoteStateListeners.add(listener);
+      return () => remoteStateListeners.delete(listener);
     },
     saveChannel(entry) {
       const result = saveChannel(entry);
@@ -3685,18 +2233,13 @@ function parsedProviderModelVersion(id) {
         nextConfig.agent = agent;
       }
       adoptConfig(nextConfig);
-      pendingOutputStyleId = selected.id;
-      if (outputStyleSaveTimer) clearTimeout(outputStyleSaveTimer);
-      outputStyleSaveTimer = setTimeout(flushOutputStyleSave, CONFIG_SAVE_DEBOUNCE_MS);
-      outputStyleSaveTimer.unref?.();
+      scheduleOutputStyleSave(selected.id);
       // Reuse the catalog already scanned above for `before` instead of a
       // second forced-fresh filesystem scan; refresh the status cache
       // in-memory (short TTL, same as getOutputStyleStatusCached) so reads
       // during the debounce window see the just-selected style.
       const freshStatus = { configured: selected.id, current: selected, styles: before.styles };
-      outputStyleStatusCache = freshStatus;
-      outputStyleStatusCacheAt = performance.now();
-      outputStyleStatusCacheDir = resolve(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR);
+      seedOutputStyleStatusCache(freshStatus);
       const hasConversation = sessionHasConversationMessages(session);
       let appliedToCurrentSession = !hasConversation;
       if (session?.id && !hasConversation) {
@@ -3791,25 +2334,28 @@ function parsedProviderModelVersion(id) {
         // JSONL and pushes the surface view to Discord. Gated on remoteEnabled
         // so non-remote sessions write nothing.
         if (remoteEnabled) {
-          const twKey = `${session.id}\u0000${currentCwd}`;
           // Reset per-turn dedup tracker so an identical answer in a later turn
           // is still written (the guard only prevents same-turn double-write).
           _lastAppendedAssistant = '';
-          if (_twKey !== twKey) {
-            try {
-              _transcriptWriter = createTranscriptWriter({
-                mixdogHome: mixdogHome(),
-                sessionId: session.id,
-                cwd: currentCwd,
-                pid: process.pid,
-              });
-              _transcriptWriter.writeSessionRecord();
-              _twKey = twKey;
-            } catch (error) {
-              process.stderr.write(`mixdog: transcript-writer: init failed: ${error?.message || error}\n`);
-              _transcriptWriter = null;
-              _twKey = '';
-            }
+          const prevKey = _twKey;
+          ensureRemoteTranscriptWriter();
+          // The writer moved to a NEW session/cwd (e.g. lazy first-turn
+          // session create after /remote, or /new mid-remote). Re-pin the
+          // channel worker's output forwarder onto the fresh transcript NOW —
+          // otherwise it keeps tailing the previous binding until an inbound
+          // Discord message triggers the steal path, so terminal-initiated
+          // turns would never forward. activate_channel_bridge is idempotent
+          // force-takeover (claim + rebind); fire-and-forget so the turn is
+          // never blocked on worker IPC.
+          if (_twKey && _twKey !== prevKey && channelsEnabled() && !envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
+            void invokeChannelStart()
+              .then(() => {
+                // stopRemote()/superseded/close may have landed while the
+                // worker was starting — never re-claim for a turned-off session.
+                if (!remoteEnabled || closeRequested) return undefined;
+                return channels.execute('activate_channel_bridge', { active: true });
+              })
+              .catch((error) => bootProfile('channels:turn-rebind-failed', { error: error?.message || String(error) }));
           }
         }
         hooks.emit('turn:start', { sessionId: session.id, prompt, cwd: currentCwd });
@@ -4037,7 +2583,7 @@ function parsedProviderModelVersion(id) {
       return { ...result, status: this.toolsStatus() };
     },
     setCwd(path) {
-      applyResolvedCwd(resolveCwdPath(currentCwd, path));
+      applyResolvedCwd(resolveCwdPath(path));
       return currentCwd;
     },
     mcpStatus() {
@@ -4248,9 +2794,19 @@ function parsedProviderModelVersion(id) {
         ...(args || {}),
         query: baseQuery,
         cwd: args?.cwd || currentCwd,
+        // Grouping hint for multi-session browse output: lets the memory
+        // service mark THIS session's group as "(current)". Not a filter.
+        ...(session?.id ? { currentSessionId: session.id } : {}),
       };
       let result = '(no results)';
       if (session?.id && args?.currentSession !== false && args?.forceCycleOnEmpty !== false) {
+        // Empty-fallback: hydrate the current transcript into the memory DB
+        // (no LLM — ingest only) and re-search session-scoped with the raw
+        // leg on. The old path also ran a synchronous cycle1 (LLM chunking)
+        // here, which made an empty recall the slowest possible recall and
+        // called the LLM even with recap/memory off; the raw rows are
+        // searchable directly (FTS/trgm + post-ingest raw embeddings), so
+        // chunking is left to the background cycle.
         const messages = Array.isArray(session.messages) ? session.messages : [];
         if (messages.length > 0) {
           await memoryMod.handleToolCall('memory', {
@@ -4259,12 +2815,6 @@ function parsedProviderModelVersion(id) {
             cwd: currentCwd,
             messages,
           });
-          await memoryMod.handleToolCall('memory', {
-            action: 'cycle1',
-            min_batch: 1,
-            session_cap: 1,
-            batch_size: Math.max(1, Math.min(100, messages.length)),
-          });
           result = toolResponseText(await memoryMod.handleToolCall('recall', {
             ...baseArgs,
             sessionId: session.id,
@@ -4417,37 +2967,30 @@ function parsedProviderModelVersion(id) {
       try { flushConfigSave(); } catch {}
       try { flushBackendSave(); } catch {}
       try { flushOutputStyleSave(); } catch {}
-      if (channelStartTimer) {
-        clearTimeout(channelStartTimer);
-        channelStartTimer = null;
-      }
-      if (providerSetupWarmupTimer) {
-        clearTimeout(providerSetupWarmupTimer);
-        providerSetupWarmupTimer = null;
-      }
-      if (providerWarmupTimer) {
-        clearTimeout(providerWarmupTimer);
-        providerWarmupTimer = null;
-      }
-      if (providerModelWarmupTimer) {
-        clearTimeout(providerModelWarmupTimer);
-        providerModelWarmupTimer = null;
-      }
-      if (modelCatalogWarmupTimer) {
-        clearTimeout(modelCatalogWarmupTimer);
-        modelCatalogWarmupTimer = null;
-      }
-      if (codeGraphPrewarmTimer) {
-        clearTimeout(codeGraphPrewarmTimer);
-        codeGraphPrewarmTimer = null;
+      if (prewarmTimers.channelStartTimer) {
+        clearTimeout(prewarmTimers.channelStartTimer);
+        prewarmTimers.channelStartTimer = null;
+      }
+      for (const timerKey of [
+        'providerSetupWarmupTimer',
+        'providerWarmupTimer',
+        'providerModelWarmupTimer',
+        'modelCatalogWarmupTimer',
+      ]) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
       }
-      if (statuslineUsageWarmupTimer) {
-        clearTimeout(statuslineUsageWarmupTimer);
-        statuslineUsageWarmupTimer = null;
+      if (prewarmTimers.codeGraphPrewarmTimer) {
+        clearTimeout(prewarmTimers.codeGraphPrewarmTimer);
+        prewarmTimers.codeGraphPrewarmTimer = null;
       }
-      if (statuslineUsageRefreshTimer) {
-        clearTimeout(statuslineUsageRefreshTimer);
-        statuslineUsageRefreshTimer = null;
+      for (const timerKey of ['statuslineUsageWarmupTimer', 'statuslineUsageRefreshTimer']) {
+        if (warmupTimers[timerKey]) {
+          clearTimeout(warmupTimers[timerKey]);
+          warmupTimers[timerKey] = null;
+        }
       }
       try { cancelBackgroundTasks({ reason, notify: false }); } catch {}
       const channelStop = channels.stop(reason, detach ? { waitForExit: false } : undefined);
@@ -4471,7 +3014,19 @@ function parsedProviderModelVersion(id) {
       let ok = false;
       if (session?.id) {
         statusRoutes?.clearGatewaySessionRoute?.(session.id);
-        ok = mgr.closeSession(session.id, reason);
+        // Bug fix: runtime stop/exit (TUI Ctrl-C, process exit) previously
+        // always tombstoned the current session, so a session you were
+        // mid-conversation in vanished from the Resume list the instant you
+        // quit and was hard-deleted by the 24h tombstone sweep. Only
+        // tombstone truly-empty scratch sessions; non-empty sessions must
+        // survive exit resumable.
+        // liveTurnMessages holds the in-flight user prompt until turn
+        // commit — an active first-turn ask has its user message there,
+        // not yet in session.messages, so it must also be checked or a
+        // first-turn exit could still burn a real session.
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        ok = mgr.closeSession(session.id, reason, { tombstone });
         session = null;
       }
       const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
@@ -4518,7 +3073,10 @@ function parsedProviderModelVersion(id) {
         const agent = clean(s.agent || '').toLowerCase();
         const leadish = agent === 'lead'
           || sourceType === 'lead'
-          || (sourceType === 'cli' && (!sourceName || sourceName === 'main'))
+          // Bug fix: side-terminal cli sessions have a non-empty/non-'main' sourceName
+          // (e.g. terminal id) and were being hidden from resume even though they are
+          // legitimate user sessions, not agent-owned. Any sourceName is fine for cli.
+          || (sourceType === 'cli')
           || (!sourceType && !sourceName && !isAgentOwner(owner));
         if (!leadish) return null;
         let preview = cleanSessionPreview(s.preview || '');
@@ -4532,7 +3090,12 @@ function parsedProviderModelVersion(id) {
           preview = userPreviews[userPreviews.length - 1] || userPreviews[0] || '';
           messageCount = msgs.filter(m => m && (m.role === 'user' || m.role === 'assistant')).length;
         }
-        if (!preview) return null;
+        // Bug fix: sessions whose preview couldn't be derived (e.g. noise-only user
+        // turns) were silently dropped from the resume list even when they had real
+        // messages. Keep the row and let preview fall back to '' (TUI renders
+        // '(no message)' for empty preview); only drop truly-empty scratch sessions
+        // with zero visible messages.
+        if (!preview && messageCount === 0) return null;
         return {
           id: s.id,
           updatedAt: s.updatedAt,
@@ -4545,17 +3108,44 @@ function parsedProviderModelVersion(id) {
       }).filter(Boolean);
     },
     async newSession() {
-      if (session?.id) mgr.closeSession(session.id, 'cli-new');
+      if (session?.id) {
+        // Bug fix: /new used to unconditionally tombstone the outgoing
+        // session, so switching to a fresh session burned whatever you'd
+        // been working on — it dropped off the Resume list immediately and
+        // was hard-deleted after the 24h tombstone sweep. Only tombstone
+        // truly-empty scratch sessions; keep non-empty ones resumable.
+        const tombstone = !hasUserConversationMessage(session.messages)
+          && !hasUserConversationMessage(session.liveTurnMessages);
+        mgr.closeSession(session.id, 'cli-new', { tombstone });
+        // Bug fix: closeSession({tombstone:false}) keeps the outgoing
+        // session file intact so it stays resumable — but that meant
+        // createCurrentSession()'s live-session reuse check (session?.id →
+        // mgr.getSession(...) not closed) happily reloaded the SAME session,
+        // so /new never actually reset the transcript and the context gauge
+        // never returned to 0. Drop the in-memory reference so a fresh
+        // session is always created.
+        session = null;
+      }
+      invalidateContextStatusCache();
       await createCurrentSession();
       return session.id;
     },
     async resume(id) {
       const previousId = session?.id || null;
+      const previousMessages = session?.messages || null;
+      const previousLive = session?.liveTurnMessages || null;
       const resumed = await mgr.resumeSession(id, toolSpecForMode(mode));
       if (!resumed) return null;
       if (previousId && previousId !== resumed.id) {
         statusRoutes?.clearGatewaySessionRoute?.(previousId);
-        mgr.closeSession(previousId, 'cli-resume');
+        // Bug fix: /resume used to unconditionally tombstone the session
+        // you were switching away from, so it vanished from the Resume
+        // list right away and was hard-deleted after the 24h sweep — the
+        // exact "burn a resumable session" bug this fix targets. Only
+        // tombstone truly-empty scratch sessions.
+        const tombstone = !hasUserConversationMessage(previousMessages)
+          && !hasUserConversationMessage(previousLive);
+        mgr.closeSession(previousId, 'cli-resume', { tombstone });
       }
       session = resumed;
       currentCwd = resumed.cwd || currentCwd;