mixdog 0.9.2 → 0.9.3

package/src/mixdog-session-runtime.mjs

@@ -1,6 +1,6 @@
 import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from 'node:fs';
 import { homedir } from 'node:os';
-import { basename, dirname, join, resolve } from 'node:path';
+import { basename, dirname, isAbsolute, join, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { performance } from 'node:perf_hooks';
 import { ensureStandaloneEnvironment } from './standalone/seeds.mjs';
@@ -38,6 +38,7 @@ import {
   renderProviderStatus,
   saveOpenAIUsageSessionKey,
   saveOpenCodeGoUsageAuth,
+  loginOpenCodeGoUsage,
   saveProviderApiKey,
   setLocalProvider,
 } from './standalone/provider-admin.mjs';
@@ -88,50 +89,125 @@ import {
   summarizeContextMessages,
 } from './runtime/agent/orchestrator/session/context-utils.mjs';
 
-function sessionMessageText(content) {
-  if (content == null) return '';
-  if (typeof content === 'string') return content;
-  const parts = Array.isArray(content)
-    ? content
-    : (content && typeof content === 'object' && Array.isArray(content.content) ? content.content : null);
-  if (parts) {
-    return parts.map((part) => {
-      if (typeof part === 'string') return part;
-      return part?.text ?? '';
-    }).filter(Boolean).join('\n');
-  }
-  if (typeof content === 'object' && typeof content.text === 'string') return content.text;
-  try { return JSON.stringify(content); } catch { return String(content); }
-}
-
-function messageContextText(message) {
-  if (!message || typeof message !== 'object') return '';
-  let text = sessionMessageText(message.content);
-  if (message.role === 'assistant' && Array.isArray(message.toolCalls) && message.toolCalls.length) {
-    try { text += `\n${JSON.stringify(message.toolCalls)}`; }
-    catch { text += `\n[${message.toolCalls.length} tool calls]`; }
-  }
-  if (message.role === 'tool' && message.toolCallId) text += `\n${message.toolCallId}`;
-  return text;
-}
-
-function isSessionPreviewNoise(text) {
-  const value = String(text || '').trim();
-  return !value
-    || value.startsWith('<system-reminder>')
-    || value.startsWith('</system-reminder>')
-    || /^#\s*permission\b/i.test(value)
-    || /^permission:\s*/i.test(value)
-    || /^cwd:\s*/i.test(value);
-}
-
-function cleanSessionPreview(text) {
-  return String(text || '')
-    .replace(/<system-reminder>[\s\S]*?<\/system-reminder>/gi, ' ')
-    .replace(/\s+/g, ' ')
-    .trim()
-    .slice(0, 160);
-}
+import {
+  sessionMessageText,
+  messageContextText,
+  isSessionPreviewNoise,
+  cleanSessionPreview,
+  clean,
+  hasOwn,
+  toolResponseText,
+  isEmptyRecallText,
+  currentSessionRecallRows,
+  sessionHasConversationMessages,
+} from './session-runtime/session-text.mjs';
+import {
+  TOOL_MODES,
+  ALL_EFFORT_LEVELS,
+  EFFORT_LABELS,
+  EFFORT_OPTIONS_BY_PROVIDER,
+  EFFORT_BY_FAMILY,
+  EFFORT_FALLBACKS,
+  normalizeToolMode,
+  normalizeEffortInput,
+  effortOptionsFor,
+  coerceEffortFor,
+  normalizeSavedEffort,
+  effortItemsFor,
+  toolSpecForMode,
+  deferredSurfaceModeForLead,
+} from './session-runtime/effort.mjs';
+import {
+  LAZY_SECRET_PROVIDERS,
+  routeFastKey,
+  fastCapableFor,
+  makeSearchCapableFor,
+  fastPreferenceFor,
+  saveModelSettings,
+} from './session-runtime/model-capabilities.mjs';
+import {
+  DEFAULT_PROVIDER,
+  DEFAULT_MODEL,
+  makeResolveDefaultProvider,
+  findPreset,
+  makeResolveRoute,
+  isLikelyRawModelId,
+  validateRequestedModelSelector,
+  ensureProviderEnabled,
+  normalizeSystemShellConfig,
+  normalizeSystemShellCommand,
+  normalizeAutoClearConfig,
+  normalizeCompactionConfig,
+  moduleEnabled,
+  setModuleEnabledInConfig,
+  formatDurationMs,
+  parseDurationMs,
+  modelMetaLooksResolved,
+  modelSettingsFor,
+  normalizeCompactTypeSetting,
+} from './session-runtime/config-helpers.mjs';
+import {
+  routeForStatusline,
+  writeStatuslineRoute,
+} from './session-runtime/statusline-route.mjs';
+import {
+  normalizeOutputStyleId,
+  listOutputStyleCatalog,
+  findOutputStyle,
+  outputStyleStatus as outputStyleStatusRaw,
+} from './session-runtime/output-styles.mjs';
+import { readJsonSafe, readTextSafe } from './session-runtime/fs-utils.mjs';
+import {
+  readProjectMcpServers,
+  countSkillFiles,
+  mcpScriptForPlugin,
+  normalizePluginMcpServerConfig,
+  pluginManifest,
+  pluginMcpServerName,
+} from './session-runtime/plugin-mcp.mjs';
+import {
+  WORKFLOW_ROUTE_SLOTS,
+  FIXED_AGENT_SLOTS,
+  SEARCH_DEFAULT_PROVIDER,
+  SEARCH_DEFAULT_MODEL,
+  workflowPresetId,
+  agentPresetSlot,
+  normalizeAgentId,
+  normalizeWorkflowId,
+  createWorkflowHelpers,
+  normalizeSearchProviderId,
+  isDefaultSearchRouteConfig,
+  isSearchCapableProvider,
+  normalizeSearchRouteConfig,
+  normalizeWorkflowRoute,
+  upsertWorkflowPreset,
+  createWorkflowRouteHelpers,
+} from './session-runtime/workflow.mjs';
+import {
+  MEASURED_TOOL_USAGE,
+  DEFERRED_DEFAULT_FULL_TOOLS,
+  DEFERRED_DEFAULT_READONLY_TOOLS,
+  DEFERRED_DEFAULT_LEAD_TOOLS,
+  toolKind,
+  toolSchemaBucket,
+  estimateToolSchemaBreakdown,
+  measuredToolUsage,
+  parseToolSelection,
+  parseToolSearchQuerySelection,
+  sortedCatalogByMeasuredUsage,
+  filterDisallowedTools,
+  sortedNamesByMeasuredUsage,
+  defaultDeferredToolNames,
+  compactToolSearchDescription,
+  toolRow,
+  toolSearchMatches,
+  applyDeferredToolSurface,
+  selectDeferredTools,
+  renderToolSearch,
+} from './session-runtime/tool-catalog.mjs';
+// Re-exported for external consumers (scripts/tool-smoke.mjs) that imported
+// these from this module before the tool-catalog extraction.
+export { defaultDeferredToolNames, compactToolSearchDescription } from './session-runtime/tool-catalog.mjs';
 
 const RUNTIME = './runtime/agent/orchestrator';
 const SEARCH_RUNTIME = './runtime/search/index.mjs';
@@ -151,26 +227,9 @@ const STANDALONE_ROOT = STANDALONE_SOURCE_ROOT;
 const MIXDOG_HOME = process.env.MIXDOG_HOME || join(homedir(), '.mixdog');
 const STANDALONE_DATA_DIR = process.env.MIXDOG_DATA_DIR || join(MIXDOG_HOME, 'data');
 
-const DEFAULT_PROVIDER = 'anthropic-oauth';
-const DEFAULT_MODEL = '';
-
-// Resolve the provider to use when a route carries no explicit provider.
-// Priority: config.defaultProvider (when it names a known provider) > DEFAULT_PROVIDER.
-function resolveDefaultProvider(config) {
-  const configured = clean(config?.defaultProvider);
-  if (configured && isKnownProvider(configured)) return configured;
-  return DEFAULT_PROVIDER;
-}
-const TOOL_MODES = new Set(['full', 'readonly', 'lead']);
-const ALL_EFFORT_LEVELS = new Set(['none', 'low', 'medium', 'high', 'xhigh', 'max']);
-const EFFORT_LABELS = {
-  none: 'None',
-  low: 'Low',
-  medium: 'Medium',
-  high: 'High',
-  xhigh: 'Extra High',
-  max: 'Max',
-};
+const resolveDefaultProvider = makeResolveDefaultProvider(isKnownProvider);
+const resolveRoute = makeResolveRoute(resolveDefaultProvider);
+const searchCapableFor = makeSearchCapableFor(normalizeSearchProviderId, isSearchCapableProvider);
 
 function envFlag(name) {
   return /^(1|true|yes|on)$/i.test(String(process.env[name] || ''));
@@ -217,37 +276,6 @@ async function profiledImport(label, spec, { optional = false } = {}) {
     throw error;
   }
 }
-const EFFORT_OPTIONS_BY_PROVIDER = {
-  openai: ['none', 'low', 'medium', 'high', 'xhigh'],
-  'openai-oauth': ['none', 'low', 'medium', 'high', 'xhigh'],
-  anthropic: ['low', 'medium', 'high', 'xhigh', 'max'],
-  'anthropic-oauth': ['low', 'medium', 'high', 'xhigh', 'max'],
-  xai: ['none', 'low', 'medium', 'high'],
-  'grok-oauth': ['none', 'low', 'medium', 'high'],
-  'opencode-go': ['high', 'max'],
-};
-const EFFORT_BY_FAMILY = {
-  opus: ['low', 'medium', 'high', 'xhigh', 'max'],
-  sonnet: ['low', 'medium', 'high'],
-  haiku: [],
-  'gpt-5.5': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5.4': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5.2': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-5': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-mini': ['none', 'low', 'medium', 'high', 'xhigh'],
-  'gpt-nano': ['none', 'low', 'medium', 'high'],
-  'gpt-codex': ['none', 'low', 'medium', 'high'],
-  grok: ['none', 'low', 'medium', 'high'],
-};
-const EFFORT_FALLBACKS = {
-  max: ['max', 'xhigh', 'high', 'medium', 'low'],
-  xhigh: ['xhigh', 'high', 'medium', 'low'],
-  high: ['high', 'medium', 'low'],
-  medium: ['medium', 'low'],
-  low: ['low'],
-  none: ['none'],
-};
-
 export const TOOL_SEARCH_TOOL = {
   name: 'tool_search',
   title: 'Tool Search',
@@ -330,86 +358,7 @@ export const SKILL_TOOL = {
   },
 };
 
-const MEASURED_TOOL_USAGE = Object.freeze({
-  read: 710,
-  code_graph: 520,
-  grep: 500,
-  find: 480,
-  glob: 460,
-  list: 430,
-  apply_patch: 400,
-  explore: 360,
-  agent: 330,
-  shell: 81,
-  cwd: 2,
-  diagnostics: 2,
-  recall: 2,
-  search: 2,
-  web_fetch: 2,
-  provider_status: 2,
-  channel_status: 2,
-});
-const MEASURED_TOOL_ORDER = Object.freeze(Object.keys(MEASURED_TOOL_USAGE));
 const LEAD_DISALLOWED_TOOLS = Object.freeze(['diagnostics', 'open_config']);
-const DEFERRED_DEFAULT_FULL_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'apply_patch',
-  'Skill',
-  'tool_search',
-]);
-const DEFERRED_DEFAULT_READONLY_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'explore',
-  'Skill',
-  'tool_search',
-]);
-const DEFERRED_DEFAULT_LEAD_TOOLS = Object.freeze([
-  'read',
-  'code_graph',
-  'grep',
-  'find',
-  'glob',
-  'list',
-  'shell',
-  'task',
-  'explore',
-  'apply_patch',
-  'agent',
-  'recall',
-  'search',
-  'web_fetch',
-  'cwd',
-  'Skill',
-  'tool_search',
-]);
-const READONLY_TOOL_NAMES = new Set([
-  'read',
-  'list',
-  'grep',
-  'find',
-  'glob',
-  'code_graph',
-  'search',
-  'web_fetch',
-  'recall',
-  'memory',
-  'provider_status',
-  'channel_status',
-  'schedule_status',
-  'fetch',
-  'Skill',
-]);
 const AGENT_HIDDEN_WRAPPER_TOOLS = new Set([]);
 
 export function __applyStandaloneToolDefaultsForTest(tool) {
@@ -423,761 +372,9 @@ export function __applyStandaloneToolDefaultsForTest(tool) {
   };
 }
 const applyStandaloneToolDefaults = __applyStandaloneToolDefaultsForTest;
-const DEFERRED_SELECT_ALIASES = {
-  filesystem: ['read', 'list', 'grep', 'find', 'glob'],
-  search: ['search', 'web_fetch'],
-  web: ['web_fetch', 'search'],
-  memory: ['memory', 'recall'],
-  channels: ['reply', 'fetch', 'react', 'edit_message', 'download_attachment', 'schedule_status', 'trigger_schedule', 'schedule_control', 'reload_config'],
-  discord: ['reply', 'fetch', 'react', 'edit_message', 'download_attachment'],
-  providers: ['provider_status'],
-  provider: ['provider_status'],
-  status: ['provider_status', 'channel_status', 'schedule_status'],
-  schedule: ['schedule_status', 'trigger_schedule', 'schedule_control'],
-  channel: ['channel_status'],
-  explore: ['explore'],
-  discovery: ['explore'],
-  agent: ['agent'],
-  graph: ['code_graph'],
-  code: ['code_graph'],
-  shell: ['shell', 'task'],
-};
-const TOOL_SEARCH_SAFE_AUTO_ALIASES = new Set([
-  'shell',
-  'web',
-  'search',
-  'agent',
-  'provider',
-  'providers',
-  'channel',
-  'schedule',
-  'memory',
-]);
-const TOOL_SEARCH_AMBIGUOUS_AUTO_QUERIES = new Set([
-  'status',
-  'state',
-  'info',
-  'list',
-  'show',
-  'config',
-]);
-const TOOL_SEARCH_STOP_WORDS = new Set([
-  'a',
-  'an',
-  'and',
-  'are',
-  'as',
-  'for',
-  'from',
-  'how',
-  'i',
-  'in',
-  'is',
-  'me',
-  'need',
-  'of',
-  'on',
-  'please',
-  'the',
-  'to',
-  'tool',
-  'tools',
-  'use',
-  'using',
-  'with',
-]);
-const TOOL_SEARCH_ROW_ALIASES = Object.freeze({
-  agent: ['delegate', 'subagent', 'worker', 'parallel agent', 'background agent', 'reviewer', 'explorer'],
-  channel_status: ['channel status', 'discord status', 'channel config'],
-  cwd: ['cwd', 'working directory', 'current directory', 'project root', 'folder'],
-  memory: ['save memory', 'store memory', 'delete memory', 'forget memory', 'memory status'],
-  provider_status: ['provider status', 'auth status', 'model status', 'oauth status', 'provider config'],
-  recall: ['recall', 'previous work', 'past work', 'prior context', 'history', 'resume context'],
-  schedule_status: ['schedule status', 'cron status'],
-  search: ['web search', 'internet search', 'current info', 'latest info', 'online search', 'docs search'],
-  shell: ['run command', 'execute command', 'terminal', 'powershell', 'bash', 'run tests', 'test command', 'build command', 'npm', 'node', 'git'],
-  task: ['background task', 'async task', 'wait task', 'cancel task', 'task status'],
-  web_fetch: ['fetch url', 'fetch page', 'open url', 'web page', 'read url', 'docs page'],
-});
-
-function normalizeToolMode(mode) {
-  const value = String(mode || '').trim().toLowerCase();
-  return TOOL_MODES.has(value) ? value : 'full';
-}
-
-function normalizeEffortInput(value) {
-  const v = clean(value).toLowerCase();
-  if (!v || v === 'auto') return null;
-  if (!ALL_EFFORT_LEVELS.has(v)) {
-    throw new Error(`effort must be one of auto, ${[...ALL_EFFORT_LEVELS].join(', ')}`);
-  }
-  return v;
-}
-
-function effortOptionsFor(provider, model) {
-  const providerAllowed = EFFORT_OPTIONS_BY_PROVIDER[provider] || null;
-  const filterProvider = (values) => {
-    const unique = [...new Set((values || []).map(clean).filter(Boolean))];
-    return providerAllowed ? unique.filter((v) => providerAllowed.includes(v)) : unique;
-  };
-  const declared = Array.isArray(model?.reasoningLevels)
-    ? model.reasoningLevels.map(clean).filter(Boolean)
-    : [];
-  const family = clean(model?.family).toLowerCase();
-  if (Array.isArray(model?.reasoningLevels)) {
-    if (declared.length) return filterProvider(declared);
-    if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
-      return filterProvider(EFFORT_BY_FAMILY[family]);
-    }
-    return [];
-  }
-  const reasoningOptionEffort = Array.isArray(model?.reasoningOptions)
-    ? model.reasoningOptions.find((option) => clean(option?.type).toLowerCase() === 'effort')
-    : null;
-  const reasoningOptionValues = Array.isArray(reasoningOptionEffort?.values)
-    ? reasoningOptionEffort.values.map(clean).filter(Boolean)
-    : [];
-  if (reasoningOptionValues.length) return filterProvider(reasoningOptionValues);
-  if (Object.prototype.hasOwnProperty.call(EFFORT_BY_FAMILY, family)) {
-    return filterProvider(EFFORT_BY_FAMILY[family]);
-  }
-  return providerAllowed || [];
-}
-
-function coerceEffortFor(provider, model, effort) {
-  if (!effort) return null;
-  const allowed = effortOptionsFor(provider, model);
-  if (!allowed || allowed.length === 0) return null;
-  if (allowed.includes(effort)) return effort;
-  for (const candidate of EFFORT_FALLBACKS[effort] || []) {
-    if (allowed.includes(candidate)) return candidate;
-  }
-  return null;
-}
-
-function hasOwn(obj, key) {
-  return Object.prototype.hasOwnProperty.call(obj || {}, key);
-}
-
-function modelSettingsFor(config, provider, model) {
-  const key = routeFastKey(provider, model);
-  const value = key ? config?.modelSettings?.[key] : null;
-  return value && typeof value === 'object' ? value : {};
-}
-
-function normalizeSavedEffort(value) {
-  try {
-    return normalizeEffortInput(value);
-  } catch {
-    return null;
-  }
-}
-
-function effortItemsFor(provider, model, activeEffort) {
-  const allowed = effortOptionsFor(provider, model);
-  const items = [];
-  for (const value of allowed || []) {
-    items.push({
-      value,
-      label: EFFORT_LABELS[value] || value,
-      description: value === activeEffort ? 'current' : '',
-    });
-  }
-  return items;
-}
-
-function toolSpecForMode(mode) {
-  return mode === 'readonly' ? ['tools:readonly'] : 'full';
-}
-
-function deferredSurfaceModeForLead(mode) {
-  return mode === 'readonly' ? 'readonly' : 'lead';
-}
-
-function clean(value) {
-  return String(value ?? '').trim();
-}
-
-// A resolved model meta carries catalog-derived fields (contextWindow, pricing,
-// capabilities, …). The lookupModelMeta() fallback for an unknown id is the
-// bare shape `{ id, provider }`, so "more than id/provider" reliably tells a
-// real catalog hit apart from that placeholder.
-function modelMetaLooksResolved(meta) {
-  if (!meta || typeof meta !== 'object') return false;
-  return Object.keys(meta).some((key) => key !== 'id' && key !== 'provider');
-}
-
-const OUTPUT_STYLE_ORDER = ['default', 'simple', 'minimal', 'oneline'];
-const OUTPUT_STYLE_ALIASES = new Map([
-  ['compact', 'default'],
-  ['normal', 'default'],
-  ['extreme', 'minimal'],
-  ['extremesimple', 'minimal'],
-  ['extreme-simple', 'minimal'],
-  ['extreme_simple', 'minimal'],
-  ['mono', 'oneline'],
-  ['oneline', 'oneline'],
-  ['one-line', 'oneline'],
-  ['one_line', 'oneline'],
-]);
-
-function normalizeOutputStyleId(value) {
-  const raw = clean(value).toLowerCase();
-  if (!raw) return '';
-  const slug = raw.replace(/[_\s]+/g, '-').replace(/^-+|-+$/g, '');
-  const compact = slug.replace(/[_.-]+/g, '');
-  if (OUTPUT_STYLE_ALIASES.has(slug)) return OUTPUT_STYLE_ALIASES.get(slug);
-  if (OUTPUT_STYLE_ALIASES.has(compact)) return OUTPUT_STYLE_ALIASES.get(compact);
-  return /^[a-z0-9.-]+$/.test(slug) ? slug : '';
-}
-
-function outputStyleCompactKey(value) {
-  return normalizeOutputStyleId(value).replace(/[_.-]+/g, '');
-}
-
-function titleCaseOutputStyle(id) {
-  return clean(id)
-    .split(/[_.-]+/)
-    .filter(Boolean)
-    .map((part) => `${part.charAt(0).toUpperCase()}${part.slice(1)}`)
-    .join(' ') || 'Default';
-}
-
-function parseOutputStyleFrontmatter(markdown) {
-  const match = String(markdown || '').match(/^---\r?\n([\s\S]*?)\r?\n---/);
-  const meta = {};
-  if (!match) return meta;
-  for (const line of match[1].split(/\r?\n/)) {
-    const kv = line.match(/^([A-Za-z0-9_-]+):\s*(.*?)\s*$/);
-    if (!kv) continue;
-    meta[kv[1]] = kv[2].replace(/^['"]|['"]$/g, '').trim();
-  }
-  return meta;
-}
-
-function readOutputStyleMetadata(filePath, source) {
-  let raw = '';
-  try { raw = readFileSync(filePath, 'utf8'); } catch { return null; }
-  const meta = parseOutputStyleFrontmatter(raw);
-  const fileId = normalizeOutputStyleId(basename(filePath).replace(/\.md$/i, ''));
-  const id = normalizeOutputStyleId(meta.name) || fileId;
-  if (!id) return null;
-  const aliases = clean(meta.aliases)
-    .split(',')
-    .map((value) => normalizeOutputStyleId(value))
-    .filter(Boolean);
-  const label = clean(meta.title || meta.label) || titleCaseOutputStyle(id);
-  return {
-    id,
-    label,
-    description: clean(meta.description),
-    aliases,
-    source,
-  };
-}
-
-function listOutputStyleCatalog(dataDir = STANDALONE_DATA_DIR) {
-  const byId = new Map();
-  const dirs = [
-    { dir: join(STANDALONE_ROOT, 'output-styles'), source: 'builtin' },
-    { dir: join(dataDir || STANDALONE_DATA_DIR, 'output-styles'), source: 'user' },
-  ];
-  for (const { dir, source } of dirs) {
-    let entries = [];
-    try { entries = readdirSync(dir, { withFileTypes: true }); } catch { continue; }
-    for (const entry of entries) {
-      if (!entry.isFile() || !entry.name.toLowerCase().endsWith('.md')) continue;
-      const style = readOutputStyleMetadata(join(dir, entry.name), source);
-      if (style) byId.set(style.id, style);
-    }
-  }
-  return [...byId.values()].sort((a, b) => {
-    const ai = OUTPUT_STYLE_ORDER.indexOf(a.id);
-    const bi = OUTPUT_STYLE_ORDER.indexOf(b.id);
-    if (ai !== bi) return (ai < 0 ? 999 : ai) - (bi < 0 ? 999 : bi);
-    return a.label.localeCompare(b.label, 'en', { sensitivity: 'base' });
-  });
-}
-
-function findOutputStyle(value, styles) {
-  const id = normalizeOutputStyleId(value);
-  const compact = outputStyleCompactKey(value);
-  if (!id && !compact) return null;
-  return (styles || []).find((style) => {
-    if (style.id === id || outputStyleCompactKey(style.id) === compact) return true;
-    if (outputStyleCompactKey(style.label) === compact) return true;
-    return (style.aliases || []).some((alias) => alias === id || outputStyleCompactKey(alias) === compact);
-  }) || null;
-}
-
-function configuredOutputStyleValue(dataDir = STANDALONE_DATA_DIR) {
-  const unified = readJsonSafe(join(dataDir || STANDALONE_DATA_DIR, 'mixdog-config.json')) || {};
-  return clean(unified.outputStyle || (unified.agent && unified.agent.outputStyle) || 'default') || 'default';
-}
-
-function outputStyleStatus(dataDir = STANDALONE_DATA_DIR) {
-  const styles = listOutputStyleCatalog(dataDir);
-  const configured = configuredOutputStyleValue(dataDir);
-  const current = findOutputStyle(configured, styles)
-    || findOutputStyle('default', styles)
-    || styles[0]
-    || { id: 'default', label: 'Default', description: '', aliases: [], source: 'builtin' };
-  return { configured, current, styles };
-}
-
-function sessionHasConversationMessages(activeSession) {
-  const messages = Array.isArray(activeSession?.messages) ? activeSession.messages : [];
-  return messages.some((message) => {
-    const role = message?.role;
-    if (role !== 'user' && role !== 'assistant' && role !== 'tool') return false;
-    const text = sessionMessageText(message.content).trim();
-    if (!text && role !== 'assistant') return false;
-    if (role === 'user' && isSessionPreviewNoise(text)) return false;
-    return true;
-  });
-}
-
-function readJsonSafe(path) {
-  try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return null; }
-}
-
-// Standard Claude Code project-local MCP ingress: read `.mcp.json` from the
-// project root and return a cleaned { name: cfg } map. Best-effort — never
-// throws. Accepts either the standard `{ mcpServers: {...} }` shape or a bare
-// name->cfg map. Self-ref servers (`mixdog` / `trib-plugin`) are stripped for
-// parity with loadConfig (which strips them from the persisted agent section
-// but never sees `.mcp.json`). Inputs are not mutated.
-function readProjectMcpServers(cwd) {
-  const path = join(cwd || '.', '.mcp.json');
-  if (!existsSync(path)) return {};
-  let raw;
-  try {
-    raw = JSON.parse(readFileSync(path, 'utf8'));
-  } catch (error) {
-    process.stderr.write(`[mcp-client] Ignoring unparseable .mcp.json at ${path}: ${error?.message || String(error)}\n`);
-    return {};
-  }
-  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) return {};
-  const map = raw.mcpServers && typeof raw.mcpServers === 'object' && !Array.isArray(raw.mcpServers)
-    ? raw.mcpServers
-    : raw;
-  if (!map || typeof map !== 'object' || Array.isArray(map)) return {};
-  const out = {};
-  for (const [name, cfg] of Object.entries(map)) {
-    const key = clean(name);
-    if (!key) continue;
-    const lower = key.toLowerCase();
-    if (lower === 'mixdog' || lower === 'trib-plugin') continue;
-    if (!cfg || typeof cfg !== 'object' || Array.isArray(cfg)) continue;
-    // stdio entries (command + no url) spawn relative to the process launch
-    // dir, but mixdog tracks the project dir in memory (no process.chdir).
-    // Anchor their cwd to the .mcp.json directory: default when absent, resolve
-    // relative values against it, keep absolute values as-is. resolve(base, p)
-    // already returns `p` unchanged when it is absolute. Clone — never mutate.
-    const isStdio = typeof cfg.command === 'string' && cfg.command !== '' && !cfg.url;
-    if (isStdio) {
-      out[key] = { ...cfg, cwd: typeof cfg.cwd === 'string' && cfg.cwd ? resolve(cwd, cfg.cwd) : resolve(cwd) };
-    } else {
-      out[key] = cfg;
-    }
-  }
-  return out;
-}
-
-function countSkillFiles(root) {
-  const skillsDir = join(root, 'skills');
-  if (!existsSync(skillsDir)) return 0;
-  let count = 0;
-  const walk = (dir) => {
-    for (const entry of readdirSync(dir, { withFileTypes: true })) {
-      const full = join(dir, entry.name);
-      if (entry.isDirectory()) walk(full);
-      else if (/^(SKILL|skill)\.md$/i.test(entry.name) || entry.name.toLowerCase().endsWith('.md')) count += 1;
-    }
-  };
-  try { walk(skillsDir); } catch { return count; }
-  return count;
-}
-
-function mcpScriptForPlugin(root) {
-  const candidates = [
-    'scripts/run-mcp.mjs',
-    'mcp/server.mjs',
-    'server.mjs',
-  ];
-  return candidates.find((rel) => existsSync(join(root, rel))) || null;
-}
-
-function pluginManifest(root) {
-  return readJsonSafe(join(root, '.codex-plugin', 'plugin.json'))
-    || readJsonSafe(join(root, 'plugin.json'))
-    || {};
-}
-
-function pluginMcpServerName(plugin = {}) {
-  const base = clean(plugin.name || plugin.title || 'plugin')
-    .toLowerCase()
-    .replace(/[^a-z0-9_.-]+/g, '-')
-    .replace(/^-+|-+$/g, '');
-  return base ? `plugin-${base}` : 'plugin-mcp';
-}
-
-function findPreset(config, key) {
-  const wanted = clean(key).toLowerCase();
-  if (!wanted) return null;
-  const presets = Array.isArray(config?.presets) ? config.presets : [];
-  return presets.find((p) => {
-    const id = clean(p?.id).toLowerCase();
-    const name = clean(p?.name).toLowerCase();
-    return id === wanted || name === wanted;
-  }) || null;
-}
-
-function resolveRoute(config, { provider, model, effort, fast } = {}) {
-  const explicitProvider = clean(provider);
-  const explicitModel = clean(model);
-  const hasExplicitEffort = effort !== undefined;
-  const explicitEffort = hasExplicitEffort ? normalizeEffortInput(effort) : undefined;
-  const hasExplicitFast = fast !== undefined;
-  const explicitFast = fast === true;
-
-  if (explicitModel && !explicitProvider) {
-    const preset = findPreset(config, explicitModel);
-    if (preset) {
-      const p = clean(preset.provider) || DEFAULT_PROVIDER;
-      const m = clean(preset.model) || DEFAULT_MODEL;
-      const saved = modelSettingsFor(config, p, m);
-      return {
-        provider: p,
-        model: m,
-        preset,
-        effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-        fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-      };
-    }
-  }
-
-  if (!explicitProvider && !explicitModel) {
-    const defaultKey = config?.default;
-    const preset = findPreset(config, defaultKey);
-    if (preset) {
-      const p = clean(preset.provider) || DEFAULT_PROVIDER;
-      const m = clean(preset.model) || DEFAULT_MODEL;
-      const saved = modelSettingsFor(config, p, m);
-      return {
-        provider: p,
-        model: m,
-        preset,
-        effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort ?? preset.effort),
-        fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : (preset.fast === true || fastPreferenceFor(config, p, m))),
-      };
-    }
-  }
-
-  const p = explicitProvider || resolveDefaultProvider(config);
-  const m = explicitModel || DEFAULT_MODEL;
-  const saved = modelSettingsFor(config, p, m);
-  return {
-    provider: p,
-    model: m,
-    preset: null,
-    effort: hasExplicitEffort ? explicitEffort : normalizeSavedEffort(saved.effort),
-    fast: hasExplicitFast ? explicitFast : (hasOwn(saved, 'fast') ? saved.fast === true : fastPreferenceFor(config, p, m)),
-  };
-}
-
-function isLikelyRawModelId(value) {
-  const model = clean(value);
-  if (!model || model.length > 160) return false;
-  if (/\s/.test(model)) return false;
-  return /^[A-Za-z0-9][A-Za-z0-9._:/@+-]*$/.test(model);
-}
-
-function validateRequestedModelSelector(config, requested = {}) {
-  const model = clean(requested.model);
-  if (!model) return;
-  if (findPreset(config, model)) return;
-  if (isLikelyRawModelId(model)) return;
-  throw new Error(`Invalid model selector "${model}". Use a preset or a model id; free-form text cannot be used as a model.`);
-}
-
-function ensureProviderEnabled(config, provider) {
-  const providers = { ...(config?.providers || {}) };
-  providers[provider] = { ...(providers[provider] || {}), enabled: true };
-  return providers;
-}
-
-const AUTO_CLEAR_DEFAULT_IDLE_MS = 60 * 60 * 1000;
-
-function normalizeSystemShellConfig(value = {}) {
-  const raw = value && typeof value === 'object' ? value : {};
-  const command = clean(raw.command ?? raw.path ?? raw.executable ?? raw.shell);
-  const envCommand = clean(process.env.MIXDOG_SHELL);
-  return {
-    command,
-    effective: command || envCommand || '',
-    source: command ? 'config' : (envCommand ? 'env' : 'auto'),
-  };
-}
-
-function normalizeSystemShellCommand(value) {
-  const command = clean(value).replace(/^auto$/i, '').replace(/^['"](.+)['"]$/, '$1').trim();
-  if (!command) return '';
-  if (process.platform === 'win32') {
-    const stem = command.split(/[\\/]/).pop().toLowerCase().replace(/\.exe$/, '');
-    if (stem !== 'powershell' && stem !== 'pwsh') {
-      throw new Error('system shell command must be powershell.exe or pwsh on Windows');
-    }
-  }
-  return command;
-}
-
-function normalizeAutoClearConfig(value = {}) {
-  const raw = value && typeof value === 'object' ? value : {};
-  const idleMs = Number(raw.idleMs ?? raw.thresholdMs ?? raw.idleMillis);
-  return {
-    enabled: raw.enabled !== false,
-    idleMs: Number.isFinite(idleMs) && idleMs > 0 ? Math.max(60_000, Math.round(idleMs)) : AUTO_CLEAR_DEFAULT_IDLE_MS,
-  };
-}
-
-function normalizeCompactTypeSetting(value, fallback = 'semantic') {
-  const raw = clean(value).toLowerCase().replace(/_/g, '-');
-  if (!raw) return fallback;
-  if (raw === '1' || raw === 'type1' || raw === 'type-1' || raw === 'semantic' || raw === 'summary' || raw === 'default') return 'semantic';
-  if (raw === '2' || raw === 'type2' || raw === 'type-2' || raw === 'recall' || raw === 'recall-fast' || raw === 'recall-fasttrack' || raw === 'recall-fast-track' || raw === 'fasttrack' || raw === 'fast-track') return 'recall-fasttrack';
-  return fallback;
-}
-
-function normalizeCompactionConfig(value = {}, { memoryEnabled = true } = {}) {
-  const raw = value && typeof value === 'object' ? value : {};
-  let compactType = normalizeCompactTypeSetting(raw.compactType ?? raw.compact_type ?? raw.type, 'semantic');
-  if (compactType === 'recall-fasttrack' && memoryEnabled === false) compactType = 'semantic';
-  return {
-    ...raw,
-    auto: raw.auto !== false && raw.enabled !== false,
-    type: compactType,
-    compactType,
-  };
-}
-
-function moduleEnabled(configLike, name, fallback = true) {
-  const entry = configLike?.modules?.[name];
-  if (entry && typeof entry === 'object' && entry.enabled === false) return false;
-  return fallback !== false;
-}
-
-function setModuleEnabledInConfig(configLike, name, enabled) {
-  const next = { ...(configLike || {}) };
-  next.modules = { ...(next.modules || {}) };
-  next.modules[name] = {
-    ...(next.modules[name] || {}),
-    enabled: enabled !== false,
-  };
-  return next;
-}
-
-function formatDurationMs(ms) {
-  const value = Math.max(0, Number(ms) || 0);
-  if (value % 3_600_000 === 0) return `${value / 3_600_000}h`;
-  if (value % 60_000 === 0) return `${value / 60_000}m`;
-  return `${Math.round(value / 1000)}s`;
-}
-
-function parseDurationMs(input) {
-  const text = clean(input).toLowerCase();
-  if (!text) return null;
-  const match = /^(\d+(?:\.\d+)?)(ms|s|m|h)?$/.exec(text);
-  if (!match) return null;
-  const n = Number(match[1]);
-  if (!Number.isFinite(n) || n <= 0) return null;
-  const unit = match[2] || 'm';
-  const mult = unit === 'h' ? 3_600_000 : unit === 'm' ? 60_000 : unit === 's' ? 1000 : 1;
-  return Math.max(60_000, Math.round(n * mult));
-}
-
-const FAST_CAPABLE_PROVIDERS = new Set(['anthropic', 'anthropic-oauth', 'openai', 'openai-oauth']);
-const LAZY_SECRET_PROVIDERS = new Set(['openai-oauth', 'anthropic-oauth', 'grok-oauth', 'ollama', 'lmstudio']);
-
-function routeFastKey(provider, model) {
-  const p = clean(provider);
-  const m = clean(model);
-  return p && m ? `${p}/${m}` : '';
-}
-
-function openAiModelMetaSupportsFast(model) {
-  const tiers = Array.isArray(model?.serviceTiers) ? model.serviceTiers : [];
-  const speedTiers = Array.isArray(model?.additionalSpeedTiers) ? model.additionalSpeedTiers : [];
-  if (tiers.length || speedTiers.length || model?.defaultServiceTier) {
-    return tiers.some((tier) => tier?.id === 'priority')
-      || speedTiers.includes('priority')
-      || model?.defaultServiceTier === 'priority';
-  }
-  const id = clean(model?.id || model).toLowerCase();
-  if (id.includes('mini') || id.includes('nano') || id.includes('codex')) return false;
-  return /^gpt-5(\.|-|$)/.test(id);
-}
-
-function openAiDirectModelSupportsFast(model) {
-  const id = clean(model?.id || model);
-  return /^gpt-5\.5(?:-\d{4}|$)/.test(id)
-    || /^gpt-5\.4(?:-\d{4}|$)/.test(id)
-    || /^gpt-5\.4-mini(?:-\d{4}|$)/.test(id);
-}
-
-function openAiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id) return false;
-  if (model?.supportsWebSearch === true) return true;
-  const tools = [
-    ...(Array.isArray(model?.supportedTools) ? model.supportedTools : []),
-    ...(Array.isArray(model?.tools) ? model.tools : []),
-    ...(Array.isArray(model?.capabilities?.tools) ? model.capabilities.tools : []),
-  ].map((tool) => clean(tool?.type || tool?.name || tool).toLowerCase());
-  if (tools.some((tool) => tool === 'web_search' || tool === 'web_search_preview')) return true;
-  if (/codex|image|audio|tts|stt|embedding|rerank|moderation|search-preview/.test(id)) return false;
-  return /^gpt-(5(?:\.|$|-)|4\.1(?:-|$)|4o(?:-|$)|4\.5(?:-|$))/.test(id)
-    || /^o[34](?:-|$)/.test(id);
-}
-
-function grokModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /imagine|image|video|composer/.test(id)) return false;
-  if (id === 'grok-build') return false;
-  return /^grok-/.test(id);
-}
-
-function geminiModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id || /embedding|aqa|imagen|veo|tts|image|computer-use|customtools/.test(id)) return false;
-  return /^gemini-(3(?:\.|-|$)|2\.5-|2\.0-flash)/.test(id);
-}
-
-function anthropicModelSupportsHostedWebSearch(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  if (!id) return false;
-  const match = id.match(/^claude-(opus|sonnet|haiku)-(\d+)(?:[-.](\d+))?/);
-  if (!match) return false;
-  const major = Number(match[2]) || 0;
-  const minor = Number(match[3]) || 0;
-  return major > 4 || (major === 4 && minor >= 0);
-}
-
-function anthropicModelMetaSupportsFast(model) {
-  const id = clean(model?.id || model).toLowerCase();
-  return /^claude-(opus|sonnet)/.test(id);
-}
-
-function fastCapableFor(provider, model) {
-  const p = clean(provider);
-  if (!FAST_CAPABLE_PROVIDERS.has(p)) return false;
-  if (p === 'openai') return openAiDirectModelSupportsFast(model);
-  if (p === 'openai-oauth') return openAiModelMetaSupportsFast(model);
-  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelMetaSupportsFast(model);
-  return false;
-}
-
-function searchCapableFor(provider, model) {
-  const p = normalizeSearchProviderId(provider);
-  if (!isSearchCapableProvider(p)) return false;
-  if (p === 'openai' || p === 'openai-oauth') return openAiModelSupportsHostedWebSearch(model);
-  if (p === 'grok-oauth' || p === 'xai') return grokModelSupportsHostedWebSearch(model);
-  if (p === 'gemini') return geminiModelSupportsHostedWebSearch(model);
-  if (p === 'anthropic' || p === 'anthropic-oauth') return anthropicModelSupportsHostedWebSearch(model);
-  return model?.supportsWebSearch === true;
-}
-
-function fastPreferenceFor(config, provider, model) {
-  const key = routeFastKey(provider, model);
-  if (!key) return false;
-  const saved = config?.modelSettings?.[key];
-  if (saved && typeof saved === 'object' && hasOwn(saved, 'fast')) return saved.fast === true;
-  return config?.fastModels?.[key] === true;
-}
-
-function saveModelSettings(cfgMod, route, { fastCapable = true, baseConfig = null } = {}) {
-  const key = routeFastKey(route?.provider, route?.model);
-  if (!key) return baseConfig || cfgMod.loadConfig();
-  const nextConfig = baseConfig || cfgMod.loadConfig();
-  const modelSettings = { ...(nextConfig.modelSettings || {}) };
-  const nextSetting = { ...(modelSettings[key] || {}) };
-  if (hasOwn(route, 'effort') && route.effort) nextSetting.effort = route.effort;
-  else delete nextSetting.effort;
-  if (fastCapable) nextSetting.fast = route.fast === true;
-  else nextSetting.fast = false;
-  modelSettings[key] = nextSetting;
-
-  // Legacy compatibility: keep fastModels true entries for old readers, but
-  // let modelSettings.fast=false override them in new readers.
-  const fastModels = { ...(nextConfig.fastModels || {}) };
-  if (nextSetting.fast === true) fastModels[key] = true;
-  else delete fastModels[key];
-
-  const savedConfig = { ...nextConfig, modelSettings, fastModels };
-  cfgMod.saveConfig(savedConfig);
-  return savedConfig;
-}
-
-function routeForStatusline(route) {
-  const out = {
-    mode: 'fixed',
-    defaultProvider: route.provider,
-    defaultModel: route.model,
-  };
-  const preset = route.preset || {};
-  if (preset.id) out.presetId = preset.id;
-  if (preset.name) out.presetName = preset.name;
-  // Prefer the preset's curated label, then the route's resolved model display
-  // (set by refreshRouteEffort from the live/offline catalog). Without the
-  // route fallback, a preset-less direct model (e.g. claude-fable-5) reaches
-  // the statusline with no display and renders as the raw id.
-  const modelDisplay = clean(preset.modelDisplay) || clean(route.modelDisplay);
-  if (modelDisplay) out.modelDisplay = modelDisplay;
-  if (route.fast === true || route.fast === false) out.fast = route.fast;
-  else if (preset.fast === true || preset.fast === false) out.fast = preset.fast;
-  if (route.effectiveEffort) {
-    out.effort = route.effectiveEffort;
-    out.displayEffort = route.effectiveEffort;
-  } else if (hasOwn(route, 'effort')) {
-    delete out.effort;
-    delete out.displayEffort;
-  }
-  return out;
-}
-
-function writeStatuslineRoute(statusRoutes, session, route) {
-  if (!session?.id || !route) return;
-  const clientHostPid = session?.clientHostPid || process.pid;
-  statusRoutes?.writeGatewaySessionRoute?.(session.id, routeForStatusline(route), { clientHostPid });
-}
+const outputStyleStatus = (dataDir = STANDALONE_DATA_DIR) => outputStyleStatusRaw(STANDALONE_ROOT, dataDir || STANDALONE_DATA_DIR);
 
 const ONBOARDING_VERSION = 1;
-const WORKFLOW_ROUTE_SLOTS = ['lead', 'agent', 'explorer', 'memory'];
-const FIXED_AGENT_SLOTS = Object.freeze([
-  { id: 'explore', label: 'Explore', description: 'Broad repository exploration', workflowSlot: 'explorer' },
-  { id: 'maintainer', label: 'Maintainer', description: 'Background memory and upkeep', workflowSlot: 'memory' },
-  { id: 'worker', label: 'Worker', description: 'Scoped implementation' },
-  { id: 'heavy-worker', label: 'Heavy Worker', description: 'Broad or multi-file implementation' },
-  { id: 'reviewer', label: 'Reviewer', description: 'Diff review and risk checks' },
-  { id: 'debugger', label: 'Debugger', description: 'Root-cause analysis and failure tracing' },
-]);
-const SEARCH_CAPABLE_PROVIDERS = new Set([
-  'openai-oauth',
-  'openai',
-  'grok-oauth',
-  'xai',
-  'gemini',
-  'anthropic',
-  'anthropic-oauth',
-]);
-const SEARCH_DEFAULT_PROVIDER = 'default';
-const SEARCH_DEFAULT_MODEL = 'default';
-const SEARCH_PROVIDER_ALIASES = Object.freeze({
-  'openai-api': 'openai',
-  'xai-api': 'xai',
-  'gemini-api': 'gemini',
-  'anthropic-api': 'anthropic',
-});
 const QUICK_SEARCH_MODELS = Object.freeze({
   'openai-oauth': [
     { id: 'gpt-5.5', display: 'GPT-5.5', latest: true, contextWindow: 1000000 },
@@ -1219,855 +416,26 @@ const QUICK_SEARCH_MODELS = Object.freeze({
     { id: 'claude-haiku-4-5-20251001', display: 'Claude Haiku 4.5', contextWindow: 200000 },
   ],
 });
-const AGENT_ROLE_IDS = new Set(FIXED_AGENT_SLOTS.map((agent) => agent.id));
-const agentDefinitionCache = new Map();
-const DEFAULT_WORKFLOW_ID = 'default';
-
-function workflowPresetId(slot) {
-  return `workflow-${slot}`;
-}
-
-function workflowPresetName(slot) {
-  return `WORKFLOW ${String(slot || '').toUpperCase()}`;
-}
-
-function agentPresetSlot(agentId) {
-  return `agent-${String(agentId || '').replace(/[^a-z0-9_.-]+/gi, '-').toLowerCase()}`;
-}
-
-function normalizeAgentId(value) {
-  const id = clean(value).toLowerCase().replace(/[\s_]+/g, '-');
-  if (id === 'explorer') return 'explore';
-  if (id === 'maint' || id === 'maintenance' || id === 'memory') return 'maintainer';
-  if (id === 'heavy' || id === 'heavyworker') return 'heavy-worker';
-  if (id === 'review') return 'reviewer';
-  if (id === 'debug') return 'debugger';
-  return AGENT_ROLE_IDS.has(id) ? id : '';
-}
-
-function normalizeWorkflowId(value, fallback = '') {
-  const id = clean(value).toLowerCase().replace(/[\s_]+/g, '-');
-  return /^[a-z0-9][a-z0-9_.-]*$/.test(id) ? id : fallback;
-}
-
-function readTextSafe(path) {
-  try { return readFileSync(path, 'utf8').trim(); } catch { return ''; }
-}
-
-function workflowSourceDirs(dataDir) {
-  return [
-    { root: join(STANDALONE_ROOT, 'workflows'), source: 'built-in' },
-    { root: join(dataDir || STANDALONE_DATA_DIR, 'workflows'), source: 'user' },
-  ];
-}
-
-function agentSourceDirs(dataDir, id) {
-  return [
-    join(dataDir || STANDALONE_DATA_DIR, 'agents', id),
-    join(STANDALONE_ROOT, 'agents', id),
-  ];
-}
-
-function readWorkflowPackFromDir(dir, source = 'built-in', dirName = '') {
-  const entry = 'WORKFLOW.md';
-  const doc = readMarkdownDocument(readTextSafe(join(dir, entry)));
-  const body = doc.body;
-  if (!body) return null;
-  const fm = doc.frontmatter || {};
-  const id = normalizeWorkflowId(clean(fm.id) || dirName || basename(dir));
-  if (!id) return null;
-  const agentsConfigured = Object.prototype.hasOwnProperty.call(fm, 'agents');
-  return {
-    id,
-    name: clean(fm.name) || id,
-    description: clean(fm.description),
-    entry,
-    agentsConfigured,
-    agents: agentsConfigured
-      ? String(fm.agents || '')
-          .split(',')
-          .map((agent) => normalizeAgentId(agent) || normalizeWorkflowId(agent))
-          .filter(Boolean)
-      : [],
-    body,
-    source,
-  };
-}
-
-function listWorkflowPacks(dataDir) {
-  const byId = new Map();
-  for (const { root, source } of workflowSourceDirs(dataDir)) {
-    if (!existsSync(root)) continue;
-    let entries = [];
-    try { entries = readdirSync(root, { withFileTypes: true }); } catch { entries = []; }
-    for (const entry of entries) {
-      if (!entry.isDirectory()) continue;
-      const dir = join(root, entry.name);
-      if (!existsSync(join(dir, 'WORKFLOW.md'))) continue;
-      const pack = readWorkflowPackFromDir(dir, source, entry.name);
-      if (pack) byId.set(pack.id, pack);
-    }
-  }
-  return [...byId.values()].sort((a, b) => {
-    if (a.id === DEFAULT_WORKFLOW_ID) return -1;
-    if (b.id === DEFAULT_WORKFLOW_ID) return 1;
-    return a.name.localeCompare(b.name);
-  });
-}
-
-function activeWorkflowId(config) {
-  return normalizeWorkflowId(config?.workflow?.active, DEFAULT_WORKFLOW_ID);
-}
-
-function loadWorkflowPack(dataDir, id) {
-  const wanted = normalizeWorkflowId(id, DEFAULT_WORKFLOW_ID);
-  for (const { root, source } of workflowSourceDirs(dataDir).reverse()) {
-    const pack = readWorkflowPackFromDir(join(root, wanted), source, wanted);
-    if (pack) return pack;
-  }
-  return readWorkflowPackFromDir(join(STANDALONE_ROOT, 'workflows', DEFAULT_WORKFLOW_ID), 'built-in', DEFAULT_WORKFLOW_ID);
-}
-
-function workflowSummary(pack) {
-  const id = normalizeWorkflowId(pack?.id, DEFAULT_WORKFLOW_ID);
-  return {
-    id,
-    name: clean(pack?.name) || (id === DEFAULT_WORKFLOW_ID ? 'Default' : id),
-    description: clean(pack?.description),
-    source: clean(pack?.source),
-  };
-}
-
-function activeWorkflowSummary(config, dataDir) {
-  return workflowSummary(loadWorkflowPack(dataDir, activeWorkflowId(config)));
-}
-
-function loadAgentDefinition(dataDir, id) {
-  const agentId = normalizeAgentId(id) || normalizeWorkflowId(id);
-  if (!agentId) return null;
-  const cacheKey = `${dataDir || STANDALONE_DATA_DIR}\n${agentId}`;
-  if (agentDefinitionCache.has(cacheKey)) return agentDefinitionCache.get(cacheKey);
-  for (const dir of agentSourceDirs(dataDir, agentId)) {
-    const manifest = readJsonSafe(join(dir, 'agent.json')) || {};
-    const entry = clean(manifest.entry) || 'AGENT.md';
-    const doc = readMarkdownDocument(readTextSafe(join(dir, entry)));
-    const body = doc.body;
-    if (!body) continue;
-    const definition = {
-      id: agentId,
-      name: clean(manifest.name) || FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
-      description: clean(manifest.description) || FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.description || '',
-      permission: normalizeAgentPermissionOrNone(doc.frontmatter.permission),
-      frontmatter: doc.frontmatter,
-      body,
-    };
-    agentDefinitionCache.set(cacheKey, definition);
-    return definition;
-  }
-  const legacyDoc = readMarkdownDocument(readTextSafe(join(STANDALONE_ROOT, 'agents', `${agentId}.md`)));
-  if (!legacyDoc.body) {
-    agentDefinitionCache.set(cacheKey, null);
-    return null;
-  }
-  const definition = {
-    id: agentId,
-    name: FIXED_AGENT_SLOTS.find((agent) => agent.id === agentId)?.label || agentId,
-    description: '',
-    permission: normalizeAgentPermissionOrNone(legacyDoc.frontmatter.permission),
-    frontmatter: legacyDoc.frontmatter,
-    body: legacyDoc.body,
-  };
-  agentDefinitionCache.set(cacheKey, definition);
-  return definition;
-}
-
-function workflowContextBlock(config, dataDir) {
-  const pack = loadWorkflowPack(dataDir, activeWorkflowId(config));
-  if (!pack) return '';
-  const lines = [
-    `# Active Workflow: ${pack.name}`,
-  ];
-  if (pack.description) lines.push(pack.description);
-  lines.push(pack.body);
-
-  const agentIds = pack.agentsConfigured ? pack.agents : FIXED_AGENT_SLOTS.map((agent) => agent.id);
-  const agentBlocks = agentIds
-    .map((id) => loadAgentDefinition(dataDir, id))
-    .filter(Boolean);
-  if (agentBlocks.length) {
-    lines.push('# Available Agents');
-    for (const agent of agentBlocks) {
-      lines.push(`## ${agent.name} (${agent.id})`);
-      if (agent.description) lines.push(agent.description);
-      lines.push(agent.body);
-    }
-  }
-  return lines.join('\n\n');
-}
-
-function normalizeWorkflowRoute(routeLike, fallback = {}) {
-  const provider = clean(routeLike?.provider) || clean(fallback.provider);
-  const model = clean(routeLike?.model) || clean(fallback.model);
-  if (!provider || !model) return null;
-  // Defensive: a workflow/agent route must carry a real model id. Reject values
-  // that are obviously free-form text (whitespace, prose) so a bad string can
-  // never be persisted as a preset/workflow route. Normal model ids pass
-  // isLikelyRawModelId unchanged.
-  if (!isLikelyRawModelId(model)) return null;
-  const effort = normalizeEffortInput(routeLike?.effort ?? fallback.effort);
-  const fast = routeLike?.fast ?? fallback.fast;
-  return {
-    provider,
-    model,
-    ...(effort ? { effort } : {}),
-    ...(fast === true ? { fast: true } : {}),
-  };
-}
-
-function normalizeSearchProviderId(provider) {
-  const id = clean(provider);
-  return SEARCH_PROVIDER_ALIASES[id] || id;
-}
-
-function isDefaultSearchRouteConfig(routeLike = {}) {
-  return normalizeSearchProviderId(routeLike?.provider) === SEARCH_DEFAULT_PROVIDER
-    && clean(routeLike?.model).toLowerCase() === SEARCH_DEFAULT_MODEL;
-}
-
-function isSearchCapableProvider(provider) {
-  return SEARCH_CAPABLE_PROVIDERS.has(normalizeSearchProviderId(provider));
-}
-
-function normalizeSearchRouteConfig(routeLike, fallback = {}) {
-  const provider = normalizeSearchProviderId(routeLike?.provider || fallback.provider);
-  const model = clean(routeLike?.model || fallback.model);
-  if (!provider || !model) return null;
-  let effort = null;
-  try {
-    effort = normalizeEffortInput(routeLike?.effort ?? fallback.effort);
-  } catch {
-    effort = null;
-  }
-  const fast = routeLike?.fast ?? fallback.fast;
-  const toolType = clean(routeLike?.toolType || fallback.toolType);
-  return {
-    provider,
-    model,
-    ...(effort ? { effort } : {}),
-    ...(fast === true ? { fast: true } : {}),
-    ...(toolType ? { toolType } : {}),
-  };
-}
-
-function upsertWorkflowPreset(presets, slot, routeLike) {
-  const route = normalizeWorkflowRoute(routeLike);
-  if (!route) return presets;
-  const id = workflowPresetId(slot);
-  const preset = {
-    id,
-    name: workflowPresetName(slot),
-    type: 'agent',
-    provider: route.provider,
-    model: route.model,
-    ...(route.effort ? { effort: route.effort } : {}),
-    ...(route.fast === true ? { fast: true } : {}),
-    tools: 'full',
-  };
-  const next = (Array.isArray(presets) ? presets : []).filter((p) => clean(p?.id) !== id && clean(p?.name) !== preset.name);
-  next.push(preset);
-  return next;
-}
-
-function summarizeWorkflowRoutes(config) {
-  const routes = config?.workflowRoutes && typeof config.workflowRoutes === 'object' ? config.workflowRoutes : {};
-  const fallbackProvider = resolveDefaultProvider(config);
-  const out = {};
-  for (const slot of WORKFLOW_ROUTE_SLOTS) {
-    const route = routes[slot];
-    // Read/interpret path: a route with a model but no provider falls back to
-    // config.defaultProvider (then DEFAULT_PROVIDER).
-    if (route?.model && (route?.provider || fallbackProvider)) {
-      out[slot] = normalizeWorkflowRoute(route, { provider: fallbackProvider });
-    }
-  }
-  return out;
-}
-
-function routeFromPreset(config, slotValue) {
-  // Maintenance slots now store a direct {provider, model} route. Accept that
-  // shape first; fall back to the legacy preset-NAME string lookup so configs
-  // written before the route migration still resolve.
-  if (slotValue && typeof slotValue === 'object' && !Array.isArray(slotValue)) {
-    const direct = normalizeWorkflowRoute(slotValue);
-    if (direct) return direct;
-  }
-  const preset = findPreset(config, slotValue);
-  return preset ? normalizeWorkflowRoute(preset) : null;
-}
-
-function agentRouteFromConfig(config, agentId, _dataDir) {
-  const id = normalizeAgentId(agentId);
-  if (!id) return null;
-  // Read/interpret path: inject config.defaultProvider (then DEFAULT_PROVIDER)
-  // when a stored route omits its provider.
-  const fallback = { provider: resolveDefaultProvider(config) };
-  const explicit = normalizeWorkflowRoute(config?.agents?.[id], fallback)
-    || (id === 'maintainer' ? normalizeWorkflowRoute(config?.agents?.maintenance, fallback) : null);
-  if (explicit) return explicit;
-
-  const agent = FIXED_AGENT_SLOTS.find((item) => item.id === id);
-  if (agent?.workflowSlot) {
-    const workflowRoute = normalizeWorkflowRoute(config?.workflowRoutes?.[agent.workflowSlot], fallback);
-    if (workflowRoute) return workflowRoute;
-  }
-
-  if (id === 'explore') return routeFromPreset(config, config?.maintenance?.explore);
-  if (id === 'maintainer') return routeFromPreset(config, config?.maintenance?.memory);
-
-  return null;
-}
-
-function toolResponseText(result) {
-  if (result && typeof result === 'object' && Array.isArray(result.content)) {
-    return result.content
-      .map((part) => (part?.type === 'text' ? part.text || '' : JSON.stringify(part)))
-      .join('\n');
-  }
-  if (typeof result === 'string') return result;
-  return JSON.stringify(result, null, 2);
-}
-
-function isEmptyRecallText(value) {
-  const text = String(value || '').trim();
-  return !text || /^\(?no results\)?$/i.test(text) || /^\(?empty memory result\)?$/i.test(text);
-}
-
-function currentSessionRecallRows(session, query, { limit = 10 } = {}) {
-  const messages = Array.isArray(session?.messages) ? session.messages : [];
-  if (!messages.length) return '(no results)';
-  const terms = [...new Set(String(query || '').toLowerCase().match(/[\p{L}\p{N}_./:-]{2,}/gu) || [])]
-    .filter(Boolean)
-    .slice(0, 16);
-  const max = Math.max(1, Math.min(100, Number(limit) || 10));
-  const rows = [];
-  for (let i = messages.length - 1; i >= 0 && rows.length < max; i -= 1) {
-    const m = messages[i];
-    if (!m || (m.role !== 'user' && m.role !== 'assistant' && m.role !== 'tool')) continue;
-    const text = messageContextText(m).replace(/\s+/g, ' ').trim();
-    if (!text) continue;
-    if (terms.length && !terms.some((term) => text.toLowerCase().includes(term))) continue;
-    rows.push(`[session:${i + 1}] ${m.role}: ${text.slice(0, 1000)}`);
-  }
-  return rows.length ? rows.join('\n') : '(no results)';
-}
-
-function parseToolSelection(value) {
-  if (Array.isArray(value)) return value.map(clean).filter(Boolean);
-  if (value && typeof value !== 'string' && typeof value[Symbol.iterator] === 'function') {
-    return [...value].map(clean).filter(Boolean);
-  }
-  return String(value || '').replace(/^select\s*:/i, '')
-    .split(/[,\s]+/)
-    .map(clean)
-    .filter(Boolean);
-}
-
-function parseToolSearchQuerySelection(query) {
-  const match = clean(query).match(/^select\s*:\s*(.+)$/i);
-  return match ? parseToolSelection(match[1]) : [];
-}
-
-function toolKind(tool) {
-  const name = clean(tool?.name);
-  if (name.startsWith('mcp__')) return 'mcp';
-  if (name.startsWith('skill:') || tool?.annotations?.mixdogKind === 'skill') return 'skill';
-  if (name === 'Skill' || name.startsWith('skill_') || name === 'skills_list' || name === 'skill_view') return 'skill';
-  if (tool?.annotations?.agentHidden) return 'control';
-  if (['apply_patch', 'shell'].includes(name)) return 'mutation';
-  return 'tool';
-}
-
-function toolSchemaBucket(tool) {
-  const name = clean(tool?.name);
-  const kind = toolKind(tool);
-  if (kind === 'mcp') return 'mcp';
-  if (kind === 'skill') return 'skills';
-  if (name === 'memory' || name === 'recall' || name.includes('memory')) return 'memory';
-  if (name === 'search' || name === 'web_fetch') return 'web';
-  if (['read', 'grep', 'find', 'glob', 'list', 'code_graph', 'explore'].includes(name)) return 'code';
-  if (['shell', 'apply_patch'].includes(name)) return 'mutation';
-  if (name === 'agent' || name === 'delegate') return 'agents';
-  if (name.includes('channel') || name.includes('discord') || name.includes('webhook')) return 'channels';
-  if (name.includes('provider') || name === 'tool_search' || name === 'cwd') return 'setup';
-  return 'other';
-}
-
-function estimateToolSchemaBreakdown(tools) {
-  const out = {};
-  for (const tool of Array.isArray(tools) ? tools : []) {
-    const bucket = toolSchemaBucket(tool);
-    const row = out[bucket] || { count: 0, tokens: 0 };
-    row.count += 1;
-    row.tokens += estimateToolSchemaTokens([tool]);
-    out[bucket] = row;
-  }
-  return out;
-}
-
-function measuredToolUsage(name) {
-  return MEASURED_TOOL_USAGE[clean(name)] || 0;
-}
-
-function measuredToolRank(name) {
-  const index = MEASURED_TOOL_ORDER.indexOf(clean(name));
-  return index === -1 ? Number.MAX_SAFE_INTEGER : index;
-}
-
-function sortedCatalogByMeasuredUsage(catalog) {
-  return (catalog || [])
-    .map((tool, index) => ({ tool, index }))
-    .sort((a, b) => {
-      const au = measuredToolUsage(a.tool?.name);
-      const bu = measuredToolUsage(b.tool?.name);
-      if (bu !== au) return bu - au;
-      const ar = measuredToolRank(a.tool?.name);
-      const br = measuredToolRank(b.tool?.name);
-      if (ar !== br) return ar - br;
-      return a.index - b.index;
-    })
-    .map((entry) => entry.tool);
-}
-
-function activeToolForSurface(tool) {
-  if (!tool || typeof tool !== 'object') return tool;
-  return JSON.parse(JSON.stringify(tool));
-}
-
-function deferredProviderMode(provider) {
-  const p = clean(provider).toLowerCase();
-  if (p === 'gemini') return 'full';
-  if (p === 'anthropic' || p === 'anthropic-oauth'
-    || p === 'openai' || p === 'openai-oauth'
-    || p === 'xai' || p === 'grok-oauth') {
-    return 'native';
-  }
-  return 'legacy';
-}
-
-function filterDisallowedTools(tools, disallowed = []) {
-  if (!Array.isArray(disallowed) || disallowed.length === 0) return tools;
-  const deny = new Set(disallowed.map((name) => clean(name)).filter(Boolean));
-  if (deny.size === 0) return tools;
-  return (tools || []).filter((tool) => !deny.has(clean(tool?.name)));
-}
-
-function sortedNamesByMeasuredUsage(names) {
-  return [...(names || [])].sort((a, b) => {
-    const au = measuredToolUsage(a);
-    const bu = measuredToolUsage(b);
-    if (bu !== au) return bu - au;
-    const ar = measuredToolRank(a);
-    const br = measuredToolRank(b);
-    if (ar !== br) return ar - br;
-    return String(a).localeCompare(String(b));
-  });
-}
-
-export function defaultDeferredToolNames(catalog, mode) {
-  const available = new Set((catalog || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  if (mode === 'lead') {
-    return new Set(DEFERRED_DEFAULT_LEAD_TOOLS.filter((name) => available.has(name)));
-  }
-  if (mode === 'readonly') {
-    return new Set(DEFERRED_DEFAULT_READONLY_TOOLS.filter((name) => available.has(name)));
-  }
-  return new Set(DEFERRED_DEFAULT_FULL_TOOLS.filter((name) => available.has(name)));
-}
-
-export function compactToolSearchDescription(value, max = 220) {
-  const text = clean(value).replace(/\s+/g, ' ');
-  return text.length > max ? `${text.slice(0, max - 1)}…` : text;
-}
-
-function toolRow(tool, activeNames = new Set()) {
-  const name = clean(tool?.name);
-  return {
-    name,
-    kind: toolKind(tool),
-    usage: measuredToolUsage(name),
-    active: activeNames.has(name),
-    description: compactToolSearchDescription(tool?.description),
-  };
-}
-
-function providerSupportsResponsesCustomTools(provider) {
-  const p = clean(provider).toLowerCase();
-  if (!p) return true;
-  return p === 'openai' || p === 'openai-oauth';
-}
-
-function openAILoadableToolSpec(tool, provider = '') {
-  if (providerSupportsResponsesCustomTools(provider) && isResponsesFreeformTool(tool)) return toResponsesCustomTool(tool);
-  return {
-    type: 'function',
-    name: clean(tool?.name),
-    description: clean(tool?.description),
-    defer_loading: true,
-    parameters: tool?.inputSchema && typeof tool.inputSchema === 'object'
-      ? tool.inputSchema
-      : { type: 'object', properties: {} },
-  };
-}
-
-function toolSearchNativePayload(catalog, names, provider = '') {
-  const selected = new Set((names || []).map(clean).filter(Boolean));
-  if (!selected.size) return null;
-  const tools = [];
-  const refs = [];
-  for (const tool of catalog || []) {
-    const name = clean(tool?.name);
-    if (!name || !selected.has(name)) continue;
-    refs.push(name);
-    tools.push(openAILoadableToolSpec(tool, provider));
-  }
-  if (!refs.length) return null;
-  return {
-    toolReferences: refs,
-    openaiTools: tools,
-    summary: `Loaded deferred tools: ${refs.join(', ')}`,
-  };
-}
-
-function toolSearchTokens(value) {
-  return (clean(value).toLowerCase().match(/[a-z0-9_.-]+/g) || [])
-    .map((token) => token.replace(/[-.]+/g, '_'))
-    .filter(Boolean);
-}
-
-function toolSearchMeaningfulTokens(value) {
-  return toolSearchTokens(value).filter((token) => !TOOL_SEARCH_STOP_WORDS.has(token));
-}
-
-function toolSearchText(row) {
-  const text = `${row.name} ${String(row.name || '').replace(/_/g, ' ')} ${row.kind} ${row.description} ${row.active ? 'active' : 'deferred'}`;
-  return `${text} ${text.replace(/[-.]+/g, '_')}`.toLowerCase();
-}
-
-function toolSearchRowAliases(name) {
-  return TOOL_SEARCH_ROW_ALIASES[clean(name)] || [];
-}
-
-function toolSearchRank(row, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return { score: 0, reasons: [] };
-  const name = clean(row?.name).toLowerCase();
-  const prettyName = name.replace(/_/g, ' ');
-  const haystack = toolSearchText(row);
-  const aliases = toolSearchRowAliases(name);
-  const aliasText = aliases.join(' ').toLowerCase();
-  const queryTokens = toolSearchMeaningfulTokens(raw);
-  const nameTokens = new Set(toolSearchTokens(`${name} ${prettyName}`));
-  const aliasTokens = new Set(toolSearchTokens(aliasText));
-  let score = 0;
-  const reasons = [];
-  if (raw === name || raw === prettyName) {
-    score += 120;
-    reasons.push('exact-name');
-  }
-  if (aliases.some((alias) => raw === alias || raw === alias.replace(/[_-]+/g, ' '))) {
-    score += 100;
-    reasons.push('exact-alias');
-  }
-  if (haystack.includes(raw)) {
-    score += 34;
-    reasons.push('phrase');
-  }
-  for (const alias of aliases) {
-    const normalizedAlias = alias.toLowerCase();
-    if (normalizedAlias && raw.includes(normalizedAlias)) {
-      score += 58;
-      reasons.push('alias-phrase');
-      break;
-    }
-  }
-  let matchedTokens = 0;
-  for (const token of queryTokens) {
-    if (nameTokens.has(token) || name.includes(token)) {
-      score += 24;
-      matchedTokens += 1;
-      continue;
-    }
-    if (aliasTokens.has(token) || aliasText.includes(token)) {
-      score += 18;
-      matchedTokens += 1;
-      continue;
-    }
-    if (haystack.includes(token)) {
-      score += 7;
-      matchedTokens += 1;
-    }
-  }
-  if (queryTokens.length && matchedTokens === queryTokens.length) {
-    score += Math.min(18, queryTokens.length * 6);
-    reasons.push('all-tokens');
-  }
-  if (clean(row?.kind).toLowerCase() === raw) score += 10;
-  if (score > 0) score += Math.min(6, Math.floor(measuredToolUsage(name) / 150));
-  return { score, reasons };
-}
-
-function toolSearchMatches(row, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return true;
-  return toolSearchRank(row, raw).score > 0;
-}
-
-function rankedToolSearchRows(rows, query) {
-  const raw = clean(query).toLowerCase();
-  if (!raw) return rows;
-  return rows
-    .map((row) => {
-      const ranked = toolSearchRank(row, raw);
-      return { ...row, score: ranked.score, reasons: ranked.reasons };
-    })
-    .filter((row) => row.score > 0)
-    .sort((a, b) => {
-      if (b.score !== a.score) return b.score - a.score;
-      if (a.active !== b.active) return a.active ? 1 : -1;
-      if (b.usage !== a.usage) return b.usage - a.usage;
-      return String(a.name).localeCompare(String(b.name));
-    });
-}
-
-function queryHasAnyPhrase(query, phrases) {
-  const text = clean(query).toLowerCase().replace(/[_-]+/g, ' ');
-  return phrases.some((phrase) => text.includes(phrase));
-}
-
-function autoToolSelectionNames(query, rows) {
-  const raw = clean(query).toLowerCase();
-  if (!raw || TOOL_SEARCH_AMBIGUOUS_AUTO_QUERIES.has(raw)) return [];
-  if (TOOL_SEARCH_SAFE_AUTO_ALIASES.has(raw) && DEFERRED_SELECT_ALIASES[raw]) {
-    return DEFERRED_SELECT_ALIASES[raw];
-  }
-  if (queryHasAnyPhrase(raw, ['save memory', 'store memory', 'delete memory', 'forget memory', 'memory status', '기억 저장', '메모리 저장'])) {
-    return ['memory'];
-  }
-  if (queryHasAnyPhrase(raw, ['run', 'execute', 'test', 'tests', 'build', 'terminal', 'command', 'powershell', 'bash', 'shell', 'npm', 'node', 'git', '실행', '테스트', '빌드', '터미널', '쉘'])) {
-    return ['shell', 'task'];
-  }
-  if (queryHasAnyPhrase(raw, ['web', 'internet', 'online', 'current info', 'latest', 'news', 'browse', 'docs', 'documentation', '웹', '인터넷', '최신', '뉴스', '문서'])) {
-    return ['search', 'web_fetch'];
-  }
-  if (queryHasAnyPhrase(raw, ['recall', 'remember', 'memory previous', 'previous', 'history', 'past', 'prior', 'earlier', 'resume', '이전', '기억', '히스토리'])) {
-    return ['recall'];
-  }
-  if (queryHasAnyPhrase(raw, ['delegate', 'subagent', 'worker', 'parallel agent', 'background agent', 'reviewer', 'explorer', '에이전트', '워커', '병렬'])) {
-    return ['agent'];
-  }
-  if (queryHasAnyPhrase(raw, ['working directory', 'project root', 'current directory', 'cwd'])) {
-    return ['cwd'];
-  }
-  const ranked = rankedToolSearchRows(rows, raw);
-  const top = ranked[0];
-  if (!top) return [];
-  const reasons = new Set(top.reasons || []);
-  if (reasons.has('exact-name') || reasons.has('exact-alias')) return [top.name];
-  return [];
-}
-
-function expandSelectionNames(names) {
-  const out = [];
-  for (const raw of names || []) {
-    const key = clean(raw);
-    if (!key) continue;
-    const alias = DEFERRED_SELECT_ALIASES[key.toLowerCase()];
-    if (alias) out.push(...alias);
-    else out.push(key);
-  }
-  return [...new Set(out)];
-}
-
-function storedDeferredToolNames(session) {
-  for (const source of [session?.deferredDiscoveredTools, session?.deferredSelectedTools]) {
-    const names = parseToolSelection(source);
-    if (names.length) return names;
-  }
-  return [];
-}
-
-function canonicalDeferredToolNames(catalog, names) {
-  const byName = new Map();
-  for (const tool of catalog || []) {
-    const name = clean(tool?.name);
-    if (!name) continue;
-    byName.set(name, name);
-    byName.set(name.toLowerCase(), name);
-  }
-  const out = [];
-  for (const raw of expandSelectionNames(names)) {
-    const name = clean(raw);
-    const canonical = byName.get(name) || byName.get(name.toLowerCase());
-    if (canonical) out.push(canonical);
-  }
-  return sortedNamesByMeasuredUsage(new Set(out));
-}
-
-function setDeferredToolState(session, names) {
-  if (!session) return [];
-  const selected = sortedNamesByMeasuredUsage(new Set(parseToolSelection(names)));
-  session.deferredDiscoveredTools = selected;
-  session.deferredSelectedTools = selected;
-  return selected;
-}
-
-function isReadonlySelectable(tool) {
-  const name = clean(tool?.name);
-  if (READONLY_TOOL_NAMES.has(name)) return true;
-  const annotations = tool?.annotations || {};
-  if (annotations.destructiveHint === true) return false;
-  if (annotations.readOnlyHint === true) return true;
-  return false;
-}
-
-function applyDeferredToolSurface(session, mode, extraTools = [], options = {}) {
-  if (!session || !Array.isArray(session.tools)) return session;
-  const providerMode = deferredProviderMode(options.provider || session.provider);
-  const byName = new Map();
-  for (const tool of [...session.tools, ...(extraTools || [])]) {
-    const name = clean(tool?.name);
-    if (!name || byName.has(name)) continue;
-    byName.set(name, activeToolForSurface(tool));
-  }
-  const catalog = sortedCatalogByMeasuredUsage([...byName.values()]);
-  const defaultNames = defaultDeferredToolNames(catalog, mode);
-  const storedNames = providerMode === 'native' ? [] : storedDeferredToolNames(session);
-  let selectedNames = providerMode === 'full'
-    ? sortedNamesByMeasuredUsage(catalog.map((tool) => clean(tool?.name)).filter(Boolean))
-    : [];
-  if (providerMode !== 'full') {
-    selectedNames = storedNames.length ? canonicalDeferredToolNames(catalog, storedNames) : [];
-    if (!selectedNames.length || providerMode === 'native') selectedNames = sortedNamesByMeasuredUsage(defaultNames);
-  }
-  const selected = new Set(selectedNames);
-  session.deferredToolCatalog = catalog;
-  session.deferredToolUsage = MEASURED_TOOL_USAGE;
-  session.deferredDefaultTools = sortedNamesByMeasuredUsage(defaultNames);
-  session.deferredProviderMode = providerMode;
-  session.deferredNativeTools = providerMode === 'native';
-  session.tools.length = 0;
-  const active = [];
-  for (const tool of catalog) {
-    if (!selected.has(clean(tool?.name))) continue;
-    if (mode === 'readonly' && !isReadonlySelectable(tool)) continue;
-    session.tools.push(tool);
-    active.push(clean(tool?.name));
-  }
-  if (providerMode === 'native') {
-    const discovered = canonicalDeferredToolNames(catalog, session.deferredDiscoveredTools || []);
-    session.deferredSelectedTools = active;
-    session.deferredDiscoveredTools = discovered.filter((name) => !selected.has(name));
-  } else {
-    setDeferredToolState(session, active);
-  }
-  return session;
-}
-
-function selectDeferredTools(session, names, mode) {
-  const catalog = Array.isArray(session?.deferredToolCatalog)
-    ? session.deferredToolCatalog
-    : (Array.isArray(session?.tools) ? session.tools : []);
-  const active = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const native = session?.deferredProviderMode === 'native' || session?.deferredNativeTools === true;
-  const discovered = new Set(Array.isArray(session?.deferredDiscoveredTools) ? session.deferredDiscoveredTools : []);
-  const byName = new Map();
-  for (const tool of catalog) {
-    const name = clean(tool?.name);
-    if (!name) continue;
-    byName.set(name, tool);
-    byName.set(name.toLowerCase(), tool);
-  }
-  const added = [];
-  const already = [];
-  const blocked = [];
-  const missing = [];
-  for (const rawName of expandSelectionNames(names)) {
-    const requestedName = clean(rawName);
-    const tool = byName.get(requestedName) || byName.get(requestedName.toLowerCase());
-    const name = clean(tool?.name);
-    if (!tool) {
-      missing.push(requestedName);
-      continue;
-    }
-    if (mode === 'readonly' && !isReadonlySelectable(tool)) {
-      blocked.push({ name, reason: 'readonly mode' });
-      continue;
-    }
-    if (active.has(name) || discovered.has(name)) {
-      already.push(name);
-      continue;
-    }
-    if (native) {
-      discovered.add(name);
-    } else {
-      session.tools.push(tool);
-      active.add(name);
-    }
-    added.push(name);
-  }
-  if (native) {
-    session.deferredDiscoveredTools = sortedNamesByMeasuredUsage(discovered);
-    session.deferredSelectedTools = sortedNamesByMeasuredUsage(active);
-  } else {
-    setDeferredToolState(session, active);
-  }
-  return { added, already, blocked, missing, native };
-}
-
-function renderToolSearch(args = {}, session, mode = 'full') {
-  const catalog = Array.isArray(session?.deferredToolCatalog)
-    ? session.deferredToolCatalog
-    : (Array.isArray(session?.tools) ? session.tools : []);
-  const rawQuery = clean(args.query);
-  const explicitSelectedNames = parseToolSelection(args.select);
-  const querySelectedNames = explicitSelectedNames.length ? [] : parseToolSearchQuerySelection(rawQuery);
-  const forcedSelectedNames = explicitSelectedNames.length ? explicitSelectedNames : querySelectedNames;
-  const query = querySelectedNames.length ? '' : rawQuery.toLowerCase();
-  const limit = Math.max(1, Math.min(50, Number(args.limit) || 20));
-  const initialActiveNames = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const initialRows = catalog.map((tool) => toolRow(tool, initialActiveNames)).filter((row) => row.name);
-  const autoSelectedNames = (!forcedSelectedNames.length && query)
-    ? autoToolSelectionNames(query, initialRows)
-    : [];
-  const selectedNames = forcedSelectedNames.length ? forcedSelectedNames : autoSelectedNames;
-  const toolSelection = selectedNames.length ? selectDeferredTools(session, selectedNames, mode) : null;
-  const selectionMode = forcedSelectedNames.length ? 'select' : (autoSelectedNames.length ? 'auto' : null);
-  const nextActiveNames = new Set((session?.tools || []).map((tool) => clean(tool?.name)).filter(Boolean));
-  const rows = [
-    ...catalog.map((tool) => toolRow(tool, nextActiveNames)),
-  ].filter((row) => row.name);
-  const matches = query
-    ? rankedToolSearchRows(rows, query)
-    : rows;
-  const selected = toolSelection
-    ? {
-        mode: selectionMode,
-        tools: toolSelection,
-      }
-    : null;
-  const nativeToolSearch = toolSelection?.native
-    ? toolSearchNativePayload(catalog, toolSelection.added, session?.provider)
-    : null;
-  return JSON.stringify({
-    selected,
-    ...(nativeToolSearch ? { nativeToolSearch } : {}),
-    totalMatches: matches.length,
-    matches: matches.slice(0, limit),
-    activeTools: sortedNamesByMeasuredUsage(nextActiveNames),
-    discoveredTools: sortedNamesByMeasuredUsage(session?.deferredDiscoveredTools || []),
-    note: 'query ranks matches and auto-loads high-confidence deferred tools; select exact tool names, or query select:a,b, to force load.',
-  }, null, 2);
-}
+// Workflow/agent pack loaders bound to this runtime's root/data layout.
+const {
+  listWorkflowPacks,
+  activeWorkflowId,
+  loadWorkflowPack,
+  workflowSummary,
+  activeWorkflowSummary,
+  loadAgentDefinition,
+  workflowContextBlock,
+} = createWorkflowHelpers({
+  rootDir: STANDALONE_ROOT,
+  dataDir: STANDALONE_DATA_DIR,
+  readMarkdownDocument,
+  normalizeAgentPermissionOrNone,
+});
+const {
+  summarizeWorkflowRoutes,
+  routeFromPreset,
+  agentRouteFromConfig,
+} = createWorkflowRouteHelpers({ resolveDefaultProvider, findPreset });
 
 export function __renderToolSearchForTest(args = {}, session = {}, mode = 'full') {
   return renderToolSearch(args, session, mode);
@@ -2881,6 +1249,11 @@ export async function createMixdogSessionRuntime({
         }
       } catch {}
     }
+    // CwdChanged: bridge an effective cwd switch to the standard hook bus.
+    // No matcher event — payload is minimal { cwd }. Fire-and-forget.
+    if (changed) {
+      try { void hooks.dispatch('CwdChanged', hookCommonPayload({ cwd: currentCwd })); } catch {}
+    }
     return currentCwd;
   }
 
@@ -2964,7 +1337,8 @@ export async function createMixdogSessionRuntime({
         mcpScript: mcpScriptForPlugin(root),
       };
       plugin.mcpServerName = pluginMcpServerName(plugin);
-      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName);
+      plugin.mcpEnabled = Object.prototype.hasOwnProperty.call(configuredMcp, plugin.mcpServerName)
+        || Object.keys(configuredMcp).some((k) => k.startsWith(`${plugin.mcpServerName}--`));
       plugins.push(plugin);
     };
 
@@ -2986,17 +1360,18 @@ export async function createMixdogSessionRuntime({
   }
 
   // Merge mixdog-config `agent.mcpServers` with project-local `.mcp.json`.
-  // On name collision the mixdog-config entry WINS. `sources[name]` records
-  // each server's origin ('config' | 'project') for status reporting.
+  // On name collision the project-local `.mcp.json` entry WINS (Claude Code
+  // precedence: project > user config). `sources[name]` records each server's
+  // origin ('config' | 'project') for status reporting.
   function resolveEffectiveMcpServers() {
     const configured = config?.mcpServers && typeof config.mcpServers === 'object'
       ? config.mcpServers
       : {};
     const project = readProjectMcpServers(currentCwd);
-    const servers = { ...project, ...configured };
+    const servers = { ...configured, ...project };
     const sources = {};
-    for (const name of Object.keys(project)) sources[name] = 'project';
     for (const name of Object.keys(configured)) sources[name] = 'config';
+    for (const name of Object.keys(project)) sources[name] = 'project';
     return { servers, sources };
   }
 
@@ -3100,6 +1475,18 @@ export async function createMixdogSessionRuntime({
     mgr,
     dataDir: cfgMod.getPluginData(),
     cwd,
+    // SubagentStart/SubagentStop: bridge internal worker spawn/finish to the
+    // standard hook bus. agent_type is passed top-level via hookCommonPayload
+    // (added to hook-bus buildEventPayload passthrough). Best-effort.
+    onSubagentEvent: (phase, info = {}) => {
+      try {
+        const event = phase === 'stop' ? 'SubagentStop' : 'SubagentStart';
+        void hooks.dispatch(event, hookCommonPayload({
+          session_id: info?.session_id || null,
+          agent_type: info?.agent_type || null,
+        }));
+      } catch { /* best-effort: subagent hook must never affect worker lifecycle */ }
+    },
   });
   bootProfile('agent:ready', { ms: (performance.now() - agentToolStartedAt).toFixed(1) });
   const agentStatusState = () => {
@@ -3308,6 +1695,58 @@ export async function createMixdogSessionRuntime({
   let pendingConfigToSave = null;
   let configSaveTimer = null;
   const CONFIG_SAVE_DEBOUNCE_MS = 150;
+  // Same debounce pattern as saveConfigAndAdopt below, but for the channels-
+  // section backend switch: channel-admin's setBackend() does a synchronous
+  // file-locked read-modify-write (updateChannelsSection), which is a
+  // secondary hitch source on the settings-toggle key handler. Coalesce
+  // rapid toggles and move the write off the key-handler tick.
+  let pendingBackendName = null;
+  let backendSaveTimer = null;
+  function flushBackendSave() {
+    if (backendSaveTimer) {
+      clearTimeout(backendSaveTimer);
+      backendSaveTimer = null;
+    }
+    if (pendingBackendName === null) return;
+    const name = pendingBackendName;
+    pendingBackendName = null;
+    try {
+      setBackend(name);
+    } catch (err) {
+      process.stderr.write(`[channels] debounced setBackend failed: ${err?.message || err}\n`);
+    }
+  }
+  // Debounced persist for the top-level `outputStyle` config key. This CANNOT
+  // ride saveConfigAndAdopt/flushConfigSave: cfgMod.saveConfig() serializes
+  // ONLY the agent-section fields (see orchestrator config.mjs saveConfig),
+  // so a top-level outputStyle adopted in memory would never reach disk and
+  // would silently revert on the next fresh catalog read/restart. Persist it
+  // through sharedCfgMod.updateConfig (whole-root RMW under the same file
+  // lock), debounced off the key-handler tick like the backend switch above.
+  let pendingOutputStyleId = null;
+  let outputStyleSaveTimer = null;
+  function flushOutputStyleSave() {
+    if (outputStyleSaveTimer) {
+      clearTimeout(outputStyleSaveTimer);
+      outputStyleSaveTimer = null;
+    }
+    if (pendingOutputStyleId === null) return;
+    const styleId = pendingOutputStyleId;
+    pendingOutputStyleId = null;
+    try {
+      sharedCfgMod.updateConfig((root) => {
+        const next = { ...(root || {}), outputStyle: styleId };
+        if (next.agent && typeof next.agent === 'object' && !Array.isArray(next.agent)) {
+          const agent = { ...next.agent };
+          delete agent.outputStyle;
+          next.agent = agent;
+        }
+        return next;
+      });
+    } catch (err) {
+      process.stderr.write(`[config] debounced outputStyle save failed: ${err?.message || err}\n`);
+    }
+  }
   function flushConfigSave() {
     if (configSaveTimer) {
       clearTimeout(configSaveTimer);
@@ -4022,11 +2461,61 @@ function parsedProviderModelVersion(id) {
         configurable: true,
         writable: true,
       });
+      // PostToolUseFailure: dispatched by loop.mjs only when a tool execution
+      // resolved to a failure (thrown-error path or an is_error result). Same
+      // shape as afterToolHook; `result` carries the error text. Best-effort.
+      Object.defineProperty(session, 'afterToolFailureHook', {
+        value: (input) => hooks.dispatch('PostToolUseFailure', hookCommonPayload({
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          cwd: input?.cwd || currentCwd,
+          tool_name: input?.name,
+          tool_input: input?.args,
+          tool_use_id: input?.toolCallId || input?.tool_use_id,
+          tool_response: input?.result,
+        })),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
+      // PostToolBatch: dispatched by loop.mjs after a full parallel batch of
+      // tool calls resolves and before the next model call. No matcher event.
+      Object.defineProperty(session, 'afterToolBatchHook', {
+        value: (input) => hooks.dispatch('PostToolBatch', hookCommonPayload({
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          cwd: input?.cwd || currentCwd,
+        })),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
+      // PreCompact / PostCompact: dispatched by manager.mjs/loop.mjs compaction
+      // flow via these session-property hooks (manager has no hooks bus access).
+      // payload { trigger: 'auto' | 'manual' }. Best-effort.
+      Object.defineProperty(session, 'preCompactHook', {
+        value: (input) => hooks.dispatch('PreCompact', hookCommonPayload({
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          cwd: input?.cwd || currentCwd,
+          trigger: input?.trigger || 'auto',
+        })),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
+      Object.defineProperty(session, 'postCompactHook', {
+        value: (input) => hooks.dispatch('PostCompact', hookCommonPayload({
+          session_id: input?.sessionId || input?.session_id || session?.id,
+          cwd: input?.cwd || currentCwd,
+          trigger: input?.trigger || 'auto',
+        })),
+        enumerable: false,
+        configurable: true,
+        writable: true,
+      });
       applyDeferredToolSurface(session, deferredSurfaceModeForLead(mode), standaloneTools, { provider: route.provider });
       applyPreSessionToolSelection();
       writeStatuslineRoute(statusRoutes, session, route);
       hooks.emit('session:create', { sessionId: session.id, provider: route.provider, model: route.model, toolMode: mode, cwd: currentCwd });
-      // SessionStart: bridge to the standard Claude Code hook bus. Best-effort;
+      // SessionStart: bridge to the standard project hook bus. Best-effort;
       // a hook error must never break session creation. additionalContext is
       // injected before the first user turn as a system-reminder context pair.
       try {
@@ -4266,6 +2755,10 @@ function parsedProviderModelVersion(id) {
   // boots the channel worker and contends for channel ownership.
   function startRemote() {
     remoteEnabled = true;
+    // A backend switch may still be sitting in its debounce window; flush it
+    // so the channel worker boots against the backend the user just chose,
+    // not the previous on-disk value.
+    try { flushBackendSave(); } catch {}
     if (envFlag('MIXDOG_DISABLE_CHANNEL_START')) {
       bootProfile('channels:start-skipped');
       return true;
@@ -4897,6 +3390,10 @@ function parsedProviderModelVersion(id) {
       return this.getOnboardingStatus();
     },
     getChannelSetup() {
+      // Flush a pending debounced backend switch first so setup readers
+      // (Settings → Channel Setting, remote toggles) never observe the
+      // previous backend during the 150ms debounce window.
+      try { flushBackendSave(); } catch {}
       return channelSetup();
     },
     getChannelWorkerStatus() {
@@ -4932,8 +3429,21 @@ function parsedProviderModelVersion(id) {
       return result;
     },
     setBackend(name) {
-      const result = setBackend(name);
-      return result;
+      // Validate synchronously (same contract as before: bad input throws on
+      // this call so the TUI's try/catch can react immediately). The actual
+      // channels-section file read-modify-write is the hitch source on the
+      // settings-toggle key handler, so defer it through the same debounce
+      // pattern as saveConfigAndAdopt/flushConfigSave instead of writing to
+      // disk synchronously inside the key handler.
+      const value = String(name || '').trim();
+      if (value !== 'discord' && value !== 'telegram') {
+        throw new Error('backend must be discord or telegram');
+      }
+      pendingBackendName = value;
+      if (backendSaveTimer) clearTimeout(backendSaveTimer);
+      backendSaveTimer = setTimeout(flushBackendSave, CONFIG_SAVE_DEBOUNCE_MS);
+      backendSaveTimer.unref?.();
+      return { ok: true, backend: value };
     },
     saveWebhookAuthtoken(token) {
       const result = saveWebhookAuthtoken(token);
@@ -5047,6 +3557,12 @@ function parsedProviderModelVersion(id) {
       invalidateProviderCaches();
       return result;
     },
+    async loginOpenCodeGoUsage() {
+      const result = await loginOpenCodeGoUsage(cfgMod);
+      reloadFullConfig();
+      invalidateProviderCaches();
+      return result;
+    },
     setLocalProvider(providerId, opts) {
       const result = setLocalProvider(cfgMod, providerId, opts);
       reloadFullConfig();
@@ -5157,26 +3673,51 @@ function parsedProviderModelVersion(id) {
         const names = before.styles.map((style) => style.label || style.id).join(', ') || 'Default';
         throw new Error(`output style must be one of ${names}`);
       }
-      if (typeof sharedCfgMod.updateConfig !== 'function') throw new Error('output style config writer unavailable');
-      sharedCfgMod.updateConfig((root) => {
-        const next = { ...(root || {}), outputStyle: selected.id };
-        if (next.agent && typeof next.agent === 'object' && !Array.isArray(next.agent)) {
-          const agent = { ...next.agent };
-          delete agent.outputStyle;
-          next.agent = agent;
-        }
-        return next;
-      });
-      invalidateOutputStyleStatusCache();
+      // Adopt in-memory immediately so same-tick readers see the new style;
+      // persist off the key-handler tick. NOTE: the disk write goes through
+      // the dedicated flushOutputStyleSave debounce (sharedCfgMod whole-root
+      // RMW) — cfgMod.saveConfig only serializes agent-section fields and
+      // would drop the top-level outputStyle key.
+      const nextConfig = { ...config, outputStyle: selected.id };
+      if (nextConfig.agent && typeof nextConfig.agent === 'object' && !Array.isArray(nextConfig.agent)) {
+        const agent = { ...nextConfig.agent };
+        delete agent.outputStyle;
+        nextConfig.agent = agent;
+      }
+      adoptConfig(nextConfig);
+      pendingOutputStyleId = selected.id;
+      if (outputStyleSaveTimer) clearTimeout(outputStyleSaveTimer);
+      outputStyleSaveTimer = setTimeout(flushOutputStyleSave, CONFIG_SAVE_DEBOUNCE_MS);
+      outputStyleSaveTimer.unref?.();
+      // Reuse the catalog already scanned above for `before` instead of a
+      // second forced-fresh filesystem scan; refresh the status cache
+      // in-memory (short TTL, same as getOutputStyleStatusCached) so reads
+      // during the debounce window see the just-selected style.
+      const freshStatus = { configured: selected.id, current: selected, styles: before.styles };
+      outputStyleStatusCache = freshStatus;
+      outputStyleStatusCacheAt = performance.now();
+      outputStyleStatusCacheDir = resolve(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR);
       const hasConversation = sessionHasConversationMessages(session);
       let appliedToCurrentSession = !hasConversation;
       if (session?.id && !hasConversation) {
-        mgr.closeSession(session.id, 'cli-output-style-switch');
+        const closedSessionId = session.id;
+        mgr.closeSession(closedSessionId, 'cli-output-style-switch');
         session = null;
-        await recreateCurrentSessionIfReady();
+        // Defer the recreate so the output-style picker can repaint first;
+        // any failure still surfaces via the existing notice path.
+        setTimeout(() => {
+          recreateCurrentSessionIfReady().catch((err) => {
+            try {
+              notifyFnForSession(closedSessionId)(
+                `Failed to start a new session after output style change: ${err?.message || err}`,
+                { level: 'error' },
+              );
+            } catch {}
+          });
+        }, 0);
       }
       invalidateContextStatusCache();
-      return { ...getOutputStyleStatusCached({ fresh: true }), appliedToCurrentSession };
+      return { ...freshStatus, appliedToCurrentSession };
     },
     async setWorkflow(workflowId) {
       const id = normalizeWorkflowId(workflowId, DEFAULT_WORKFLOW_ID);
@@ -5389,6 +3930,18 @@ function parsedProviderModelVersion(id) {
         return { result, session };
       } catch (error) {
         hooks.emit('turn:error', { sessionId: session?.id || null, elapsedMs: Date.now() - startedAt, error: error?.message || String(error) });
+        // StopFailure: bridge a turn error to the standard hook bus. Spec:
+        // output + exit code ignored, so pure fire-and-forget. error_type is a
+        // simple regex mapping from the error message (default 'unknown').
+        try {
+          const msg = String(error?.message || error || '').toLowerCase();
+          const errorType = /rate.?limit|429|too many requests/.test(msg) ? 'rate_limit'
+            : /overloaded|529/.test(msg) ? 'overloaded'
+            : /authenticat|unauthorized|401|invalid.*api.?key/.test(msg) ? 'authentication_failed'
+            : /server.?error|5\d\d|internal error/.test(msg) ? 'server_error'
+            : 'unknown';
+          void hooks.dispatch('StopFailure', hookCommonPayload({ session_id: session?.id || null, error_type: errorType }));
+        } catch { /* best-effort: StopFailure hook must never break teardown */ }
         throw error;
       } finally {
         activeTurnCount = Math.max(0, activeTurnCount - 1);
@@ -5415,7 +3968,14 @@ function parsedProviderModelVersion(id) {
       if (activeTurnCount > 0) {
         return { changed: false, reason: 'compact skipped: turn in progress' };
       }
+      // Manual compact bypasses loop.mjs, so its PreCompact/PostCompact never
+      // fire here — dispatch them explicitly via the session-property hooks
+      // (wired at session create). Best-effort; a hook must not block compaction.
+      try { await session.preCompactHook?.({ trigger: 'manual' }); }
+      catch { /* best-effort: PreCompact hook must never break manual compact */ }
       const result = await mgr.compactSessionMessages(session.id);
+      try { await session.postCompactHook?.({ trigger: 'manual' }); }
+      catch { /* best-effort: PostCompact hook must never break manual compact */ }
       session = mgr.getSession(session.id) || session;
       if (options.recoverAgent === true) {
         try { agentTool.recoverWorkers?.({ clientHostPid: session?.clientHostPid || process.pid }); } catch {}
@@ -5587,9 +4147,15 @@ function parsedProviderModelVersion(id) {
       const removed = registryRemovePlugin(key, { dataDir });
       const nextConfig = { ...config };
       const serverName = pluginMcpServerName(plugin);
-      if (nextConfig.mcpServers && Object.prototype.hasOwnProperty.call(nextConfig.mcpServers, serverName)) {
+      const prefix = `${serverName}--`;
+      const hasMatch = nextConfig.mcpServers && Object.keys(nextConfig.mcpServers).some(
+        (k) => k === serverName || k.startsWith(prefix)
+      );
+      if (hasMatch) {
         const current = { ...nextConfig.mcpServers };
-        delete current[serverName];
+        for (const k of Object.keys(current)) {
+          if (k === serverName || k.startsWith(prefix)) delete current[k];
+        }
         saveConfigAndAdopt({ ...nextConfig, mcpServers: current });
         await connectConfiguredMcp({ reset: true });
         invalidatePreSessionToolSurface();
@@ -5602,22 +4168,50 @@ function parsedProviderModelVersion(id) {
       const root = clean(plugin.root);
       const script = clean(plugin.mcpScript);
       if (!root || !script) throw new Error('plugin has no MCP script');
-      const scriptPath = join(root, script);
-      if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
       const serverName = pluginMcpServerName(plugin);
       const nextConfig = { ...config };
-      nextConfig.mcpServers = {
-        ...(nextConfig.mcpServers || {}),
-        [serverName]: {
-          command: 'node',
-          args: [scriptPath],
-          cwd: root,
-          env: {
+      if (script === '.mcp.json') {
+        const mcpJsonPath = join(root, script);
+        if (!existsSync(mcpJsonPath)) throw new Error(`plugin MCP manifest not found: ${mcpJsonPath}`);
+        const manifest = readJsonSafe(mcpJsonPath) || {};
+        const rawServers = manifest.mcpServers;
+        const isPlainObject = (v) => v !== null && typeof v === 'object' && !Array.isArray(v);
+        if (!isPlainObject(rawServers)) throw new Error(`plugin .mcp.json missing mcpServers object: ${mcpJsonPath}`);
+        const keys = Object.keys(rawServers).filter((k) => isPlainObject(rawServers[k]));
+        if (!keys.length) throw new Error(`plugin .mcp.json has no mcpServers: ${mcpJsonPath}`);
+        const ownedPrefix = `${serverName}--`;
+        const nextServers = {};
+        for (const [k, v] of Object.entries(nextConfig.mcpServers || {})) {
+          if (k === serverName || k.startsWith(ownedPrefix)) continue;
+          nextServers[k] = v;
+        }
+        for (const serverKey of keys) {
+          const cfg = normalizePluginMcpServerConfig(rawServers[serverKey], root);
+          cfg.env = {
+            ...(cfg.env || {}),
             MIXDOG_PLUGIN_ROOT: root,
             MIXDOG_PLUGIN_DATA: join(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
+          };
+          const key = keys.length === 1 ? serverName : `${serverName}--${serverKey}`;
+          nextServers[key] = cfg;
+        }
+        nextConfig.mcpServers = nextServers;
+      } else {
+        const scriptPath = join(root, script);
+        if (!existsSync(scriptPath)) throw new Error(`plugin MCP script not found: ${scriptPath}`);
+        nextConfig.mcpServers = {
+          ...(nextConfig.mcpServers || {}),
+          [serverName]: {
+            command: 'node',
+            args: [scriptPath],
+            cwd: root,
+            env: {
+              MIXDOG_PLUGIN_ROOT: root,
+              MIXDOG_PLUGIN_DATA: join(cfgMod.getPluginData?.() || STANDALONE_DATA_DIR, 'plugins', 'data', clean(plugin.id || plugin.name || serverName)),
+            },
           },
-        },
-      };
+        };
+      }
       saveConfigAndAdopt(nextConfig);
       const status = await connectConfiguredMcp({ reset: true });
       invalidatePreSessionToolSurface();
@@ -5801,10 +4395,28 @@ function parsedProviderModelVersion(id) {
     async close(reason = 'cli-exit', options = {}) {
       const detach = options?.detach === true || options?.wait === false || options?.waitForExit === false;
       closeRequested = true;
+      // SessionEnd: bridge teardown to the standard hook bus. reason mapped to
+      // standard values ('clear'/'exit' where applicable, else 'other'). Short
+      // await guard so a slow hook cannot wedge teardown; best-effort.
+      try {
+        const rl = String(reason || '').toLowerCase();
+        const endReason = /clear/.test(rl) ? 'clear'
+          : /exit|quit|cli-exit|shutdown|sigint|sigterm/.test(rl) ? 'exit'
+          : 'other';
+        if (session?.id) {
+          await withTeardownDeadline(
+            Promise.resolve(hooks.dispatch('SessionEnd', hookCommonPayload({ session_id: session.id, reason: endReason }))).catch(() => {}),
+            300,
+            undefined,
+          );
+        }
+      } catch { /* best-effort: SessionEnd hook must never wedge teardown */ }
       // Persist any change that is still sitting in the debounce window so a
       // toggle made right before exit is not lost. Synchronous + best-effort:
       // teardown must continue even if the final write fails.
       try { flushConfigSave(); } catch {}
+      try { flushBackendSave(); } catch {}
+      try { flushOutputStyleSave(); } catch {}
       if (channelStartTimer) {
         clearTimeout(channelStartTimer);
         channelStartTimer = null;