mixdog 0.9.1 → 0.9.3

package/src/mixdog-session-runtime.mjs

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
 import { ensureStandaloneEnvironment } from './standalone/seeds.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,17 +32,22 @@ import {
   PROVIDER_STATUS_TOOL,
   beginOAuthProviderLogin,
   forgetProviderAuth,
+  isKnownProvider,
   loginOAuthProvider,
   providerSetup,
   renderProviderStatus,
   saveOpenAIUsageSessionKey,
   saveOpenCodeGoUsageAuth,
+  loginOpenCodeGoUsage,
   saveProviderApiKey,
   setLocalProvider,
 } 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 +58,16 @@ import {
   deleteSchedule,
   deleteWebhook,
   forgetDiscordToken,
+  forgetTelegramToken,
   forgetWebhookAuthtoken,
   renderChannelStatus,
   saveChannel,
   saveDiscordToken,
+  saveTelegramToken,
   saveSchedule,
   saveWebhook,
   saveWebhookAuthtoken,
+  setBackend,
   setScheduleEnabled,
   setWebhookEnabled,
   setWebhookConfig,
@@ -69,233 +84,130 @@ 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;
-  const parts = Array.isArray(content)
-    ? content
-    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
-  if (parts) {
-    return parts.map((part) => {
-      if (typeof part === 'string') return part;
-      return part?.text ?? '';
-    }).filter(Boolean).join('\n');
-  }
-  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
-  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);
-  if (message.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
-    try { text += `\n${JSON.stringify(message.toolCalls)}`; }
-    catch { text += `\n[${message.toolCalls.length} tool calls]`; }
-  }
-  if (message.role === 'tool' && message.toolCallId) text += `\n${message.toolCallId}`;
-  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
-    || value.startsWith('<system-reminder>')
-    || value.startsWith('</system-reminder>')
-    || /^#\s*permission\b/i.test(value)
-    || /^permission:\s*/i.test(value)
-    || /^cwd:\s*/i.test(value);
-}
-
-function cleanSessionPreview(text) {
-  return String(text || '')
-    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, 160);
-}
+import {
+  sessionMessageText,
+  messageContextText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+  hasOwn,
+  toolResponseText,
+  isEmptyRecallText,
+  currentSessionRecallRows,
+  sessionHasConversationMessages,
+} from './session-runtime/session-text.mjs';
+import {
+  TOOL_MODES,
+  ALL_EFFORT_LEVELS,
+  EFFORT_LABELS,
+  EFFORT_OPTIONS_BY_PROVIDER,
+  EFFORT_BY_FAMILY,
+  EFFORT_FALLBACKS,
+  normalizeToolMode,
+  normalizeEffortInput,
+  effortOptionsFor,
+  coerceEffortFor,
+  normalizeSavedEffort,
+  effortItemsFor,
+  toolSpecForMode,
+  deferredSurfaceModeForLead,
+} from './session-runtime/effort.mjs';
+import {
+  LAZY_SECRET_PROVIDERS,
+  routeFastKey,
+  fastCapableFor,
+  makeSearchCapableFor,
+  fastPreferenceFor,
+  saveModelSettings,
+} from './session-runtime/model-capabilities.mjs';
+import {
+  DEFAULT_PROVIDER,
+  DEFAULT_MODEL,
+  makeResolveDefaultProvider,
+  findPreset,
+  makeResolveRoute,
+  isLikelyRawModelId,
+  validateRequestedModelSelector,
+  ensureProviderEnabled,
+  normalizeSystemShellConfig,
+  normalizeSystemShellCommand,
+  normalizeAutoClearConfig,
+  normalizeCompactionConfig,
+  moduleEnabled,
+  setModuleEnabledInConfig,
+  formatDurationMs,
+  parseDurationMs,
+  modelMetaLooksResolved,
+  modelSettingsFor,
+  normalizeCompactTypeSetting,
+} from './session-runtime/config-helpers.mjs';
+import {
+  routeForStatusline,
+  writeStatuslineRoute,
+} from './session-runtime/statusline-route.mjs';
+import {
+  normalizeOutputStyleId,
+  listOutputStyleCatalog,
+  findOutputStyle,
+  outputStyleStatus as outputStyleStatusRaw,
+} from './session-runtime/output-styles.mjs';
+import { readJsonSafe, readTextSafe } from './session-runtime/fs-utils.mjs';
+import {
+  readProjectMcpServers,
+  countSkillFiles,
+  mcpScriptForPlugin,
+  normalizePluginMcpServerConfig,
+  pluginManifest,
+  pluginMcpServerName,
+} from './session-runtime/plugin-mcp.mjs';
+import {
+  WORKFLOW_ROUTE_SLOTS,
+  FIXED_AGENT_SLOTS,
+  SEARCH_DEFAULT_PROVIDER,
+  SEARCH_DEFAULT_MODEL,
+  workflowPresetId,
+  agentPresetSlot,
+  normalizeAgentId,
+  normalizeWorkflowId,
+  createWorkflowHelpers,
+  normalizeSearchProviderId,
+  isDefaultSearchRouteConfig,
+  isSearchCapableProvider,
+  normalizeSearchRouteConfig,
+  normalizeWorkflowRoute,
+  upsertWorkflowPreset,
+  createWorkflowRouteHelpers,
+} from './session-runtime/workflow.mjs';
+import {
+  MEASURED_TOOL_USAGE,
+  DEFERRED_DEFAULT_FULL_TOOLS,
+  DEFERRED_DEFAULT_READONLY_TOOLS,
+  DEFERRED_DEFAULT_LEAD_TOOLS,
+  toolKind,
+  toolSchemaBucket,
+  estimateToolSchemaBreakdown,
+  measuredToolUsage,
+  parseToolSelection,
+  parseToolSearchQuerySelection,
+  sortedCatalogByMeasuredUsage,
+  filterDisallowedTools,
+  sortedNamesByMeasuredUsage,
+  defaultDeferredToolNames,
+  compactToolSearchDescription,
+  toolRow,
+  toolSearchMatches,
+  applyDeferredToolSurface,
+  selectDeferredTools,
+  renderToolSearch,
+} from './session-runtime/tool-catalog.mjs';
+// 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';
 
 const RUNTIME = './runtime/agent/orchestrator';
 const SEARCH_RUNTIME = './runtime/search/index.mjs';
@@ -315,18 +227,9 @@ const STANDALONE_ROOT = STANDALONE_SOURCE_ROOT;
 const MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
 const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(MIXDOG_HOME, 'data');
 
-const DEFAULT_PROVIDER = 'anthropic-oauth';
-const DEFAULT_MODEL = '';
-const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
-const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
-const EFFORT_LABELS = {
-  none: 'None',
-  low: 'Low',
-  medium: 'Medium',
-  high: 'High',
-  xhigh: 'Extra High',
-  max: 'Max',
-};
+const resolveDefaultProvider = makeResolveDefaultProvider(isKnownProvider);
+const resolveRoute = makeResolveRoute(resolveDefaultProvider);
+const searchCapableFor = makeSearchCapableFor(normalizeSearchProviderId, isSearchCapableProvider);
 
 function envFlag(name) {
   return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
@@ -373,37 +276,6 @@ async function profiledImport(label, spec, { optional = false } = {}) {
     throw error;
   }
 }
-const EFFORT_OPTIONS_BY_PROVIDER = {
-  openai: ['none', 'low', 'medium', 'high', 'xhigh'],
-  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
-  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
-  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
-  xai: ['none', 'low', 'medium', 'high'],
-  'grok-oauth': ['none', 'low', 'medium', 'high'],
-  'opencode-go': ['high', 'max'],
-};
-const EFFORT_BY_FAMILY = {
-  opus: ['low', 'medium', 'high', 'xhigh', 'max'],
-  sonnet: ['low', 'medium', 'high'],
-  haiku: [],
-  'gpt-5.5': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5.4': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5.2': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-mini': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-nano': ['none', 'low', 'medium', 'high'],
-  'gpt-codex': ['none', 'low', 'medium', 'high'],
-  grok: ['none', 'low', 'medium', 'high'],
-};
-const EFFORT_FALLBACKS = {
-  max: ['max', 'xhigh', 'high', 'medium', 'low'],
-  xhigh: ['xhigh', 'high', 'medium', 'low'],
-  high: ['high', 'medium', 'low'],
-  medium: ['medium', 'low'],
-  low: ['low'],
-  none: ['none'],
-};
-
 export const TOOL_SEARCH_TOOL = {
   name: 'tool_search',
   title: 'Tool Search',
@@ -486,89 +358,10 @@ export const SKILL_TOOL = {
   },
 };
 
-const MEASURED_TOOL_USAGE = Object.freeze({
-  read: 710,
-  code_graph: 520,
-  grep: 500,
-  find: 480,
-  glob: 460,
-  list: 430,
-  apply_patch: 400,
-  explore: 360,
-  agent: 330,
-  shell: 81,
-  cwd: 2,
-  diagnostics: 2,
-  recall: 2,
-  search: 2,
-  web_fetch: 2,
-  provider_status: 2,
-  channel_status: 2,
-});
-const MEASURED_TOOL_ORDER = Object.freeze(Object.keys(MEASURED_TOOL_USAGE));
 const LEAD_DISALLOWED_TOOLS = Object.freeze(['diagnostics', 'open_config']);
-const DEFERRED_DEFAULT_FULL_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'apply_patch',
-  'Skill',
-  'tool_search',
-]);
-const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'Skill',
-  'tool_search',
-]);
-const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'shell',
-  'task',
-  'explore',
-  'apply_patch',
-  'agent',
-  'recall',
-  'search',
-  'web_fetch',
-  'cwd',
-  'Skill',
-  'tool_search',
-]);
-const READONLY_TOOL_NAMES = new Set([
-  'read',
-  'list',
-  'grep',
-  'find',
-  'glob',
-  'code_graph',
-  'search',
-  'web_fetch',
-  'recall',
-  'memory',
-  'provider_status',
-  'channel_status',
-  'schedule_status',
-  'fetch',
-  'Skill',
-]);
-const AGENT_HIDDEN_WRAPPER_TOOLS = new Set(['search']);
-
-function applyStandaloneToolDefaults(tool) {
+const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
+
+export function __applyStandaloneToolDefaultsForTest(tool) {
   if (!tool || !AGENT_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;
   return {
     ...tool,
@@ -578,712 +371,10 @@ function applyStandaloneToolDefaults(tool) {
     },
   };
 }
-const DEFERRED_SELECT_ALIASES = {
-  filesystem: ['read', 'list', 'grep', 'find', 'glob'],
-  search: ['search', 'web_fetch'],
-  web: ['web_fetch', 'search'],
-  memory: ['memory', 'recall'],
-  channels: ['reply', 'fetch', 'react', 'edit_message', 'download_attachment', 'schedule_status', 'trigger_schedule', 'schedule_control', 'reload_config'],
-  discord: ['reply', 'fetch', 'react', 'edit_message', 'download_attachment'],
-  providers: ['provider_status'],
-  provider: ['provider_status'],
-  status: ['provider_status', 'channel_status', 'schedule_status'],
-  schedule: ['schedule_status', 'trigger_schedule', 'schedule_control'],
-  channel: ['channel_status'],
-  explore: ['explore'],
-  discovery: ['explore'],
-  agent: ['agent'],
-  graph: ['code_graph'],
-  code: ['code_graph'],
-  shell: ['shell', 'task'],
-};
-const TOOL_SEARCH_SAFE_AUTO_ALIASES = new Set([
-  'shell',
-  'web',
-  'search',
-  'agent',
-  'provider',
-  'providers',
-  'channel',
-  'schedule',
-  'memory',
-]);
-const TOOL_SEARCH_AMBIGUOUS_AUTO_QUERIES = new Set([
-  'status',
-  'state',
-  'info',
-  'list',
-  'show',
-  'config',
-]);
-const TOOL_SEARCH_STOP_WORDS = new Set([
-  'a',
-  'an',
-  'and',
-  'are',
-  'as',
-  'for',
-  'from',
-  'how',
-  'i',
-  'in',
-  'is',
-  'me',
-  'need',
-  'of',
-  'on',
-  'please',
-  'the',
-  'to',
-  'tool',
-  'tools',
-  'use',
-  'using',
-  'with',
-]);
-const TOOL_SEARCH_ROW_ALIASES = Object.freeze({
-  agent: ['delegate', 'subagent', 'worker', 'parallel agent', 'background agent', 'reviewer', 'explorer'],
-  channel_status: ['channel status', 'discord status', 'channel config'],
-  cwd: ['cwd', 'working directory', 'current directory', 'project root', 'folder'],
-  memory: ['save memory', 'store memory', 'delete memory', 'forget memory', 'memory status'],
-  provider_status: ['provider status', 'auth status', 'model status', 'oauth status', 'provider config'],
-  recall: ['recall', 'previous work', 'past work', 'prior context', 'history', 'resume context'],
-  schedule_status: ['schedule status', 'cron status'],
-  search: ['web search', 'internet search', 'current info', 'latest info', 'online search', 'docs search'],
-  shell: ['run command', 'execute command', 'terminal', 'powershell', 'bash', 'run tests', 'test command', 'build command', 'npm', 'node', 'git'],
-  task: ['background task', 'async task', 'wait task', 'cancel task', 'task status'],
-  web_fetch: ['fetch url', 'fetch page', 'open url', 'web page', 'read url', 'docs page'],
-});
-
-function normalizeToolMode(mode) {
-  const value = String(mode || '').trim().toLowerCase();
-  return TOOL_MODES.has(value) ? value : 'full';
-}
-
-function normalizeEffortInput(value) {
-  const v = clean(value).toLowerCase();
-  if (!v || v === 'auto') return null;
-  if (!ALL_EFFORT_LEVELS.has(v)) {
-    throw new Error(`effort must be one of auto, ${[...ALL_EFFORT_LEVELS].join(', ')}`);
-  }
-  return v;
-}
-
-function effortOptionsFor(provider, model) {
-  const providerAllowed = EFFORT_OPTIONS_BY_PROVIDER[provider] || null;
-  const filterProvider = (values) => {
-    const unique = [...new Set((values || []).map(clean).filter(Boolean))];
-    return providerAllowed ? unique.filter((v) => providerAllowed.includes(v)) : unique;
-  };
-  const declared = Array.isArray(model?.reasoningLevels)
-    ? model.reasoningLevels.map(clean).filter(Boolean)
-    : [];
-  const family = clean(model?.family).toLowerCase();
-  if (Array.isArray(model?.reasoningLevels)) {
-    if (declared.length) return filterProvider(declared);
-    if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
-      return filterProvider(EFFORT_BY_FAMILY[family]);
-    }
-    return [];
-  }
-  const reasoningOptionEffort = Array.isArray(model?.reasoningOptions)
-    ? model.reasoningOptions.find((option) => clean(option?.type).toLowerCase() === 'effort')
-    : null;
-  const reasoningOptionValues = Array.isArray(reasoningOptionEffort?.values)
-    ? reasoningOptionEffort.values.map(clean).filter(Boolean)
-    : [];
-  if (reasoningOptionValues.length) return filterProvider(reasoningOptionValues);
-  if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
-    return filterProvider(EFFORT_BY_FAMILY[family]);
-  }
-  return providerAllowed || [];
-}
-
-function coerceEffortFor(provider, model, effort) {
-  if (!effort) return null;
-  const allowed = effortOptionsFor(provider, model);
-  if (!allowed || allowed.length === 0) return null;
-  if (allowed.includes(effort)) return effort;
-  for (const candidate of EFFORT_FALLBACKS[effort] || []) {
-    if (allowed.includes(candidate)) return candidate;
-  }
-  return null;
-}
-
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj || {}, key);
-}
-
-function modelSettingsFor(config, provider, model) {
-  const key = routeFastKey(provider, model);
-  const value = key ? config?.modelSettings?.[key] : null;
-  return value && typeof value === 'object' ? value : {};
-}
-
-function normalizeSavedEffort(value) {
-  try {
-    return normalizeEffortInput(value);
-  } catch {
-    return null;
-  }
-}
-
-function effortItemsFor(provider, model, activeEffort) {
-  const allowed = effortOptionsFor(provider, model);
-  const items = [];
-  for (const value of allowed || []) {
-    items.push({
-      value,
-      label: EFFORT_LABELS[value] || value,
-      description: value === activeEffort ? 'current' : '',
-    });
-  }
-  return items;
-}
-
-function toolSpecForMode(mode) {
-  return mode === 'readonly' ? ['tools:readonly'] : 'full';
-}
-
-function deferredSurfaceModeForLead(mode) {
-  return mode === 'readonly' ? 'readonly' : 'lead';
-}
-
-function clean(value) {
-  return String(value ?? '').trim();
-}
-
-// A resolved model meta carries catalog-derived fields (contextWindow, pricing,
-// capabilities, …). The lookupModelMeta() fallback for an unknown id is the
-// bare shape `{ id, provider }`, so "more than id/provider" reliably tells a
-// real catalog hit apart from that placeholder.
-function modelMetaLooksResolved(meta) {
-  if (!meta || typeof meta !== 'object') return false;
-  return Object.keys(meta).some((key) => key !== 'id' && key !== 'provider');
-}
-
-const OUTPUT_STYLE_ORDER = ['default', 'simple', 'extreme-simple'];
-const OUTPUT_STYLE_ALIASES = new Map([
-  ['compact', 'default'],
-  ['normal', 'default'],
-  ['extreme', 'extreme-simple'],
-  ['extremesimple', 'extreme-simple'],
-  ['extreme-simple', 'extreme-simple'],
-  ['extreme_simple', 'extreme-simple'],
-]);
-
-function normalizeOutputStyleId(value) {
-  const raw = clean(value).toLowerCase();
-  if (!raw) return '';
-  const slug = raw.replace(/[_\s]+/g, '-').replace(/^-+|-+$/g, '');
-  const compact = slug.replace(/[_.-]+/g, '');
-  if (OUTPUT_STYLE_ALIASES.has(slug)) return OUTPUT_STYLE_ALIASES.get(slug);
-  if (OUTPUT_STYLE_ALIASES.has(compact)) return OUTPUT_STYLE_ALIASES.get(compact);
-  return /^[a-z0-9.-]+$/.test(slug) ? slug : '';
-}
-
-function outputStyleCompactKey(value) {
-  return normalizeOutputStyleId(value).replace(/[_.-]+/g, '');
-}
-
-function titleCaseOutputStyle(id) {
-  return clean(id)
-    .split(/[_.-]+/)
-    .filter(Boolean)
-    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-    .join(' ') || 'Default';
-}
-
-function parseOutputStyleFrontmatter(markdown) {
-  const match = String(markdown || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  const meta = {};
-  if (!match) return meta;
-  for (const line of match[1].split(/\r?\n/)) {
-    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
-    if (!kv) continue;
-    meta[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '').trim();
-  }
-  return meta;
-}
-
-function readOutputStyleMetadata(filePath, source) {
-  let raw = '';
-  try { raw = readFileSync(filePath, 'utf8'); } catch { return null; }
-  const meta = parseOutputStyleFrontmatter(raw);
-  const fileId = normalizeOutputStyleId(basename(filePath).replace(/\.md$/i, ''));
-  const id = normalizeOutputStyleId(meta.name) || fileId;
-  if (!id) return null;
-  const aliases = clean(meta.aliases)
-    .split(',')
-    .map((value) => normalizeOutputStyleId(value))
-    .filter(Boolean);
-  const label = clean(meta.title || meta.label) || titleCaseOutputStyle(id);
-  return {
-    id,
-    label,
-    description: clean(meta.description),
-    aliases,
-    source,
-  };
-}
-
-function listOutputStyleCatalog(dataDir = STANDALONE_DATA_DIR) {
-  const byId = new Map();
-  const dirs = [
-    { dir: join(STANDALONE_ROOT, 'output-styles'), source: 'builtin' },
-    { dir: join(dataDir || STANDALONE_DATA_DIR, 'output-styles'), source: 'user' },
-  ];
-  for (const { dir, source } of dirs) {
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue;
-      const style = readOutputStyleMetadata(join(dir, entry.name), source);
-      if (style) byId.set(style.id, style);
-    }
-  }
-  return [...byId.values()].sort((a, b) => {
-    const ai = OUTPUT_STYLE_ORDER.indexOf(a.id);
-    const bi = OUTPUT_STYLE_ORDER.indexOf(b.id);
-    if (ai !== bi) return (ai < 0 ? 999 : ai) - (bi < 0 ? 999 : bi);
-    return a.label.localeCompare(b.label, 'en', { sensitivity: 'base' });
-  });
-}
-
-function findOutputStyle(value, styles) {
-  const id = normalizeOutputStyleId(value);
-  const compact = outputStyleCompactKey(value);
-  if (!id && !compact) return null;
-  return (styles || []).find((style) => {
-    if (style.id === id || outputStyleCompactKey(style.id) === compact) return true;
-    if (outputStyleCompactKey(style.label) === compact) return true;
-    return (style.aliases || []).some((alias) => alias === id || outputStyleCompactKey(alias) === compact);
-  }) || null;
-}
-
-function configuredOutputStyleValue(dataDir = STANDALONE_DATA_DIR) {
-  const unified = readJsonSafe(join(dataDir || STANDALONE_DATA_DIR, 'mixdog-config.json')) || {};
-  return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'default') || 'default';
-}
-
-function outputStyleStatus(dataDir = STANDALONE_DATA_DIR) {
-  const styles = listOutputStyleCatalog(dataDir);
-  const configured = configuredOutputStyleValue(dataDir);
-  const current = findOutputStyle(configured, styles)
-    || findOutputStyle('default', styles)
-    || styles[0]
-    || { id: 'default', label: 'Default', description: '', aliases: [], source: 'builtin' };
-  return { configured, current, styles };
-}
-
-function sessionHasConversationMessages(activeSession) {
-  const messages = Array.isArray(activeSession?.messages) ? activeSession.messages : [];
-  return messages.some((message) => {
-    const role = message?.role;
-    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
-    const text = sessionMessageText(message.content).trim();
-    if (!text && role !== 'assistant') return false;
-    if (role === 'user' && isSessionPreviewNoise(text)) return false;
-    return true;
-  });
-}
-
-function readJsonSafe(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
-}
-
-function countSkillFiles(root) {
-  const skillsDir = join(root, 'skills');
-  if (!existsSync(skillsDir)) return 0;
-  let count = 0;
-  const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (/^(SKILL|skill)\.md$/i.test(entry.name) || entry.name.toLowerCase().endsWith('.md')) count += 1;
-    }
-  };
-  try { walk(skillsDir); } catch { return count; }
-  return count;
-}
-
-function mcpScriptForPlugin(root) {
-  const candidates = [
-    'scripts/run-mcp.mjs',
-    'mcp/server.mjs',
-    'server.mjs',
-  ];
-  return candidates.find((rel) => existsSync(join(root, rel))) || null;
-}
-
-function pluginManifest(root) {
-  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json'))
-    || readJsonSafe(join(root, 'plugin.json'))
-    || {};
-}
-
-function pluginMcpServerName(plugin = {}) {
-  const base = clean(plugin.name || plugin.title || 'plugin')
-    .toLowerCase()
-    .replace(/[^a-z0-9_.-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return base ? `plugin-${base}` : 'plugin-mcp';
-}
-
-function findPreset(config, key) {
-  const wanted = clean(key).toLowerCase();
-  if (!wanted) return null;
-  const presets = Array.isArray(config?.presets) ? config.presets : [];
-  return presets.find((p) => {
-    const id = clean(p?.id).toLowerCase();
-    const name = clean(p?.name).toLowerCase();
-    return id === wanted || name === wanted;
-  }) || null;
-}
-
-function resolveRoute(config, { provider, model, effort, fast } = {}) {
-  const explicitProvider = clean(provider);
-  const explicitModel = clean(model);
-  const hasExplicitEffort = effort !== undefined;
-  const explicitEffort = hasExplicitEffort ? normalizeEffortInput(effort) : undefined;
-  const hasExplicitFast = fast !== undefined;
-  const explicitFast = fast === true;
-
-  if (explicitModel && !explicitProvider) {
-    const preset = findPreset(config, explicitModel);
-    if (preset) {
-      const p = clean(preset.provider) || DEFAULT_PROVIDER;
-      const m = clean(preset.model) || DEFAULT_MODEL;
-      const saved = modelSettingsFor(config, p, m);
-      return {
-        provider: p,
-        model: m,
-        preset,
-        effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-        fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-      };
-    }
-  }
-
-  if (!explicitProvider && !explicitModel) {
-    const defaultKey = config?.default;
-    const preset = findPreset(config, defaultKey);
-    if (preset) {
-      const p = clean(preset.provider) || DEFAULT_PROVIDER;
-      const m = clean(preset.model) || DEFAULT_MODEL;
-      const saved = modelSettingsFor(config, p, m);
-      return {
-        provider: p,
-        model: m,
-        preset,
-        effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-        fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-      };
-    }
-  }
-
-  const p = explicitProvider || DEFAULT_PROVIDER;
-  const m = explicitModel || DEFAULT_MODEL;
-  const saved = modelSettingsFor(config, p, m);
-  return {
-    provider: p,
-    model: m,
-    preset: null,
-    effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort),
-    fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : fastPreferenceFor(config, p, m)),
-  };
-}
-
-function isLikelyRawModelId(value) {
-  const model = clean(value);
-  if (!model || model.length > 160) return false;
-  if (/\s/.test(model)) return false;
-  return /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(model);
-}
-
-function validateRequestedModelSelector(config, requested = {}) {
-  const model = clean(requested.model);
-  if (!model) return;
-  if (findPreset(config, model)) return;
-  if (isLikelyRawModelId(model)) return;
-  throw new Error(`Invalid model selector "${model}". Use a preset or a model id; free-form text cannot be used as a model.`);
-}
-
-function ensureProviderEnabled(config, provider) {
-  const providers = { ...(config?.providers || {}) };
-  providers[provider] = { ...(providers[provider] || {}), enabled: true };
-  return providers;
-}
-
-const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
-
-function normalizeSystemShellConfig(value = {}) {
-  const raw = value && typeof value === 'object' ? value : {};
-  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
-  const envCommand = clean(process.env.MIXDOG_SHELL);
-  return {
-    command,
-    effective: command || envCommand || '',
-    source: command ? 'config' : (envCommand ? 'env' : 'auto'),
-  };
-}
-
-function normalizeSystemShellCommand(value) {
-  const command = clean(value).replace(/^auto$/i, '').replace(/^['"](.+)['"]$/, '$1').trim();
-  if (!command) return '';
-  if (process.platform === 'win32') {
-    const stem = command.split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
-    if (stem !== 'powershell' && stem !== 'pwsh') {
-      throw new Error('system shell command must be powershell.exe or pwsh on Windows');
-    }
-  }
-  return command;
-}
-
-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 } : {}),
-  };
-}
-
-function normalizeCompactTypeSetting(value, fallback = 'semantic') {
-  const raw = clean(value).toLowerCase().replace(/_/g, '-');
-  if (!raw) return fallback;
-  if (raw === '1' || raw === 'type1' || raw === 'type-1' || raw === 'semantic' || raw === 'summary' || raw === 'default') return 'semantic';
-  if (raw === '2' || raw === 'type2' || raw === 'type-2' || raw === 'recall' || raw === 'recall-fast' || raw === 'recall-fasttrack' || raw === 'recall-fast-track' || raw === 'fasttrack' || raw === 'fast-track') return 'recall-fasttrack';
-  return fallback;
-}
-
-function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
-  const raw = value && typeof value === 'object' ? value : {};
-  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'semantic');
-  if (compactType === 'recall-fasttrack' && memoryEnabled === false) compactType = 'semantic';
-  return {
-    ...raw,
-    auto: raw.auto !== false && raw.enabled !== false,
-    type: compactType,
-    compactType,
-  };
-}
-
-function moduleEnabled(configLike, name, fallback = true) {
-  const entry = configLike?.modules?.[name];
-  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-  return fallback !== false;
-}
-
-function setModuleEnabledInConfig(configLike, name, enabled) {
-  const next = { ...(configLike || {}) };
-  next.modules = { ...(next.modules || {}) };
-  next.modules[name] = {
-    ...(next.modules[name] || {}),
-    enabled: enabled !== false,
-  };
-  return next;
-}
-
-function formatDurationMs(ms) {
-  const value = Math.max(0, Number(ms) || 0);
-  if (value % 3_600_000 === 0) return `${value / 3_600_000}h`;
-  if (value % 60_000 === 0) return `${value / 60_000}m`;
-  return `${Math.round(value / 1000)}s`;
-}
-
-function parseDurationMs(input) {
-  const text = clean(input).toLowerCase();
-  if (!text) return null;
-  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(text);
-  if (!match) return null;
-  const n = Number(match[1]);
-  if (!Number.isFinite(n) || n <= 0) return null;
-  const unit = match[2] || 'm';
-  const mult = unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1000 : 1;
-  return Math.max(60_000, Math.round(n * mult));
-}
-
-const FAST_CAPABLE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth', 'openai', 'openai-oauth']);
-const LAZY_SECRET_PROVIDERS = new Set(['openai-oauth', 'anthropic-oauth', 'grok-oauth', 'ollama', 'lmstudio']);
-
-function routeFastKey(provider, model) {
-  const p = clean(provider);
-  const m = clean(model);
-  return p && m ? `${p}/${m}` : '';
-}
-
-function openAiModelMetaSupportsFast(model) {
-  const tiers = Array.isArray(model?.serviceTiers) ? model.serviceTiers : [];
-  const speedTiers = Array.isArray(model?.additionalSpeedTiers) ? model.additionalSpeedTiers : [];
-  if (tiers.length || speedTiers.length || model?.defaultServiceTier) {
-    return tiers.some((tier) => tier?.id === 'priority')
-      || speedTiers.includes('priority')
-      || model?.defaultServiceTier === 'priority';
-  }
-  const id = clean(model?.id || model).toLowerCase();
-  if (id.includes('mini') || id.includes('nano') || id.includes('codex')) return false;
-  return /^gpt-5(\.|-|$)/.test(id);
-}
-
-function openAiDirectModelSupportsFast(model) {
-  const id = clean(model?.id || model);
-  return /^gpt-5\.5(?:-\d{4}|$)/.test(id)
-    || /^gpt-5\.4(?:-\d{4}|$)/.test(id)
-    || /^gpt-5\.4-mini(?:-\d{4}|$)/.test(id);
-}
-
-function openAiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id) return false;
-  if (model?.supportsWebSearch === true) return true;
-  const tools = [
-    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
-    ...(Array.isArray(model?.tools) ? model.tools : []),
-    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
-  ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
-  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
-  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
-  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id)
-    || /^o[34](?:-|$)/.test(id);
-}
-
-function grokModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /imagine|image|video|composer/.test(id)) return false;
-  if (id === 'grok-build') return false;
-  return /^grok-/.test(id);
-}
-
-function geminiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
-  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
-}
-
-function anthropicModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id) return false;
-  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
-  if (!match) return false;
-  const major = Number(match[2]) || 0;
-  const minor = Number(match[3]) || 0;
-  return major > 4 || (major === 4 && minor >= 0);
-}
-
-function anthropicModelMetaSupportsFast(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  return /^claude-(opus|sonnet)/.test(id);
-}
-
-function fastCapableFor(provider, model) {
-  const p = clean(provider);
-  if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
-  if (p === 'openai') return openAiDirectModelSupportsFast(model);
-  if (p === 'openai-oauth') return openAiModelMetaSupportsFast(model);
-  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
-  return false;
-}
-
-function searchCapableFor(provider, model) {
-  const p = normalizeSearchProviderId(provider);
-  if (!isSearchCapableProvider(p)) return false;
-  if (p === 'openai' || p === 'openai-oauth') return openAiModelSupportsHostedWebSearch(model);
-  if (p === 'grok-oauth' || p === 'xai') return grokModelSupportsHostedWebSearch(model);
-  if (p === 'gemini') return geminiModelSupportsHostedWebSearch(model);
-  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelSupportsHostedWebSearch(model);
-  return model?.supportsWebSearch === true;
-}
-
-function fastPreferenceFor(config, provider, model) {
-  const key = routeFastKey(provider, model);
-  if (!key) return false;
-  const saved = config?.modelSettings?.[key];
-  if (saved && typeof saved === 'object' && hasOwn(saved, 'fast')) return saved.fast === true;
-  return config?.fastModels?.[key] === true;
-}
-
-function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
-  const key = routeFastKey(route?.provider, route?.model);
-  if (!key) return baseConfig || cfgMod.loadConfig();
-  const nextConfig = baseConfig || cfgMod.loadConfig();
-  const modelSettings = { ...(nextConfig.modelSettings || {}) };
-  const nextSetting = { ...(modelSettings[key] || {}) };
-  if (hasOwn(route, 'effort') && route.effort) nextSetting.effort = route.effort;
-  else delete nextSetting.effort;
-  if (fastCapable) nextSetting.fast = route.fast === true;
-  else nextSetting.fast = false;
-  modelSettings[key] = nextSetting;
-
-  // Legacy compatibility: keep fastModels true entries for old readers, but
-  // let modelSettings.fast=false override them in new readers.
-  const fastModels = { ...(nextConfig.fastModels || {}) };
-  if (nextSetting.fast === true) fastModels[key] = true;
-  else delete fastModels[key];
-
-  const savedConfig = { ...nextConfig, modelSettings, fastModels };
-  cfgMod.saveConfig(savedConfig);
-  return savedConfig;
-}
-
-function routeForStatusline(route) {
-  const out = {
-    mode: 'fixed',
-    defaultProvider: route.provider,
-    defaultModel: route.model,
-  };
-  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;
-  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) {
-    out.effort = route.effectiveEffort;
-    out.displayEffort = route.effectiveEffort;
-  } else if (hasOwn(route, 'effort')) {
-    delete out.effort;
-    delete out.displayEffort;
-  }
-  return out;
-}
-
-function writeStatuslineRoute(statusRoutes, session, route) {
-  if (!session?.id || !route) return;
-  const clientHostPid = session?.clientHostPid || process.pid;
-  statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route), { clientHostPid });
-}
+const applyStandaloneToolDefaults = __applyStandaloneToolDefaultsForTest;
+const outputStyleStatus = (dataDir = STANDALONE_DATA_DIR) => outputStyleStatusRaw(STANDALONE_ROOT, dataDir || STANDALONE_DATA_DIR);
 
 const ONBOARDING_VERSION = 1;
-const WORKFLOW_ROUTE_SLOTS = ['lead', 'agent', 'explorer', 'memory'];
-const FIXED_AGENT_SLOTS = Object.freeze([
-  { id: 'explore', label: 'Explore', description: 'Broad repository exploration', workflowSlot: 'explorer' },
-  { id: 'maintainer', label: 'Maintainer', description: 'Background memory and upkeep', workflowSlot: 'memory' },
-  { id: 'worker', label: 'Worker', description: 'Scoped implementation' },
-  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Broad or multi-file implementation' },
-  { id: 'reviewer', label: 'Reviewer', description: 'Diff review and risk checks' },
-  { id: 'debugger', label: 'Debugger', description: 'Root-cause analysis and failure tracing' },
-]);
-const SEARCH_CAPABLE_PROVIDERS = new Set([
-  'openai-oauth',
-  'openai',
-  'grok-oauth',
-  'xai',
-  'gemini',
-  'anthropic',
-  'anthropic-oauth',
-]);
-const SEARCH_DEFAULT_PROVIDER = 'default';
-const SEARCH_DEFAULT_MODEL = 'default';
-const SEARCH_PROVIDER_ALIASES = Object.freeze({
-  'openai-api': 'openai',
-  'xai-api': 'xai',
-  'gemini-api': 'gemini',
-  'anthropic-api': 'anthropic',
-});
 const QUICK_SEARCH_MODELS = Object.freeze({
   'openai-oauth': [
     { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
@@ -1314,851 +405,37 @@ const QUICK_SEARCH_MODELS = Object.freeze({
     { 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 },
-  ],
-});
-const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
-const agentDefinitionCache = new Map();
-const DEFAULT_WORKFLOW_ID = 'default';
-
-function workflowPresetId(slot) {
-  return `workflow-${slot}`;
-}
-
-function workflowPresetName(slot) {
-  return `WORKFLOW ${String(slot || '').toUpperCase()}`;
-}
-
-function agentPresetSlot(agentId) {
-  return `agent-${String(agentId || '').replace(/[^a-z0-9_.-]+/gi, '-').toLowerCase()}`;
-}
-
-function normalizeAgentId(value) {
-  const id = clean(value).toLowerCase().replace(/[\s_]+/g, '-');
-  if (id === 'explorer') return 'explore';
-  if (id === 'maint' || id === 'maintenance' || id === 'memory') return 'maintainer';
-  if (id === 'heavy' || id === 'heavyworker') return 'heavy-worker';
-  if (id === 'review') return 'reviewer';
-  if (id === 'debug') return 'debugger';
-  return AGENT_ROLE_IDS.has(id) ? id : '';
-}
-
-function normalizeWorkflowId(value, fallback = '') {
-  const id = clean(value).toLowerCase().replace(/[\s_]+/g, '-');
-  return /^[a-z0-9][a-z0-9_.-]*$/.test(id) ? id : fallback;
-}
-
-function readTextSafe(path) {
-  try { return readFileSync(path, 'utf8').trim(); } catch { return ''; }
-}
-
-function workflowSourceDirs(dataDir) {
-  return [
-    { root: join(STANDALONE_ROOT, 'workflows'), source: 'built-in' },
-    { root: join(dataDir || STANDALONE_DATA_DIR, 'workflows'), source: 'user' },
-  ];
-}
-
-function agentSourceDirs(dataDir, id) {
-  return [
-    join(dataDir || STANDALONE_DATA_DIR, 'agents', id),
-    join(STANDALONE_ROOT, 'agents', 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));
-  if (!body) return null;
-  const agentsConfigured = Array.isArray(manifest.agents);
-  return {
-    id,
-    name: clean(manifest.name) || id,
-    description: clean(manifest.description),
-    entry,
-    agentsConfigured,
-    agents: agentsConfigured ? manifest.agents.map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent)).filter(Boolean) : [],
-    body,
-    source,
-  };
-}
-
-function listWorkflowPacks(dataDir) {
-  const byId = new Map();
-  for (const { root, source } of workflowSourceDirs(dataDir)) {
-    if (!existsSync(root)) continue;
-    let entries = [];
-    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);
-      if (pack) byId.set(pack.id, pack);
-    }
-  }
-  return [...byId.values()].sort((a, b) => {
-    if (a.id === DEFAULT_WORKFLOW_ID) return -1;
-    if (b.id === DEFAULT_WORKFLOW_ID) return 1;
-    return a.name.localeCompare(b.name);
-  });
-}
-
-function activeWorkflowId(config) {
-  return normalizeWorkflowId(config?.workflow?.active, DEFAULT_WORKFLOW_ID);
-}
-
-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);
-    if (pack) return pack;
-  }
-  return readWorkflowPackFromDir(join(STANDALONE_ROOT, 'workflows', DEFAULT_WORKFLOW_ID), 'built-in');
-}
-
-function workflowSummary(pack) {
-  const id = normalizeWorkflowId(pack?.id, DEFAULT_WORKFLOW_ID);
-  return {
-    id,
-    name: clean(pack?.name) || (id === DEFAULT_WORKFLOW_ID ? 'Default' : id),
-    description: clean(pack?.description),
-    source: clean(pack?.source),
-  };
-}
-
-function activeWorkflowSummary(config, dataDir) {
-  return workflowSummary(loadWorkflowPack(dataDir, activeWorkflowId(config)));
-}
-
-function loadAgentDefinition(dataDir, id) {
-  const agentId = normalizeAgentId(id) || normalizeWorkflowId(id);
-  if (!agentId) return null;
-  const cacheKey = `${dataDir || STANDALONE_DATA_DIR}\n${agentId}`;
-  if (agentDefinitionCache.has(cacheKey)) return agentDefinitionCache.get(cacheKey);
-  for (const dir of agentSourceDirs(dataDir, agentId)) {
-    const manifest = readJsonSafe(join(dir, 'agent.json')) || {};
-    const entry = clean(manifest.entry) || 'AGENT.md';
-    const doc = readMarkdownDocument(readTextSafe(join(dir, entry)));
-    const body = doc.body;
-    if (!body) continue;
-    const definition = {
-      id: agentId,
-      name: clean(manifest.name) || FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
-      description: clean(manifest.description) || FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.description || '',
-      permission: normalizeAgentPermissionOrNone(doc.frontmatter.permission),
-      frontmatter: doc.frontmatter,
-      body,
-    };
-    agentDefinitionCache.set(cacheKey, definition);
-    return definition;
-  }
-  const legacyDoc = readMarkdownDocument(readTextSafe(join(STANDALONE_ROOT, 'agents', `${agentId}.md`)));
-  if (!legacyDoc.body) {
-    agentDefinitionCache.set(cacheKey, null);
-    return null;
-  }
-  const definition = {
-    id: agentId,
-    name: FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
-    description: '',
-    permission: normalizeAgentPermissionOrNone(legacyDoc.frontmatter.permission),
-    frontmatter: legacyDoc.frontmatter,
-    body: legacyDoc.body,
-  };
-  agentDefinitionCache.set(cacheKey, definition);
-  return definition;
-}
-
-function workflowContextBlock(config, dataDir) {
-  const pack = loadWorkflowPack(dataDir, activeWorkflowId(config));
-  if (!pack) return '';
-  const lines = [
-    `# Active Workflow: ${pack.name}`,
-  ];
-  if (pack.description) lines.push(pack.description);
-  lines.push(pack.body);
-
-  const agentIds = pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id);
-  const agentBlocks = agentIds
-    .map((id) => loadAgentDefinition(dataDir, id))
-    .filter(Boolean);
-  if (agentBlocks.length) {
-    lines.push('# Available Agents');
-    for (const agent of agentBlocks) {
-      lines.push(`## ${agent.name} (${agent.id})`);
-      if (agent.description) lines.push(agent.description);
-      lines.push(agent.body);
-    }
-  }
-  return lines.join('\n\n');
-}
-
-function normalizeWorkflowRoute(routeLike, fallback = {}) {
-  const provider = clean(routeLike?.provider) || clean(fallback.provider);
-  const model = clean(routeLike?.model) || clean(fallback.model);
-  if (!provider || !model) return null;
-  // Defensive: a workflow/agent route must carry a real model id. Reject values
-  // that are obviously free-form text (whitespace, prose) so a bad string can
-  // never be persisted as a preset/workflow route. Normal model ids pass
-  // isLikelyRawModelId unchanged.
-  if (!isLikelyRawModelId(model)) return null;
-  const effort = normalizeEffortInput(routeLike?.effort ?? fallback.effort);
-  const fast = routeLike?.fast ?? fallback.fast;
-  return {
-    provider,
-    model,
-    ...(effort ? { effort } : {}),
-    ...(fast === true ? { fast: true } : {}),
-  };
-}
-
-function normalizeSearchProviderId(provider) {
-  const id = clean(provider);
-  return SEARCH_PROVIDER_ALIASES[id] || id;
-}
-
-function isDefaultSearchRouteConfig(routeLike = {}) {
-  return normalizeSearchProviderId(routeLike?.provider) === SEARCH_DEFAULT_PROVIDER
-    && clean(routeLike?.model).toLowerCase() === SEARCH_DEFAULT_MODEL;
-}
-
-function isSearchCapableProvider(provider) {
-  return SEARCH_CAPABLE_PROVIDERS.has(normalizeSearchProviderId(provider));
-}
-
-function normalizeSearchRouteConfig(routeLike, fallback = {}) {
-  const provider = normalizeSearchProviderId(routeLike?.provider || fallback.provider);
-  const model = clean(routeLike?.model || fallback.model);
-  if (!provider || !model) return null;
-  let effort = null;
-  try {
-    effort = normalizeEffortInput(routeLike?.effort ?? fallback.effort);
-  } catch {
-    effort = null;
-  }
-  const fast = routeLike?.fast ?? fallback.fast;
-  const toolType = clean(routeLike?.toolType || fallback.toolType);
-  return {
-    provider,
-    model,
-    ...(effort ? { effort } : {}),
-    ...(fast === true ? { fast: true } : {}),
-    ...(toolType ? { toolType } : {}),
-  };
-}
-
-function upsertWorkflowPreset(presets, slot, routeLike) {
-  const route = normalizeWorkflowRoute(routeLike);
-  if (!route) return presets;
-  const id = workflowPresetId(slot);
-  const preset = {
-    id,
-    name: workflowPresetName(slot),
-    type: 'agent',
-    provider: route.provider,
-    model: route.model,
-    ...(route.effort ? { effort: route.effort } : {}),
-    ...(route.fast === true ? { fast: true } : {}),
-    tools: 'full',
-  };
-  const next = (Array.isArray(presets) ? presets : []).filter((p) => clean(p?.id) !== id && clean(p?.name) !== preset.name);
-  next.push(preset);
-  return next;
-}
-
-function summarizeWorkflowRoutes(config) {
-  const routes = config?.workflowRoutes && typeof config.workflowRoutes === 'object' ? config.workflowRoutes : {};
-  const out = {};
-  for (const slot of WORKFLOW_ROUTE_SLOTS) {
-    const route = routes[slot];
-    if (route?.provider && route?.model) out[slot] = normalizeWorkflowRoute(route);
-  }
-  return out;
-}
-
-function routeFromPreset(config, slotValue) {
-  // Maintenance slots now store a direct {provider, model} route. Accept that
-  // shape first; fall back to the legacy preset-NAME string lookup so configs
-  // written before the route migration still resolve.
-  if (slotValue && typeof slotValue === 'object' && !Array.isArray(slotValue)) {
-    const direct = normalizeWorkflowRoute(slotValue);
-    if (direct) return direct;
-  }
-  const preset = findPreset(config, slotValue);
-  return preset ? normalizeWorkflowRoute(preset) : null;
-}
-
-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);
-  if (explicit) return explicit;
-
-  const agent = FIXED_AGENT_SLOTS.find((item) => item.id === id);
-  if (agent?.workflowSlot) {
-    const workflowRoute = normalizeWorkflowRoute(config?.workflowRoutes?.[agent.workflowSlot]);
-    if (workflowRoute) return workflowRoute;
-  }
-
-  if (id === 'explore') return routeFromPreset(config, config?.maintenance?.explore);
-  if (id === 'maintainer') return routeFromPreset(config, config?.maintenance?.memory);
-
-  return null;
-}
-
-function toolResponseText(result) {
-  if (result && typeof result === 'object' && Array.isArray(result.content)) {
-    return result.content
-      .map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part)))
-      .join('\n');
-  }
-  if (typeof result === 'string') return result;
-  return JSON.stringify(result, null, 2);
-}
-
-function isEmptyRecallText(value) {
-  const text = String(value || '').trim();
-  return !text || /^\(?no results\)?$/i.test(text) || /^\(?empty memory result\)?$/i.test(text);
-}
-
-function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
-  const messages = Array.isArray(session?.messages) ? session.messages : [];
-  if (!messages.length) return '(no results)';
-  const terms = [...new Set(String(query || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{2,}/gu) || [])]
-    .filter(Boolean)
-    .slice(0, 16);
-  const max = Math.max(1, Math.min(100, Number(limit) || 10));
-  const rows = [];
-  for (let i = messages.length - 1; i >= 0 && rows.length < max; i -= 1) {
-    const m = messages[i];
-    if (!m || (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool')) continue;
-    const text = messageContextText(m).replace(/\s+/g, ' ').trim();
-    if (!text) continue;
-    if (terms.length && !terms.some((term) => text.toLowerCase().includes(term))) continue;
-    rows.push(`[session:${i + 1}] ${m.role}: ${text.slice(0, 1000)}`);
-  }
-  return rows.length ? rows.join('\n') : '(no results)';
-}
-
-function parseToolSelection(value) {
-  if (Array.isArray(value)) return value.map(clean).filter(Boolean);
-  if (value && typeof value !== 'string' && typeof value[Symbol.iterator] === 'function') {
-    return [...value].map(clean).filter(Boolean);
-  }
-  return String(value || '').replace(/^select\s*:/i, '')
-    .split(/[,\s]+/)
-    .map(clean)
-    .filter(Boolean);
-}
-
-function parseToolSearchQuerySelection(query) {
-  const match = clean(query).match(/^select\s*:\s*(.+)$/i);
-  return match ? parseToolSelection(match[1]) : [];
-}
-
-function toolKind(tool) {
-  const name = clean(tool?.name);
-  if (name.startsWith('mcp__')) return 'mcp';
-  if (name.startsWith('skill:') || tool?.annotations?.mixdogKind === 'skill') return 'skill';
-  if (name === 'Skill' || name.startsWith('skill_') || name === 'skills_list' || name === 'skill_view') return 'skill';
-  if (tool?.annotations?.agentHidden) return 'control';
-  if (['apply_patch', 'shell'].includes(name)) return 'mutation';
-  return 'tool';
-}
-
-function toolSchemaBucket(tool) {
-  const name = clean(tool?.name);
-  const kind = toolKind(tool);
-  if (kind === 'mcp') return 'mcp';
-  if (kind === 'skill') return 'skills';
-  if (name === 'memory' || name === 'recall' || name.includes('memory')) return 'memory';
-  if (name === 'search' || name === 'web_fetch') return 'web';
-  if (['read', 'grep', 'find', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
-  if (['shell', 'apply_patch'].includes(name)) return 'mutation';
-  if (name === 'agent' || name === 'delegate') return 'agents';
-  if (name.includes('channel') || name.includes('discord') || name.includes('webhook')) return 'channels';
-  if (name.includes('provider') || name === 'tool_search' || name === 'cwd') return 'setup';
-  return 'other';
-}
-
-function estimateToolSchemaBreakdown(tools) {
-  const out = {};
-  for (const tool of Array.isArray(tools) ? tools : []) {
-    const bucket = toolSchemaBucket(tool);
-    const row = out[bucket] || { count: 0, tokens: 0 };
-    row.count += 1;
-    row.tokens += estimateToolSchemaTokens([tool]);
-    out[bucket] = row;
-  }
-  return out;
-}
-
-function measuredToolUsage(name) {
-  return MEASURED_TOOL_USAGE[clean(name)] || 0;
-}
-
-function measuredToolRank(name) {
-  const index = MEASURED_TOOL_ORDER.indexOf(clean(name));
-  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
-}
-
-function sortedCatalogByMeasuredUsage(catalog) {
-  return (catalog || [])
-    .map((tool, index) => ({ tool, index }))
-    .sort((a, b) => {
-      const au = measuredToolUsage(a.tool?.name);
-      const bu = measuredToolUsage(b.tool?.name);
-      if (bu !== au) return bu - au;
-      const ar = measuredToolRank(a.tool?.name);
-      const br = measuredToolRank(b.tool?.name);
-      if (ar !== br) return ar - br;
-      return a.index - b.index;
-    })
-    .map((entry) => entry.tool);
-}
-
-function activeToolForSurface(tool) {
-  if (!tool || typeof tool !== 'object') return tool;
-  return JSON.parse(JSON.stringify(tool));
-}
-
-function deferredProviderMode(provider) {
-  const p = clean(provider).toLowerCase();
-  if (p === 'gemini') return 'full';
-  if (p === 'anthropic' || p === 'anthropic-oauth'
-    || p === 'openai' || p === 'openai-oauth'
-    || p === 'xai' || p === 'grok-oauth') {
-    return 'native';
-  }
-  return 'legacy';
-}
-
-function filterDisallowedTools(tools, disallowed = []) {
-  if (!Array.isArray(disallowed) || disallowed.length === 0) return tools;
-  const deny = new Set(disallowed.map((name) => clean(name)).filter(Boolean));
-  if (deny.size === 0) return tools;
-  return (tools || []).filter((tool) => !deny.has(clean(tool?.name)));
-}
-
-function sortedNamesByMeasuredUsage(names) {
-  return [...(names || [])].sort((a, b) => {
-    const au = measuredToolUsage(a);
-    const bu = measuredToolUsage(b);
-    if (bu !== au) return bu - au;
-    const ar = measuredToolRank(a);
-    const br = measuredToolRank(b);
-    if (ar !== br) return ar - br;
-    return String(a).localeCompare(String(b));
-  });
-}
-
-export function defaultDeferredToolNames(catalog, mode) {
-  const available = new Set((catalog || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  if (mode === 'lead') {
-    return new Set(DEFERRED_DEFAULT_LEAD_TOOLS.filter((name) => available.has(name)));
-  }
-  if (mode === 'readonly') {
-    return new Set(DEFERRED_DEFAULT_READONLY_TOOLS.filter((name) => available.has(name)));
-  }
-  return new Set(DEFERRED_DEFAULT_FULL_TOOLS.filter((name) => available.has(name)));
-}
-
-export function compactToolSearchDescription(value, max = 220) {
-  const text = clean(value).replace(/\s+/g, ' ');
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-function toolRow(tool, activeNames = new Set()) {
-  const name = clean(tool?.name);
-  return {
-    name,
-    kind: toolKind(tool),
-    usage: measuredToolUsage(name),
-    active: activeNames.has(name),
-    description: compactToolSearchDescription(tool?.description),
-  };
-}
-
-function providerSupportsResponsesCustomTools(provider) {
-  const p = clean(provider).toLowerCase();
-  if (!p) return true;
-  return p === 'openai' || p === 'openai-oauth';
-}
-
-function openAILoadableToolSpec(tool, provider = '') {
-  if (providerSupportsResponsesCustomTools(provider) && isResponsesFreeformTool(tool)) return toResponsesCustomTool(tool);
-  return {
-    type: 'function',
-    name: clean(tool?.name),
-    description: clean(tool?.description),
-    defer_loading: true,
-    parameters: tool?.inputSchema && typeof tool.inputSchema === 'object'
-      ? tool.inputSchema
-      : { type: 'object', properties: {} },
-  };
-}
-
-function toolSearchNativePayload(catalog, names, provider = '') {
-  const selected = new Set((names || []).map(clean).filter(Boolean));
-  if (!selected.size) return null;
-  const tools = [];
-  const refs = [];
-  for (const tool of catalog || []) {
-    const name = clean(tool?.name);
-    if (!name || !selected.has(name)) continue;
-    refs.push(name);
-    tools.push(openAILoadableToolSpec(tool, provider));
-  }
-  if (!refs.length) return null;
-  return {
-    toolReferences: refs,
-    openaiTools: tools,
-    summary: `Loaded deferred tools: ${refs.join(', ')}`,
-  };
-}
-
-function toolSearchTokens(value) {
-  return (clean(value).toLowerCase().match(/[a-z0-9_.-]+/g) || [])
-    .map((token) => token.replace(/[-.]+/g, '_'))
-    .filter(Boolean);
-}
-
-function toolSearchMeaningfulTokens(value) {
-  return toolSearchTokens(value).filter((token) => !TOOL_SEARCH_STOP_WORDS.has(token));
-}
-
-function toolSearchText(row) {
-  const text = `${row.name} ${String(row.name || '').replace(/_/g, ' ')} ${row.kind} ${row.description} ${row.active ? 'active' : 'deferred'}`;
-  return `${text} ${text.replace(/[-.]+/g, '_')}`.toLowerCase();
-}
-
-function toolSearchRowAliases(name) {
-  return TOOL_SEARCH_ROW_ALIASES[clean(name)] || [];
-}
-
-function toolSearchRank(row, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return { score: 0, reasons: [] };
-  const name = clean(row?.name).toLowerCase();
-  const prettyName = name.replace(/_/g, ' ');
-  const haystack = toolSearchText(row);
-  const aliases = toolSearchRowAliases(name);
-  const aliasText = aliases.join(' ').toLowerCase();
-  const queryTokens = toolSearchMeaningfulTokens(raw);
-  const nameTokens = new Set(toolSearchTokens(`${name} ${prettyName}`));
-  const aliasTokens = new Set(toolSearchTokens(aliasText));
-  let score = 0;
-  const reasons = [];
-  if (raw === name || raw === prettyName) {
-    score += 120;
-    reasons.push('exact-name');
-  }
-  if (aliases.some((alias) => raw === alias || raw === alias.replace(/[_-]+/g, ' '))) {
-    score += 100;
-    reasons.push('exact-alias');
-  }
-  if (haystack.includes(raw)) {
-    score += 34;
-    reasons.push('phrase');
-  }
-  for (const alias of aliases) {
-    const normalizedAlias = alias.toLowerCase();
-    if (normalizedAlias && raw.includes(normalizedAlias)) {
-      score += 58;
-      reasons.push('alias-phrase');
-      break;
-    }
-  }
-  let matchedTokens = 0;
-  for (const token of queryTokens) {
-    if (nameTokens.has(token) || name.includes(token)) {
-      score += 24;
-      matchedTokens += 1;
-      continue;
-    }
-    if (aliasTokens.has(token) || aliasText.includes(token)) {
-      score += 18;
-      matchedTokens += 1;
-      continue;
-    }
-    if (haystack.includes(token)) {
-      score += 7;
-      matchedTokens += 1;
-    }
-  }
-  if (queryTokens.length && matchedTokens === queryTokens.length) {
-    score += Math.min(18, queryTokens.length * 6);
-    reasons.push('all-tokens');
-  }
-  if (clean(row?.kind).toLowerCase() === raw) score += 10;
-  if (score > 0) score += Math.min(6, Math.floor(measuredToolUsage(name) / 150));
-  return { score, reasons };
-}
-
-function toolSearchMatches(row, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return true;
-  return toolSearchRank(row, raw).score > 0;
-}
-
-function rankedToolSearchRows(rows, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return rows;
-  return rows
-    .map((row) => {
-      const ranked = toolSearchRank(row, raw);
-      return { ...row, score: ranked.score, reasons: ranked.reasons };
-    })
-    .filter((row) => row.score > 0)
-    .sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      if (a.active !== b.active) return a.active ? 1 : -1;
-      if (b.usage !== a.usage) return b.usage - a.usage;
-      return String(a.name).localeCompare(String(b.name));
-    });
-}
-
-function queryHasAnyPhrase(query, phrases) {
-  const text = clean(query).toLowerCase().replace(/[_-]+/g, ' ');
-  return phrases.some((phrase) => text.includes(phrase));
-}
-
-function autoToolSelectionNames(query, rows) {
-  const raw = clean(query).toLowerCase();
-  if (!raw || TOOL_SEARCH_AMBIGUOUS_AUTO_QUERIES.has(raw)) return [];
-  if (TOOL_SEARCH_SAFE_AUTO_ALIASES.has(raw) && DEFERRED_SELECT_ALIASES[raw]) {
-    return DEFERRED_SELECT_ALIASES[raw];
-  }
-  if (queryHasAnyPhrase(raw, ['save memory', 'store memory', 'delete memory', 'forget memory', 'memory status', '기억 저장', '메모리 저장'])) {
-    return ['memory'];
-  }
-  if (queryHasAnyPhrase(raw, ['run', 'execute', 'test', 'tests', 'build', 'terminal', 'command', 'powershell', 'bash', 'shell', 'npm', 'node', 'git', '실행', '테스트', '빌드', '터미널', '쉘'])) {
-    return ['shell', 'task'];
-  }
-  if (queryHasAnyPhrase(raw, ['web', 'internet', 'online', 'current info', 'latest', 'news', 'browse', 'docs', 'documentation', '웹', '인터넷', '최신', '뉴스', '문서'])) {
-    return ['search', 'web_fetch'];
-  }
-  if (queryHasAnyPhrase(raw, ['recall', 'remember', 'memory previous', 'previous', 'history', 'past', 'prior', 'earlier', 'resume', '이전', '기억', '히스토리'])) {
-    return ['recall'];
-  }
-  if (queryHasAnyPhrase(raw, ['delegate', 'subagent', 'worker', 'parallel agent', 'background agent', 'reviewer', 'explorer', '에이전트', '워커', '병렬'])) {
-    return ['agent'];
-  }
-  if (queryHasAnyPhrase(raw, ['working directory', 'project root', 'current directory', 'cwd'])) {
-    return ['cwd'];
-  }
-  const ranked = rankedToolSearchRows(rows, raw);
-  const top = ranked[0];
-  if (!top) return [];
-  const reasons = new Set(top.reasons || []);
-  if (reasons.has('exact-name') || reasons.has('exact-alias')) return [top.name];
-  return [];
-}
-
-function expandSelectionNames(names) {
-  const out = [];
-  for (const raw of names || []) {
-    const key = clean(raw);
-    if (!key) continue;
-    const alias = DEFERRED_SELECT_ALIASES[key.toLowerCase()];
-    if (alias) out.push(...alias);
-    else out.push(key);
-  }
-  return [...new Set(out)];
-}
-
-function storedDeferredToolNames(session) {
-  for (const source of [session?.deferredDiscoveredTools, session?.deferredSelectedTools]) {
-    const names = parseToolSelection(source);
-    if (names.length) return names;
-  }
-  return [];
-}
-
-function canonicalDeferredToolNames(catalog, names) {
-  const byName = new Map();
-  for (const tool of catalog || []) {
-    const name = clean(tool?.name);
-    if (!name) continue;
-    byName.set(name, name);
-    byName.set(name.toLowerCase(), name);
-  }
-  const out = [];
-  for (const raw of expandSelectionNames(names)) {
-    const name = clean(raw);
-    const canonical = byName.get(name) || byName.get(name.toLowerCase());
-    if (canonical) out.push(canonical);
-  }
-  return sortedNamesByMeasuredUsage(new Set(out));
-}
-
-function setDeferredToolState(session, names) {
-  if (!session) return [];
-  const selected = sortedNamesByMeasuredUsage(new Set(parseToolSelection(names)));
-  session.deferredDiscoveredTools = selected;
-  session.deferredSelectedTools = selected;
-  return selected;
-}
-
-function isReadonlySelectable(tool) {
-  const name = clean(tool?.name);
-  if (READONLY_TOOL_NAMES.has(name)) return true;
-  const annotations = tool?.annotations || {};
-  if (annotations.destructiveHint === true) return false;
-  if (annotations.readOnlyHint === true) return true;
-  return false;
-}
-
-function applyDeferredToolSurface(session, mode, extraTools = [], options = {}) {
-  if (!session || !Array.isArray(session.tools)) return session;
-  const providerMode = deferredProviderMode(options.provider || session.provider);
-  const byName = new Map();
-  for (const tool of [...session.tools, ...(extraTools || [])]) {
-    const name = clean(tool?.name);
-    if (!name || byName.has(name)) continue;
-    byName.set(name, activeToolForSurface(tool));
-  }
-  const catalog = sortedCatalogByMeasuredUsage([...byName.values()]);
-  const defaultNames = defaultDeferredToolNames(catalog, mode);
-  const storedNames = providerMode === 'native' ? [] : storedDeferredToolNames(session);
-  let selectedNames = providerMode === 'full'
-    ? sortedNamesByMeasuredUsage(catalog.map((tool) => clean(tool?.name)).filter(Boolean))
-    : [];
-  if (providerMode !== 'full') {
-    selectedNames = storedNames.length ? canonicalDeferredToolNames(catalog, storedNames) : [];
-    if (!selectedNames.length || providerMode === 'native') selectedNames = sortedNamesByMeasuredUsage(defaultNames);
-  }
-  const selected = new Set(selectedNames);
-  session.deferredToolCatalog = catalog;
-  session.deferredToolUsage = MEASURED_TOOL_USAGE;
-  session.deferredDefaultTools = sortedNamesByMeasuredUsage(defaultNames);
-  session.deferredProviderMode = providerMode;
-  session.deferredNativeTools = providerMode === 'native';
-  session.tools.length = 0;
-  const active = [];
-  for (const tool of catalog) {
-    if (!selected.has(clean(tool?.name))) continue;
-    if (mode === 'readonly' && !isReadonlySelectable(tool)) continue;
-    session.tools.push(tool);
-    active.push(clean(tool?.name));
-  }
-  if (providerMode === 'native') {
-    const discovered = canonicalDeferredToolNames(catalog, session.deferredDiscoveredTools || []);
-    session.deferredSelectedTools = active;
-    session.deferredDiscoveredTools = discovered.filter((name) => !selected.has(name));
-  } else {
-    setDeferredToolState(session, active);
-  }
-  return session;
-}
-
-function selectDeferredTools(session, names, mode) {
-  const catalog = Array.isArray(session?.deferredToolCatalog)
-    ? session.deferredToolCatalog
-    : (Array.isArray(session?.tools) ? session.tools : []);
-  const active = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const native = session?.deferredProviderMode === 'native' || session?.deferredNativeTools === true;
-  const discovered = new Set(Array.isArray(session?.deferredDiscoveredTools) ? session.deferredDiscoveredTools : []);
-  const byName = new Map();
-  for (const tool of catalog) {
-    const name = clean(tool?.name);
-    if (!name) continue;
-    byName.set(name, tool);
-    byName.set(name.toLowerCase(), tool);
-  }
-  const added = [];
-  const already = [];
-  const blocked = [];
-  const missing = [];
-  for (const rawName of expandSelectionNames(names)) {
-    const requestedName = clean(rawName);
-    const tool = byName.get(requestedName) || byName.get(requestedName.toLowerCase());
-    const name = clean(tool?.name);
-    if (!tool) {
-      missing.push(requestedName);
-      continue;
-    }
-    if (mode === 'readonly' && !isReadonlySelectable(tool)) {
-      blocked.push({ name, reason: 'readonly mode' });
-      continue;
-    }
-    if (active.has(name) || discovered.has(name)) {
-      already.push(name);
-      continue;
-    }
-    if (native) {
-      discovered.add(name);
-    } else {
-      session.tools.push(tool);
-      active.add(name);
-    }
-    added.push(name);
-  }
-  if (native) {
-    session.deferredDiscoveredTools = sortedNamesByMeasuredUsage(discovered);
-    session.deferredSelectedTools = sortedNamesByMeasuredUsage(active);
-  } else {
-    setDeferredToolState(session, active);
-  }
-  return { added, already, blocked, missing, native };
-}
-
-function renderToolSearch(args = {}, session, mode = 'full') {
-  const catalog = Array.isArray(session?.deferredToolCatalog)
-    ? session.deferredToolCatalog
-    : (Array.isArray(session?.tools) ? session.tools : []);
-  const rawQuery = clean(args.query);
-  const explicitSelectedNames = parseToolSelection(args.select);
-  const querySelectedNames = explicitSelectedNames.length ? [] : parseToolSearchQuerySelection(rawQuery);
-  const forcedSelectedNames = explicitSelectedNames.length ? explicitSelectedNames : querySelectedNames;
-  const query = querySelectedNames.length ? '' : rawQuery.toLowerCase();
-  const limit = Math.max(1, Math.min(50, Number(args.limit) || 20));
-  const initialActiveNames = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const initialRows = catalog.map((tool) => toolRow(tool, initialActiveNames)).filter((row) => row.name);
-  const autoSelectedNames = (!forcedSelectedNames.length && query)
-    ? autoToolSelectionNames(query, initialRows)
-    : [];
-  const selectedNames = forcedSelectedNames.length ? forcedSelectedNames : autoSelectedNames;
-  const toolSelection = selectedNames.length ? selectDeferredTools(session, selectedNames, mode) : null;
-  const selectionMode = forcedSelectedNames.length ? 'select' : (autoSelectedNames.length ? 'auto' : null);
-  const nextActiveNames = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const rows = [
-    ...catalog.map((tool) => toolRow(tool, nextActiveNames)),
-  ].filter((row) => row.name);
-  const matches = query
-    ? rankedToolSearchRows(rows, query)
-    : rows;
-  const selected = toolSelection
-    ? {
-        mode: selectionMode,
-        tools: toolSelection,
-      }
-    : null;
-  const nativeToolSearch = toolSelection?.native
-    ? toolSearchNativePayload(catalog, toolSelection.added, session?.provider)
-    : null;
-  return JSON.stringify({
-    selected,
-    ...(nativeToolSearch ? { nativeToolSearch } : {}),
-    totalMatches: matches.length,
-    matches: matches.slice(0, limit),
-    activeTools: sortedNamesByMeasuredUsage(nextActiveNames),
-    discoveredTools: sortedNamesByMeasuredUsage(session?.deferredDiscoveredTools || []),
-    note: 'query ranks matches and auto-loads high-confidence deferred tools; select exact tool names, or query select:a,b, to force load.',
-  }, null, 2);
-}
+  '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,
+  activeWorkflowId,
+  loadWorkflowPack,
+  workflowSummary,
+  activeWorkflowSummary,
+  loadAgentDefinition,
+  workflowContextBlock,
+} = createWorkflowHelpers({
+  rootDir: STANDALONE_ROOT,
+  dataDir: STANDALONE_DATA_DIR,
+  readMarkdownDocument,
+  normalizeAgentPermissionOrNone,
+});
+const {
+  summarizeWorkflowRoutes,
+  routeFromPreset,
+  agentRouteFromConfig,
+} = createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset });
 
 export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full') {
   return renderToolSearch(args, session, mode);
@@ -2182,8 +459,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 +876,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 +910,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 +944,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 +957,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 +966,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 +977,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 +1102,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 +1119,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 +1234,26 @@ 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 {}
+    }
+    // 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;
   }
 
@@ -2879,17 +1267,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 = {}) {
@@ -2943,7 +1337,8 @@ export async function createMixdogSessionRuntime({
         mcpScript: mcpScriptForPlugin(root),
       };
       plugin.mcpServerName = pluginMcpServerName(plugin);
-      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName);
+      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName)
+        || Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
       plugins.push(plugin);
     };
 
@@ -2964,19 +1359,53 @@ 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 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
       : {};
-    if (Object.keys(servers).length === 0) return mcpStatus();
+    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 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 +1413,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 +1462,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();
@@ -3011,6 +1475,18 @@ export async function createMixdogSessionRuntime({
     mgr,
     dataDir: cfgMod.getPluginData(),
     cwd,
+    // SubagentStart/SubagentStop: bridge internal worker spawn/finish to the
+    // standard hook bus. agent_type is passed top-level via hookCommonPayload
+    // (added to hook-bus buildEventPayload passthrough). Best-effort.
+    onSubagentEvent: (phase, info = {}) => {
+      try {
+        const event = phase === 'stop' ? 'SubagentStop' : 'SubagentStart';
+        void hooks.dispatch(event, hookCommonPayload({
+          session_id: info?.session_id || null,
+          agent_type: info?.agent_type || null,
+        }));
+      } catch { /* best-effort: subagent hook must never affect worker lifecycle */ }
+    },
   });
   bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
   const agentStatusState = () => {
@@ -3035,10 +1511,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 +1647,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 +1662,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 };
@@ -3216,6 +1695,58 @@ export async function createMixdogSessionRuntime({
   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);
@@ -3631,17 +2162,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 +2180,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 +2189,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 +2229,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 +2277,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 +2299,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 +2339,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 +2412,7 @@ function parsedProviderModelVersion(id) {
         preset: route.preset || undefined,
         tools: toolSpecForMode(mode),
         owner: 'cli',
-        role: 'lead',
+        agent: 'lead',
         lane: 'cli',
         sourceType: 'lead',
         sourceName: 'main',
@@ -3906,11 +2461,61 @@ function parsedProviderModelVersion(id) {
         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,
+      });
       applyDeferredToolSurface(session, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
       applyPreSessionToolSelection();
       writeStatuslineRoute(statusRoutes, session, route);
       hooks.emit('session:create', { sessionId: session.id, provider: route.provider, model: route.model, toolMode: mode, cwd: currentCwd });
-      // SessionStart: bridge to the standard Claude Code hook bus. Best-effort;
+      // SessionStart: bridge to the standard project hook bus. Best-effort;
       // a hook error must never break session creation. additionalContext is
       // injected before the first user turn as a system-reminder context pair.
       try {
@@ -4021,6 +2626,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 +2707,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 +2732,63 @@ 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;
+    // 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.
+    try { flushBackendSave(); } catch {}
+    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 +2816,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 +2824,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 +2854,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 +2982,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 +3023,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 +3105,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 +3221,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 +3258,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 +3321,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 +3373,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 });
@@ -4629,11 +3390,24 @@ function parsedProviderModelVersion(id) {
       return this.getOnboardingStatus();
     },
     getChannelSetup() {
+      // Flush a pending debounced backend switch first so setup readers
+      // (Settings → Channel Setting, remote toggles) never observe the
+      // previous backend during the 150ms debounce window.
+      try { flushBackendSave(); } catch {}
       return channelSetup();
     },
     getChannelWorkerStatus() {
       return channels.status();
     },
+    startRemote() {
+      return startRemote();
+    },
+    stopRemote(reason) {
+      return stopRemote(reason);
+    },
+    isRemoteEnabled() {
+      return isRemoteEnabled();
+    },
     saveDiscordToken(token) {
       const result = saveDiscordToken(token);
       reloadChannelsSoon();
@@ -4644,6 +3418,33 @@ function parsedProviderModelVersion(id) {
       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();
@@ -4756,6 +3557,12 @@ function parsedProviderModelVersion(id) {
       invalidateProviderCaches();
       return result;
     },
+    async loginOpenCodeGoUsage() {
+      const result = await loginOpenCodeGoUsage(cfgMod);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      return result;
+    },
     setLocalProvider(providerId, opts) {
       const result = setLocalProvider(cfgMod, providerId, opts);
       reloadFullConfig();
@@ -4866,26 +3673,51 @@ function parsedProviderModelVersion(id) {
         const names = before.styles.map((style) => style.label || style.id).join(', ') || 'Default';
         throw new Error(`output style must be one of ${names}`);
       }
-      if (typeof sharedCfgMod.updateConfig !== 'function') throw new Error('output style config writer unavailable');
-      sharedCfgMod.updateConfig((root) => {
-        const next = { ...(root || {}), outputStyle: selected.id };
-        if (next.agent && typeof next.agent === 'object' && !Array.isArray(next.agent)) {
-          const agent = { ...next.agent };
-          delete agent.outputStyle;
-          next.agent = agent;
-        }
-        return next;
-      });
-      invalidateOutputStyleStatusCache();
+      // Adopt in-memory immediately so same-tick readers see the new style;
+      // persist off the key-handler tick. NOTE: the disk write goes through
+      // the dedicated flushOutputStyleSave debounce (sharedCfgMod whole-root
+      // RMW) — cfgMod.saveConfig only serializes agent-section fields and
+      // would drop the top-level outputStyle key.
+      const nextConfig = { ...config, outputStyle: selected.id };
+      if (nextConfig.agent && typeof nextConfig.agent === 'object' && !Array.isArray(nextConfig.agent)) {
+        const agent = { ...nextConfig.agent };
+        delete agent.outputStyle;
+        nextConfig.agent = agent;
+      }
+      adoptConfig(nextConfig);
+      pendingOutputStyleId = selected.id;
+      if (outputStyleSaveTimer) clearTimeout(outputStyleSaveTimer);
+      outputStyleSaveTimer = setTimeout(flushOutputStyleSave, CONFIG_SAVE_DEBOUNCE_MS);
+      outputStyleSaveTimer.unref?.();
+      // 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);
       const hasConversation = sessionHasConversationMessages(session);
       let appliedToCurrentSession = !hasConversation;
       if (session?.id && !hasConversation) {
-        mgr.closeSession(session.id, 'cli-output-style-switch');
+        const closedSessionId = session.id;
+        mgr.closeSession(closedSessionId, 'cli-output-style-switch');
         session = null;
-        await recreateCurrentSessionIfReady();
+        // Defer the recreate so the output-style picker can repaint first;
+        // any failure still surfaces via the existing notice path.
+        setTimeout(() => {
+          recreateCurrentSessionIfReady().catch((err) => {
+            try {
+              notifyFnForSession(closedSessionId)(
+                `Failed to start a new session after output style change: ${err?.message || err}`,
+                { level: 'error' },
+              );
+            } catch {}
+          });
+        }, 0);
       }
       invalidateContextStatusCache();
-      return { ...getOutputStyleStatusCached({ fresh: true }), appliedToCurrentSession };
+      return { ...freshStatus, appliedToCurrentSession };
     },
     async setWorkflow(workflowId) {
       const id = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
@@ -4933,6 +3765,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 +3786,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 +3840,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 +3859,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 +3903,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.
@@ -5008,6 +3930,18 @@ function parsedProviderModelVersion(id) {
         return { result, session };
       } catch (error) {
         hooks.emit('turn:error', { sessionId: session?.id || null, elapsedMs: Date.now() - startedAt, error: error?.message || String(error) });
+        // StopFailure: bridge a turn error to the standard hook bus. Spec:
+        // output + exit code ignored, so pure fire-and-forget. error_type is a
+        // simple regex mapping from the error message (default 'unknown').
+        try {
+          const msg = String(error?.message || error || '').toLowerCase();
+          const errorType = /rate.?limit|429|too many requests/.test(msg) ? 'rate_limit'
+            : /overloaded|529/.test(msg) ? 'overloaded'
+            : /authenticat|unauthorized|401|invalid.*api.?key/.test(msg) ? 'authentication_failed'
+            : /server.?error|5\d\d|internal error/.test(msg) ? 'server_error'
+            : 'unknown';
+          void hooks.dispatch('StopFailure', hookCommonPayload({ session_id: session?.id || null, error_type: errorType }));
+        } catch { /* best-effort: StopFailure hook must never break teardown */ }
         throw error;
       } finally {
         activeTurnCount = Math.max(0, activeTurnCount - 1);
@@ -5034,7 +3968,14 @@ function parsedProviderModelVersion(id) {
       if (activeTurnCount > 0) {
         return { changed: false, reason: 'compact skipped: turn in progress' };
       }
+      // Manual compact bypasses loop.mjs, so its PreCompact/PostCompact never
+      // fire here — dispatch them explicitly via the session-property hooks
+      // (wired at session create). Best-effort; a hook must not block compaction.
+      try { await session.preCompactHook?.({ trigger: 'manual' }); }
+      catch { /* best-effort: PreCompact hook must never break manual compact */ }
       const result = await mgr.compactSessionMessages(session.id);
+      try { await session.postCompactHook?.({ trigger: 'manual' }); }
+      catch { /* best-effort: PostCompact hook must never break manual compact */ }
       session = mgr.getSession(session.id) || session;
       if (options.recoverAgent === true) {
         try { agentTool.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
@@ -5206,9 +4147,15 @@ function parsedProviderModelVersion(id) {
       const removed = registryRemovePlugin(key, { dataDir });
       const nextConfig = { ...config };
       const serverName = pluginMcpServerName(plugin);
-      if (nextConfig.mcpServers && Object.prototype.hasOwnProperty.call(nextConfig.mcpServers, serverName)) {
+      const prefix = `${serverName}--`;
+      const hasMatch = nextConfig.mcpServers && Object.keys(nextConfig.mcpServers).some(
+        (k) => k === serverName || k.startsWith(prefix)
+      );
+      if (hasMatch) {
         const current = { ...nextConfig.mcpServers };
-        delete current[serverName];
+        for (const k of Object.keys(current)) {
+          if (k === serverName || k.startsWith(prefix)) delete current[k];
+        }
         saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
         await connectConfiguredMcp({ reset: true });
         invalidatePreSessionToolSurface();
@@ -5221,22 +4168,50 @@ function parsedProviderModelVersion(id) {
       const root = clean(plugin.root);
       const script = clean(plugin.mcpScript);
       if (!root || !script) throw new Error('plugin has no MCP script');
-      const scriptPath = join(root, script);
-      if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
       const serverName = pluginMcpServerName(plugin);
       const nextConfig = { ...config };
-      nextConfig.mcpServers = {
-        ...(nextConfig.mcpServers || {}),
-        [serverName]: {
-          command: 'node',
-          args: [scriptPath],
-          cwd: root,
-          env: {
+      if (script === '.mcp.json') {
+        const mcpJsonPath = join(root, script);
+        if (!existsSync(mcpJsonPath)) throw new Error(`plugin MCP manifest not found: ${mcpJsonPath}`);
+        const manifest = readJsonSafe(mcpJsonPath) || {};
+        const rawServers = manifest.mcpServers;
+        const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+        if (!isPlainObject(rawServers)) throw new Error(`plugin .mcp.json missing mcpServers object: ${mcpJsonPath}`);
+        const keys = Object.keys(rawServers).filter((k) => isPlainObject(rawServers[k]));
+        if (!keys.length) throw new Error(`plugin .mcp.json has no mcpServers: ${mcpJsonPath}`);
+        const ownedPrefix = `${serverName}--`;
+        const nextServers = {};
+        for (const [k, v] of Object.entries(nextConfig.mcpServers || {})) {
+          if (k === serverName || k.startsWith(ownedPrefix)) continue;
+          nextServers[k] = v;
+        }
+        for (const serverKey of keys) {
+          const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], root);
+          cfg.env = {
+            ...(cfg.env || {}),
             MIXDOG_PLUGIN_ROOT: root,
             MIXDOG_PLUGIN_DATA: join(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
+          };
+          const key = keys.length === 1 ? serverName : `${serverName}--${serverKey}`;
+          nextServers[key] = cfg;
+        }
+        nextConfig.mcpServers = nextServers;
+      } else {
+        const scriptPath = join(root, script);
+        if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
+        nextConfig.mcpServers = {
+          ...(nextConfig.mcpServers || {}),
+          [serverName]: {
+            command: 'node',
+            args: [scriptPath],
+            cwd: root,
+            env: {
+              MIXDOG_PLUGIN_ROOT: root,
+              MIXDOG_PLUGIN_DATA: join(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
+            },
           },
-        },
-      };
+        };
+      }
       saveConfigAndAdopt(nextConfig);
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
@@ -5306,7 +4281,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 +4317,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 +4324,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,
@@ -5413,10 +4395,28 @@ function parsedProviderModelVersion(id) {
     async close(reason = 'cli-exit', options = {}) {
       const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
       closeRequested = true;
+      // SessionEnd: bridge teardown to the standard hook bus. reason mapped to
+      // standard values ('clear'/'exit' where applicable, else 'other'). Short
+      // await guard so a slow hook cannot wedge teardown; best-effort.
+      try {
+        const rl = String(reason || '').toLowerCase();
+        const endReason = /clear/.test(rl) ? 'clear'
+          : /exit|quit|cli-exit|shutdown|sigint|sigterm/.test(rl) ? 'exit'
+          : 'other';
+        if (session?.id) {
+          await withTeardownDeadline(
+            Promise.resolve(hooks.dispatch('SessionEnd', hookCommonPayload({ session_id: session.id, reason: endReason }))).catch(() => {}),
+            300,
+            undefined,
+          );
+        }
+      } catch { /* best-effort: SessionEnd hook must never wedge teardown */ }
       // Persist any change that is still sitting in the debounce window so a
       // toggle made right before exit is not lost. Synchronous + best-effort:
       // teardown must continue even if the final write fails.
       try { flushConfigSave(); } catch {}
+      try { flushBackendSave(); } catch {}
+      try { flushOutputStyleSave(); } catch {}
       if (channelStartTimer) {
         clearTimeout(channelStartTimer);
         channelStartTimer = null;
@@ -5433,6 +4433,10 @@ function parsedProviderModelVersion(id) {
         clearTimeout(providerModelWarmupTimer);
         providerModelWarmupTimer = null;
       }
+      if (modelCatalogWarmupTimer) {
+        clearTimeout(modelCatalogWarmupTimer);
+        modelCatalogWarmupTimer = null;
+      }
       if (codeGraphPrewarmTimer) {
         clearTimeout(codeGraphPrewarmTimer);
         codeGraphPrewarmTimer = null;
@@ -5511,8 +4515,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));