mixdog 0.9.1 → 0.9.2

package/src/mixdog-session-runtime.mjs

@@ -12,10 +12,17 @@ import { createStandaloneMemoryRuntime } from './standalone/memory-runtime-proxy
 import { createStandaloneHookBus } from './standalone/hook-bus.mjs';
 import { writeLastSessionCwd } from './runtime/shared/user-cwd.mjs';
 import { cancelBackgroundTasks } from './runtime/shared/background-tasks.mjs';
+import { createTranscriptWriter } from './runtime/shared/transcript-writer.mjs';
+import { mixdogHome } from './runtime/shared/plugin-paths.mjs';
+import { checkLatestVersion, runGlobalUpdate, localPackageVersion } from './runtime/shared/update-checker.mjs';
 import {
   modelVisibleToolCompletionMessage,
   shouldPersistModelVisibleToolCompletion,
 } from './runtime/shared/tool-execution-contract.mjs';
+import {
+  channelNotificationModelContent,
+  shouldMirrorChannelNotificationToPending,
+} from './runtime/shared/channel-notification-routing.mjs';
 import {
   normalizeAgentPermissionOrNone,
   readMarkdownDocument,
@@ -25,6 +32,7 @@ import {
   PROVIDER_STATUS_TOOL,
   beginOAuthProviderLogin,
   forgetProviderAuth,
+  isKnownProvider,
   loginOAuthProvider,
   providerSetup,
   renderProviderStatus,
@@ -35,7 +43,10 @@ import {
 } from './standalone/provider-admin.mjs';
 import { createUsageDashboard } from './standalone/usage-dashboard.mjs';
 import { fetchOAuthUsageSnapshot } from './runtime/agent/orchestrator/providers/oauth-usage.mjs';
-import { getModelMetadataSync } from './runtime/agent/orchestrator/providers/model-catalog.mjs';
+import {
+  getModelMetadataSync,
+  warmCatalogsInBackground,
+} from './runtime/agent/orchestrator/providers/model-catalog.mjs';
 import {
   isResponsesFreeformTool,
   toResponsesCustomTool,
@@ -46,13 +57,16 @@ import {
   deleteSchedule,
   deleteWebhook,
   forgetDiscordToken,
+  forgetTelegramToken,
   forgetWebhookAuthtoken,
   renderChannelStatus,
   saveChannel,
   saveDiscordToken,
+  saveTelegramToken,
   saveSchedule,
   saveWebhook,
   saveWebhookAuthtoken,
+  setBackend,
   setScheduleEnabled,
   setWebhookEnabled,
   setWebhookConfig,
@@ -69,74 +83,11 @@ import {
   estimateRequestReserveTokens,
   estimateTranscriptContextUsage,
   estimateToolSchemaTokens,
+  resolveCompactBufferTokens,
+  resolveCompactTriggerTokens,
+  summarizeContextMessages,
 } from './runtime/agent/orchestrator/session/context-utils.mjs';
 
-// Default compaction buffer rules — kept in lockstep with the worker runtime
-// (loop.mjs resolveCompactBufferRatio / manager.mjs compactBufferRatioForSession
-// and compact.mjs compactionBufferTokensForBoundary). By default the trigger is
-// the effective compact boundary itself; explicit buffer settings can lower it.
-const CONTEXT_DEFAULT_BUFFER_RATIO = 0;
-const CONTEXT_MAX_BUFFER_RATIO = 0.25;
-const CONTEXT_LEGACY_DEFAULT_BUFFER_RATIO = 0.1;
-function resolveContextBufferRatio(cfg = {}) {
-  // Percent-named inputs (bufferPercent/bufferPct/*_BUFFER_PERCENT): a value of
-  // 1 means 1% (→0.01). Ratio-named inputs (bufferRatio/bufferFraction): 0.01
-  // means 1%, while a value > 1 is treated as a legacy percent (10 → 10%).
-  const candidates = [
-    [cfg.bufferPercent, true],
-    [cfg.bufferPct, true],
-    [cfg.bufferRatio, false],
-    [cfg.bufferFraction, false],
-    [process.env.MIXDOG_AGENT_COMPACT_BUFFER_PERCENT, true],
-    [process.env.MIXDOG_AGENT_COMPACT_BUFFER_RATIO, false],
-  ];
-  for (const [raw, isPercent] of candidates) {
-    const n = Number(raw);
-    if (!Number.isFinite(n) || n <= 0) continue;
-    return isPercent ? Math.min(1, n / 100) : (n > 1 ? n / 100 : n);
-  }
-  return CONTEXT_DEFAULT_BUFFER_RATIO;
-}
-function isLegacyDefaultContextBufferTelemetry(cfg = {}, boundaryTokens = 0) {
-  const boundary = Number(boundaryTokens);
-  if (!Number.isFinite(boundary) || boundary <= 0) return false;
-  if (Number(process.env.MIXDOG_AGENT_COMPACT_BUFFER_TOKENS) > 0) return false;
-  for (const envName of ['MIXDOG_AGENT_COMPACT_BUFFER_PERCENT', 'MIXDOG_AGENT_COMPACT_BUFFER_RATIO']) {
-    const n = Number(process.env[envName]);
-    if (Number.isFinite(n) && n > 0) return false;
-  }
-  for (const key of ['bufferPercent', 'bufferPct', 'bufferFraction']) {
-    const n = Number(cfg?.[key]);
-    if (Number.isFinite(n) && n > 0) return false;
-  }
-  const explicitTokens = Number(cfg?.bufferTokens ?? cfg?.buffer);
-  const ratio = Number(cfg?.bufferRatio);
-  if (!Number.isFinite(explicitTokens) || explicitTokens <= 0 || !Number.isFinite(ratio) || Math.abs(ratio - CONTEXT_LEGACY_DEFAULT_BUFFER_RATIO) > 1e-9) {
-    return false;
-  }
-  const expectedTokens = Math.floor(boundary * CONTEXT_LEGACY_DEFAULT_BUFFER_RATIO);
-  const cfgBoundary = Number(cfg?.boundaryTokens);
-  const cfgTrigger = Number(cfg?.triggerTokens);
-  return Math.floor(explicitTokens) === expectedTokens
-    || (Number.isFinite(cfgBoundary) && Math.floor(cfgBoundary) === Math.floor(boundary)
-      && Number.isFinite(cfgTrigger) && cfgTrigger > 0
-      && Math.floor(explicitTokens) === Math.max(0, Math.floor(boundary - cfgTrigger)));
-}
-function contextDefaultBufferTokens(boundaryTokens, cfg = {}) {
-  const boundary = Number(boundaryTokens);
-  if (!Number.isFinite(boundary) || boundary <= 0) return 0;
-  const effectiveCfg = isLegacyDefaultContextBufferTelemetry(cfg, boundary)
-    ? { ...cfg, bufferTokens: null, buffer: null, bufferRatio: null }
-    : cfg;
-  const cap = Math.max(0, Math.floor(boundary * CONTEXT_MAX_BUFFER_RATIO));
-  const explicit = Number(effectiveCfg.bufferTokens ?? effectiveCfg.buffer);
-  if (Number.isFinite(explicit) && explicit > 0) {
-    return Math.min(Math.floor(explicit), cap);
-  }
-  const ratio = resolveContextBufferRatio(effectiveCfg);
-  return Math.max(0, Math.min(Math.floor(boundary * ratio), cap));
-}
-
 function sessionMessageText(content) {
   if (content == null) return '';
   if (typeof content === 'string') return content;
@@ -153,10 +104,6 @@ function sessionMessageText(content) {
   try { return JSON.stringify(content); } catch { return String(content); }
 }
 
-function roughTokenCount(text) {
-  return Math.ceil(String(text ?? '').length / 4);
-}
-
 function messageContextText(message) {
   if (!message || typeof message !== 'object') return '';
   let text = sessionMessageText(message.content);
@@ -168,117 +115,6 @@ function messageContextText(message) {
   return text;
 }
 
-function stripSystemReminder(text) {
-  return String(text || '')
-    .replace(/^\s*<system-reminder>\s*/i, '')
-    .replace(/\s*<\/system-reminder>\s*$/i, '')
-    .trim();
-}
-
-function splitMarkdownSections(text) {
-  const sections = [];
-  let current = [];
-  for (const line of String(text || '').split(/\r?\n/)) {
-    if (/^#\s+/.test(line) && current.length) {
-      const body = current.join('\n').trim();
-      if (body) sections.push(body);
-      current = [line];
-    } else {
-      current.push(line);
-    }
-  }
-  const tail = current.join('\n').trim();
-  if (tail) sections.push(tail);
-  return sections;
-}
-
-function reminderSectionBucket(section) {
-  const heading = String(section.match(/^#\s+([^\n]+)/)?.[1] || '').trim().toLowerCase();
-  if (heading.includes('core memory')) return 'memory';
-  if (heading.includes('active workflow') || heading.includes('available agents') || heading.includes('workflow')) return 'workflow';
-  if (heading.includes('workspace')) return 'workspace';
-  if (heading.includes('environment')) return 'environment';
-  return 'other';
-}
-
-function summarizeContextMessages(messages) {
-  const rows = {
-    system: { count: 0, tokens: 0 },
-    user: { count: 0, tokens: 0 },
-    assistant: { count: 0, tokens: 0 },
-    tool: { count: 0, tokens: 0 },
-    other: { count: 0, tokens: 0 },
-  };
-  const semantic = {
-    system: { count: 0, tokens: 0 },
-    chat: { count: 0, tokens: 0 },
-    assistant: { count: 0, tokens: 0 },
-    toolResults: { count: 0, tokens: 0 },
-    reminders: { count: 0, tokens: 0, otherTokens: 0 },
-    workflow: { tokens: 0 },
-    memory: { tokens: 0 },
-    workspace: { tokens: 0 },
-    environment: { tokens: 0 },
-    other: { tokens: 0 },
-  };
-  let toolCallCount = 0;
-  let toolCallTokens = 0;
-  let toolResultCount = 0;
-  let toolResultTokens = 0;
-  for (const message of messages || []) {
-    const role = rows[message?.role] ? message.role : 'other';
-    const text = messageContextText(message);
-    const tokens = roughTokenCount(text) + 4;
-    rows[role].count += 1;
-    rows[role].tokens += tokens;
-    if (role === 'system') {
-      semantic.system.count += 1;
-      semantic.system.tokens += tokens;
-    } else if (role === 'user') {
-      if (String(text || '').trim().startsWith('<system-reminder>')) {
-        semantic.reminders.count += 1;
-        semantic.reminders.tokens += tokens;
-        let sectionTokens = 0;
-        for (const section of splitMarkdownSections(stripSystemReminder(text))) {
-          const bucket = reminderSectionBucket(section);
-          const sectionTokenCount = roughTokenCount(section);
-          semantic[bucket].tokens += sectionTokenCount;
-          sectionTokens += sectionTokenCount;
-        }
-        semantic.reminders.otherTokens += Math.max(0, tokens - sectionTokens);
-      } else {
-        semantic.chat.count += 1;
-        semantic.chat.tokens += tokens;
-      }
-    } else if (role === 'assistant') {
-      semantic.assistant.count += 1;
-      semantic.assistant.tokens += tokens;
-    } else if (role === 'tool') {
-      semantic.toolResults.count += 1;
-      semantic.toolResults.tokens += tokens;
-    }
-    if (message?.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
-      toolCallCount += message.toolCalls.length;
-      try { toolCallTokens += roughTokenCount(JSON.stringify(message.toolCalls)); }
-      catch { toolCallTokens += roughTokenCount(`[${message.toolCalls.length} tool calls]`); }
-    }
-    if (message?.role === 'tool') {
-      toolResultCount += 1;
-      toolResultTokens += tokens;
-    }
-  }
-  return {
-    count: Array.isArray(messages) ? messages.length : 0,
-    estimatedTokens: Array.isArray(messages) ? estimateMessagesTokens(messages) : 0,
-    roles: rows,
-    semantic,
-    toolCallCount,
-    toolCallTokens,
-    toolResultCount,
-    toolResultTokens,
-  };
-}
-
 function isSessionPreviewNoise(text) {
   const value = String(text || '').trim();
   return !value
@@ -317,6 +153,14 @@ const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(MIXDOG_HOME, 'da
 
 const DEFAULT_PROVIDER = 'anthropic-oauth';
 const DEFAULT_MODEL = '';
+
+// Resolve the provider to use when a route carries no explicit provider.
+// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
+function resolveDefaultProvider(config) {
+  const configured = clean(config?.defaultProvider);
+  if (configured && isKnownProvider(configured)) return configured;
+  return DEFAULT_PROVIDER;
+}
 const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
 const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
 const EFFORT_LABELS = {
@@ -566,9 +410,9 @@ const READONLY_TOOL_NAMES = new Set([
   'fetch',
   'Skill',
 ]);
-const AGENT_HIDDEN_WRAPPER_TOOLS = new Set(['search']);
+const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
 
-function applyStandaloneToolDefaults(tool) {
+export function __applyStandaloneToolDefaultsForTest(tool) {
   if (!tool || !AGENT_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;
   return {
     ...tool,
@@ -578,6 +422,7 @@ function applyStandaloneToolDefaults(tool) {
     },
   };
 }
+const applyStandaloneToolDefaults = __applyStandaloneToolDefaultsForTest;
 const DEFERRED_SELECT_ALIASES = {
   filesystem: ['read', 'list', 'grep', 'find', 'glob'],
   search: ['search', 'web_fetch'],
@@ -762,14 +607,18 @@ function modelMetaLooksResolved(meta) {
   return Object.keys(meta).some((key) => key !== 'id' && key !== 'provider');
 }
 
-const OUTPUT_STYLE_ORDER = ['default', 'simple', 'extreme-simple'];
+const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'oneline'];
 const OUTPUT_STYLE_ALIASES = new Map([
   ['compact', 'default'],
   ['normal', 'default'],
-  ['extreme', 'extreme-simple'],
-  ['extremesimple', 'extreme-simple'],
-  ['extreme-simple', 'extreme-simple'],
-  ['extreme_simple', 'extreme-simple'],
+  ['extreme', 'minimal'],
+  ['extremesimple', 'minimal'],
+  ['extreme-simple', 'minimal'],
+  ['extreme_simple', 'minimal'],
+  ['mono', 'oneline'],
+  ['oneline', 'oneline'],
+  ['one-line', 'oneline'],
+  ['one_line', 'oneline'],
 ]);
 
 function normalizeOutputStyleId(value) {
@@ -892,6 +741,49 @@ function readJsonSafe(path) {
   try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
 }
 
+// Standard Claude Code project-local MCP ingress: read `.mcp.json` from the
+// project root and return a cleaned { name: cfg } map. Best-effort — never
+// throws. Accepts either the standard `{ mcpServers: {...} }` shape or a bare
+// name->cfg map. Self-ref servers (`mixdog` / `trib-plugin`) are stripped for
+// parity with loadConfig (which strips them from the persisted agent section
+// but never sees `.mcp.json`). Inputs are not mutated.
+function readProjectMcpServers(cwd) {
+  const path = join(cwd || '.', '.mcp.json');
+  if (!existsSync(path)) return {};
+  let raw;
+  try {
+    raw = JSON.parse(readFileSync(path, 'utf8'));
+  } catch (error) {
+    process.stderr.write(`[mcp-client] Ignoring unparseable .mcp.json at ${path}: ${error?.message || String(error)}\n`);
+    return {};
+  }
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
+  const map = raw.mcpServers && typeof raw.mcpServers === 'object' && !Array.isArray(raw.mcpServers)
+    ? raw.mcpServers
+    : raw;
+  if (!map || typeof map !== 'object' || Array.isArray(map)) return {};
+  const out = {};
+  for (const [name, cfg] of Object.entries(map)) {
+    const key = clean(name);
+    if (!key) continue;
+    const lower = key.toLowerCase();
+    if (lower === 'mixdog' || lower === 'trib-plugin') continue;
+    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) continue;
+    // stdio entries (command + no url) spawn relative to the process launch
+    // dir, but mixdog tracks the project dir in memory (no process.chdir).
+    // Anchor their cwd to the .mcp.json directory: default when absent, resolve
+    // relative values against it, keep absolute values as-is. resolve(base, p)
+    // already returns `p` unchanged when it is absolute. Clone — never mutate.
+    const isStdio = typeof cfg.command === 'string' && cfg.command !== '' && !cfg.url;
+    if (isStdio) {
+      out[key] = { ...cfg, cwd: typeof cfg.cwd === 'string' && cfg.cwd ? resolve(cwd, cfg.cwd) : resolve(cwd) };
+    } else {
+      out[key] = cfg;
+    }
+  }
+  return out;
+}
+
 function countSkillFiles(root) {
   const skillsDir = join(root, 'skills');
   if (!existsSync(skillsDir)) return 0;
@@ -982,7 +874,7 @@ function resolveRoute(config, { provider, model, effort, fast } = {}) {
     }
   }
 
-  const p = explicitProvider || DEFAULT_PROVIDER;
+  const p = explicitProvider || resolveDefaultProvider(config);
   const m = explicitModel || DEFAULT_MODEL;
   const saved = modelSettingsFor(config, p, m);
   return {
@@ -1043,12 +935,9 @@ function normalizeSystemShellCommand(value) {
 function normalizeAutoClearConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
-  const compactType = clean(raw.compactType ?? raw.compact_type ?? raw.type);
-  const normalizedCompactType = compactType ? normalizeCompactTypeSetting(compactType, 'semantic') : '';
   return {
     enabled: raw.enabled !== false,
     idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
-    ...(normalizedCompactType ? { compactType: normalizedCompactType } : {}),
   };
 }
 
@@ -1238,7 +1127,12 @@ function routeForStatusline(route) {
   const preset = route.preset || {};
   if (preset.id) out.presetId = preset.id;
   if (preset.name) out.presetName = preset.name;
-  if (preset.modelDisplay) out.modelDisplay = preset.modelDisplay;
+  // Prefer the preset's curated label, then the route's resolved model display
+  // (set by refreshRouteEffort from the live/offline catalog). Without the
+  // route fallback, a preset-less direct model (e.g. claude-fable-5) reaches
+  // the statusline with no display and renders as the raw id.
+  const modelDisplay = clean(preset.modelDisplay) || clean(route.modelDisplay);
+  if (modelDisplay) out.modelDisplay = modelDisplay;
   if (route.fast === true || route.fast === false) out.fast = route.fast;
   else if (preset.fast === true || preset.fast === false) out.fast = preset.fast;
   if (route.effectiveEffort) {
@@ -1374,22 +1268,27 @@ function agentSourceDirs(dataDir, id) {
   ];
 }
 
-function readWorkflowPackFromDir(dir, source = 'built-in') {
-  const manifest = readJsonSafe(join(dir, 'workflow.json'));
-  if (!manifest || typeof manifest !== 'object') return null;
-  const id = normalizeWorkflowId(manifest.id || manifest.name);
-  if (!id) return null;
-  const entry = clean(manifest.entry) || 'WORKFLOW.md';
-  const body = readTextSafe(join(dir, entry));
+function readWorkflowPackFromDir(dir, source = 'built-in', dirName = '') {
+  const entry = 'WORKFLOW.md';
+  const doc = readMarkdownDocument(readTextSafe(join(dir, entry)));
+  const body = doc.body;
   if (!body) return null;
-  const agentsConfigured = Array.isArray(manifest.agents);
+  const fm = doc.frontmatter || {};
+  const id = normalizeWorkflowId(clean(fm.id) || dirName || basename(dir));
+  if (!id) return null;
+  const agentsConfigured = Object.prototype.hasOwnProperty.call(fm, 'agents');
   return {
     id,
-    name: clean(manifest.name) || id,
-    description: clean(manifest.description),
+    name: clean(fm.name) || id,
+    description: clean(fm.description),
     entry,
     agentsConfigured,
-    agents: agentsConfigured ? manifest.agents.map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent)).filter(Boolean) : [],
+    agents: agentsConfigured
+      ? String(fm.agents || '')
+          .split(',')
+          .map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent))
+          .filter(Boolean)
+      : [],
     body,
     source,
   };
@@ -1403,7 +1302,9 @@ function listWorkflowPacks(dataDir) {
     try { entries = readdirSync(root, { withFileTypes: true }); } catch { entries = []; }
     for (const entry of entries) {
       if (!entry.isDirectory()) continue;
-      const pack = readWorkflowPackFromDir(join(root, entry.name), source);
+      const dir = join(root, entry.name);
+      if (!existsSync(join(dir, 'WORKFLOW.md'))) continue;
+      const pack = readWorkflowPackFromDir(dir, source, entry.name);
       if (pack) byId.set(pack.id, pack);
     }
   }
@@ -1421,10 +1322,10 @@ function activeWorkflowId(config) {
 function loadWorkflowPack(dataDir, id) {
   const wanted = normalizeWorkflowId(id, DEFAULT_WORKFLOW_ID);
   for (const { root, source } of workflowSourceDirs(dataDir).reverse()) {
-    const pack = readWorkflowPackFromDir(join(root, wanted), source);
+    const pack = readWorkflowPackFromDir(join(root, wanted), source, wanted);
     if (pack) return pack;
   }
-  return readWorkflowPackFromDir(join(STANDALONE_ROOT, 'workflows', DEFAULT_WORKFLOW_ID), 'built-in');
+  return readWorkflowPackFromDir(join(STANDALONE_ROOT, 'workflows', DEFAULT_WORKFLOW_ID), 'built-in', DEFAULT_WORKFLOW_ID);
 }
 
 function workflowSummary(pack) {
@@ -1579,10 +1480,15 @@ function upsertWorkflowPreset(presets, slot, routeLike) {
 
 function summarizeWorkflowRoutes(config) {
   const routes = config?.workflowRoutes && typeof config.workflowRoutes === 'object' ? config.workflowRoutes : {};
+  const fallbackProvider = resolveDefaultProvider(config);
   const out = {};
   for (const slot of WORKFLOW_ROUTE_SLOTS) {
     const route = routes[slot];
-    if (route?.provider && route?.model) out[slot] = normalizeWorkflowRoute(route);
+    // Read/interpret path: a route with a model but no provider falls back to
+    // config.defaultProvider (then DEFAULT_PROVIDER).
+    if (route?.model && (route?.provider || fallbackProvider)) {
+      out[slot] = normalizeWorkflowRoute(route, { provider: fallbackProvider });
+    }
   }
   return out;
 }
@@ -1602,13 +1508,16 @@ function routeFromPreset(config, slotValue) {
 function agentRouteFromConfig(config, agentId, _dataDir) {
   const id = normalizeAgentId(agentId);
   if (!id) return null;
-  const explicit = normalizeWorkflowRoute(config?.agents?.[id])
-    || (id === 'maintainer' ? normalizeWorkflowRoute(config?.agents?.maintenance) : null);
+  // Read/interpret path: inject config.defaultProvider (then DEFAULT_PROVIDER)
+  // when a stored route omits its provider.
+  const fallback = { provider: resolveDefaultProvider(config) };
+  const explicit = normalizeWorkflowRoute(config?.agents?.[id], fallback)
+    || (id === 'maintainer' ? normalizeWorkflowRoute(config?.agents?.maintenance, fallback) : null);
   if (explicit) return explicit;
 
   const agent = FIXED_AGENT_SLOTS.find((item) => item.id === id);
   if (agent?.workflowSlot) {
-    const workflowRoute = normalizeWorkflowRoute(config?.workflowRoutes?.[agent.workflowSlot]);
+    const workflowRoute = normalizeWorkflowRoute(config?.workflowRoutes?.[agent.workflowSlot], fallback);
     if (workflowRoute) return workflowRoute;
   }
 
@@ -2182,8 +2091,17 @@ export async function createMixdogSessionRuntime({
   model,
   cwd = process.cwd(),
   toolMode = 'full',
+  remote = false,
 } = {}) {
   bootProfile('session-runtime:start', { provider, model, toolMode, cwd });
+  let remoteEnabled = remote === true;
+  // Remote-mode transcript writer (Discord outbound). Lazily created per
+  // session.id + cwd inside ask(); only active while remoteEnabled.
+  let _transcriptWriter = null;
+  let _twKey = '';
+  // Last assistant text handed to the transcript writer (via onAssistantText),
+  // so the post-turn final-content append can skip an exact duplicate.
+  let _lastAppendedAssistant = '';
   process.env.MIXDOG_QUIET_SESSION_LOG ??= '1';
   const standaloneStartedAt = performance.now();
   ensureStandaloneEnvironment({
@@ -2590,9 +2508,11 @@ export async function createMixdogSessionRuntime({
   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 = '';
@@ -2622,6 +2542,7 @@ export async function createMixdogSessionRuntime({
   }
   const sessionPrewarmDelayMs = envDelayMs('MIXDOG_SESSION_PREWARM_DELAY_MS', 50, { min: 0, max: 10_000 });
   const providerSetupWarmupDelayMs = envDelayMs('MIXDOG_PROVIDER_SETUP_WARMUP_DELAY_MS', 300, { min: 0, max: 60_000 });
+  const modelCatalogWarmupDelayMs = envDelayMs('MIXDOG_MODEL_CATALOG_WARMUP_DELAY_MS', 200, { min: 0, max: 60_000 });
   const providerWarmupDelayMs = envDelayMs('MIXDOG_PROVIDER_WARMUP_DELAY_MS', 1_500, { min: 0, max: 60_000 });
   // Background model-catalog prefetch delay. Kept short so the first `/model`
   // open finds a warm cache instead of paying a cold full network load. The
@@ -2655,6 +2576,7 @@ export async function createMixdogSessionRuntime({
   const modelPrefetchEnabled = !envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')
     && !envFlag('MIXDOG_DISABLE_MODEL_PREFETCH');
   const codeGraphPrewarmEnabled = !envFlag('MIXDOG_DISABLE_CODE_GRAPH_PREWARM');
+  const modelCatalogWarmupEnabled = !envFlag('MIXDOG_DISABLE_MODEL_CATALOG_WARMUP');
   // Lazy code-graph prewarm (default ON): do NOT prewarm at startup / on cwd
   // change — that fired ~250ms after the first frame and, in a large tree,
   // burned a worker (and felt like a freeze) before the user did anything.
@@ -2667,8 +2589,8 @@ export async function createMixdogSessionRuntime({
   const notificationListeners = new Set();
   let providerModelsCache = { models: null, at: 0 };
   let providerModelsPromise = null;
+  let providerModelsLoadSeq = 0;
   let searchProviderModelsCache = { models: null, at: 0 };
-  let searchProviderModelsPromise = null;
   let usageDashboardCache = { dashboard: null, at: 0 };
   let usageDashboardPromise = null;
   let providerSetupCache = { setup: null, at: 0 };
@@ -2676,6 +2598,9 @@ export async function createMixdogSessionRuntime({
   let providerSetupPromise = null;
   let providerInitPromise = null;
   let mcpFailures = [];
+  let lastProjectMcpKey = null;
+  let mcpConnectGeneration = 0;
+  let mcpConnectInFlight = null;
   let preSessionToolSurface = null;
   let contextStatusCacheKey = null;
   let contextStatusCacheValue = null;
@@ -2684,11 +2609,87 @@ export async function createMixdogSessionRuntime({
   hooks.emit('runtime:start', { cwd: currentCwd, provider: route.provider, model: route.model, toolMode: mode });
   bootProfile('hooks:ready', { ms: (performance.now() - hooksStartedAt).toFixed(1) });
 
+  // ---------------------------------------------------------------------
+  // Self-update (npm registry version check + optional auto-install).
+  // updateCheckState mirrors the last-known checkLatestVersion() result;
+  // updateProcessState tracks the in-flight install lifecycle so the TUI can
+  // poll getUpdateStatus() instead of needing a push/event channel. Both are
+  // purely in-memory (per runtime instance) — the on-disk cache lives inside
+  // update-checker.mjs and is what actually enforces the 24h TTL.
+  let updateCheckState = {
+    currentVersion: null,
+    latestVersion: null,
+    updateAvailable: false,
+    lastCheckedAt: 0,
+  };
+  // phase: 'idle' | 'checking' | 'installing' | 'installed' | 'failed'
+  let updateProcessState = { phase: 'idle', version: null, error: null };
+
+  function autoUpdateEnabled() {
+    return config?.update?.auto === true;
+  }
+
+  async function checkForUpdateInternal({ force = false } = {}) {
+    if (updateProcessState.phase !== 'installing') updateProcessState.phase = 'checking';
+    try {
+      const result = await checkLatestVersion({ force, dataDir: cfgMod.getPluginData?.() || STANDALONE_DATA_DIR });
+      updateCheckState = {
+        currentVersion: result.currentVersion,
+        latestVersion: result.latestVersion,
+        updateAvailable: result.updateAvailable,
+        lastCheckedAt: result.lastCheckedAt,
+      };
+    } catch {
+      // checkLatestVersion() is already silent-safe; this catch is belt-and-
+      // braces so a boot-time call can never crash the runtime.
+    } finally {
+      if (updateProcessState.phase === 'checking') updateProcessState.phase = 'idle';
+    }
+    return updateCheckState;
+  }
+
+  async function runUpdateNowInternal() {
+    if (updateProcessState.phase === 'installing') {
+      return { ...updateProcessState, alreadyInstalling: true, error: 'update already in progress' };
+    }
+    updateProcessState = { phase: 'installing', version: null, error: null };
+    try {
+      const result = await runGlobalUpdate();
+      if (result?.ok) {
+        updateProcessState = { phase: 'installed', version: result.version || null, error: null };
+      } else {
+        updateProcessState = { phase: 'failed', version: null, error: result?.error || 'update failed' };
+      }
+    } catch (err) {
+      updateProcessState = { phase: 'failed', version: null, error: err?.message || String(err) };
+    }
+    return updateProcessState;
+  }
+
+  // Non-blocking boot hook: fires after the runtime object below is fully
+  // constructed (setTimeout(0) defers past the synchronous return), so a
+  // slow/hanging registry request or npm install can never delay session
+  // boot. Auto-update defaults to OFF (config.update.auto is undefined until
+  // 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.
+  const updateBootTimer = setTimeout(() => {
+    void (async () => {
+      await checkForUpdateInternal({ force: false });
+      if (autoUpdateEnabled() && updateCheckState.updateAvailable) {
+        await runUpdateNowInternal();
+      }
+    })().catch(() => {});
+  }, 0);
+  updateBootTimer.unref?.();
+
   function mcpTransportLabel(cfg = {}) {
     if (cfg.autoDetect) return `autoDetect:${cfg.autoDetect}`;
-    if (cfg.transport === 'http' || cfg.url) return 'http';
-    if (cfg.command) return 'stdio';
-    return 'unknown';
+    try {
+      return mcpClient.resolveMcpTransportKind(cfg);
+    } catch {
+      return 'unknown';
+    }
   }
 
   function emitRuntimeNotification(content, meta = {}) {
@@ -2733,9 +2734,7 @@ export async function createMixdogSessionRuntime({
   }
 
   function mcpStatus() {
-    const configured = config?.mcpServers && typeof config.mcpServers === 'object'
-      ? config.mcpServers
-      : {};
+    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 = [];
@@ -2752,6 +2751,7 @@ export async function createMixdogSessionRuntime({
         toolCount: live?.toolCount || 0,
         tools: live?.tools || [],
         error: fail?.msg || null,
+        source: sources[name] || 'config',
       });
       connected.delete(name);
     }
@@ -2866,6 +2866,21 @@ export async function createMixdogSessionRuntime({
     } 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 {}
+    }
     return currentCwd;
   }
 
@@ -2879,17 +2894,23 @@ export async function createMixdogSessionRuntime({
   }
 
   function skillContent(name) {
-    const content = typeof contextMod.loadSkillContent === 'function'
-      ? contextMod.loadSkillContent(name, currentCwd)
+    const res = typeof contextMod.loadSkillResource === 'function'
+      ? contextMod.loadSkillResource(name, currentCwd)
       : null;
-    if (!content) throw new Error(`skill not found: ${name}`);
-    return { name, content };
+    if (!res) throw new Error(`skill not found: ${name}`);
+    return { name, content: res.content, dir: res.dir };
   }
 
   function skillToolContent(name) {
     const skill = skillContent(name);
-    const escapedName = String(skill.name || '').replace(/[<>&]/g, (ch) => ({ '<': '&lt;', '>': '&gt;', '&': '&amp;' }[ch]));
-    return `<skill>\n<name>${escapedName}</name>\n${skill.content}\n</skill>`;
+    // Return the general tool envelope so the main/Lead session behaves the
+    // same as agent-loop sessions: the model-visible tool_result is the short
+    // stub (`Loaded skill: <name>`) and the full SKILL.md body is delivered
+    // ONCE as a separate injected role:'user' message (newMessages). The
+    // envelope passes through internal-tools._normalize untouched (it preserves
+    // __toolEnvelope objects), and the agent loop's central normalizeToolEnvelope
+    // splits it into stub + injected user body.
+    return contextMod.buildSkillToolEnvelope(skill.name, skill.content, skill.dir);
   }
 
   function addProjectSkill(input = {}) {
@@ -2964,19 +2985,52 @@ export async function createMixdogSessionRuntime({
     };
   }
 
-  async function connectConfiguredMcp({ reset = false } = {}) {
-    if (reset) await mcpClient.disconnectAll?.();
-    mcpFailures = [];
-    const servers = config?.mcpServers && typeof config.mcpServers === 'object'
+  // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
+  // On name collision the mixdog-config entry WINS. `sources[name]` records
+  // each server's origin ('config' | 'project') for status reporting.
+  function resolveEffectiveMcpServers() {
+    const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
       : {};
-    if (Object.keys(servers).length === 0) return mcpStatus();
+    const project = readProjectMcpServers(currentCwd);
+    const servers = { ...project, ...configured };
+    const sources = {};
+    for (const name of Object.keys(project)) sources[name] = 'project';
+    for (const name of Object.keys(configured)) sources[name] = 'config';
+    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 mcpClient.connectMcpServers(servers);
-    } catch (error) {
-      mcpFailures = Array.isArray(error?.failures)
-        ? error.failures
-        : [{ name: 'mcp', msg: error?.message || String(error) }];
+      await run;
+    } finally {
+      if (mcpConnectInFlight === run) mcpConnectInFlight = null;
     }
     return mcpStatus();
   }
@@ -2984,10 +3038,42 @@ export async function createMixdogSessionRuntime({
   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: { transport: 'http', url } };
+      return { name, config: withOptionalHeaders({ type: 'http', url }) };
     }
     const command = clean(input.command);
     if (!command) throw new Error('MCP server command or URL is required');
@@ -3001,7 +3087,10 @@ export async function createMixdogSessionRuntime({
     if (resolvedCwd !== root && !resolvedCwd.startsWith(`${root}\\`) && !resolvedCwd.startsWith(`${root}/`)) {
       throw new Error('MCP server cwd must stay under the current project');
     }
-    return { name, config: { command, args, cwd: resolvedCwd } };
+    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();
@@ -3035,10 +3124,12 @@ export async function createMixdogSessionRuntime({
       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 : {};
-      if (meta.silent_to_agent === true || meta.silent_to_agent === 'true') return;
-      const instruction = typeof meta.instruction === 'string' ? meta.instruction.trim() : '';
-      const content = instruction || String(params.content || '').trim();
-      emitRuntimeNotification(content, meta);
+      const content = channelNotificationModelContent(params);
+      if (!content) return;
+      const handled = emitRuntimeNotification(content, meta);
+      if (!handled && session?.id && shouldMirrorChannelNotificationToPending(meta)) {
+        try { mgr.enqueuePendingMessage(session.id, content); } catch {}
+      }
     },
   });
   bootProfile('channels:worker-ready', { ms: (performance.now() - channelsStartedAt).toFixed(1) });
@@ -3169,6 +3260,7 @@ export async function createMixdogSessionRuntime({
     },
   });
   internalTools.markBootReady?.();
+  try { lastProjectMcpKey = resolve(currentCwd) + '\u0000' + JSON.stringify(readProjectMcpServers(currentCwd)); } catch { lastProjectMcpKey = null; }
   void connectConfiguredMcp()
     .then((status) => bootProfile('mcp:ready', {
       connected: Number(status?.connectedCount || 0),
@@ -3183,8 +3275,8 @@ export async function createMixdogSessionRuntime({
   function invalidateProviderCaches() {
     providerModelsCache = { models: null, at: 0 };
     providerModelsPromise = null;
+    providerModelsLoadSeq += 1;
     searchProviderModelsCache = { models: null, at: 0 };
-    searchProviderModelsPromise = null;
     usageDashboardCache = { dashboard: null, at: 0 };
     usageDashboardPromise = null;
     providerSetupCache = { setup: null, at: 0 };
@@ -3631,17 +3723,11 @@ function parsedProviderModelVersion(id) {
       searchProviderModelsCache = { models: rows, at: Date.now() };
       return providerModelsFromCacheRows(rows);
     }
-    if (!searchProviderModelsPromise) {
-      searchProviderModelsPromise = loadSearchProviderModelsFresh()
-        .then((models) => {
-          searchProviderModelsCache = { models, at: Date.now() };
-          return models;
-        })
-        .finally(() => {
-          searchProviderModelsPromise = null;
-        });
+    if (force) {
+      const models = await loadSearchProviderModelsFresh({ forceRefresh: true });
+      searchProviderModelsCache = { models, at: Date.now() };
+      return providerModelsFromCacheRows(models);
     }
-    return providerModelsFromCacheRows(await searchProviderModelsPromise);
   }
 
   function enabledSearchProviderConfig() {
@@ -3655,7 +3741,7 @@ function parsedProviderModelVersion(id) {
     return out;
   }
 
-  async function loadSearchProviderModelsFresh() {
+  async function loadSearchProviderModelsFresh({ forceRefresh = false } = {}) {
     const searchProviders = enabledSearchProviderConfig();
     const providerNames = Object.keys(searchProviders);
     if (!providerNames.length) return [];
@@ -3664,7 +3750,13 @@ function parsedProviderModelVersion(id) {
       const provider = reg.getProvider(name);
       if (typeof provider?.listModels !== 'function') return [];
       try {
-        const models = await provider.listModels();
+        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) {
@@ -3698,14 +3790,20 @@ function parsedProviderModelVersion(id) {
     return results;
   }
 
-  async function loadProviderModelsFresh() {
+  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 {
-        const models = await provider.listModels();
+        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) {
@@ -3740,10 +3838,17 @@ function parsedProviderModelVersion(id) {
       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) => {
-          providerModelsCache = { models, at: Date.now() };
+          if (seq === providerModelsLoadSeq) providerModelsCache = { models, at: Date.now() };
           return models;
         })
         .finally(() => {
@@ -3755,9 +3860,10 @@ function parsedProviderModelVersion(id) {
 
   function warmProviderModelCache() {
     if (Array.isArray(providerModelsCache.models) || providerModelsPromise) return providerModelsPromise;
+    const seq = ++providerModelsLoadSeq;
     providerModelsPromise = loadProviderModelsFresh()
       .then((models) => {
-        providerModelsCache = { models, at: Date.now() };
+        if (seq === providerModelsLoadSeq) providerModelsCache = { models, at: Date.now() };
         bootProfile('provider-models:warm-ready', { count: models.length });
         return models;
       })
@@ -3794,12 +3900,22 @@ function parsedProviderModelVersion(id) {
     const requested = hasOwn(route, 'effort') ? route.effort : (route.preset?.effort || null);
     const effectiveEffort = coerceEffortFor(route.provider, modelMeta, requested);
     const fastCapable = fastCapableFor(route.provider, modelMeta);
+    // Carry the catalog display name onto the route so the statusline shows a
+    // human label (e.g. "Claude Fable 5") for preset-less direct models instead
+    // of the raw id. `name` is only trusted when it differs from the raw model
+    // id (some providers echo the id as `name`), so it can't clobber a better
+    // already-resolved label. Falls back to existing route.modelDisplay, then unset.
+    const metaName = clean(modelMeta?.name);
+    const modelDisplay = clean(modelMeta?.display) || clean(modelMeta?.displayName)
+      || (metaName && metaName !== clean(route.model) ? metaName : '')
+      || clean(route.modelDisplay);
     route = {
       ...route,
       fast: fastCapable ? route.fast === true : false,
       fastCapable,
       effectiveEffort,
       effortOptions: effortItemsFor(route.provider, modelMeta, effectiveEffort),
+      ...(modelDisplay ? { modelDisplay } : {}),
     };
     return route;
   }
@@ -3857,7 +3973,7 @@ function parsedProviderModelVersion(id) {
         preset: route.preset || undefined,
         tools: toolSpecForMode(mode),
         owner: 'cli',
-        role: 'lead',
+        agent: 'lead',
         lane: 'cli',
         sourceType: 'lead',
         sourceName: 'main',
@@ -4021,6 +4137,27 @@ function parsedProviderModelVersion(id) {
     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?.();
+  }
+
   function scheduleStatuslineUsageWarmup(delayMs = statuslineUsageWarmupDelayMs) {
     const providerId = clean(route?.provider);
     if (!providerId || !providerId.includes('oauth')) {
@@ -4081,6 +4218,22 @@ function parsedProviderModelVersion(id) {
     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');
@@ -4090,28 +4243,59 @@ function parsedProviderModelVersion(id) {
       bootProfile('channels:start-disabled');
       return;
     }
-    if (channelStartTimer || closeRequested) return;
+    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;
       }
-      const startedAt = performance.now();
-      bootProfile('channels:start:begin');
-      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),
-        }));
+      void invokeChannelStart();
     }, delayMs);
     channelStartTimer.unref?.();
   }
 
+  // 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.
+  function startRemote() {
+    remoteEnabled = true;
+    if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
+      bootProfile('channels:start-skipped');
+      return true;
+    }
+    if (!channelsEnabled()) {
+      bootProfile('channels:start-disabled');
+      return true;
+    }
+    if (closeRequested) return true;
+    if (channelStartTimer) {
+      clearTimeout(channelStartTimer);
+      channelStartTimer = null;
+    }
+    bootProfile('channels:start-scheduled', { delayMs: 0, immediate: true });
+    void invokeChannelStart();
+    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; }
+    channels.stop(reason || 'remote-disabled', { waitForExit: false }).catch(() => {});
+    return true;
+  }
+
+  function isRemoteEnabled() {
+    return remoteEnabled;
+  }
+
   function withTeardownDeadline(promise, ms, fallback = false) {
     let timer = null;
     return Promise.race([
@@ -4139,6 +4323,7 @@ function parsedProviderModelVersion(id) {
     bootProfile('code-graph:prewarm-lazy', { reason: 'startup-deferred-to-first-turn' });
   }
   scheduleProviderSetupWarmup();
+  scheduleModelCatalogWarmup();
   scheduleProviderWarmup();
   // Warm the provider model catalog in the background, but keep it on its own
   // delay so short-lived detached runtimes can exit before /models I/O starts.
@@ -4146,7 +4331,10 @@ function parsedProviderModelVersion(id) {
   // MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS explicitly.
   scheduleProviderModelWarmup();
   scheduleStatuslineUsageWarmup();
-  scheduleChannelStart();
+  // Channels are opt-in: only boot the worker when this session started in (or
+  // was toggled into) remote mode. Non-remote sessions never contend for the
+  // channel; see startRemote()/stopRemote() and the `/remote` toggle.
+  if (remoteEnabled) startRemote();
 
   function contextStatusCacheKeyFor({ messages, tools }) {
     const compaction = session?.compaction || {};
@@ -4173,10 +4361,12 @@ function parsedProviderModelVersion(id) {
       lastContextTokensUpdatedAt: Number(session?.lastContextTokensUpdatedAt || 0),
       lastContextTokensStaleAfterCompact: session?.lastContextTokensStaleAfterCompact === true,
       lastInputTokens: Number(session?.lastInputTokens || 0),
+      lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
       lastOutputTokens: Number(session?.lastOutputTokens || 0),
       lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
       lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
       totalInputTokens: Number(session?.totalInputTokens || 0),
+      totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
       totalOutputTokens: Number(session?.totalOutputTokens || 0),
       totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
       totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
@@ -4299,38 +4489,13 @@ function parsedProviderModelVersion(id) {
       // the gauge numerator.
       const usedTokens = estimatedContextTokens;
       const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
-      const autoCompactTokenLimit = Number(session?.autoCompactTokenLimit || 0);
-      // The runtime fires auto-compaction at the effective boundary by default.
-      // Compute the same trigger here so /context shows what will actually fire
-      // before any compaction telemetry (session.compaction.triggerTokens) is
-      // recorded. Explicit buffer settings can still lower the trigger.
-      // An explicit autoCompactTokenLimit (provider/catalog/seed supplied)
-      // still takes precedence and is honored verbatim when it sits at or below
-      // the boundary.
-      const defaultCompactBufferTokens = contextDefaultBufferTokens(compactBoundaryTokens, session?.compaction || {});
-      const defaultCompactTriggerTokens = compactBoundaryTokens
-        ? Math.max(1, compactBoundaryTokens - defaultCompactBufferTokens)
-        : 0;
-      // Only an explicit auto-compact limit STRICTLY BELOW the boundary is a
-      // real trigger; a persisted value == boundary is a legacy derived
-      // full-window artifact and must fall through to the default trigger.
-      // Likewise ignore persisted default-buffer telemetry so the displayed
-      // trigger matches what the runtime now actually fires.
-      const persistedTriggerTokens = Number(session?.compaction?.triggerTokens || 0);
-      const legacyDefaultTriggerTelemetry = isLegacyDefaultContextBufferTelemetry(session?.compaction || {}, compactBoundaryTokens)
-        && persistedTriggerTokens > 0
-        && persistedTriggerTokens < compactBoundaryTokens;
-      const usablePersistedTrigger = persistedTriggerTokens > 0
-        && !legacyDefaultTriggerTelemetry
-        && (!compactBoundaryTokens || persistedTriggerTokens < compactBoundaryTokens)
-        ? persistedTriggerTokens
-        : 0;
-      const compactTriggerTokens = autoCompactTokenLimit && compactBoundaryTokens && autoCompactTokenLimit < compactBoundaryTokens
-        ? autoCompactTokenLimit
-        : (usablePersistedTrigger || defaultCompactTriggerTokens || 0);
-      const compactBufferTokens = Number(compactBoundaryTokens && compactTriggerTokens
+      // Use the same shared compact-policy math as manager/loop. Do not trust
+      // persisted trigger telemetry as an independent policy input: it is an
+      // output snapshot and was the source of repeated /context false positives.
+      const compactTriggerTokens = resolveCompactTriggerTokens(session || {}, compactBoundaryTokens) || 0;
+      const compactBufferTokens = compactBoundaryTokens
         ? Math.max(0, compactBoundaryTokens - compactTriggerTokens)
-        : defaultCompactBufferTokens);
+        : resolveCompactBufferTokens(compactBoundaryTokens, session?.compaction || {});
       const value = {
         sessionId: session?.id || null,
         provider: route.provider,
@@ -4365,11 +4530,13 @@ function parsedProviderModelVersion(id) {
         },
         usage: {
           lastInputTokens: Number(session?.lastInputTokens || 0),
+          lastUncachedInputTokens: Number(session?.lastUncachedInputTokens || 0),
           lastOutputTokens: Number(session?.lastOutputTokens || 0),
           lastCachedReadTokens: Number(session?.lastCachedReadTokens || 0),
           lastCacheWriteTokens: Number(session?.lastCacheWriteTokens || 0),
           lastContextTokens,
           totalInputTokens: Number(session?.totalInputTokens || 0),
+          totalUncachedInputTokens: Number(session?.totalUncachedInputTokens || 0),
           totalOutputTokens: Number(session?.totalOutputTokens || 0),
           totalCachedReadTokens: Number(session?.totalCachedReadTokens || 0),
           totalCacheWriteTokens: Number(session?.totalCacheWriteTokens || 0),
@@ -4445,6 +4612,21 @@ function parsedProviderModelVersion(id) {
         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);
     },
@@ -4546,7 +4728,9 @@ function parsedProviderModelVersion(id) {
         }
         await channels.stop('settings-disabled', { waitForExit: false }).catch(() => {});
       } else {
-        scheduleChannelStart(0);
+        // 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();
@@ -4581,14 +4765,57 @@ function parsedProviderModelVersion(id) {
       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 };
+    },
     async completeOnboarding(payload = {}) {
-      const defaultRoute = normalizeWorkflowRoute(payload.defaultRoute, route);
+      // Only fall back to the live runtime route when the caller actually sent a
+      // defaultRoute. The onboarding "partial save" path (Main left unset, only
+      // Search/agent picks) omits defaultRoute entirely and must NOT persist the
+      // current route as Main or recreate the session.
+      const defaultRoute = hasOwn(payload, 'defaultRoute')
+        ? normalizeWorkflowRoute(payload.defaultRoute, route)
+        : null;
       const workflowInput = payload.workflowRoutes && typeof payload.workflowRoutes === 'object'
         ? payload.workflowRoutes
         : {};
       const nextConfig = { ...config };
+      if (hasOwn(payload, 'defaultProvider')) {
+        const requested = clean(payload.defaultProvider);
+        if (requested) {
+          if (!isKnownProvider(requested)) throw new Error(`unknown provider "${payload.defaultProvider}"`);
+          nextConfig.defaultProvider = requested;
+        }
+      }
       let presets = Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [];
       const workflowRoutes = { ...(nextConfig.workflowRoutes || {}) };
+      // Track slots actually written THIS call so maintenance mirroring never
+      // clobbers an existing slot the payload did not touch.
+      const touchedWorkflowSlots = new Set();
 
       if (defaultRoute) {
         presets = upsertWorkflowPreset(presets, 'lead', defaultRoute);
@@ -4601,18 +4828,51 @@ function parsedProviderModelVersion(id) {
         if (!normalized) continue;
         workflowRoutes[slot] = normalized;
         presets = upsertWorkflowPreset(presets, slot, normalized);
+        touchedWorkflowSlots.add(slot);
       }
 
       nextConfig.presets = presets;
       nextConfig.workflowRoutes = workflowRoutes;
-      // Maintenance slots store a direct {provider, model} route. Reuse the
-      // onboarding workflow routes directly; only overwrite a slot when its
-      // workflow route was actually provided, otherwise keep the existing slot.
+      // Maintenance slots store a direct {provider, model} route. Only mirror a
+      // slot that was actually written this call (touchedWorkflowSlots); an
+      // untouched slot keeps its existing maintenance value.
       nextConfig.maintenance = {
         ...(nextConfig.maintenance || {}),
-        ...(workflowRoutes.explorer ? { explore: normalizeWorkflowRoute(workflowRoutes.explorer) } : {}),
-        ...(workflowRoutes.memory ? { memory: normalizeWorkflowRoute(workflowRoutes.memory) } : {}),
+        ...(touchedWorkflowSlots.has('explorer') ? { explore: normalizeWorkflowRoute(workflowRoutes.explorer) } : {}),
+        ...(touchedWorkflowSlots.has('memory') ? { memory: normalizeWorkflowRoute(workflowRoutes.memory) } : {}),
       };
+      // Per-agent onboarding routes (id → route) for the full FIXED_AGENT_SLOTS
+      // roster. Mirrors setAgentRoute persistence: config.agents[id], an
+      // agent-<id> preset, and (for workflow-backed agents) the workflowRoute +
+      // maintenance slot. Agents omitted from the payload inherit defaultRoute.
+      const agentInput = payload.agentRoutes && typeof payload.agentRoutes === 'object'
+        ? payload.agentRoutes
+        : null;
+      if (agentInput) {
+        const nextAgents = { ...(nextConfig.agents || {}) };
+        const nextMaintenance = { ...(nextConfig.maintenance || {}) };
+        for (const agent of FIXED_AGENT_SLOTS) {
+          // Persist ONLY agents with an explicit override in the payload. An
+          // omitted agent is left untouched (existing value preserved, or
+          // unwritten so the runtime dynamically follows the Main Model). Never
+          // fall back to defaultRoute here — that would overwrite an agent the
+          // user did not choose.
+          const routeToSave = normalizeWorkflowRoute(agentInput[agent.id]);
+          if (!routeToSave) continue;
+          nextAgents[agent.id] = routeToSave;
+          presets = upsertWorkflowPreset(presets, agentPresetSlot(agent.id), routeToSave);
+          if (agent.workflowSlot) {
+            workflowRoutes[agent.workflowSlot] = routeToSave;
+            presets = upsertWorkflowPreset(presets, agent.workflowSlot, routeToSave);
+            if (agent.id === 'explore') nextMaintenance.explore = routeToSave;
+            if (agent.id === 'maintainer') nextMaintenance.memory = routeToSave;
+          }
+        }
+        nextConfig.agents = nextAgents;
+        nextConfig.presets = presets;
+        nextConfig.workflowRoutes = workflowRoutes;
+        nextConfig.maintenance = nextMaintenance;
+      }
       nextConfig.onboarding = {
         ...(nextConfig.onboarding || {}),
         completed: true,
@@ -4620,6 +4880,14 @@ function parsedProviderModelVersion(id) {
         completedAt: new Date().toISOString(),
       };
 
+      // Optional native web-search route. Only persisted when provided; mirrors
+      // setSearchRoute's config write (skip provider capability validation here
+      // since onboarding routes come from the vetted provider model list).
+      if (payload.searchRoute) {
+        const searchToSave = normalizeSearchRouteConfig(payload.searchRoute);
+        if (searchToSave) nextConfig.searchRoute = searchToSave;
+      }
+
       saveConfigAndAdopt(nextConfig);
       if (defaultRoute) {
         route = resolveRoute(config, { provider: defaultRoute.provider, model: defaultRoute.model, effort: defaultRoute.effort });
@@ -4634,6 +4902,15 @@ function parsedProviderModelVersion(id) {
     getChannelWorkerStatus() {
       return channels.status();
     },
+    startRemote() {
+      return startRemote();
+    },
+    stopRemote(reason) {
+      return stopRemote(reason);
+    },
+    isRemoteEnabled() {
+      return isRemoteEnabled();
+    },
     saveDiscordToken(token) {
       const result = saveDiscordToken(token);
       reloadChannelsSoon();
@@ -4644,6 +4921,20 @@ function parsedProviderModelVersion(id) {
       reloadChannelsSoon();
       return result;
     },
+    saveTelegramToken(token) {
+      const result = saveTelegramToken(token);
+      reloadChannelsSoon();
+      return result;
+    },
+    forgetTelegramToken() {
+      const result = forgetTelegramToken();
+      reloadChannelsSoon();
+      return result;
+    },
+    setBackend(name) {
+      const result = setBackend(name);
+      return result;
+    },
     saveWebhookAuthtoken(token) {
       const result = saveWebhookAuthtoken(token);
       reloadChannelsSoon();
@@ -4933,6 +5224,13 @@ function parsedProviderModelVersion(id) {
       saveConfigAndAdopt(nextConfig);
       return routeToSave;
     },
+    async setDefaultProvider(provider) {
+      const requested = clean(provider);
+      if (!requested) throw new Error('provider is required');
+      if (!isKnownProvider(requested)) throw new Error(`unknown provider "${provider}"`);
+      saveConfigAndAdopt({ ...config, defaultProvider: requested });
+      return requested;
+    },
     async ask(prompt, options = {}) {
       activeTurnCount += 1;
       // Lazy code-graph prewarm: kick off the build ONCE, on the first real
@@ -4947,6 +5245,32 @@ function parsedProviderModelVersion(id) {
       try {
         await refreshSessionForCwdIfNeeded('cwd-change');
         if (!session?.id) await createCurrentSession('turn');
+        // Remote outbound: ensure a transcript writer bound to the current
+        // session.id + cwd. The channel worker's OutputForwarder tails this
+        // 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 = '';
+            }
+          }
+        }
         hooks.emit('turn:start', { sessionId: session.id, prompt, cwd: currentCwd });
         // UserPromptSubmit: bridge to the standard hook bus. A hook FAILURE
         // must not block the turn, but a genuine blocked===true MUST throw.
@@ -4975,6 +5299,14 @@ function parsedProviderModelVersion(id) {
                 name: call?.name || 'tool',
                 callId: call?.id || null,
               });
+              // Mirror each tool card the TUI shows into the transcript so the
+              // forwarder renders the same one-line tool summary on Discord.
+              // calls carry { name, arguments, id } (loop.mjs response.toolCalls);
+              // some providers use `input` — accept either.
+              if (remoteEnabled && _transcriptWriter) {
+                try { _transcriptWriter.appendToolUse(call?.name, call?.input ?? call?.arguments); }
+                catch (error) { process.stderr.write(`mixdog: transcript-writer: onToolCall failed: ${error?.message || error}\n`); }
+              }
             }
             if (typeof options.onToolCall === 'function') {
               return await options.onToolCall(iter, calls);
@@ -4986,9 +5318,40 @@ function parsedProviderModelVersion(id) {
           {
             onTextDelta: options.onTextDelta,
             onReasoningDelta: options.onReasoningDelta,
-            onAssistantText: options.onAssistantText,
+            onAssistantText: (text) => {
+              // Capture the same assistant text the TUI renders (final answer +
+              // mid-turn preamble). Feed the writer, then ALWAYS call through to
+              // the caller's hook so terminal rendering is never affected.
+              if (remoteEnabled && _transcriptWriter) {
+                try {
+                  const value = typeof text === 'string' ? text : (text == null ? '' : String(text));
+                  if (value.trim()) {
+                    _transcriptWriter.appendAssistant(value);
+                    // Track the last line we wrote so the post-turn final
+                    // append below can skip an identical re-write (buffered
+                    // providers surface the final answer here AND in result).
+                    _lastAppendedAssistant = value;
+                  }
+                }
+                catch (error) { process.stderr.write(`mixdog: transcript-writer: onAssistantText failed: ${error?.message || error}\n`); }
+              }
+              return options.onAssistantText?.(text);
+            },
             onUsageDelta: options.onUsageDelta,
-            onToolResult: options.onToolResult,
+            onToolResult: (message) => {
+              // Surface Edit diffs only: the forwarder reads toolUseResult
+              // {oldString,newString}. Other tool results carry no diff payload,
+              // so we append only when those fields are present.
+              if (remoteEnabled && _transcriptWriter) {
+                try {
+                  const tur = message?.toolUseResult;
+                  if (tur && (tur.oldString != null || tur.newString != null)) {
+                    _transcriptWriter.appendToolResult({ oldString: tur.oldString ?? '', newString: tur.newString ?? '' });
+                  }
+                } catch (error) { process.stderr.write(`mixdog: transcript-writer: onToolResult failed: ${error?.message || error}\n`); }
+              }
+              return options.onToolResult?.(message);
+            },
             onToolApproval: options.onToolApproval,
             onCompactEvent: options.onCompactEvent,
             onStageChange: options.onStageChange,
@@ -4999,6 +5362,24 @@ function parsedProviderModelVersion(id) {
           },
         );
         session = mgr.getSession(session.id) || session;
+        // Final assistant text: onAssistantText fires only for buffered
+        // (non-streaming) providers and for mid-turn preamble. Streaming
+        // providers deliver the final answer via onTextDelta (which we do NOT
+        // tap, to avoid per-delta spam), so append the authoritative final
+        // content here from result.content. To avoid double-writing the
+        // buffered case, only append when it differs from the last assistant
+        // line onAssistantText already wrote.
+        if (remoteEnabled && _transcriptWriter) {
+          try {
+            const finalText = result?.content != null ? String(result.content) : '';
+            if (finalText.trim() && finalText !== _lastAppendedAssistant) {
+              _transcriptWriter.appendAssistant(finalText);
+              _lastAppendedAssistant = finalText;
+            }
+          } catch (error) {
+            process.stderr.write(`mixdog: transcript-writer: final append failed: ${error?.message || error}\n`);
+          }
+        }
         hooks.emit('turn:end', { sessionId: session.id, elapsedMs: Date.now() - startedAt });
         // Stop: bridge to the standard hook bus. Best-effort; ignore result,
         // never throw.
@@ -5306,7 +5687,15 @@ function parsedProviderModelVersion(id) {
       return result;
     },
     async setRoute(next, options = {}) {
-      const applyToCurrentSession = options?.applyToCurrentSession !== false;
+      // Model/provider changes take effect on the NEXT session only — never
+      // rewrite a running session's provider/model in place. A live turn's
+      // prompt cache (Anthropic/OpenAI/etc.) is provider-keyed; flipping
+      // session.provider mid-conversation forces a full cache-miss rewrite
+      // of the entire history on the very next turn (seen as a promptΔ
+      // spike + cache_ratio=0% in session-bench). `route` (this closure
+      // variable) still updates immediately so the NEXT createCurrentSession()
+      // picks it up; only the currently-open session is left untouched.
+      const applyToCurrentSession = options?.applyToCurrentSession === true;
       const requested = { ...(next || {}) };
       validateRequestedModelSelector(config, requested);
       const providerExplicitlyRequested = clean(next?.provider) !== '';
@@ -5334,12 +5723,6 @@ function parsedProviderModelVersion(id) {
       const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
       selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
       adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: config }), { hasSecrets: configHasSecrets });
-      if (!applyToCurrentSession) {
-        persistLeadRoute(selectedRoute);
-        refreshStatuslineUsageSnapshot(route);
-        scheduleStatuslineUsageRefresh();
-        return selectedRoute;
-      }
       const leadRoute = persistLeadRoute(selectedRoute);
       route = resolveRoute(config, leadRoute
         ? { model: workflowPresetId('lead') }
@@ -5347,6 +5730,11 @@ function parsedProviderModelVersion(id) {
       await refreshRouteEffort(modelMeta);
       refreshStatuslineUsageSnapshot(route);
       scheduleStatuslineUsageRefresh();
+      if (!applyToCurrentSession) {
+        // `route` is updated for the next session; the open session (and its
+        // live provider/model/cache chain) is left alone on purpose.
+        return route;
+      }
       if (session) {
         const updated = mgr.updateSessionRoute?.(session.id, {
           provider: route.provider,
@@ -5433,6 +5821,10 @@ function parsedProviderModelVersion(id) {
         clearTimeout(providerModelWarmupTimer);
         providerModelWarmupTimer = null;
       }
+      if (modelCatalogWarmupTimer) {
+        clearTimeout(modelCatalogWarmupTimer);
+        modelCatalogWarmupTimer = null;
+      }
       if (codeGraphPrewarmTimer) {
         clearTimeout(codeGraphPrewarmTimer);
         codeGraphPrewarmTimer = null;
@@ -5511,8 +5903,8 @@ function parsedProviderModelVersion(id) {
         if (owner && !['cli', 'user', 'mixdog', 'legacy'].includes(owner)) return null;
         const sourceType = clean(s.sourceType || '').toLowerCase();
         const sourceName = clean(s.sourceName || '').toLowerCase();
-        const role = clean(s.role || '').toLowerCase();
-        const leadish = role === 'lead'
+        const agent = clean(s.agent || '').toLowerCase();
+        const leadish = agent === 'lead'
           || sourceType === 'lead'
           || (sourceType === 'cli' && (!sourceName || sourceName === 'main'))
           || (!sourceType && !sourceName && !isAgentOwner(owner));