mixdog 0.8.1 → 0.9.1

package/src/mixdog-session-runtime.mjs

@@ -3,14 +3,23 @@ import { homedir } from 'node:os';
 import { basename, dirname, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
-import { ensureProjectMixdogMd, ensureStandaloneEnvironment } from './standalone/seeds.mjs';
-import { createStandaloneBridge } from './standalone/bridge-tool.mjs';
+import { ensureStandaloneEnvironment } from './standalone/seeds.mjs';
+import { createStandaloneAgent } from './standalone/agent-tool.mjs';
+import { isAgentOwner } from './runtime/agent/orchestrator/agent-owner.mjs';
 import { EXPLORE_TOOL, runExplore } from './standalone/explore-tool.mjs';
 import { createStandaloneChannelWorker } from './standalone/channel-worker.mjs';
+import { createStandaloneMemoryRuntime } from './standalone/memory-runtime-proxy.mjs';
 import { createStandaloneHookBus } from './standalone/hook-bus.mjs';
 import { writeLastSessionCwd } from './runtime/shared/user-cwd.mjs';
 import { cancelBackgroundTasks } from './runtime/shared/background-tasks.mjs';
-import { createWorkspaceRouter, formatWorkspaceSessionContext } from './runtime/shared/workspace-router.mjs';
+import {
+  modelVisibleToolCompletionMessage,
+  shouldPersistModelVisibleToolCompletion,
+} from './runtime/shared/tool-execution-contract.mjs';
+import {
+  normalizeAgentPermissionOrNone,
+  readMarkdownDocument,
+} from './runtime/shared/markdown-frontmatter.mjs';
 import { setConfiguredShell } from './runtime/agent/orchestrator/tools/builtin/shell-runtime.mjs';
 import {
   PROVIDER_STATUS_TOOL,
@@ -25,6 +34,12 @@ import {
   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 {
+  isResponsesFreeformTool,
+  toResponsesCustomTool,
+} from './runtime/agent/orchestrator/providers/custom-tool-wire.mjs';
 import {
   channelSetup,
   deleteChannel,
@@ -52,9 +67,76 @@ import {
 import {
   estimateMessagesTokens,
   estimateRequestReserveTokens,
+  estimateTranscriptContextUsage,
   estimateToolSchemaTokens,
 } 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;
@@ -113,9 +195,8 @@ function splitMarkdownSections(text) {
 function reminderSectionBucket(section) {
   const heading = String(section.match(/^#\s+([^\n]+)/)?.[1] || '').trim().toLowerCase();
   if (heading.includes('core memory')) return 'memory';
-  if (heading.includes('mixdog-project-context') || heading.includes('project-context')) return 'project';
   if (heading.includes('active workflow') || heading.includes('available agents') || heading.includes('workflow')) return 'workflow';
-  if (heading.includes('workspace') || heading === 'role' || heading.includes('role-identity') || heading.includes('task-brief')) return 'workspace';
+  if (heading.includes('workspace')) return 'workspace';
   if (heading.includes('environment')) return 'environment';
   return 'other';
 }
@@ -134,7 +215,6 @@ function summarizeContextMessages(messages) {
     assistant: { count: 0, tokens: 0 },
     toolResults: { count: 0, tokens: 0 },
     reminders: { count: 0, tokens: 0, otherTokens: 0 },
-    project: { tokens: 0 },
     workflow: { tokens: 0 },
     memory: { tokens: 0 },
     workspace: { tokens: 0 },
@@ -252,6 +332,10 @@ function envFlag(name) {
   return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
 }
 
+function envPresent(name) {
+  return process.env[name] !== undefined && process.env[name] !== '';
+}
+
 function envDelayMs(name, fallback, { min = 0, max = 60_000 } = {}) {
   const raw = process.env[name];
   if (raw === undefined || raw === '') return fallback;
@@ -292,7 +376,7 @@ async function profiledImport(label, spec, { optional = false } = {}) {
 const EFFORT_OPTIONS_BY_PROVIDER = {
   openai: ['none', 'low', 'medium', 'high', 'xhigh'],
   'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
-  anthropic: ['low', 'medium', 'high', 'max'],
+  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
   'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
   xai: ['none', 'low', 'medium', 'high'],
   'grok-oauth': ['none', 'low', 'medium', 'high'],
@@ -329,15 +413,15 @@ export const TOOL_SEARCH_TOOL = {
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false,
-    bridgeHidden: true,
+    agentHidden: true,
   },
-  description: 'Search the current standalone tool surface and select deferred tools/skills for the task. Use before unfamiliar or currently inactive tools.',
+  description: 'Search deferred tools; confident queries load matches.',
   inputSchema: {
     type: 'object',
     properties: {
-      query: { type: 'string', description: 'Optional search text, e.g. shell, bridge, memory, skill, mcp.' },
-      select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Tool/skill names to activate, as comma-separated text or an array.' },
-      limit: { type: 'number', description: 'Maximum matches to return.' },
+      query: { type: 'string', description: 'Search text; confident hits load. select:a,b forces exact names.' },
+      select: { anyOf: [{ type: 'string' }, { type: 'array', items: { type: 'string' } }], description: 'Force exact tool names.' },
+      limit: { type: 'number', description: 'Max matches.' },
     },
     additionalProperties: false,
   },
@@ -352,43 +436,66 @@ const CHANNEL_STATUS_TOOL = {
     destructiveHint: false,
     idempotentHint: true,
     openWorldHint: false,
-    bridgeHidden: true,
+    agentHidden: true,
   },
-  description: 'List standalone Discord/channel/schedule/webhook configuration status. Read-only and never returns secrets.',
+  description: 'List channel/schedule/webhook status. No secrets.',
   inputSchema: { type: 'object', properties: {}, additionalProperties: false },
 };
 
 const CWD_TOOL = {
   name: 'cwd',
-  title: 'Current Working Directory',
+  title: 'Work Project',
   annotations: {
-    title: 'Current Working Directory',
+    title: 'Work Project',
     readOnlyHint: false,
     destructiveHint: false,
     idempotentHint: false,
     openWorldHint: false,
-    bridgeHidden: true,
+    agentHidden: true,
   },
-  description: 'Show or set the standalone session working directory. Default get; action=set requires path.',
+  description: 'Show or set the session work project for tool execution.',
   inputSchema: {
     type: 'object',
     properties: {
-      action: { type: 'string', enum: ['get', 'set'], description: 'Default get, or set when path is provided.' },
-      path: { type: 'string', description: 'Directory path for action=set. Relative paths resolve from the current cwd.' },
+      action: { type: 'string', enum: ['get', 'set'], description: 'Default get.' },
+      path: { type: 'string', description: 'Project directory for set.' },
     },
     additionalProperties: false,
   },
 };
 
+export const SKILL_TOOL = {
+  name: 'Skill',
+  title: 'Skill',
+  annotations: {
+    title: 'Skill',
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false,
+    agentHidden: false,
+  },
+  description: 'Load a named SKILL.md into context.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      name: { type: 'string', description: 'Skill name.' },
+    },
+    required: ['name'],
+    additionalProperties: false,
+  },
+};
+
 const MEASURED_TOOL_USAGE = Object.freeze({
   read: 710,
   code_graph: 520,
   grep: 500,
+  find: 480,
   glob: 460,
   list: 430,
   apply_patch: 400,
   explore: 360,
-  bridge: 330,
+  agent: 330,
   shell: 81,
   cwd: 2,
   diagnostics: 2,
@@ -399,44 +506,54 @@ const MEASURED_TOOL_USAGE = Object.freeze({
   channel_status: 2,
 });
 const MEASURED_TOOL_ORDER = Object.freeze(Object.keys(MEASURED_TOOL_USAGE));
-const DEFERRED_ALWAYS_ACTIVE_TOOLS = new Set([
+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',
-  'recall',
-  'search',
-  'web_fetch',
 ]);
-const LEAD_DISALLOWED_TOOLS = Object.freeze(['diagnostics', 'open_config']);
-const DEFERRED_DEFAULT_FULL_LIMIT = 9;
 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',
-  'bridge',
+  'agent',
   'recall',
   'search',
   'web_fetch',
   'cwd',
+  'Skill',
   'tool_search',
 ]);
 const READONLY_TOOL_NAMES = new Set([
   'read',
   'list',
   'grep',
+  'find',
   'glob',
   'code_graph',
   'search',
@@ -447,21 +564,22 @@ const READONLY_TOOL_NAMES = new Set([
   'channel_status',
   'schedule_status',
   'fetch',
+  'Skill',
 ]);
-const BRIDGE_HIDDEN_WRAPPER_TOOLS = new Set(['explore', 'search']);
+const AGENT_HIDDEN_WRAPPER_TOOLS = new Set(['search']);
 
 function applyStandaloneToolDefaults(tool) {
-  if (!tool || !BRIDGE_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;
+  if (!tool || !AGENT_HIDDEN_WRAPPER_TOOLS.has(tool.name)) return tool;
   return {
     ...tool,
     annotations: {
       ...(tool.annotations || {}),
-      bridgeHidden: true,
+      agentHidden: true,
     },
   };
 }
 const DEFERRED_SELECT_ALIASES = {
-  filesystem: ['read', 'list', 'grep', 'glob'],
+  filesystem: ['read', 'list', 'grep', 'find', 'glob'],
   search: ['search', 'web_fetch'],
   web: ['web_fetch', 'search'],
   memory: ['memory', 'recall'],
@@ -474,11 +592,68 @@ const DEFERRED_SELECT_ALIASES = {
   channel: ['channel_status'],
   explore: ['explore'],
   discovery: ['explore'],
-  bridge: ['bridge'],
+  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();
@@ -503,8 +678,21 @@ function effortOptionsFor(provider, model) {
   const declared = Array.isArray(model?.reasoningLevels)
     ? model.reasoningLevels.map(clean).filter(Boolean)
     : [];
-  if (Array.isArray(model?.reasoningLevels)) return filterProvider(declared);
   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]);
   }
@@ -557,10 +745,23 @@ 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'],
@@ -793,6 +994,21 @@ function resolveRoute(config, { provider, model, effort, fast } = {}) {
   };
 }
 
+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 };
@@ -827,12 +1043,51 @@ function normalizeSystemShellCommand(value) {
 function normalizeAutoClearConfig(value = {}) {
   const raw = value && typeof value === 'object' ? value : {};
   const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
+  const compactType = clean(raw.compactType ?? raw.compact_type ?? raw.type);
+  const normalizedCompactType = compactType ? normalizeCompactTypeSetting(compactType, 'semantic') : '';
   return {
     enabled: raw.enabled !== false,
     idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
+    ...(normalizedCompactType ? { compactType: normalizedCompactType } : {}),
+  };
+}
+
+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`;
@@ -881,6 +1136,44 @@ function openAiDirectModelSupportsFast(model) {
     || /^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);
@@ -895,6 +1188,16 @@ function fastCapableFor(provider, 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;
@@ -903,10 +1206,10 @@ function fastPreferenceFor(config, provider, model) {
   return config?.fastModels?.[key] === true;
 }
 
-function saveModelSettings(cfgMod, route, { fastCapable = true } = {}) {
+function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
   const key = routeFastKey(route?.provider, route?.model);
-  if (!key) return cfgMod.loadConfig();
-  const nextConfig = cfgMod.loadConfig();
+  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;
@@ -948,17 +1251,80 @@ function routeForStatusline(route) {
   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 ONBOARDING_VERSION = 1;
-const WORKFLOW_ROUTE_SLOTS = ['lead', 'bridge', 'explorer', 'memory'];
+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: 'web-researcher', label: 'Web Researcher', description: 'External current-info research' },
   { 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 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+  ],
+  openai: [
+    { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5.4', display: 'GPT-5.4', latest: true, contextWindow: 1000000 },
+    { id: 'gpt-5', display: 'GPT-5', contextWindow: 400000 },
+    { id: 'gpt-4.1', display: 'GPT-4.1', contextWindow: 1000000 },
+    { id: 'gpt-4o', display: 'GPT-4o', contextWindow: 128000 },
+  ],
+  'grok-oauth': [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  xai: [
+    { id: 'grok-4.3', display: 'Grok 4.3', latest: true, contextWindow: 1000000 },
+    { id: 'grok-4.20', display: 'Grok 4.20', contextWindow: 1000000 },
+    { id: 'grok-4', display: 'Grok 4', contextWindow: 256000 },
+  ],
+  gemini: [
+    { id: 'gemini-3-pro', display: 'Gemini 3 Pro', latest: true, contextWindow: 1000000 },
+    { id: 'gemini-2.5-pro', display: 'Gemini 2.5 Pro', contextWindow: 1000000 },
+    { id: 'gemini-2.5-flash', display: 'Gemini 2.5 Flash', contextWindow: 1000000 },
+    { id: 'gemini-2.0-flash', display: 'Gemini 2.0 Flash', contextWindow: 1000000 },
+  ],
+  'anthropic-oauth': [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+  anthropic: [
+    { id: 'claude-opus-4-8', display: 'Claude Opus 4.8', latest: true, contextWindow: 1000000 },
+    { id: 'claude-sonnet-4-6', display: 'Claude Sonnet 4.6', latest: true, contextWindow: 1000000 },
+    { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
+  ],
+});
 const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
 const agentDefinitionCache = new Map();
 const DEFAULT_WORKFLOW_ID = 'default';
@@ -1016,12 +1382,14 @@ function readWorkflowPackFromDir(dir, source = 'built-in') {
   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,
-    agents: Array.isArray(manifest.agents) ? manifest.agents.map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent)).filter(Boolean) : [],
+    agentsConfigured,
+    agents: agentsConfigured ? manifest.agents.map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent)).filter(Boolean) : [],
     body,
     source,
   };
@@ -1059,6 +1427,20 @@ function loadWorkflowPack(dataDir, id) {
   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;
@@ -1067,20 +1449,22 @@ function loadAgentDefinition(dataDir, id) {
   for (const dir of agentSourceDirs(dataDir, agentId)) {
     const manifest = readJsonSafe(join(dir, 'agent.json')) || {};
     const entry = clean(manifest.entry) || 'AGENT.md';
-    const body = readTextSafe(join(dir, entry));
+    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 legacyBody = readTextSafe(join(dataDir || STANDALONE_DATA_DIR, 'roles', `${agentId}.md`))
-    || readTextSafe(join(STANDALONE_ROOT, 'agents', `${agentId}.md`));
-  if (!legacyBody) {
+  const legacyDoc = readMarkdownDocument(readTextSafe(join(STANDALONE_ROOT, 'agents', `${agentId}.md`)));
+  if (!legacyDoc.body) {
     agentDefinitionCache.set(cacheKey, null);
     return null;
   }
@@ -1088,7 +1472,9 @@ function loadAgentDefinition(dataDir, id) {
     id: agentId,
     name: FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
     description: '',
-    body: legacyBody,
+    permission: normalizeAgentPermissionOrNone(legacyDoc.frontmatter.permission),
+    frontmatter: legacyDoc.frontmatter,
+    body: legacyDoc.body,
   };
   agentDefinitionCache.set(cacheKey, definition);
   return definition;
@@ -1103,7 +1489,7 @@ function workflowContextBlock(config, dataDir) {
   if (pack.description) lines.push(pack.description);
   lines.push(pack.body);
 
-  const agentIds = pack.agents.length ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id);
+  const agentIds = pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id);
   const agentBlocks = agentIds
     .map((id) => loadAgentDefinition(dataDir, id))
     .filter(Boolean);
@@ -1122,6 +1508,11 @@ 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 {
@@ -1132,6 +1523,41 @@ function normalizeWorkflowRoute(routeLike, fallback = {}) {
   };
 }
 
+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;
@@ -1139,7 +1565,7 @@ function upsertWorkflowPreset(presets, slot, routeLike) {
   const preset = {
     id,
     name: workflowPresetName(slot),
-    type: 'bridge',
+    type: 'agent',
     provider: route.provider,
     model: route.model,
     ...(route.effort ? { effort: route.effort } : {}),
@@ -1161,24 +1587,19 @@ function summarizeWorkflowRoutes(config) {
   return out;
 }
 
-function legacyWorkflowRolePreset(dataDir, role) {
-  try {
-    const file = join(dataDir, 'user-workflow.json');
-    if (!existsSync(file)) return '';
-    const raw = JSON.parse(readFileSync(file, 'utf8'));
-    const found = (raw?.roles || []).find((item) => clean(item?.name) === role);
-    return clean(found?.preset);
-  } catch {
-    return '';
+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;
   }
-}
-
-function routeFromPreset(config, presetName) {
-  const preset = findPreset(config, presetName);
+  const preset = findPreset(config, slotValue);
   return preset ? normalizeWorkflowRoute(preset) : null;
 }
 
-function agentRouteFromConfig(config, agentId, dataDir) {
+function agentRouteFromConfig(config, agentId, _dataDir) {
   const id = normalizeAgentId(agentId);
   if (!id) return null;
   const explicit = normalizeWorkflowRoute(config?.agents?.[id])
@@ -1194,7 +1615,7 @@ function agentRouteFromConfig(config, agentId, dataDir) {
   if (id === 'explore') return routeFromPreset(config, config?.maintenance?.explore);
   if (id === 'maintainer') return routeFromPreset(config, config?.maintenance?.memory);
 
-  return routeFromPreset(config, legacyWorkflowRolePreset(dataDir, id));
+  return null;
 }
 
 function toolResponseText(result) {
@@ -1233,17 +1654,26 @@ function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
 
 function parseToolSelection(value) {
   if (Array.isArray(value)) return value.map(clean).filter(Boolean);
-  return String(value || '')
+  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_') || name === 'skills_list') return 'skill';
-  if (tool?.annotations?.bridgeHidden) return 'control';
+  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';
 }
@@ -1255,9 +1685,9 @@ function toolSchemaBucket(tool) {
   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', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
+  if (['read', 'grep', 'find', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
   if (['shell', 'apply_patch'].includes(name)) return 'mutation';
-  if (name === 'bridge' || name === 'delegate' || name.includes('bridge')) return 'agents';
+  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';
@@ -1304,6 +1734,17 @@ function activeToolForSurface(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));
@@ -1324,24 +1765,14 @@ function sortedNamesByMeasuredUsage(names) {
 }
 
 export function defaultDeferredToolNames(catalog, mode) {
+  const available = new Set((catalog || []).map((tool) => clean(tool?.name)).filter(Boolean));
   if (mode === 'lead') {
-    const available = new Set((catalog || []).map((tool) => clean(tool?.name)).filter(Boolean));
     return new Set(DEFERRED_DEFAULT_LEAD_TOOLS.filter((name) => available.has(name)));
   }
   if (mode === 'readonly') {
-    const available = new Set((catalog || []).map((tool) => clean(tool?.name)).filter(Boolean));
     return new Set(DEFERRED_DEFAULT_READONLY_TOOLS.filter((name) => available.has(name)));
   }
-  const names = new Set(DEFERRED_ALWAYS_ACTIVE_TOOLS);
-  const limit = DEFERRED_DEFAULT_FULL_LIMIT;
-  for (const tool of sortedCatalogByMeasuredUsage(catalog)) {
-    const name = clean(tool?.name);
-    if (!name || names.has(name)) continue;
-    if (mode === 'readonly' && !isReadonlySelectable(tool)) continue;
-    names.add(name);
-    if (names.size >= DEFERRED_ALWAYS_ACTIVE_TOOLS.size + limit) break;
-  }
-  return names;
+  return new Set(DEFERRED_DEFAULT_FULL_TOOLS.filter((name) => available.has(name)));
 }
 
 export function compactToolSearchDescription(value, max = 220) {
@@ -1360,25 +1791,180 @@ function toolRow(tool, activeNames = new Set()) {
   };
 }
 
+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;
-  const haystack = toolSearchText(row);
-  if (haystack.includes(raw)) return true;
-  const tokens = toolSearchTokens(raw);
-  if (tokens.length === 0) return haystack.includes(raw);
-  return tokens.some((token) => haystack.includes(token));
+  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) {
@@ -1393,6 +1979,39 @@ function expandSelectionNames(names) {
   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;
@@ -1402,8 +2021,9 @@ function isReadonlySelectable(tool) {
   return false;
 }
 
-function applyDeferredToolSurface(session, mode, extraTools = []) {
+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);
@@ -1412,14 +2032,34 @@ function applyDeferredToolSurface(session, mode, extraTools = []) {
   }
   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.deferredSelectedTools = sortedNamesByMeasuredUsage(defaultNames);
+  session.deferredDefaultTools = sortedNamesByMeasuredUsage(defaultNames);
+  session.deferredProviderMode = providerMode;
+  session.deferredNativeTools = providerMode === 'native';
   session.tools.length = 0;
+  const active = [];
   for (const tool of catalog) {
-    if (!defaultNames.has(clean(tool?.name))) continue;
+    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;
 }
@@ -1428,57 +2068,106 @@ 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) => tool?.name).filter(Boolean));
-  const byName = new Map(catalog.map((tool) => [tool?.name, tool]).filter(([name]) => name));
+  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 name of expandSelectionNames(names)) {
-    const tool = byName.get(name);
+  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(name);
+      missing.push(requestedName);
       continue;
     }
     if (mode === 'readonly' && !isReadonlySelectable(tool)) {
       blocked.push({ name, reason: 'readonly mode' });
       continue;
     }
-    if (active.has(name)) {
+    if (active.has(name) || discovered.has(name)) {
       already.push(name);
       continue;
     }
-    session.tools.push(tool);
-    active.add(name);
+    if (native) {
+      discovered.add(name);
+    } else {
+      session.tools.push(tool);
+      active.add(name);
+    }
     added.push(name);
   }
-  session.deferredSelectedTools = sortedNamesByMeasuredUsage(active);
-  return { added, already, blocked, missing };
+  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 activeNames = new Set((session?.tools || []).map((tool) => tool?.name).filter(Boolean));
-  const query = clean(args.query).toLowerCase();
-  const selectedNames = parseToolSelection(args.select);
+  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 selection = selectedNames.length ? selectDeferredTools(session, selectedNames, mode) : null;
-  const nextActiveNames = new Set((session?.tools || []).map((tool) => tool?.name).filter(Boolean));
-  const rows = catalog.map((tool) => toolRow(tool, nextActiveNames)).filter((row) => row.name);
+  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
-    ? rows.filter((row) => toolSearchMatches(row, 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: selection,
+    selected,
+    ...(nativeToolSearch ? { nativeToolSearch } : {}),
     totalMatches: matches.length,
     matches: matches.slice(0, limit),
     activeTools: sortedNamesByMeasuredUsage(nextActiveNames),
-    note: 'standalone: tool_search adds deferred tools to the current session schema for the next model iteration.',
+    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);
 }
 
+export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full') {
+  return renderToolSearch(args, session, mode);
+}
+
+export function __saveModelSettingsForTest(cfgMod, route, options = {}) {
+  return saveModelSettings(cfgMod, route, options);
+}
+
 function resolveCwdPath(currentCwd, value) {
   const raw = clean(value);
   if (!raw) throw new Error('cwd: path is required for action=set');
@@ -1501,7 +2190,6 @@ export async function createMixdogSessionRuntime({
     rootDir: STANDALONE_ROOT,
     dataDir: STANDALONE_DATA_DIR,
   });
-  ensureProjectMixdogMd({ cwd });
   bootProfile('standalone-env:ready', { ms: (performance.now() - standaloneStartedAt).toFixed(1) });
 
   const importsStartedAt = performance.now();
@@ -1533,18 +2221,51 @@ export async function createMixdogSessionRuntime({
     profiledImport('code-graph-tool-defs', CODE_GRAPH_TOOL_DEFS, { optional: true }),
   ]);
   bootProfile('imports:ready', { ms: (performance.now() - importsStartedAt).toFixed(1) });
+  const pluginDataDir = cfgMod.getPluginData();
+  const memoryRuntime = createStandaloneMemoryRuntime({
+    entry: join(STANDALONE_ROOT, MEMORY_RUNTIME.replace(/^\.\//, '')),
+    dataDir: pluginDataDir,
+    cwd,
+  });
   let memoryModPromise = null;
-  let memoryInitPromise = null;
   let searchModPromise = null;
   let codeGraphModPromise = null;
+  let outputStyleStatusCache = null;
+  let outputStyleStatusCacheAt = 0;
+  let outputStyleStatusCacheDir = '';
+
+  const memoryEnabled = () => moduleEnabled(config, 'memory', true);
+  const channelsEnabled = () => moduleEnabled(config, 'channels', true);
+  const getOutputStyleStatusCached = ({ fresh = false } = {}) => {
+    const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+    const cacheDir = resolve(dataDir);
+    const now = performance.now();
+    if (
+      !fresh
+      && outputStyleStatusCache
+      && outputStyleStatusCacheDir === cacheDir
+      && now - outputStyleStatusCacheAt < 2500
+    ) {
+      return outputStyleStatusCache;
+    }
+    outputStyleStatusCache = outputStyleStatus(dataDir);
+    outputStyleStatusCacheAt = now;
+    outputStyleStatusCacheDir = cacheDir;
+    return outputStyleStatusCache;
+  };
+  const invalidateOutputStyleStatusCache = () => {
+    outputStyleStatusCache = null;
+    outputStyleStatusCacheAt = 0;
+    outputStyleStatusCacheDir = '';
+  };
 
   async function getMemoryModule() {
+    if (!memoryEnabled()) throw new Error('memory is disabled in settings');
     const startedAt = performance.now();
-    memoryModPromise ??= import(MEMORY_RUNTIME);
+    memoryModPromise ??= Promise.resolve(memoryRuntime);
     const mod = await memoryModPromise;
     if (typeof mod?.init === 'function') {
-      memoryInitPromise ??= mod.init();
-      await memoryInitPromise;
+      await mod.init();
     }
     bootProfile('memory-runtime:ready', { ms: (performance.now() - startedAt).toFixed(1) });
     return mod;
@@ -1558,6 +2279,211 @@ export async function createMixdogSessionRuntime({
     return mod;
   }
 
+  function normalizeSearchAllowedDomain(site) {
+    const raw = clean(site);
+    if (!raw) return '';
+    try {
+      return new URL(/^https?:\/\//i.test(raw) ? raw : `https://${raw}`).hostname.toLowerCase();
+    } catch {
+      return raw.replace(/^https?:\/\//i, '').split('/')[0].toLowerCase();
+    }
+  }
+
+  function nativeSearchUserLocation(locale) {
+    if (!locale || typeof locale !== 'object' || Array.isArray(locale)) return null;
+    const location = { type: 'approximate' };
+    for (const key of ['country', 'region', 'city', 'timezone']) {
+      const value = clean(locale[key]);
+      if (value) location[key] = value;
+    }
+    return Object.keys(location).length > 1 ? location : null;
+  }
+
+  function nativeSearchTool(args = {}, toolType = 'web_search', providerId = '') {
+    const providerName = normalizeSearchProviderId(providerId);
+    const domain = normalizeSearchAllowedDomain(args.site);
+    const type = clean(toolType) || 'web_search';
+    const location = nativeSearchUserLocation(args.locale);
+    if (providerName === 'gemini') {
+      return { type: type || 'google_search' };
+    }
+    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') {
+      const tool = {
+        type: 'web_search_20250305',
+        name: 'web_search',
+        max_uses: Math.max(1, Math.min(10, Number(args.maxResults) || 5)),
+      };
+      if (domain) tool.allowed_domains = [domain];
+      if (location) tool.user_location = location;
+      return tool;
+    }
+    if (providerName === 'grok-oauth' || providerName === 'xai') {
+      const tool = { type };
+      if (domain) tool.filters = { allowed_domains: [domain] };
+      return tool;
+    }
+    const tool = {
+      type,
+    };
+    if (type === 'web_search') {
+      tool.search_context_size = clean(args.contextSize) || 'low';
+      if (domain) tool.filters = { allowed_domains: [domain] };
+      if (location) tool.user_location = location;
+    }
+    return tool;
+  }
+
+  function nativeSearchToolTypes(routeLike = {}) {
+    const envToolType = clean(process.env.MIXDOG_NATIVE_SEARCH_TOOL_TYPE);
+    if (envToolType) return [envToolType];
+    const configured = clean(routeLike.toolType);
+    if (configured) return [configured];
+    const providerName = normalizeSearchProviderId(routeLike.provider);
+    if (providerName === 'gemini') return ['google_search'];
+    if (providerName === 'anthropic' || providerName === 'anthropic-oauth') return ['web_search'];
+    if (providerName === 'grok-oauth' || providerName === 'xai') return ['web_search'];
+    return ['web_search', 'web_search_preview'];
+  }
+
+  function currentMainSearchModelMeta() {
+    if (!route?.provider || !route?.model) return null;
+    return { ...route, id: route.model, display: route.model, name: route.model };
+  }
+
+  function nativeSearchRoutes() {
+    const cfg = ensureFullConfig();
+    searchRoute = normalizeSearchRouteConfig(cfg.searchRoute) || normalizeSearchRouteConfig(searchRoute);
+    if (!searchRoute) return [];
+    if (isDefaultSearchRouteConfig(searchRoute)) {
+      const mainModel = currentMainSearchModelMeta();
+      if (!mainModel || !searchCapableFor(route.provider, mainModel)) return [];
+      return [{
+        key: `default\n${route.provider}\n${route.model}`,
+        provider: normalizeSearchProviderId(route.provider),
+        model: route.model,
+        source: 'default-search-route',
+        effort: route.effectiveEffort || route.effort || null,
+        fast: route.fast === true,
+        toolType: searchRoute.toolType || null,
+      }];
+    }
+    const providerName = normalizeSearchProviderId(searchRoute.provider);
+    if (!isSearchCapableProvider(providerName)) return [];
+    return [{
+      key: `${providerName}\n${searchRoute.model}`,
+      provider: providerName,
+      model: searchRoute.model,
+      source: 'search-route',
+      effort: searchRoute.effort || null,
+      fast: searchRoute.fast === true,
+      toolType: searchRoute.toolType || null,
+    }];
+  }
+
+  function nativeSearchMessages(searchArgs = {}) {
+    const prompt = searchArgs.prompt || '';
+    return [
+      {
+        role: 'system',
+        content: [
+          'You are Mixdog native web search.',
+          'Use the hosted web_search tool for current or external facts.',
+          'Answer concisely, cite source URLs, and do not request local tools or file edits.',
+        ].join('\n'),
+      },
+      { role: 'user', content: prompt },
+    ];
+  }
+
+  function flattenNativeSearchSources(result = {}) {
+    const out = [];
+    const add = (source, fallbackTitle = '') => {
+      if (!source || typeof source !== 'object') return;
+      const url = clean(source.url || source.uri || source.href || source.source_url);
+      if (!url) return;
+      out.push({
+        title: clean(source.title || source.query || source.name || fallbackTitle || url),
+        url,
+        snippet: clean(source.snippet || source.text || source.description),
+        source: source.source || 'native-web-search',
+        provider: source.provider || 'native-web-search',
+      });
+    };
+    for (const citation of Array.isArray(result.citations) ? result.citations : []) add(citation);
+    for (const call of Array.isArray(result.webSearchCalls) ? result.webSearchCalls : []) {
+      const action = call?.action || {};
+      for (const source of Array.isArray(action.sources) ? action.sources : []) add(source, action.query || '');
+      if (action.url) add({ url: action.url, title: action.query || '' });
+      for (const url of Array.isArray(action.urls) ? action.urls : []) add({ url, title: action.query || '' });
+    }
+    const seen = new Set();
+    return out.filter((item) => {
+      const key = item.url || `${item.title}\n${item.snippet}`;
+      if (!key || seen.has(key)) return false;
+      seen.add(key);
+      return true;
+    });
+  }
+
+  async function runNativeWebSearch(searchArgs = {}, { signal } = {}) {
+    const candidates = nativeSearchRoutes();
+    if (!candidates.length) {
+      if (isDefaultSearchRouteConfig(searchRoute)) {
+        throw new Error(`default search route requires the current main model to support native web search (${route?.provider || 'unknown'}/${route?.model || 'unknown'})`);
+      }
+      throw new Error('search route is not configured; open /search to choose a search provider/model');
+    }
+    const errors = [];
+    for (const candidate of candidates) {
+      for (const toolType of nativeSearchToolTypes(candidate)) {
+        try {
+          await ensureProvidersReady(ensureProviderEnabled(config, candidate.provider));
+          const providerImpl = reg.getProvider(candidate.provider);
+          if (!providerImpl || typeof providerImpl.send !== 'function') {
+            throw new Error(`provider "${candidate.provider}" is not ready`);
+          }
+          const model = candidate.model;
+          const searchTool = nativeSearchTool(searchArgs, toolType, candidate.provider);
+          const startedAt = Date.now();
+          const result = await providerImpl.send(
+            nativeSearchMessages(searchArgs),
+            model,
+            undefined,
+            {
+              signal,
+              role: 'web-search',
+              sessionId: `${session?.id || 'search'}:native-search:${Date.now().toString(36)}`,
+              sourceType: 'native-search',
+              sourceName: 'search',
+              nativeTools: [searchTool],
+              nativeInclude: candidate.provider === 'openai' || candidate.provider === 'openai-oauth'
+                ? ['web_search_call.action.sources']
+                : [],
+              toolChoice: candidate.provider === 'gemini' ? 'auto' : 'required',
+              ...(candidate.effort ? { effort: candidate.effort } : {}),
+              fast: candidate.fast === true,
+              onStageChange: () => {},
+              onStreamDelta: () => {},
+            },
+          );
+          const sources = flattenNativeSearchSources(result);
+          return {
+            content: String(result?.content || '').trim(),
+            provider: candidate.provider,
+            model: result?.model || candidate.model || null,
+            usage: result?.usage || null,
+            citations: sources,
+            webSearchCalls: result?.webSearchCalls || [],
+            durationMs: Date.now() - startedAt,
+          };
+        } catch (err) {
+          errors.push(`${candidate.provider}${candidate.model ? `/${candidate.model}` : ''}/${toolType}: ${err?.message || String(err)}`);
+        }
+      }
+    }
+    throw new Error(`native web search failed: ${errors.join(' | ')}`);
+  }
+
   async function getCodeGraphModule() {
     const startedAt = performance.now();
     codeGraphModPromise ??= import(CODE_GRAPH_RUNTIME);
@@ -1578,8 +2504,7 @@ export async function createMixdogSessionRuntime({
     };
     nextConfig.default = workflowPresetId('lead');
 
-    cfgMod.saveConfig(nextConfig);
-    config = nextConfig;
+    saveConfigAndAdopt(nextConfig);
     return leadRoute;
   }
 
@@ -1620,6 +2545,10 @@ export async function createMixdogSessionRuntime({
   async function loadCoreMemoryContext() {
     // Boot should not pay for memory/PG startup unless explicitly requested.
     // Recall and memory tools still initialize the memory service on first use.
+    if (!memoryEnabled()) {
+      bootProfile('core-memory:disabled');
+      return '';
+    }
     if (process.env.MIXDOG_BOOT_CORE_MEMORY !== '1') {
       bootProfile('core-memory:skipped');
       return '';
@@ -1652,32 +2581,100 @@ export async function createMixdogSessionRuntime({
   setConfiguredShell(normalizeSystemShellConfig(config.shell).command);
   let configHasSecrets = false;
   let route = resolveRoute(config, { provider, model });
+  let searchRoute = normalizeSearchRouteConfig(config.searchRoute);
   bootProfile('config:ready', { ms: (performance.now() - configStartedAt).toFixed(1) });
   let mode = normalizeToolMode(toolMode);
   let session = null;
   let sessionCreatePromise = null;
   let currentCwd = cwd;
   let sessionNeedsCwdRefresh = false;
-  const workspaceRouter = createWorkspaceRouter({ entryCwd: cwd });
   let closeRequested = false;
   let channelStartTimer = null;
+  let providerSetupWarmupTimer = null;
   let providerWarmupTimer = null;
   let providerModelWarmupTimer = null;
+  let codeGraphPrewarmTimer = null;
+  let codeGraphPrewarmInFlight = false;
+  let codeGraphPrewarmQueuedCwd = '';
+  let statuslineUsageWarmupTimer = null;
+  let statuslineUsageRefreshTimer = null;
   let activeTurnCount = 0;
   let firstTurnCompleted = false;
+  function hookTranscriptPath(sessionId) {
+    const id = clean(sessionId);
+    if (!id || !/^[A-Za-z0-9_-]+$/.test(id)) return null;
+    const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+    return join(dataDir, 'sessions', `${id}.json`);
+  }
+  function hookEffortPayload() {
+    const level = clean(route.effectiveEffort || route.effort);
+    return level ? { level: level.toLowerCase() } : undefined;
+  }
+  function hookCommonPayload(extra = {}) {
+    const sid = clean(extra.session_id || extra.sessionId || session?.id);
+    return {
+      ...(sid ? { session_id: sid, transcript_path: hookTranscriptPath(sid) } : {}),
+      cwd: currentCwd,
+      permission_mode: session?.permissionMode || 'default',
+      ...(hookEffortPayload() ? { effort: hookEffortPayload() } : {}),
+      ...extra,
+    };
+  }
   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 providerWarmupDelayMs = envDelayMs('MIXDOG_PROVIDER_WARMUP_DELAY_MS', 1_500, { min: 0, max: 60_000 });
-  const providerModelWarmupDelayMs = envDelayMs('MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS', 15_000, { min: 0, max: 120_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
+  // work is async + unref'd, so short-lived detached runtimes still exit
+  // cleanly without waiting on it. Operators can raise it via env if a
+  // detached runtime must avoid the /models round-trip entirely.
+  const providerModelWarmupDelayMs = envDelayMs('MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS', 2_000, { min: 0, max: 120_000 });
+  const codeGraphPrewarmDelayMs = envDelayMs('MIXDOG_CODE_GRAPH_PREWARM_DELAY_MS', 250, { min: 0, max: 60_000 });
+  const statuslineUsageWarmupDelayMs = envDelayMs('MIXDOG_STATUSLINE_USAGE_WARMUP_DELAY_MS', 800, { min: 0, max: 60_000 });
+  // Idle keep-alive: re-fetch usage before the statusline's 10-min staleness cut
+  // (LIVE_USAGE_SNAPSHOT_MAX_AGE_MS) so the usage segment does not disappear
+  // while the session sits idle with no turns to trigger a refresh.
+  const statuslineUsageRefreshDelayMs = envDelayMs('MIXDOG_STATUSLINE_USAGE_REFRESH_MS', 240_000, { min: 30_000, max: 540_000 });
   const channelStartDelayMs = envDelayMs('MIXDOG_CHANNEL_START_DELAY_MS', 10_000, { min: 0, max: 120_000 });
   const backgroundBusyRetryMs = envDelayMs('MIXDOG_BACKGROUND_BUSY_RETRY_MS', 1_000, { min: 50, max: 10_000 });
+  const sessionPrewarmEnabled = !envFlag('MIXDOG_DISABLE_SESSION_PREWARM')
+    && (envFlag('MIXDOG_ENABLE_SESSION_PREWARM') || envPresent('MIXDOG_SESSION_PREWARM_DELAY_MS'));
+  const providerWarmupEnabled = !envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')
+    && (
+      envFlag('MIXDOG_ENABLE_PROVIDER_WARMUP')
+      || envFlag('MIXDOG_PROVIDER_WARMUP_BEFORE_FIRST_TURN')
+      || envPresent('MIXDOG_PROVIDER_WARMUP_DELAY_MS')
+      || envPresent('MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS')
+    );
+  // Boot-time model-catalog prefetch is intentionally decoupled from the
+  // heavier providerWarmupEnabled gate (which stays opt-in for provider
+  // *init* side effects). Fetching the model list in the background after a
+  // short delay is cheap, fire-and-forget, and unref'd, so it is ON by
+  // default — otherwise the FIRST `/model` open always paid a cold full
+  // network load. Operators can still disable it explicitly.
+  const modelPrefetchEnabled = !envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')
+    && !envFlag('MIXDOG_DISABLE_MODEL_PREFETCH');
+  const codeGraphPrewarmEnabled = !envFlag('MIXDOG_DISABLE_CODE_GRAPH_PREWARM');
+  // 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.
+  // Instead prewarm ONCE on the first real turn, when a code lookup is actually
+  // imminent. Operators who want the old eager behavior can set
+  // MIXDOG_CODE_GRAPH_PREWARM_EAGER=1.
+  const codeGraphPrewarmLazy = codeGraphPrewarmEnabled && !envFlag('MIXDOG_CODE_GRAPH_PREWARM_EAGER');
+  let codeGraphFirstTurnPrewarmDone = false;
   const modelMetaByRoute = new Map();
   const notificationListeners = new Set();
   let providerModelsCache = { models: null, at: 0 };
   let providerModelsPromise = null;
+  let searchProviderModelsCache = { models: null, at: 0 };
+  let searchProviderModelsPromise = null;
+  let usageDashboardCache = { dashboard: null, at: 0 };
+  let usageDashboardPromise = null;
   let providerSetupCache = { setup: null, at: 0 };
+  let providerSetupQuickCache = { setup: null, at: 0 };
   let providerSetupPromise = null;
   let providerInitPromise = null;
-  const PROVIDER_SETUP_CACHE_TTL_MS = 10_000;
   let mcpFailures = [];
   let preSessionToolSurface = null;
   let contextStatusCacheKey = null;
@@ -1687,72 +2684,6 @@ 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) });
 
-  function contextContentLength(content) {
-    if (typeof content === 'string') return content.length;
-    if (!Array.isArray(content)) {
-      try { return JSON.stringify(content ?? '').length; } catch { return String(content ?? '').length; }
-    }
-    let length = 0;
-    for (const part of content) {
-      if (typeof part === 'string') length += part.length;
-      else if (typeof part?.text === 'string') length += part.text.length;
-      else {
-        try { length += JSON.stringify(part ?? '').length; } catch { length += String(part ?? '').length; }
-      }
-    }
-    return length;
-  }
-
-  function sameContextStatusKey(a, b) {
-    if (!a || !b || a.length !== b.length) return false;
-    for (let i = 0; i < a.length; i++) {
-      if (!Object.is(a[i], b[i])) return false;
-    }
-    return true;
-  }
-
-  function buildContextStatusCacheKey(messages, tools, bridgeMode) {
-    const lastMessage = messages[messages.length - 1] || null;
-    const compaction = session?.compaction || null;
-    return [
-      session?.id || null,
-      route.provider,
-      route.model,
-      currentCwd,
-      mode,
-      bridgeMode,
-      messages,
-      messages.length,
-      lastMessage,
-      lastMessage?.role || null,
-      lastMessage?.content || null,
-      contextContentLength(lastMessage?.content),
-      Array.isArray(lastMessage?.toolCalls) ? lastMessage.toolCalls.length : 0,
-      tools,
-      tools.length,
-      session?.contextWindow || null,
-      session?.rawContextWindow || null,
-      session?.effectiveContextWindowPercent || null,
-      session?.lastContextTokens || 0,
-      session?.lastContextTokensUpdatedAt || 0,
-      session?.lastContextTokensStaleAfterCompact === true,
-      session?.lastInputTokens || 0,
-      session?.lastOutputTokens || 0,
-      session?.lastCachedReadTokens || 0,
-      session?.lastCacheWriteTokens || 0,
-      session?.totalInputTokens || 0,
-      session?.totalOutputTokens || 0,
-      session?.totalCachedReadTokens || 0,
-      session?.totalCacheWriteTokens || 0,
-      session?.compactBoundaryTokens || 0,
-      compaction,
-      compaction?.lastChangedAt || 0,
-      compaction?.lastCompactAt || 0,
-      compaction?.boundaryTokens || 0,
-      compaction?.triggerTokens || 0,
-    ];
-  }
-
   function mcpTransportLabel(cfg = {}) {
     if (cfg.autoDetect) return `autoDetect:${cfg.autoDetect}`;
     if (cfg.transport === 'http' || cfg.url) return 'http';
@@ -1762,23 +2693,42 @@ export async function createMixdogSessionRuntime({
 
   function emitRuntimeNotification(content, meta = {}) {
     const text = String(content || '').trim();
-    if (!text) return;
+    if (!text) return false;
     const event = { content: text, meta: meta && typeof meta === 'object' ? meta : {} };
+    let handled = false;
     for (const listener of [...notificationListeners]) {
-      try { listener(event); } catch {}
+      try {
+        if (listener(event) === true) handled = true;
+      } catch {}
     }
+    return handled;
   }
 
   function notifyFnForSession(callerSessionId) {
     return (text, meta = {}) => {
-      const hadRuntimeListener = notificationListeners.size > 0;
-      emitRuntimeNotification(text, meta);
-      // TUI sessions keep their own Claude-Code-style command queue via
-      // onNotification. Headless/model-tool callers have no listener, so fall
-      // back to the session manager pending-message queue.
-      if (!hadRuntimeListener && callerSessionId && typeof mgr.enqueuePendingMessage === 'function') {
-        try { mgr.enqueuePendingMessage(callerSessionId, String(text || '')); } catch {}
+      const handledByRuntimeListener = emitRuntimeNotification(text, meta);
+      let enqueued = false;
+      // TUI sessions consume raw execution notifications for UI/task cards via
+      // onNotification, but those raw envelopes are internal-only in pending
+      // drain. Always mirror terminal completions with a model-visible wrapper
+      // while keeping the raw text for UI display.
+      if (callerSessionId && typeof mgr.enqueuePendingMessage === 'function'
+        && shouldPersistModelVisibleToolCompletion(text, meta)) {
+        try {
+          const visible = modelVisibleToolCompletionMessage(text, meta);
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+        } catch {}
+      }
+      // Headless/API listeners may exist but not consume the event; preserve
+      // the old fallback for non-terminal notifications only when unhandled.
+      if (!enqueued && !handledByRuntimeListener && callerSessionId
+        && typeof mgr.enqueuePendingMessage === 'function') {
+        try {
+          const visible = modelVisibleToolCompletionMessage(text, meta);
+          if (visible) enqueued = mgr.enqueuePendingMessage(callerSessionId, visible) > 0;
+        } catch {}
       }
+      return enqueued || handledByRuntimeListener;
     };
   }
 
@@ -1840,40 +2790,92 @@ export async function createMixdogSessionRuntime({
     };
   }
 
+  function scheduleCodeGraphPrewarm(delayMs = codeGraphPrewarmDelayMs, reason = 'cwd') {
+    if (!codeGraphPrewarmEnabled) {
+      bootProfile('code-graph:prewarm-skipped', { reason: 'disabled' });
+      return;
+    }
+    if (closeRequested) return;
+    codeGraphPrewarmQueuedCwd = currentCwd;
+    if (codeGraphPrewarmTimer) return;
+    codeGraphPrewarmTimer = setTimeout(() => {
+      codeGraphPrewarmTimer = null;
+      if (closeRequested) return;
+      if (activeTurnCount > 0 || sessionCreatePromise) {
+        bootProfile('code-graph:prewarm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
+        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'busy');
+        return;
+      }
+      if (codeGraphPrewarmInFlight) {
+        bootProfile('code-graph:prewarm-deferred', { reason: 'in-flight' });
+        scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'in-flight');
+        return;
+      }
+      const prewarmCwd = codeGraphPrewarmQueuedCwd || currentCwd;
+      codeGraphPrewarmQueuedCwd = '';
+      codeGraphPrewarmInFlight = true;
+      const startedAt = performance.now();
+      bootProfile('code-graph:prewarm:start', { cwd: prewarmCwd, reason });
+      void getCodeGraphModule()
+        .then((mod) => {
+          if (typeof mod?.prewarmCodeGraphIfProject !== 'function') return false;
+          return mod.prewarmCodeGraphIfProject(prewarmCwd);
+        })
+        .then((scheduled) => bootProfile(scheduled ? 'code-graph:prewarm:scheduled' : 'code-graph:prewarm:no-project', {
+          cwd: prewarmCwd,
+          ms: (performance.now() - startedAt).toFixed(1),
+        }))
+        .catch((error) => bootProfile('code-graph:prewarm:failed', {
+          cwd: prewarmCwd,
+          ms: (performance.now() - startedAt).toFixed(1),
+          error: error?.message || String(error),
+        }))
+        .finally(() => {
+          codeGraphPrewarmInFlight = false;
+          if (codeGraphPrewarmQueuedCwd && !closeRequested) {
+            scheduleCodeGraphPrewarm(backgroundBusyRetryMs, 'queued');
+          }
+        });
+    }, delayMs);
+    codeGraphPrewarmTimer.unref?.();
+  }
+
   function applyResolvedCwd(nextCwd, { markRefresh = true } = {}) {
     const resolved = resolve(nextCwd);
     const stat = statSync(resolved);
     if (!stat.isDirectory()) throw new Error(`cwd: not a directory: ${resolved}`);
     const changed = resolve(currentCwd) !== resolved;
     currentCwd = resolved;
-    ensureProjectMixdogMd({ cwd: currentCwd });
     process.env.MIXDOG_SESSION_CWD = currentCwd;
     writeLastSessionCwd(currentCwd);
     if (session) session.cwd = currentCwd;
-    if (changed && markRefresh && session?.id) sessionNeedsCwdRefresh = true;
+    // cwd changes NEVER recreate the session: a mid-conversation cwd switch must
+    // preserve the full message history (and the BP1–BP3 prompt cache). We only
+    // retarget the live session's cwd in place; tool execution already reads the
+    // current cwd per turn. `cwd` is intentionally absent from the prompt
+    // context (see composeSystemPrompt), so there is nothing prompt-side to
+    // refresh either. `markRefresh`/`changed` are kept only for signature
+    // compatibility with existing callers.
+    void markRefresh;
+    // Lazy mode: before the first turn (e.g. the initial project-selection
+    // cwd set), do NOT prewarm — that is exactly the post-first-frame freeze
+    // we are avoiding. Once a turn has run, an in-session cwd switch DOES
+    // prewarm the new dir, since a lookup there is now likely.
+    if (codeGraphPrewarmLazy && !codeGraphFirstTurnPrewarmDone) {
+      bootProfile('code-graph:prewarm-lazy', { reason: 'cwd-deferred-to-first-turn' });
+    } else {
+      scheduleCodeGraphPrewarm(changed ? 0 : codeGraphPrewarmDelayMs, changed ? 'cwd-change' : 'cwd');
+    }
     return currentCwd;
   }
 
   async function refreshSessionForCwdIfNeeded(reason = 'cwd-change') {
-    if (!session?.id || !sessionNeedsCwdRefresh) return session;
-    const previousId = session.id;
-    statusRoutes?.clearGatewaySessionRoute?.(previousId);
-    mgr.closeSession(previousId, reason);
-    session = null;
+    // No-op: cwd changes are applied in place by applyResolvedCwd and never
+    // tear down the session. Retained as a stable hook for ask()'s pre-turn
+    // call so the surrounding turn flow is unchanged.
+    void reason;
     sessionNeedsCwdRefresh = false;
-    return await createCurrentSession();
-  }
-
-  function buildWorkspaceContext() {
-    try {
-      return formatWorkspaceSessionContext(workspaceRouter.snapshot(currentCwd));
-    } catch (error) {
-      return [
-        '# Workspace',
-        `current cwd: ${currentCwd}`,
-        `project candidates: unavailable (${error?.message || String(error)})`,
-      ].join('\n');
-    }
+    return session;
   }
 
   function skillContent(name) {
@@ -1884,6 +2886,12 @@ export async function createMixdogSessionRuntime({
     return { name, content };
   }
 
+  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>`;
+  }
+
   function addProjectSkill(input = {}) {
     const name = clean(input.name).replace(/[^a-zA-Z0-9_.-]+/g, '-').replace(/^-+|-+$/g, '');
     if (!name) throw new Error('skill name is required');
@@ -1996,30 +3004,25 @@ export async function createMixdogSessionRuntime({
     return { name, config: { command, args, cwd: resolvedCwd } };
   }
 
-  const persistedBridgeMode = (() => {
-    try { return (sharedCfgMod.readSection('agent') || {}).bridgeMode; } catch { return undefined; }
-  })();
-  const bridgeStartedAt = performance.now();
-  const bridge = createStandaloneBridge({
+  const agentToolStartedAt = performance.now();
+  const agentTool = createStandaloneAgent({
     cfgMod,
     reg,
     mgr,
     dataDir: cfgMod.getPluginData(),
     cwd,
-    defaultMode: persistedBridgeMode ?? 'async',
   });
-  bootProfile('bridge:ready', { ms: (performance.now() - bridgeStartedAt).toFixed(1) });
-  const bridgeStatusState = () => {
+  bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
+  const agentStatusState = () => {
     try {
-      const status = bridge.getStatus?.({ clientHostPid: session?.clientHostPid || process.pid }) || {};
+      const status = agentTool.getStatus?.({ clientHostPid: session?.clientHostPid || process.pid }) || {};
       return {
-        bridgeMode: bridge.getDefaultMode?.() || status.bridgeMode || 'async',
-        bridgeWorkers: Array.isArray(status.workers) ? status.workers : [],
-        bridgeJobs: Array.isArray(status.jobs) ? status.jobs : [],
-        bridgeScope: status.scope || null,
+        agentWorkers: Array.isArray(status.workers) ? status.workers : [],
+        agentJobs: Array.isArray(status.jobs) ? status.jobs : [],
+        agentScope: status.scope || null,
       };
     } catch {
-      return { bridgeMode: bridge.getDefaultMode?.() || 'async', bridgeWorkers: [], bridgeJobs: [], bridgeScope: null };
+      return { agentWorkers: [], agentJobs: [], agentScope: null };
     }
   };
   const channelsStartedAt = performance.now();
@@ -2028,18 +3031,28 @@ export async function createMixdogSessionRuntime({
     rootDir: STANDALONE_ROOT,
     dataDir: cfgMod.getPluginData(),
     cwd,
+    onNotify: (msg) => {
+      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);
+    },
   });
   bootProfile('channels:worker-ready', { ms: (performance.now() - channelsStartedAt).toFixed(1) });
   const toolsStartedAt = performance.now();
   const standaloneTools = [
     TOOL_SEARCH_TOOL,
+    SKILL_TOOL,
     CWD_TOOL,
     EXPLORE_TOOL,
     ...(searchToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'search' || tool?.name === 'web_fetch'),
     ...(memoryToolDefs?.TOOL_DEFS || []).filter((tool) => tool?.name === 'recall' || tool?.name === 'memory'),
     ...(channelToolDefs?.TOOL_DEFS || []).filter((tool) => channels.isChannelTool(tool?.name)),
     ...(codeGraphToolDefs?.CODE_GRAPH_TOOL_DEFS || []).filter((tool) => tool?.name === 'code_graph'),
-    ...bridge.tools,
+    ...agentTool.tools,
     PROVIDER_STATUS_TOOL,
     CHANNEL_STATUS_TOOL,
   ].map(applyStandaloneToolDefaults);
@@ -2060,7 +3073,7 @@ export async function createMixdogSessionRuntime({
       : [];
     const tools = filterDisallowedTools(previewTools, LEAD_DISALLOWED_TOOLS);
     const surface = { tools: Array.isArray(tools) ? tools.slice() : [] };
-    applyDeferredToolSurface(surface, mode, standaloneTools);
+    applyDeferredToolSurface(surface, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
     return surface;
   }
 
@@ -2075,7 +3088,11 @@ export async function createMixdogSessionRuntime({
     const selected = Array.isArray(preSessionToolSurface.deferredSelectedTools)
       ? preSessionToolSurface.deferredSelectedTools
       : [];
-    if (selected.length) selectDeferredTools(session, selected, mode);
+    const discovered = Array.isArray(preSessionToolSurface.deferredDiscoveredTools)
+      ? preSessionToolSurface.deferredDiscoveredTools
+      : [];
+    const replay = [...new Set([...selected, ...discovered])];
+    if (replay.length) selectDeferredTools(session, replay, deferredSurfaceModeForLead(mode));
   }
   internalTools.setInternalToolsProvider({
     tools: standaloneTools,
@@ -2091,35 +3108,8 @@ export async function createMixdogSessionRuntime({
           routingSessionId: callerSessionId,
           clientHostPid: callerCtx?.clientHostPid || session?.clientHostPid || process.pid,
           notifyFn: notifyFnForSession(callerSessionId),
-          agentSearch: name === 'search'
-            ? async (searchArgs) => {
-              const query = Array.isArray(searchArgs.keywords)
-                ? searchArgs.keywords.join('\n')
-                : String(searchArgs.keywords || searchArgs.query || '');
-              const prompt = searchArgs.prompt || [
-                'Perform a concise web research task for Mixdog search.',
-                '',
-                `Query: ${query}`,
-                searchArgs.site ? `Site/domain restriction: ${searchArgs.site}` : null,
-                searchArgs.type ? `Search type: ${searchArgs.type}` : null,
-                searchArgs.locale ? `Locale: ${typeof searchArgs.locale === 'string' ? searchArgs.locale : JSON.stringify(searchArgs.locale)}` : null,
-                `Max results: ${Math.max(1, Math.min(20, Number(searchArgs.maxResults) || 10))}`,
-                '',
-                'Return a short answer first, then cite useful results as title + URL + one-line snippet.',
-                'Do not edit files.',
-              ].filter(Boolean).join('\n');
-              const rendered = await bridge.execute({
-                type: 'spawn',
-                agent: 'web-researcher',
-                tag: `search_${Date.now().toString(36)}`,
-                prompt,
-                cwd: callerCwd,
-                wait: true,
-                firstResponseTimeoutMs: Number.isFinite(Number(searchArgs.firstResponseTimeoutMs)) ? Number(searchArgs.firstResponseTimeoutMs) : 120_000,
-                idleTimeoutMs: Number.isFinite(Number(searchArgs.idleTimeoutMs)) ? Number(searchArgs.idleTimeoutMs) : 30 * 60_000,
-              }, { invocationSource: 'user-command', callerCwd });
-              return String(rendered || '').replace(/^bridge result[^\n]*\n/i, '').trim();
-            }
+          nativeSearch: name === 'search'
+            ? async (searchArgs) => runNativeWebSearch(searchArgs, { signal: callerCtx?.signal || session?.controller?.signal })
             : undefined,
         });
       }
@@ -2133,7 +3123,9 @@ export async function createMixdogSessionRuntime({
         if (!codeGraphMod?.executeCodeGraphTool) throw new Error('code_graph runtime is not available');
         return await codeGraphMod.executeCodeGraphTool(name, args || {}, args?.cwd || callerCwd);
       }
-      if (name === 'tool_search') return renderToolSearch(args, session, mode);
+      if (name === 'tool_search') {
+        return renderToolSearch(args, activeToolSurface(), mode);
+      }
       if (name === 'explore') {
         const callerSessionId = callerCtx?.callerSessionId || session?.id || null;
         return await runExplore(args || {}, {
@@ -2153,9 +3145,12 @@ export async function createMixdogSessionRuntime({
         }
         return JSON.stringify({ cwd: currentCwd, sessionId: session?.id || null }, null, 2);
       }
-      if (name === 'bridge') {
+      if (name === 'Skill') {
+        return skillToolContent(args?.name);
+      }
+      if (name === 'agent') {
         const callerSessionId = callerCtx?.callerSessionId || session?.id || null;
-        return await bridge.execute(args, {
+        return await agentTool.execute(args, {
           callerCwd,
           invocationSource: 'model-tool',
           callerSessionId,
@@ -2164,9 +3159,12 @@ export async function createMixdogSessionRuntime({
           notifyFn: notifyFnForSession(callerSessionId),
         });
       }
-      if (name === 'provider_status') return renderProviderStatus(cfgMod.loadConfig());
+      if (name === 'provider_status') return renderProviderStatus(displayConfig());
       if (name === 'channel_status') return renderChannelStatus();
-      if (channels.isChannelTool(name)) return await channels.execute(name, args || {});
+      if (channels.isChannelTool(name)) {
+        if (!channelsEnabled()) throw new Error('channels are disabled in settings');
+        return await channels.execute(name, args || {});
+      }
       throw new Error(`unknown standalone internal tool: ${name}`);
     },
   });
@@ -2185,16 +3183,81 @@ export async function createMixdogSessionRuntime({
   function invalidateProviderCaches() {
     providerModelsCache = { models: null, at: 0 };
     providerModelsPromise = null;
+    searchProviderModelsCache = { models: null, at: 0 };
+    searchProviderModelsPromise = null;
+    usageDashboardCache = { dashboard: null, at: 0 };
+    usageDashboardPromise = null;
     providerSetupCache = { setup: null, at: 0 };
+    providerSetupQuickCache = { setup: null, at: 0 };
     providerSetupPromise = null;
     providerInitPromise = null;
     modelMetaByRoute.clear();
   }
 
+  function adoptConfig(nextConfig, { hasSecrets = configHasSecrets } = {}) {
+    config = nextConfig;
+    configHasSecrets = hasSecrets === true;
+    setConfiguredShell(normalizeSystemShellConfig(config.shell).command);
+    searchRoute = normalizeSearchRouteConfig(config.searchRoute) || normalizeSearchRouteConfig(searchRoute);
+    return config;
+  }
+
+  // Persisting mixdog-config.json is heavy: it takes a cross-process file
+  // lock, does an atomic temp+rename, and on win32 shells out to icacls
+  // (an external process, multiple times per write) to enforce an owner-only
+  // ACL. Doing that synchronously on EVERY option toggle froze the TUI main
+  // thread, so adjusting a picker felt laggy and unresponsive. We split the
+  // two concerns: adopt the new config in-memory IMMEDIATELY (so getProfile/
+  // getAutoClear/etc. and the UI read fresh values on the same tick), and
+  // DEBOUNCE the actual disk write so a burst of toggles collapses into a
+  // single persist after input settles. The security model is unchanged —
+  // cfgMod.saveConfig still strips apiKey (keychain-only) and still applies
+  // the owner-only ACL; we only changed WHEN it runs, never HOW.
+  let pendingConfigToSave = null;
+  let configSaveTimer = null;
+  const CONFIG_SAVE_DEBOUNCE_MS = 150;
+  function flushConfigSave() {
+    if (configSaveTimer) {
+      clearTimeout(configSaveTimer);
+      configSaveTimer = null;
+    }
+    if (pendingConfigToSave === null) return;
+    const snapshot = pendingConfigToSave;
+    pendingConfigToSave = null;
+    try {
+      cfgMod.saveConfig(snapshot);
+    } catch (err) {
+      process.stderr.write(`[config] debounced saveConfig failed: ${err?.message || err}\n`);
+    }
+  }
+  function saveConfigAndAdopt(nextConfig, { hasSecrets = configHasSecrets } = {}) {
+    // In-memory adopt is synchronous and first so callers that read back the
+    // value immediately (e.g. setProfile -> getProfile) see the new state.
+    const adopted = adoptConfig(nextConfig, { hasSecrets });
+    // Persist the adopted object; coalesce rapid successive changes into one
+    // disk write after CONFIG_SAVE_DEBOUNCE_MS of quiet.
+    pendingConfigToSave = config;
+    if (configSaveTimer) clearTimeout(configSaveTimer);
+    configSaveTimer = setTimeout(flushConfigSave, CONFIG_SAVE_DEBOUNCE_MS);
+    configSaveTimer.unref?.();
+    return adopted;
+  }
+
+  function reloadFullConfig() {
+    // A pending debounced write holds the only copy of the latest change.
+    // Flush it before re-reading from disk so loadConfig() observes (and the
+    // subsequent adopt preserves) that change instead of reverting to a stale
+    // on-disk snapshot.
+    flushConfigSave();
+    return adoptConfig(cfgMod.loadConfig(), { hasSecrets: true });
+  }
+
   function ensureFullConfig() {
     if (configHasSecrets) return config;
-    config = cfgMod.loadConfig();
-    configHasSecrets = true;
+    return reloadFullConfig();
+  }
+
+  function displayConfig() {
     return config;
   }
 
@@ -2207,6 +3270,19 @@ export async function createMixdogSessionRuntime({
     return ensureFullConfig();
   }
 
+  function refreshStatuslineUsageSnapshot(routeLike = {}) {
+    const providerId = clean(routeLike.provider);
+    const modelId = clean(routeLike.model);
+    if (!providerId || !providerId.includes('oauth')) return;
+    const providerObj = reg.getProvider(providerId);
+    if (!providerObj) return;
+    void fetchOAuthUsageSnapshot({ provider: providerId, model: modelId }, providerObj, (message) => {
+      if (process.env.MIXDOG_STATUSLINE_TRACE) {
+        try { process.stderr.write(`[statusline] ${message}\n`); } catch {}
+      }
+    }).catch(() => {});
+  }
+
   async function ensureProvidersReady(providerConfig = config.providers || {}) {
     if (providerInitPromise) return await providerInitPromise;
     providerInitPromise = reg.initProviders(providerConfig)
@@ -2216,13 +3292,23 @@ export async function createMixdogSessionRuntime({
     return await providerInitPromise;
   }
 
-  async function cachedProviderSetup({ force = false } = {}) {
-    const now = Date.now();
-    if (!force && providerSetupCache.setup && now - providerSetupCache.at < PROVIDER_SETUP_CACHE_TTL_MS) {
+  async function cachedProviderSetup({ force = false, quick = false } = {}) {
+    if (!force && providerSetupCache.setup) {
       return providerSetupCache.setup;
     }
-    if (!force && providerSetupPromise) return await providerSetupPromise;
-    providerSetupPromise = providerSetup(cfgMod.loadConfig())
+    if (quick) {
+      if (!force && providerSetupQuickCache.setup) {
+        return providerSetupQuickCache.setup;
+      }
+      const setup = await providerSetup(displayConfig(), { detectLocal: false, checkSecrets: false });
+      providerSetupQuickCache = { setup, at: Date.now() };
+      if (!providerSetupPromise && !providerSetupWarmupTimer && !closeRequested) {
+        scheduleProviderSetupWarmup(0);
+      }
+      return setup;
+    }
+    if (providerSetupPromise) return await providerSetupPromise;
+    providerSetupPromise = providerSetup(displayConfig(), { detectLocal: true })
       .then((setup) => {
         providerSetupCache = { setup, at: Date.now() };
         return setup;
@@ -2370,9 +3456,10 @@ function parsedProviderModelVersion(id) {
       description: m.description || '',
       supportsVision: m.supportsVision === true,
       supportsFunctionCalling: m.supportsFunctionCalling === true,
+      supportsWebSearch: searchCapableFor(name, m),
       supportsPromptCaching: m.supportsPromptCaching === true,
       supportsReasoning: m.supportsReasoning === true,
-      reasoningLevels: Array.isArray(m.reasoningLevels) ? m.reasoningLevels : [],
+      reasoningLevels: Array.isArray(m.reasoningLevels) ? m.reasoningLevels : undefined,
       reasoningOptions: Array.isArray(m.reasoningOptions) ? m.reasoningOptions : [],
       reasoningContentField: m.reasoningContentField || null,
       mode: m.mode || null,
@@ -2394,40 +3481,265 @@ function parsedProviderModelVersion(id) {
     return sortProviderModels((rows || []).map(hydrateProviderModelRow));
   }
 
-  async function loadProviderModelsFresh() {
+  function quickProviderModelRows() {
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    const addRoute = (routeLike = {}) => {
+      const provider = clean(routeLike.provider);
+      const model = clean(routeLike.model);
+      if (!provider || !model) return;
+      const key = `${provider}:${model}`;
+      if (seen.has(key)) return;
+      seen.add(key);
+      const row = providerModelCacheRow(provider, {
+        id: model,
+        name: routeLike.modelDisplay || routeLike.display || model,
+        display: routeLike.modelDisplay || routeLike.display || model,
+        latest: routeLike.latest === true,
+        supportsReasoning: !!routeLike.effort,
+        mode: 'chat',
+      });
+      rows.push(row);
+      modelMetaByRoute.set(modelMetaKey(provider, model), row);
+    };
+
+    addRoute(route);
+    for (const preset of pickerConfig.presets || []) addRoute(preset);
+    for (const workflowRoute of Object.values(pickerConfig.workflowRoutes || {})) addRoute(workflowRoute);
+    for (const agentRoute of Object.values(pickerConfig.agents || {})) addRoute(agentRoute);
+    return providerModelsFromCacheRows(rows);
+  }
+
+  function addQuickSearchModel(rows, seen, provider, model) {
+    const providerName = normalizeSearchProviderId(provider);
+    const modelId = clean(model?.id || model);
+    if (!providerName || !modelId || !isSearchCapableProvider(providerName)) return;
+    const key = `${providerName}:${modelId}`;
+    if (seen.has(key)) return;
+    const row = providerModelCacheRow(providerName, {
+      id: modelId,
+      name: model?.name || model?.display || modelId,
+      display: model?.display || model?.name || modelId,
+      contextWindow: model?.contextWindow || null,
+      outputTokens: model?.outputTokens || null,
+      latest: model?.latest === true,
+      supportsWebSearch: true,
+      supportsFunctionCalling: model?.supportsFunctionCalling === true,
+      supportsPromptCaching: model?.supportsPromptCaching === true,
+      supportsReasoning: model?.supportsReasoning === true,
+      reasoningLevels: Array.isArray(model?.reasoningLevels) ? model.reasoningLevels : undefined,
+      reasoningOptions: Array.isArray(model?.reasoningOptions) ? model.reasoningOptions : [],
+      mode: 'chat',
+    });
+    if (row.supportsWebSearch !== true) return;
+    seen.add(key);
+    rows.push({
+      ...row,
+      provider: providerName,
+      searchCapable: true,
+      searchToolType: row.searchToolType || 'web_search',
+    });
+  }
+
+  function addDefaultSearchModel(rows, seen = new Set()) {
+    const mainModel = currentMainSearchModelMeta();
+    if (!mainModel || !searchCapableFor(route.provider, mainModel)) return;
+    const key = `${SEARCH_DEFAULT_PROVIDER}:${SEARCH_DEFAULT_MODEL}`;
+    if (seen.has(key)) return;
+    seen.add(key);
+    rows.push({
+      id: SEARCH_DEFAULT_MODEL,
+      provider: SEARCH_DEFAULT_PROVIDER,
+      display: 'Default',
+      name: 'Default',
+      description: `Use current main model: ${route.provider}/${route.model}`,
+      supportsWebSearch: true,
+      searchCapable: true,
+      searchToolType: 'web_search',
+      mode: 'chat',
+    });
+  }
+
+  function quickSearchProviderModelRows() {
+    const pickerConfig = displayConfig();
+    const rows = [];
+    const seen = new Set();
+    addDefaultSearchModel(rows, seen);
+    for (const [name, providerConfig] of Object.entries(pickerConfig.providers || {})) {
+      const providerName = normalizeSearchProviderId(name);
+      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
+      for (const model of QUICK_SEARCH_MODELS[providerName] || []) {
+        addQuickSearchModel(rows, seen, providerName, model);
+      }
+    }
+    const configuredSearch = normalizeSearchRouteConfig(pickerConfig.searchRoute) || normalizeSearchRouteConfig(searchRoute);
+    if (configuredSearch?.provider && configuredSearch?.model) {
+      addQuickSearchModel(rows, seen, configuredSearch.provider, {
+        id: configuredSearch.model,
+        display: configuredSearch.model,
+      });
+    }
+    const mainModel = currentMainSearchModelMeta();
+    if (mainModel && searchCapableFor(route.provider, mainModel)) {
+      addQuickSearchModel(rows, seen, route.provider, {
+        id: route.model,
+        display: route.model,
+      });
+    }
+    return searchModelsFromRows(rows);
+  }
+
+  function searchModelsFromRows(rows) {
+    return sortProviderModels((rows || [])
+      .filter((row) => row.supportsWebSearch === true)
+      .map((row) => ({
+        ...row,
+        provider: normalizeSearchProviderId(row.provider),
+        searchCapable: true,
+        searchToolType: row.searchToolType || 'web_search',
+      })));
+  }
+
+  function searchRowsWithDefault(rows = []) {
+    const out = [];
+    const seen = new Set();
+    addDefaultSearchModel(out, seen);
+    for (const row of rows || []) {
+      const providerName = normalizeSearchProviderId(row?.provider);
+      const modelId = clean(row?.id || row?.model);
+      if (providerName === SEARCH_DEFAULT_PROVIDER && modelId.toLowerCase() === SEARCH_DEFAULT_MODEL) continue;
+      const key = `${providerName}:${modelId}`;
+      if (!providerName || !modelId || seen.has(key)) continue;
+      seen.add(key);
+      out.push(row);
+    }
+    return out;
+  }
+
+  async function collectSearchProviderModels({ force = false } = {}) {
+    if (!force && Array.isArray(searchProviderModelsCache.models)) {
+      return providerModelsFromCacheRows(searchRowsWithDefault(searchProviderModelsCache.models));
+    }
+    if (!force && Array.isArray(providerModelsCache.models)) {
+      const rows = searchRowsWithDefault(searchModelsFromRows(providerModelsCache.models));
+      searchProviderModelsCache = { models: rows, at: Date.now() };
+      return providerModelsFromCacheRows(rows);
+    }
+    if (!force) {
+      const rows = searchRowsWithDefault(quickSearchProviderModelRows());
+      searchProviderModelsCache = { models: rows, at: Date.now() };
+      return providerModelsFromCacheRows(rows);
+    }
+    if (!searchProviderModelsPromise) {
+      searchProviderModelsPromise = loadSearchProviderModelsFresh()
+        .then((models) => {
+          searchProviderModelsCache = { models, at: Date.now() };
+          return models;
+        })
+        .finally(() => {
+          searchProviderModelsPromise = null;
+        });
+    }
+    return providerModelsFromCacheRows(await searchProviderModelsPromise);
+  }
+
+  function enabledSearchProviderConfig() {
     ensureFullConfig();
+    const out = {};
+    for (const [name, providerConfig] of Object.entries(config.providers || {})) {
+      const providerName = normalizeSearchProviderId(name);
+      if (!providerConfig?.enabled || !isSearchCapableProvider(providerName)) continue;
+      out[providerName] = { ...providerConfig, enabled: true };
+    }
+    return out;
+  }
+
+  async function loadSearchProviderModelsFresh() {
+    const searchProviders = enabledSearchProviderConfig();
+    const providerNames = Object.keys(searchProviders);
+    if (!providerNames.length) return [];
     await ensureProvidersReady(config.providers || {});
-    const allProviders = reg.getAllProviders();
+    const providerResults = await Promise.all(providerNames.map(async (name) => {
+      const provider = reg.getProvider(name);
+      if (typeof provider?.listModels !== 'function') return [];
+      try {
+        const models = await provider.listModels();
+        if (!Array.isArray(models)) return [];
+        const rows = [];
+        for (const m of models) {
+          if (!m?.id || !isSelectableLlmModel(m)) continue;
+          const row = providerModelCacheRow(name, m);
+          if (row.supportsWebSearch !== true) continue;
+          rows.push({
+            ...row,
+            provider: normalizeSearchProviderId(row.provider),
+            searchCapable: true,
+            searchToolType: row.searchToolType || 'web_search',
+          });
+          modelMetaByRoute.set(modelMetaKey(name, m.id), row);
+        }
+        return rows;
+      } catch {
+        // Keep the picker responsive if one search-capable provider has a
+        // transient catalog/auth failure.
+        return [];
+      }
+    }));
     const results = [];
     const seen = new Set();
-    for (const [name, provider] of allProviders) {
-      if (typeof provider?.listModels !== 'function') continue;
+    addDefaultSearchModel(results, seen);
+    for (const row of providerResults.flat()) {
+      const key = `${normalizeSearchProviderId(row.provider)}:${row.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(row);
+    }
+    return results;
+  }
+
+  async function loadProviderModelsFresh() {
+    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();
-        if (Array.isArray(models)) {
-          for (const m of models) {
-            if (!m?.id) continue;
-            if (!isSelectableLlmModel(m)) continue;
-            const key = `${name}:${m.id}`;
-            if (seen.has(key)) continue;
-            seen.add(key);
-            const row = providerModelCacheRow(name, m);
-            results.push(row);
-            modelMetaByRoute.set(modelMetaKey(name, m.id), row);
-          }
+        if (!Array.isArray(models)) return [];
+        const rows = [];
+        for (const m of models) {
+          if (!m?.id) continue;
+          if (!isSelectableLlmModel(m)) continue;
+          rows.push(providerModelCacheRow(name, m));
         }
+        return rows;
       } catch {
         // Ignore per-provider catalog failures so one bad credential or
         // transient /models error does not hide other authenticated models.
+        return [];
       }
+    }));
+    const results = [];
+    const seen = new Set();
+    for (const row of providerResults.flat()) {
+      const key = `${row.provider}:${row.id}`;
+      if (seen.has(key)) continue;
+      seen.add(key);
+      results.push(row);
+      modelMetaByRoute.set(modelMetaKey(row.provider, row.id), row);
     }
     return results;
   }
 
-  async function collectProviderModels({ force = false } = {}) {
+  async function collectProviderModels({ force = false, quick = false } = {}) {
     if (!force && Array.isArray(providerModelsCache.models)) {
       return providerModelsFromCacheRows(providerModelsCache.models);
     }
+    if (!force && quick) {
+      warmProviderModelCache();
+      return quickProviderModelRows();
+    }
     if (!providerModelsPromise) {
       providerModelsPromise = loadProviderModelsFresh()
         .then((models) => {
@@ -2465,7 +3777,7 @@ function parsedProviderModelVersion(id) {
     const models = await collectProviderModels();
     const picked = models[0] || null;
     if (!picked) {
-      throw new Error('No provider models available. Run /providers to authenticate, then /model to choose a model.');
+      throw new Error('No provider models available. Open /providers to sign in, then /model to choose a model.');
     }
     route = {
       ...route,
@@ -2498,7 +3810,7 @@ function parsedProviderModelVersion(id) {
 
   function requireModelRoute() {
     if (routeHasModel()) return;
-    throw new Error('No model configured. Run /providers to authenticate, then /model to choose a model.');
+    throw new Error('No model configured. Open /providers to sign in, then /model to choose a model.');
   }
 
   async function recreateCurrentSessionIfReady() {
@@ -2537,8 +3849,8 @@ function parsedProviderModelVersion(id) {
       const coreMemoryContext = await loadCoreMemoryContext();
       if (closeRequested) throw new Error('runtime is closing');
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
+      const workflow = activeWorkflowSummary(config, dataDir);
       const workflowContext = workflowContextBlock(config, dataDir);
-      const workspaceContext = buildWorkspaceContext();
       const sessionOpts = {
         provider: route.provider,
         model: route.model,
@@ -2553,9 +3865,12 @@ function parsedProviderModelVersion(id) {
         disallowedTools: LEAD_DISALLOWED_TOOLS,
         cwd: currentCwd,
         coreMemoryContext,
+        workflow,
         workflowContext,
-        workspaceContext,
         fast: route.fast === true,
+        compaction: config.compaction && typeof config.compaction === 'object'
+          ? normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() })
+          : undefined,
       };
       if (hasOwn(route, 'effort') || route.effectiveEffort) {
         sessionOpts.effort = route.effectiveEffort || null;
@@ -2563,15 +3878,55 @@ function parsedProviderModelVersion(id) {
       session = mgr.createSession(sessionOpts);
       sessionNeedsCwdRefresh = false;
       Object.defineProperty(session, 'beforeToolHook', {
-        value: (input) => hooks.beforeTool(input),
+        value: (input) => hooks.beforeTool(hookCommonPayload({
+          ...input,
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          tool_name: input?.name || input?.tool_name,
+          tool_input: input?.args || input?.tool_input,
+          tool_use_id: input?.toolCallId || input?.tool_use_id,
+          cwd: input?.cwd || currentCwd,
+        })),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
+      // PostToolUse: bridge runtime tool completions to the standard hook bus.
+      // dispatch() returns a promise; the loop's afterToolHook caller already
+      // try/catches, so a rejection cannot escape the tool loop.
+      Object.defineProperty(session, 'afterToolHook', {
+        value: (input) => hooks.dispatch('PostToolUse', hookCommonPayload({
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          cwd: input?.cwd || currentCwd,
+          tool_name: input?.name,
+          tool_input: input?.args,
+          tool_use_id: input?.toolCallId || input?.tool_use_id,
+          tool_response: input?.result,
+        })),
         enumerable: false,
         configurable: true,
         writable: true,
       });
-      applyDeferredToolSurface(session, mode, standaloneTools);
+      applyDeferredToolSurface(session, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
       applyPreSessionToolSelection();
-      statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route));
+      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;
+      // a hook error must never break session creation. additionalContext is
+      // injected before the first user turn as a system-reminder context pair.
+      try {
+        const startSource = /resume/i.test(String(reason || ''))
+          ? 'resume'
+          : (/clear/i.test(String(reason || '')) ? 'clear' : 'startup');
+        const startDispatch = await hooks.dispatch('SessionStart', hookCommonPayload({ session_id: session.id, source: startSource, model: route.model }));
+        const startContext = Array.isArray(startDispatch?.additionalContext)
+          ? startDispatch.additionalContext.join('\n\n')
+          : String(startDispatch?.additionalContext || '');
+        if (startContext.trim()) {
+          session.messages.push({ role: 'user', content: `<system-reminder>\n# SessionStart Hook Context\n${startContext.trim()}\n</system-reminder>` });
+          session.messages.push({ role: 'assistant', content: '.' });
+          session.updatedAt = Date.now();
+        }
+      } catch { /* best-effort: never break session create */ }
       bootProfile('session:create:ready', {
         ms: (performance.now() - startedAt).toFixed(1),
         reason,
@@ -2590,7 +3945,10 @@ function parsedProviderModelVersion(id) {
   }
 
   function scheduleLeadSessionPrewarm() {
-    if (envFlag('MIXDOG_DISABLE_SESSION_PREWARM')) return;
+    if (!sessionPrewarmEnabled) {
+      bootProfile('session:prewarm-skipped');
+      return;
+    }
     const timer = setTimeout(() => {
       if (closeRequested || session?.id || sessionCreatePromise || activeTurnCount > 0) return;
       void createCurrentSession('prewarm')
@@ -2601,7 +3959,7 @@ function parsedProviderModelVersion(id) {
   }
 
   function scheduleProviderWarmup(delayMs = providerWarmupDelayMs) {
-    if (envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')) {
+    if (!providerWarmupEnabled) {
       bootProfile('providers:warm-skipped');
       return;
     }
@@ -2609,6 +3967,10 @@ function parsedProviderModelVersion(id) {
     providerWarmupTimer = setTimeout(() => {
       providerWarmupTimer = null;
       if (closeRequested) return;
+      if (!firstTurnCompleted && !envFlag('MIXDOG_PROVIDER_WARMUP_BEFORE_FIRST_TURN')) {
+        bootProfile('providers:warm-deferred', { reason: 'first-turn-pending' });
+        return;
+      }
       if (activeTurnCount > 0 || sessionCreatePromise) {
         bootProfile('providers:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
         scheduleProviderWarmup(backgroundBusyRetryMs);
@@ -2616,8 +3978,7 @@ function parsedProviderModelVersion(id) {
       }
       const providersStartedAt = performance.now();
       try {
-        config = cfgMod.loadConfig();
-        configHasSecrets = true;
+        reloadFullConfig();
       } catch (error) {
         bootProfile('config:full-failed', { error: error?.message || String(error) });
       }
@@ -2625,28 +3986,27 @@ function parsedProviderModelVersion(id) {
         .then(() => {
           bootProfile('providers:init:ready', { ms: (performance.now() - providersStartedAt).toFixed(1) });
           if (closeRequested) return null;
-          if (activeTurnCount > 0 || sessionCreatePromise) {
-            bootProfile('providers:optional-warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
-            scheduleProviderWarmup(backgroundBusyRetryMs);
-            return null;
-          }
-          return cachedProviderSetup();
-        })
-        .then((setup) => {
-          if (!setup) return;
-          bootProfile('provider-setup:warm-ready', {
-            api: Array.isArray(setup?.api) ? setup.api.length : 0,
-            oauth: Array.isArray(setup?.oauth) ? setup.oauth.length : 0,
-            local: Array.isArray(setup?.local) ? setup.local.length : 0,
-          });
+          return true;
         })
         .catch((error) => bootProfile('providers:warm-failed', { error: error?.message || String(error) }));
     }, delayMs);
     providerWarmupTimer.unref?.();
   }
 
+  function scheduleProviderSetupWarmup(delayMs = providerSetupWarmupDelayMs) {
+    if (providerSetupWarmupTimer || closeRequested) return;
+    providerSetupWarmupTimer = setTimeout(() => {
+      providerSetupWarmupTimer = null;
+      if (closeRequested) return;
+      void cachedProviderSetup()
+        .then(() => bootProfile('provider-setup:warm-ready'))
+        .catch((error) => bootProfile('provider-setup:warm-failed', { error: error?.message || String(error) }));
+    }, delayMs);
+    providerSetupWarmupTimer.unref?.();
+  }
+
   function scheduleProviderModelWarmup(delayMs = providerModelWarmupDelayMs) {
-    if (envFlag('MIXDOG_DISABLE_PROVIDER_WARMUP')) return;
+    if (!modelPrefetchEnabled) return;
     if (providerModelWarmupTimer || closeRequested) return;
     providerModelWarmupTimer = setTimeout(() => {
       providerModelWarmupTimer = null;
@@ -2661,11 +4021,75 @@ function parsedProviderModelVersion(id) {
     providerModelWarmupTimer.unref?.();
   }
 
+  function scheduleStatuslineUsageWarmup(delayMs = statuslineUsageWarmupDelayMs) {
+    const providerId = clean(route?.provider);
+    if (!providerId || !providerId.includes('oauth')) {
+      bootProfile('statusline-usage:warm-skipped', { provider: providerId || null });
+      return;
+    }
+    if (statuslineUsageWarmupTimer || closeRequested) return;
+    statuslineUsageWarmupTimer = setTimeout(async () => {
+      statuslineUsageWarmupTimer = null;
+      if (closeRequested) return;
+      if (activeTurnCount > 0 || sessionCreatePromise) {
+        bootProfile('statusline-usage:warm-deferred', { reason: activeTurnCount > 0 ? 'turn-active' : 'session-create' });
+        scheduleStatuslineUsageWarmup(backgroundBusyRetryMs);
+        return;
+      }
+      try {
+        ensureConfigForRouteProvider();
+        await ensureProvidersReady(ensureProviderEnabled(config, route.provider));
+        if (closeRequested) return;
+        refreshStatuslineUsageSnapshot(route);
+        bootProfile('statusline-usage:warm-ready', { provider: clean(route?.provider) });
+      } catch (error) {
+        bootProfile('statusline-usage:warm-failed', { error: error?.message || String(error) });
+      } finally {
+        scheduleStatuslineUsageRefresh();
+      }
+    }, delayMs);
+    statuslineUsageWarmupTimer.unref?.();
+  }
+
+  // Idle keep-alive loop: periodically re-fetch the OAuth usage snapshot so its
+  // cachedAt stays "live-fresh" and the statusline usage segment does not vanish
+  // after LIVE_USAGE_SNAPSHOT_MAX_AGE_MS while the session is idle. Turn-driven
+  // refreshes (recordStandaloneStatusTelemetry) already cover active sessions.
+  function scheduleStatuslineUsageRefresh(delayMs = statuslineUsageRefreshDelayMs) {
+    const providerId = clean(route?.provider);
+    if (!providerId || !providerId.includes('oauth')) return;
+    if (statuslineUsageRefreshTimer || closeRequested) return;
+    statuslineUsageRefreshTimer = setTimeout(async () => {
+      statuslineUsageRefreshTimer = null;
+      if (closeRequested) return;
+      if (activeTurnCount > 0 || sessionCreatePromise) {
+        // Active turns refresh usage on their own; just re-arm the idle loop.
+        scheduleStatuslineUsageRefresh();
+        return;
+      }
+      try {
+        ensureConfigForRouteProvider();
+        await ensureProvidersReady(ensureProviderEnabled(config, route.provider));
+        if (closeRequested) return;
+        refreshStatuslineUsageSnapshot(route);
+      } catch {
+        // Usage display must never affect the session runtime.
+      } finally {
+        scheduleStatuslineUsageRefresh();
+      }
+    }, delayMs);
+    statuslineUsageRefreshTimer.unref?.();
+  }
+
   function scheduleChannelStart(delayMs = channelStartDelayMs) {
     if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
       bootProfile('channels:start-skipped');
       return;
     }
+    if (!channelsEnabled()) {
+      bootProfile('channels:start-disabled');
+      return;
+    }
     if (channelStartTimer || closeRequested) return;
     bootProfile('channels:start-scheduled', { delayMs });
     channelStartTimer = setTimeout(() => {
@@ -2700,12 +4124,31 @@ function parsedProviderModelVersion(id) {
     });
   }
 
-  bootProfile('session-runtime:ready', { lazySession: true, prewarmSession: true });
+  bootProfile('session-runtime:ready', {
+    lazySession: true,
+    prewarmSession: sessionPrewarmEnabled,
+    providerWarmup: providerWarmupEnabled,
+    codeGraphPrewarm: codeGraphPrewarmEnabled,
+  });
   scheduleLeadSessionPrewarm();
+  // Lazy mode (default): skip the startup prewarm entirely; the first turn
+  // triggers it instead (see ask()). Eager mode keeps the old startup schedule.
+  if (!codeGraphPrewarmLazy) {
+    scheduleCodeGraphPrewarm(codeGraphPrewarmDelayMs, 'startup');
+  } else {
+    bootProfile('code-graph:prewarm-lazy', { reason: 'startup-deferred-to-first-turn' });
+  }
+  scheduleProviderSetupWarmup();
   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.
+  // Operators that want earlier catalog warming can lower
+  // MIXDOG_PROVIDER_MODEL_WARMUP_DELAY_MS explicitly.
+  scheduleProviderModelWarmup();
+  scheduleStatuslineUsageWarmup();
   scheduleChannelStart();
 
-  function contextStatusCacheKeyFor({ messages, tools, bridgeMode }) {
+  function contextStatusCacheKeyFor({ messages, tools }) {
     const compaction = session?.compaction || {};
     const lastMessage = messages[messages.length - 1] || null;
     return {
@@ -2715,7 +4158,6 @@ function parsedProviderModelVersion(id) {
       model: route.model,
       cwd: currentCwd,
       mode,
-      bridgeMode,
       messages,
       messageCount: messages.length,
       lastMessage,
@@ -2788,23 +4230,25 @@ function parsedProviderModelVersion(id) {
     get toolMode() {
       return mode;
     },
-    get bridgeMode() {
-      return bridge.getDefaultMode();
-    },
     get autoClear() {
       return normalizeAutoClearConfig(config.autoClear);
     },
     get systemShell() {
       return normalizeSystemShellConfig(config.shell);
     },
+    get searchRoute() {
+      searchRoute = normalizeSearchRouteConfig(config.searchRoute) || normalizeSearchRouteConfig(searchRoute);
+      return searchRoute;
+    },
     get workflow() {
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      const pack = loadWorkflowPack(dataDir, activeWorkflowId(config));
-      return pack ? { id: pack.id, name: pack.name, description: pack.description, source: pack.source } : { id: DEFAULT_WORKFLOW_ID, name: 'Default' };
+      if (session?.workflow && typeof session.workflow === 'object') {
+        return workflowSummary(session.workflow);
+      }
+      return activeWorkflowSummary(config, dataDir);
     },
     get outputStyle() {
-      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      return outputStyleStatus(dataDir).current;
+      return getOutputStyleStatusCached().current;
     },
     get cwd() {
       return currentCwd;
@@ -2813,10 +4257,16 @@ function parsedProviderModelVersion(id) {
       return session;
     },
     contextStatus() {
-      const messages = Array.isArray(session?.messages) ? session.messages : [];
+      // Prefer the in-flight working transcript while a turn is running so the
+      // context gauge reflects LIVE growth (user turn + tool calls/results) as
+      // it accumulates, instead of freezing at the pre-turn committed snapshot.
+      // askSession() sets session.liveTurnMessages for the turn duration and
+      // clears it on commit/cancel/error, after which we fall back to the
+      // authoritative committed transcript.
+      const liveTurnMessages = Array.isArray(session?.liveTurnMessages) ? session.liveTurnMessages : null;
+      const messages = liveTurnMessages || (Array.isArray(session?.messages) ? session.messages : []);
       const tools = Array.isArray(session?.tools) ? session.tools : [];
-      const bridgeMode = bridge.getDefaultMode();
-      const cacheKey = contextStatusCacheKeyFor({ messages, tools, bridgeMode });
+      const cacheKey = contextStatusCacheKeyFor({ messages, tools });
       if (contextStatusCacheValue && sameContextStatusCacheKey(cacheKey, contextStatusCacheKey)) {
         return contextStatusCacheValue;
       }
@@ -2829,7 +4279,9 @@ function parsedProviderModelVersion(id) {
       const rawWindow = Number(session?.rawContextWindow || session?.contextWindow || 0);
       const effectiveWindow = Number(session?.contextWindow || rawWindow || 0);
       const lastContextTokens = Number(session?.lastContextTokens || 0);
-      const estimatedContextTokens = messageSummary.estimatedTokens + requestReserveTokens;
+      const estimatedContextTokens = estimateTranscriptContextUsage(messages, tools, {
+        messageCount: messageSummary.count,
+      });
       const compactAt = Number(session?.compaction?.lastChangedAt || session?.compaction?.lastCompactAt || 0);
       const usageAt = Number(session?.lastContextTokensUpdatedAt || 0);
       const lastUsageStale = !!lastContextTokens && (
@@ -2839,31 +4291,58 @@ function parsedProviderModelVersion(id) {
       );
       const compactBoundaryTokens = Number(session?.compactBoundaryTokens || session?.compaction?.boundaryTokens || 0);
       const displayWindow = compactBoundaryTokens || effectiveWindow;
-      const usedTokens = lastUsageStale
-        ? estimatedContextTokens
-        : Math.max(estimatedContextTokens, lastContextTokens || 0);
+      // The transcript estimate is the single source of truth for the displayed
+      // context footprint. Provider-reported input_tokens (lastContextTokens)
+      // swing non-monotonically and are not window-bounded on some providers
+      // (e.g. OpenAI gpt-5.5 Responses API), so they are kept only as secondary
+      // metadata (lastApiRequestTokens / usage.lastContextTokens) and never feed
+      // the gauge numerator.
+      const usedTokens = estimatedContextTokens;
       const freeTokens = displayWindow ? Math.max(0, displayWindow - usedTokens) : 0;
       const autoCompactTokenLimit = Number(session?.autoCompactTokenLimit || 0);
-      const defaultCompactTriggerTokens = compactBoundaryTokens ? Math.max(1, compactBoundaryTokens) : 0;
-      const compactTriggerTokens = autoCompactTokenLimit && compactBoundaryTokens && autoCompactTokenLimit <= compactBoundaryTokens
+      // 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
-        : Number(session?.compaction?.triggerTokens || defaultCompactTriggerTokens || 0);
-      const compactBufferTokens = Number(session?.compaction?.bufferTokens || (compactBoundaryTokens && compactTriggerTokens ? Math.max(0, compactBoundaryTokens - compactTriggerTokens) : 0));
+        : (usablePersistedTrigger || defaultCompactTriggerTokens || 0);
+      const compactBufferTokens = Number(compactBoundaryTokens && compactTriggerTokens
+        ? Math.max(0, compactBoundaryTokens - compactTriggerTokens)
+        : defaultCompactBufferTokens);
       const value = {
         sessionId: session?.id || null,
         provider: route.provider,
         model: route.model,
         cwd: currentCwd,
         toolMode: mode,
-        bridgeMode,
         contextWindow: displayWindow || effectiveWindow || null,
         effectiveContextWindow: effectiveWindow || null,
         rawContextWindow: rawWindow || null,
         effectiveContextWindowPercent: session?.effectiveContextWindowPercent || null,
         usedTokens,
-        usedSource: lastContextTokens && !lastUsageStale && lastContextTokens >= estimatedContextTokens
-          ? 'last_api_request'
-          : 'estimated',
+        usedSource: 'estimated',
         currentEstimatedTokens: estimatedContextTokens,
         lastApiRequestTokens: lastContextTokens || 0,
         lastApiRequestStale: lastUsageStale,
@@ -2901,26 +4380,64 @@ function parsedProviderModelVersion(id) {
       return value;
     },
     listProviders() {
-      return renderProviderStatus(cfgMod.loadConfig());
+      return renderProviderStatus(displayConfig());
     },
     async getProviderSetup() {
       return await cachedProviderSetup();
     },
     async getUsageDashboard(options = {}) {
-      const nextConfig = cfgMod.loadConfig();
-      return await createUsageDashboard(nextConfig, {
-        ...(options || {}),
-        setup: await cachedProviderSetup(),
-        getProvider: (providerId) => reg.getProvider(providerId),
-        log: (message) => {
-          if (process.env.MIXDOG_USAGE_TRACE) {
-            try { process.stderr.write(`[usage] ${message}\n`); } catch {}
-          }
-        },
-      });
+      const forceSetup = options?.force === true || options?.refresh === true;
+      if (!forceSetup && usageDashboardCache.dashboard) {
+        const cached = {
+          ...usageDashboardCache.dashboard,
+          refresh: false,
+          checking: false,
+          cached: true,
+          cachedAt: usageDashboardCache.at,
+        };
+        if (typeof options?.onUpdate === 'function') {
+          try { options.onUpdate(cached); } catch {}
+        }
+        return cached;
+      }
+      if (!forceSetup && usageDashboardPromise) return await usageDashboardPromise;
+      const quickSetup = options?.quickSetup !== false;
+      const getProvider = (providerId) => reg.getProvider(providerId);
+      const log = (message) => {
+        if (process.env.MIXDOG_USAGE_TRACE) {
+          try { process.stderr.write(`[usage] ${message}\n`); } catch {}
+        }
+      };
+      if (quickSetup && typeof options?.onUpdate === 'function') {
+        const previewConfig = displayConfig();
+        const previewSetup = await cachedProviderSetup({ force: false, quick: true });
+        await createUsageDashboard(previewConfig, {
+          ...(options || {}),
+          preview: true,
+          setup: previewSetup,
+          getProvider,
+          log,
+        });
+      }
+      const buildDashboard = async () => {
+        const dashboard = await createUsageDashboard(displayConfig(), {
+          ...(options || {}),
+          setup: await cachedProviderSetup({ force: forceSetup, quick: false }),
+          getProvider,
+          log,
+        });
+        usageDashboardCache = { dashboard, at: Date.now() };
+        return dashboard;
+      };
+      if (forceSetup) return await buildDashboard();
+      usageDashboardPromise = buildDashboard()
+        .finally(() => {
+          usageDashboardPromise = null;
+        });
+      return await usageDashboardPromise;
     },
     getOnboardingStatus() {
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = displayConfig();
       return {
         completed: nextConfig?.onboarding?.completed === true,
         version: nextConfig?.onboarding?.version || 0,
@@ -2931,17 +4448,118 @@ function parsedProviderModelVersion(id) {
     getAutoClear() {
       return normalizeAutoClearConfig(config.autoClear);
     },
+    // --- User profile (/profile statusline command) ---------------------
+    // getProfile returns the normalized { title, language } plus the resolved
+    // language catalog entry and the full language list for the picker UI.
+    getProfile() {
+      const profile = cfgMod.normalizeProfileConfig(config.profile);
+      return {
+        ...profile,
+        languageEntry: cfgMod.profileLanguageEntry(profile.language),
+        languages: cfgMod.PROFILE_LANGUAGES,
+      };
+    },
+    // setProfile patches title and/or language and persists. Unknown language
+    // ids normalize back to 'system'. Prompt-side injection is wired separately
+    // (composeSystemPrompt) — this only owns the stored value.
+    setProfile(input = {}) {
+      const current = cfgMod.normalizeProfileConfig(config.profile);
+      const next = { ...current };
+      if (hasOwn(input, 'title') || hasOwn(input, 'name')) {
+        next.title = input.title ?? input.name ?? '';
+      }
+      if (hasOwn(input, 'language') || hasOwn(input, 'lang')) {
+        next.language = input.language ?? input.lang ?? 'system';
+      }
+      const normalized = cfgMod.normalizeProfileConfig(next);
+      saveConfigAndAdopt({ ...config, profile: normalized });
+      return this.getProfile();
+    },
+    getCompactionSettings() {
+      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    setCompactionSettings(input = {}) {
+      const current = normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+      const next = { ...current };
+      if (hasOwn(input, 'auto')) next.auto = input.auto !== false;
+      if (hasOwn(input, 'enabled')) next.auto = input.enabled !== false;
+      if (hasOwn(input, 'type') || hasOwn(input, 'compactType') || hasOwn(input, 'compact_type')) {
+        const requestedType = input.type ?? input.compactType ?? input.compact_type;
+        const compactType = normalizeCompactTypeSetting(requestedType, current.compactType || current.type || 'semantic');
+        if (compactType === 'recall-fasttrack' && !memoryEnabled()) {
+          throw new Error('recall-fasttrack compact requires memory to be enabled');
+        }
+        next.type = compactType;
+        next.compactType = compactType;
+      }
+      const nextConfig = { ...config };
+      nextConfig.compaction = normalizeCompactionConfig(next, { memoryEnabled: memoryEnabled() });
+      saveConfigAndAdopt(nextConfig);
+      if (session) {
+        session.compaction = {
+          ...(session.compaction || {}),
+          ...normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() }),
+        };
+      }
+      invalidateContextStatusCache();
+      return normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() });
+    },
+    getMemorySettings() {
+      return {
+        enabled: memoryEnabled(),
+        compactFastTrackAvailable: memoryEnabled(),
+      };
+    },
+    async setMemoryEnabled(enabled) {
+      const nextConfig = setModuleEnabledInConfig({ ...config }, 'memory', enabled !== false);
+      if (enabled === false) {
+        nextConfig.compaction = normalizeCompactionConfig(nextConfig.compaction, { memoryEnabled: false });
+      }
+      saveConfigAndAdopt(nextConfig);
+      if (!memoryEnabled() && memoryModPromise) {
+        await memoryModPromise.then((mod) => mod?.stop?.()).catch(() => {});
+        memoryModPromise = null;
+      }
+      if (session && config.compaction) {
+        session.compaction = {
+          ...(session.compaction || {}),
+          ...normalizeCompactionConfig(config.compaction, { memoryEnabled: memoryEnabled() }),
+        };
+      }
+      invalidatePreSessionToolSurface();
+      invalidateContextStatusCache();
+      return this.getMemorySettings();
+    },
+    getChannelSettings(options = {}) {
+      return {
+        enabled: channelsEnabled(),
+        ...(options?.includeStatus === false ? {} : { status: channels.status() }),
+      };
+    },
+    async setChannelsEnabled(enabled) {
+      const nextConfig = setModuleEnabledInConfig({ ...config }, 'channels', enabled !== false);
+      saveConfigAndAdopt(nextConfig);
+      if (!channelsEnabled()) {
+        if (channelStartTimer) {
+          clearTimeout(channelStartTimer);
+          channelStartTimer = null;
+        }
+        await channels.stop('settings-disabled', { waitForExit: false }).catch(() => {});
+      } else {
+        scheduleChannelStart(0);
+      }
+      invalidatePreSessionToolSurface();
+      return this.getChannelSettings();
+    },
     getSystemShell() {
       return normalizeSystemShellConfig(config.shell);
     },
     setSystemShell(input = {}) {
       const command = normalizeSystemShellCommand(typeof input === 'string' ? input : input?.command);
-      const nextConfig = cfgMod.loadConfig();
-      cfgMod.saveConfig({
-        ...nextConfig,
-        shell: command ? { ...(nextConfig.shell || {}), command } : {},
+      saveConfigAndAdopt({
+        ...config,
+        shell: command ? { ...(config.shell || {}), command } : {},
       });
-      config = cfgMod.loadConfig();
       setConfiguredShell(command);
       return normalizeSystemShellConfig(config.shell);
     },
@@ -2960,9 +4578,7 @@ function parsedProviderModelVersion(id) {
         next.idleMs = idleMs;
         if (!hasOwn(input, 'enabled')) next.enabled = true;
       }
-      const nextConfig = cfgMod.loadConfig();
-      cfgMod.saveConfig({ ...nextConfig, autoClear: next });
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt({ ...config, autoClear: next });
       return { ...normalizeAutoClearConfig(config.autoClear), label: formatDurationMs(normalizeAutoClearConfig(config.autoClear).idleMs) };
     },
     async completeOnboarding(payload = {}) {
@@ -2970,7 +4586,7 @@ function parsedProviderModelVersion(id) {
       const workflowInput = payload.workflowRoutes && typeof payload.workflowRoutes === 'object'
         ? payload.workflowRoutes
         : {};
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       let presets = Array.isArray(nextConfig.presets) ? nextConfig.presets.slice() : [];
       const workflowRoutes = { ...(nextConfig.workflowRoutes || {}) };
 
@@ -2989,10 +4605,13 @@ function parsedProviderModelVersion(id) {
 
       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.
       nextConfig.maintenance = {
         ...(nextConfig.maintenance || {}),
-        explore: workflowRoutes.explorer ? workflowPresetId('explorer') : (nextConfig.maintenance?.explore || 'haiku'),
-        memory: workflowRoutes.memory ? workflowPresetId('memory') : (nextConfig.maintenance?.memory || 'haiku'),
+        ...(workflowRoutes.explorer ? { explore: normalizeWorkflowRoute(workflowRoutes.explorer) } : {}),
+        ...(workflowRoutes.memory ? { memory: normalizeWorkflowRoute(workflowRoutes.memory) } : {}),
       };
       nextConfig.onboarding = {
         ...(nextConfig.onboarding || {}),
@@ -3001,8 +4620,7 @@ function parsedProviderModelVersion(id) {
         completedAt: new Date().toISOString(),
       };
 
-      cfgMod.saveConfig(nextConfig);
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt(nextConfig);
       if (defaultRoute) {
         route = resolveRoute(config, { provider: defaultRoute.provider, model: defaultRoute.model, effort: defaultRoute.effort });
         if (session?.id) mgr.closeSession(session.id, 'cli-onboarding-complete');
@@ -3085,26 +4703,34 @@ function parsedProviderModelVersion(id) {
       const result = String(secret || '').trim()
         ? saveProviderApiKey(cfgMod, providerId, secret)
         : await loginOAuthProvider(cfgMod, providerId);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();
       return result;
     },
     async loginOAuthProvider(providerId) {
       const result = await loginOAuthProvider(cfgMod, providerId);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();
       return result;
     },
     async beginOAuthProviderLogin(providerId) {
       const result = await beginOAuthProviderLogin(cfgMod, providerId);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       return {
         ...result,
+        waitForCallback: result.waitForCallback?.then((completed) => {
+          reloadFullConfig();
+          if (completed) {
+            invalidateProviderCaches();
+            warmProviderModelCache();
+          }
+          return completed;
+        }),
         completeCode: async (code) => {
           const completed = await result.completeCode(code);
-          config = cfgMod.loadConfig();
+          reloadFullConfig();
           invalidateProviderCaches();
           warmProviderModelCache();
           return completed;
@@ -3113,42 +4739,97 @@ function parsedProviderModelVersion(id) {
     },
     saveProviderApiKey(providerId, secret) {
       const result = saveProviderApiKey(cfgMod, providerId, secret);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();
       return result;
     },
     saveOpenAIUsageSessionKey(secret) {
       const result = saveOpenAIUsageSessionKey(cfgMod, secret);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       return result;
     },
     saveOpenCodeGoUsageAuth(opts) {
       const result = saveOpenCodeGoUsageAuth(cfgMod, opts);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       return result;
     },
     setLocalProvider(providerId, opts) {
       const result = setLocalProvider(cfgMod, providerId, opts);
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();
       return result;
     },
     forgetProviderAuth(providerId) {
-      const result = forgetProviderAuth(providerId);
-      config = cfgMod.loadConfig();
+      const result = forgetProviderAuth(cfgMod, providerId);
+      reloadFullConfig();
       invalidateProviderCaches();
       warmProviderModelCache();
       return result;
     },
     listPresets() {
-      return cfgMod.listPresets(cfgMod.loadConfig());
+      return cfgMod.listPresets(displayConfig());
     },
     async listProviderModels(options = {}) {
-      return await collectProviderModels({ force: options.force === true || options.refresh === true });
+      return await collectProviderModels({
+        force: options.force === true || options.refresh === true,
+        quick: options.quick === true,
+      });
+    },
+    getSearchRoute() {
+      searchRoute = normalizeSearchRouteConfig(config.searchRoute) || normalizeSearchRouteConfig(searchRoute);
+      return searchRoute;
+    },
+    async listSearchModels(options = {}) {
+      return await collectSearchProviderModels({ force: options.force === true || options.refresh === true });
+    },
+    async setSearchRoute(next) {
+      let selectedRoute = normalizeSearchRouteConfig(next);
+      if (!selectedRoute && next?.model && searchRoute?.provider) {
+        selectedRoute = normalizeSearchRouteConfig({ ...next, provider: searchRoute.provider });
+      }
+      if (!selectedRoute) throw new Error('search route requires provider and model');
+      if (isDefaultSearchRouteConfig(selectedRoute)) {
+        ensureFullConfig();
+        const routeToSave = normalizeSearchRouteConfig({
+          provider: SEARCH_DEFAULT_PROVIDER,
+          model: SEARCH_DEFAULT_MODEL,
+          ...(selectedRoute.toolType ? { toolType: selectedRoute.toolType } : {}),
+        });
+        const nextConfig = { ...config };
+        nextConfig.searchRoute = routeToSave;
+        saveConfigAndAdopt(nextConfig);
+        searchRoute = normalizeSearchRouteConfig(config.searchRoute);
+        invalidateProviderCaches();
+        return searchRoute;
+      }
+      if (!isSearchCapableProvider(selectedRoute.provider)) {
+        throw new Error(`provider "${selectedRoute.provider}" does not support Mixdog native search`);
+      }
+      ensureFullConfig();
+      await reg.initProviders(ensureProviderEnabled(config, selectedRoute.provider));
+      const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+      if (!searchCapableFor(selectedRoute.provider, modelMeta)) {
+        throw new Error(`model "${selectedRoute.model}" is not marked as web-search capable`);
+      }
+      const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
+      const effort = coerceEffortFor(selectedRoute.provider, modelMeta, selectedRoute.effort);
+      selectedRoute = {
+        ...selectedRoute,
+        ...(effort ? { effort } : {}),
+        fast: fastCapable ? selectedRoute.fast === true : false,
+      };
+      adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: config }), { hasSecrets: configHasSecrets });
+      const routeToSave = normalizeSearchRouteConfig(selectedRoute);
+      const nextConfig = { ...config };
+      nextConfig.searchRoute = routeToSave;
+      saveConfigAndAdopt(nextConfig);
+      searchRoute = normalizeSearchRouteConfig(config.searchRoute);
+      invalidateProviderCaches();
+      return searchRoute;
     },
     listAgents() {
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
@@ -3160,7 +4841,7 @@ function parsedProviderModelVersion(id) {
       }));
     },
     listWorkflows() {
-      const currentConfig = cfgMod.loadConfig();
+      const currentConfig = displayConfig();
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
       const active = activeWorkflowId(currentConfig);
       return listWorkflowPacks(dataDir).map((workflow) => ({
@@ -3173,16 +4854,13 @@ function parsedProviderModelVersion(id) {
       }));
     },
     getOutputStyle() {
-      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      return outputStyleStatus(dataDir);
+      return getOutputStyleStatusCached();
     },
     listOutputStyles() {
-      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      return outputStyleStatus(dataDir);
+      return getOutputStyleStatusCached();
     },
     async setOutputStyle(value) {
-      const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
-      const before = outputStyleStatus(dataDir);
+      const before = getOutputStyleStatusCached({ fresh: true });
       const selected = findOutputStyle(value, before.styles);
       if (!selected) {
         const names = before.styles.map((style) => style.label || style.id).join(', ') || 'Default';
@@ -3198,6 +4876,7 @@ function parsedProviderModelVersion(id) {
         }
         return next;
       });
+      invalidateOutputStyleStatusCache();
       const hasConversation = sessionHasConversationMessages(session);
       let appliedToCurrentSession = !hasConversation;
       if (session?.id && !hasConversation) {
@@ -3206,23 +4885,17 @@ function parsedProviderModelVersion(id) {
         await recreateCurrentSessionIfReady();
       }
       invalidateContextStatusCache();
-      return { ...outputStyleStatus(dataDir), appliedToCurrentSession };
+      return { ...getOutputStyleStatusCached({ fresh: true }), appliedToCurrentSession };
     },
     async setWorkflow(workflowId) {
       const id = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
       const dataDir = cfgMod.getPluginData?.() || STANDALONE_DATA_DIR;
       const pack = loadWorkflowPack(dataDir, id);
       if (!pack || pack.id !== id) throw new Error(`workflow "${workflowId}" not found`);
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       nextConfig.workflow = { ...(nextConfig.workflow || {}), active: id };
-      cfgMod.saveConfig(nextConfig);
-      config = cfgMod.loadConfig();
-      if (session?.id) {
-        mgr.closeSession(session.id, 'cli-workflow-switch');
-        session = null;
-      }
-      await recreateCurrentSessionIfReady();
-      return { id: pack.id, name: pack.name, description: pack.description, source: pack.source };
+      saveConfigAndAdopt(nextConfig);
+      return workflowSummary(pack);
     },
     async setAgentRoute(agentId, next) {
       const id = normalizeAgentId(agentId);
@@ -3232,12 +4905,12 @@ function parsedProviderModelVersion(id) {
       const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
       const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
       selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
-      config = saveModelSettings(cfgMod, selectedRoute, { fastCapable });
+      adoptConfig(saveModelSettings(cfgMod, selectedRoute, { fastCapable, baseConfig: config }), { hasSecrets: configHasSecrets });
 
       const routeToSave = normalizeWorkflowRoute(selectedRoute);
       if (!routeToSave) throw new Error('agent route requires provider and model');
       const agent = FIXED_AGENT_SLOTS.find((item) => item.id === id);
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       nextConfig.agents = {
         ...(nextConfig.agents || {}),
         [id]: routeToSave,
@@ -3249,24 +4922,48 @@ function parsedProviderModelVersion(id) {
           [agent.workflowSlot]: routeToSave,
         };
         nextConfig.presets = upsertWorkflowPreset(nextConfig.presets, agent.workflowSlot, routeToSave);
+        // Maintenance slots store a direct {provider, model} route now, so
+        // mirror the agent route straight in instead of a preset-id string.
         nextConfig.maintenance = {
           ...(nextConfig.maintenance || {}),
-          ...(id === 'explore' ? { explore: workflowPresetId('explorer') } : {}),
-          ...(id === 'maintainer' ? { memory: workflowPresetId('memory') } : {}),
+          ...(id === 'explore' ? { explore: routeToSave } : {}),
+          ...(id === 'maintainer' ? { memory: routeToSave } : {}),
         };
       }
-      cfgMod.saveConfig(nextConfig);
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt(nextConfig);
       return routeToSave;
     },
     async ask(prompt, options = {}) {
       activeTurnCount += 1;
+      // Lazy code-graph prewarm: kick off the build ONCE, on the first real
+      // turn, so a likely code lookup hits a warm cache — without paying the
+      // post-first-frame prewarm freeze on idle startup. The schedule is async
+      // + unref'd (worker thread), so it never blocks this turn.
+      if (codeGraphPrewarmLazy && !codeGraphFirstTurnPrewarmDone) {
+        codeGraphFirstTurnPrewarmDone = true;
+        scheduleCodeGraphPrewarm(0, 'first-turn');
+      }
       const startedAt = Date.now();
       try {
         await refreshSessionForCwdIfNeeded('cwd-change');
         if (!session?.id) await createCurrentSession('turn');
         hooks.emit('turn:start', { sessionId: session.id, prompt, cwd: currentCwd });
-        const turnContext = [options.context || ''].map((part) => String(part || '').trim()).filter(Boolean).join('\n\n');
+        // UserPromptSubmit: bridge to the standard hook bus. A hook FAILURE
+        // must not block the turn, but a genuine blocked===true MUST throw.
+        let promptDispatch = null;
+        try {
+          promptDispatch = await hooks.dispatch('UserPromptSubmit', hookCommonPayload({ session_id: session.id, prompt }));
+        } catch { /* hook failure never blocks the turn */ }
+        if (promptDispatch?.blocked === true) {
+          throw new Error(`prompt blocked by hook: ${promptDispatch.reason || ''}`);
+        }
+        const hookContext = Array.isArray(promptDispatch?.additionalContext)
+          ? promptDispatch.additionalContext.join('\n\n')
+          : String(promptDispatch?.additionalContext || '');
+        const turnContext = [options.context || '', hookContext]
+          .map((part) => String(part || '').trim())
+          .filter(Boolean)
+          .join('\n\n');
         const result = await mgr.askSession(
           session.id,
           prompt,
@@ -3289,16 +4986,25 @@ function parsedProviderModelVersion(id) {
           {
             onTextDelta: options.onTextDelta,
             onReasoningDelta: options.onReasoningDelta,
+            onAssistantText: options.onAssistantText,
             onUsageDelta: options.onUsageDelta,
             onToolResult: options.onToolResult,
+            onToolApproval: options.onToolApproval,
+            onCompactEvent: options.onCompactEvent,
             onStageChange: options.onStageChange,
             onStreamDelta: options.onStreamDelta,
             drainSteering: options.drainSteering,
             onSteerMessage: options.onSteerMessage,
+            notifyFn: notifyFnForSession(session.id),
           },
         );
         session = mgr.getSession(session.id) || session;
         hooks.emit('turn:end', { sessionId: session.id, elapsedMs: Date.now() - startedAt });
+        // Stop: bridge to the standard hook bus. Best-effort; ignore result,
+        // never throw.
+        try {
+          await hooks.dispatch('Stop', hookCommonPayload({ session_id: session.id }));
+        } catch { /* best-effort: Stop hook must never break the turn */ }
         return { result, session };
       } catch (error) {
         hooks.emit('turn:error', { sessionId: session?.id || null, elapsedMs: Date.now() - startedAt, error: error?.message || String(error) });
@@ -3307,27 +5013,31 @@ function parsedProviderModelVersion(id) {
         activeTurnCount = Math.max(0, activeTurnCount - 1);
         if (!firstTurnCompleted) {
           firstTurnCompleted = true;
+          scheduleProviderWarmup();
           scheduleProviderModelWarmup();
         }
       }
     },
     async clear(options = {}) {
       if (!session?.id) return false;
-      const cleared = await mgr.clearSessionMessages(session.id);
+      const cleared = await mgr.clearSessionMessages(session.id, options);
       if (!cleared) return false;
       session = typeof cleared === 'object' ? cleared : (mgr.getSession(session.id) || session);
-      if (options.recoverBridge === true) {
-        try { bridge.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
+      if (options.recoverAgent === true) {
+        try { agentTool.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
       }
       invalidateContextStatusCache();
       return true;
     },
     async compact(options = {}) {
       if (!session?.id) return null;
+      if (activeTurnCount > 0) {
+        return { changed: false, reason: 'compact skipped: turn in progress' };
+      }
       const result = await mgr.compactSessionMessages(session.id);
       session = mgr.getSession(session.id) || session;
-      if (options.recoverBridge === true) {
-        try { bridge.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
+      if (options.recoverAgent === true) {
+        try { agentTool.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
       }
       invalidateContextStatusCache();
       return result;
@@ -3339,25 +5049,15 @@ function parsedProviderModelVersion(id) {
       await recreateCurrentSessionIfReady();
       return mode;
     },
-    setBridgeMode(nextMode) {
-      const applied = bridge.setDefaultMode(nextMode);
-      try { sharedCfgMod.updateSection('agent', (s) => ({ ...(s || {}), bridgeMode: applied })); } catch {}
-      return applied;
-    },
-    toggleBridgeMode() {
-      const applied = bridge.toggleDefaultMode();
-      try { sharedCfgMod.updateSection('agent', (s) => ({ ...(s || {}), bridgeMode: applied })); } catch {}
-      return applied;
-    },
-    bridgeStatus() {
-      return bridgeStatusState();
+    agentStatus() {
+      return agentStatusState();
     },
     get clientHostPid() {
       return session?.clientHostPid || process.pid;
     },
-    bridgeControl(args = {}) {
+    agentControl(args = {}) {
       const callerSessionId = session?.id || null;
-      return bridge.execute(args, {
+      return agentTool.execute(args, {
         callerCwd: currentCwd,
         invocationSource: 'user-command',
         callerSessionId,
@@ -3387,6 +5087,7 @@ function parsedProviderModelVersion(id) {
         activeCount: rows.filter((row) => row.active).length,
         tools,
         activeTools: sortedNamesByMeasuredUsage(activeNames),
+        discoveredTools: sortedNamesByMeasuredUsage(surface?.deferredDiscoveredTools || []),
       };
     },
     selectTools(names) {
@@ -3402,7 +5103,7 @@ function parsedProviderModelVersion(id) {
       return mcpStatus();
     },
     async reconnectMcp() {
-      config = cfgMod.loadConfig();
+      reloadFullConfig();
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       if (session?.id) mgr.closeSession(session.id, 'cli-mcp-reconnect');
@@ -3411,13 +5112,12 @@ function parsedProviderModelVersion(id) {
     },
     async addMcpServer(input = {}) {
       const { name, config: serverConfig } = normalizeMcpServerInput(input);
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       nextConfig.mcpServers = {
         ...(nextConfig.mcpServers || {}),
         [name]: serverConfig,
       };
-      cfgMod.saveConfig(nextConfig);
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt(nextConfig);
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       if (session?.id) mgr.closeSession(session.id, 'cli-mcp-add');
@@ -3427,7 +5127,7 @@ function parsedProviderModelVersion(id) {
     async removeMcpServer(name) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       const current = nextConfig.mcpServers && typeof nextConfig.mcpServers === 'object'
         ? { ...nextConfig.mcpServers }
         : {};
@@ -3435,8 +5135,7 @@ function parsedProviderModelVersion(id) {
         throw new Error(`MCP server not configured: ${serverName}`);
       }
       delete current[serverName];
-      cfgMod.saveConfig({ ...nextConfig, mcpServers: current });
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       if (session?.id) mgr.closeSession(session.id, 'cli-mcp-remove');
@@ -3446,7 +5145,7 @@ function parsedProviderModelVersion(id) {
     async setMcpServerEnabled(name, enabled) {
       const serverName = clean(name);
       if (!serverName) throw new Error('MCP server name is required');
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       const current = nextConfig.mcpServers && typeof nextConfig.mcpServers === 'object'
         ? { ...nextConfig.mcpServers }
         : {};
@@ -3454,8 +5153,7 @@ function parsedProviderModelVersion(id) {
         throw new Error(`MCP server not configured: ${serverName}`);
       }
       current[serverName] = { ...(current[serverName] || {}), enabled: enabled !== false };
-      cfgMod.saveConfig({ ...nextConfig, mcpServers: current });
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       if (session?.id) mgr.closeSession(session.id, 'cli-mcp-toggle');
@@ -3506,13 +5204,12 @@ function parsedProviderModelVersion(id) {
       const key = clean(plugin.id || plugin.name || plugin);
       const dataDir = cfgMod.getPluginData?.();
       const removed = registryRemovePlugin(key, { dataDir });
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       const serverName = pluginMcpServerName(plugin);
       if (nextConfig.mcpServers && Object.prototype.hasOwnProperty.call(nextConfig.mcpServers, serverName)) {
         const current = { ...nextConfig.mcpServers };
         delete current[serverName];
-        cfgMod.saveConfig({ ...nextConfig, mcpServers: current });
-        config = cfgMod.loadConfig();
+        saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
         await connectConfiguredMcp({ reset: true });
         invalidatePreSessionToolSurface();
       }
@@ -3527,7 +5224,7 @@ function parsedProviderModelVersion(id) {
       const scriptPath = join(root, script);
       if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
       const serverName = pluginMcpServerName(plugin);
-      const nextConfig = cfgMod.loadConfig();
+      const nextConfig = { ...config };
       nextConfig.mcpServers = {
         ...(nextConfig.mcpServers || {}),
         [serverName]: {
@@ -3540,8 +5237,7 @@ function parsedProviderModelVersion(id) {
           },
         },
       };
-      cfgMod.saveConfig(nextConfig);
-      config = cfgMod.loadConfig();
+      saveConfigAndAdopt(nextConfig);
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
       if (session?.id) mgr.closeSession(session.id, 'cli-plugin-mcp-enable');
@@ -3609,8 +5305,11 @@ function parsedProviderModelVersion(id) {
       }
       return result;
     },
-    async setRoute(next) {
+    async setRoute(next, options = {}) {
+      const applyToCurrentSession = options?.applyToCurrentSession !== false;
       const requested = { ...(next || {}) };
+      validateRequestedModelSelector(config, requested);
+      const providerExplicitlyRequested = clean(next?.provider) !== '';
       if (requested.effort === undefined && !requested.provider && !requested.model && hasOwn(route, 'effort')) {
         requested.effort = route.effort;
       }
@@ -3620,14 +5319,34 @@ function parsedProviderModelVersion(id) {
       let selectedRoute = resolveRoute(config, requested);
       await reg.initProviders(ensureProviderEnabled(config, selectedRoute.provider));
       const modelMeta = await lookupModelMeta(selectedRoute.provider, selectedRoute.model);
+      // Guard (A안 / strict reject): a free-text string must never become the
+      // lead model. When the caller did not pin a provider, the route did not
+      // match a preset, and the model is unknown to both the live provider
+      // catalog (modelMeta is still the {id,provider} placeholder) and the
+      // offline catalog, refuse BEFORE any config write so a partial save
+      // (saveModelSettings/adoptConfig/persistLeadRoute) can never land.
+      if (!providerExplicitlyRequested
+        && !selectedRoute.preset
+        && !modelMetaLooksResolved(modelMeta)
+        && !getModelMetadataSync(selectedRoute.model, selectedRoute.provider)) {
+        throw new Error(`unknown model: ${selectedRoute.provider}/${selectedRoute.model}`);
+      }
       const fastCapable = fastCapableFor(selectedRoute.provider, modelMeta);
       selectedRoute = { ...selectedRoute, fast: fastCapable ? selectedRoute.fast === true : false };
-      config = saveModelSettings(cfgMod, selectedRoute, { fastCapable });
+      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') }
         : selectedRoute);
       await refreshRouteEffort(modelMeta);
+      refreshStatuslineUsageSnapshot(route);
+      scheduleStatuslineUsageRefresh();
       if (session) {
         const updated = mgr.updateSessionRoute?.(session.id, {
           provider: route.provider,
@@ -3642,7 +5361,7 @@ function parsedProviderModelVersion(id) {
           session.fast = route.fast === true;
           session.effort = route.effectiveEffort || null;
         }
-        statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route));
+        writeStatuslineRoute(statusRoutes, session, route);
         invalidateContextStatusCache();
       }
       return route;
@@ -3656,14 +5375,14 @@ function parsedProviderModelVersion(id) {
         throw new Error(`fast mode is not available for ${route.provider}/${route.model}`);
       }
       route = resolveRoute(config, { provider: route.provider, model: route.model, effort: route.effort, fast: fastCapable ? enabled : false });
-      config = saveModelSettings(cfgMod, route, { fastCapable });
+      adoptConfig(saveModelSettings(cfgMod, route, { fastCapable, baseConfig: config }), { hasSecrets: configHasSecrets });
       const leadRoute = persistLeadRoute(route);
       if (leadRoute) route = resolveRoute(config, { model: workflowPresetId('lead') });
       await refreshRouteEffort(modelMeta);
       if (session) {
         session.fast = route.fast === true;
         session.effort = route.effectiveEffort || null;
-        statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route));
+        writeStatuslineRoute(statusRoutes, session, route);
         invalidateContextStatusCache();
       }
       return route.fast === true;
@@ -3676,15 +5395,17 @@ function parsedProviderModelVersion(id) {
     async setEffort(value) {
       const normalized = normalizeEffortInput(value);
       route = { ...route, effort: normalized };
-      config = saveModelSettings(cfgMod, route, { fastCapable: route.fastCapable !== false });
+      const modelMeta = await lookupModelMeta(route.provider, route.model);
+      const fastCapable = fastCapableFor(route.provider, modelMeta);
+      adoptConfig(saveModelSettings(cfgMod, route, { fastCapable, baseConfig: config }), { hasSecrets: configHasSecrets });
       const leadRoute = persistLeadRoute(route);
       if (leadRoute) {
         route = resolveRoute(config, { model: workflowPresetId('lead') });
       }
-      await refreshRouteEffort();
+      await refreshRouteEffort(modelMeta);
       if (session) {
         session.effort = route.effectiveEffort || null;
-        statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route));
+        writeStatuslineRoute(statusRoutes, session, route);
         invalidateContextStatusCache();
       }
       return route;
@@ -3692,10 +5413,18 @@ function parsedProviderModelVersion(id) {
     async close(reason = 'cli-exit', options = {}) {
       const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
       closeRequested = true;
+      // 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 {}
       if (channelStartTimer) {
         clearTimeout(channelStartTimer);
         channelStartTimer = null;
       }
+      if (providerSetupWarmupTimer) {
+        clearTimeout(providerSetupWarmupTimer);
+        providerSetupWarmupTimer = null;
+      }
       if (providerWarmupTimer) {
         clearTimeout(providerWarmupTimer);
         providerWarmupTimer = null;
@@ -3704,9 +5433,21 @@ function parsedProviderModelVersion(id) {
         clearTimeout(providerModelWarmupTimer);
         providerModelWarmupTimer = null;
       }
+      if (codeGraphPrewarmTimer) {
+        clearTimeout(codeGraphPrewarmTimer);
+        codeGraphPrewarmTimer = null;
+      }
+      if (statuslineUsageWarmupTimer) {
+        clearTimeout(statuslineUsageWarmupTimer);
+        statuslineUsageWarmupTimer = null;
+      }
+      if (statuslineUsageRefreshTimer) {
+        clearTimeout(statuslineUsageRefreshTimer);
+        statuslineUsageRefreshTimer = null;
+      }
       try { cancelBackgroundTasks({ reason, notify: false }); } catch {}
       const channelStop = channels.stop(reason, detach ? { waitForExit: false } : undefined);
-      try { bridge.closeAll(reason); } catch {}
+      try { agentTool.closeAll(reason); } catch {}
       let mcpStop = null;
       try { mcpStop = mcpClient.disconnectAll?.(); } catch {}
       const openaiWsStop = globalThis.__mixdogOpenaiWsRuntimeLoaded === true
@@ -3715,14 +5456,35 @@ function parsedProviderModelVersion(id) {
           .catch(() => {})
         : null;
       const patchStop = closePatchRuntimeIfLoaded(detach ? { waitForExit: false } : undefined);
+      const memoryStop = memoryModPromise
+        ? memoryModPromise
+          .then((mod) => (typeof mod?.stop === 'function' ? mod.stop() : null))
+          .catch(() => {})
+          .finally(() => {
+            memoryModPromise = null;
+          })
+        : null;
       let ok = false;
       if (session?.id) {
         statusRoutes?.clearGatewaySessionRoute?.(session.id);
         ok = mgr.closeSession(session.id, reason);
         session = null;
       }
+      const shellJobsStop = globalThis.__mixdogShellJobsRuntimeLoaded === true
+        ? import('./runtime/agent/orchestrator/tools/builtin/shell-jobs.mjs')
+          .then((mod) => mod?.shutdownShellJobs?.(reason, { sync: !detach }))
+          .catch(() => {})
+        : null;
+      const bashSessionsStop = globalThis.__mixdogBashSessionRuntimeLoaded === true
+        ? import('./runtime/agent/orchestrator/tools/bash-session.mjs')
+          .then((mod) => mod?.shutdownBashSessions?.(reason))
+          .catch(() => {})
+        : null;
       if (detach) {
         try { await withTeardownDeadline(channelStop, 300, false); } catch {}
+        try { await withTeardownDeadline(shellJobsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(bashSessionsStop, 300, false); } catch {}
+        try { await withTeardownDeadline(memoryStop, 1500, false); } catch {}
         for (const stop of [mcpStop, openaiWsStop, patchStop]) {
           Promise.resolve(stop).catch(() => {});
         }
@@ -3733,6 +5495,9 @@ function parsedProviderModelVersion(id) {
         withTeardownDeadline(mcpStop, 1500, false),
         withTeardownDeadline(openaiWsStop, 1500, false),
         withTeardownDeadline(patchStop, 1500, false),
+        withTeardownDeadline(memoryStop, 5500, false),
+        withTeardownDeadline(shellJobsStop, 1500, false),
+        withTeardownDeadline(bashSessionsStop, 1500, false),
       ]);
       return ok;
     },
@@ -3750,7 +5515,7 @@ function parsedProviderModelVersion(id) {
         const leadish = role === 'lead'
           || sourceType === 'lead'
           || (sourceType === 'cli' && (!sourceName || sourceName === 'main'))
-          || (!sourceType && !sourceName && owner !== 'bridge');
+          || (!sourceType && !sourceName && !isAgentOwner(owner));
         if (!leadish) return null;
         let preview = cleanSessionPreview(s.preview || '');
         let messageCount = Math.max(0, Number(s.messageCount) || 0);
@@ -3796,11 +5561,11 @@ function parsedProviderModelVersion(id) {
       await refreshRouteEffort();
       session.effort = route.effectiveEffort || null;
       session.cwd = currentCwd;
-      applyDeferredToolSurface(session, mode, standaloneTools);
+      applyDeferredToolSurface(session, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
       invalidatePreSessionToolSurface();
       invalidateContextStatusCache();
       sessionNeedsCwdRefresh = false;
-      statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route));
+      writeStatuslineRoute(statusRoutes, session, route);
       return {
         id: resumed.id,
         messages: resumed.messages || [],