mixdog 0.8.0 → 0.9.0

package/src/runtime/agent/orchestrator/config.mjs

@@ -1,9 +1,11 @@
 import { resolvePluginData } from '../../shared/plugin-paths.mjs';
 import { readSection, updateSection, getAgentApiKey, AGENT_PROVIDER_ENV } from '../../shared/config.mjs';
-import { OPENAI_COMPAT_PRESETS } from './providers/openai-compat.mjs';
-import { hasAnthropicOAuthCredentials } from './providers/anthropic-oauth.mjs';
-import { hasOpenAIOAuthCredentials } from './providers/openai-oauth.mjs';
-import { hasGrokOAuthCredentials } from './providers/grok-oauth.mjs';
+import { OPENAI_COMPAT_PRESETS } from './providers/openai-compat-presets.mjs';
+import {
+    hasAnthropicOAuthCredentials,
+    hasOpenAIOAuthCredentials,
+    hasGrokOAuthCredentials,
+} from './providers/oauth-credential-probes.mjs';
 
 // Thin wrapper around resolvePluginData so callers in this orchestrator tree
 // can import a single helper without reaching into shared/.
@@ -17,7 +19,7 @@ export function getPluginData() {
 // llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
 //
 // Every hidden maintenance slot carries a CONCRETE preset here, so
-// resolvePresetName() (bridge-llm) always resolves a model directly from
+// resolvePresetName() (agent-dispatch) always resolves a model directly from
 // `maint[slot]` — no shared `defaultPreset` fallback is needed or used.
 // Memory cycles + Lead helper fan-out (explore/cycle1/cycle2/cycle3) and
 // entry-driven dispatch (scheduler/webhook) all default to `haiku`. The three
@@ -28,13 +30,6 @@ export function getPluginData() {
 // scheduler/webhook still let a per-entry config.json model win first (the
 // caller passes it explicitly via opts.preset); the haiku default below only
 // applies when an entry omits its own model.
-export const DEFAULT_MAINTENANCE = Object.freeze({
-    explore: 'haiku',
-    memory: 'haiku',
-    scheduler: 'haiku',
-    webhook: 'haiku',
-});
-
 // Slots surfaced as tunable rows in the Maintenance Setup panel. This is the
 // UI / allow-list view (GET cleanup + POST validation) and is intentionally a
 // SUBSET of DEFAULT_MAINTENANCE: scheduler/webhook carry a per-entry model and
@@ -42,6 +37,56 @@ export const DEFAULT_MAINTENANCE = Object.freeze({
 // an entry omits its own model.
 export const MAINTENANCE_SLOTS = Object.freeze(['explore', 'memory']);
 
+// --- User profile (statusline /profile) -------------------------------------
+// Supported response languages for the /profile picker. `system` is the default
+// sentinel: it leaves the language unset so the model follows the user's locale
+// / written language (no forced "Always respond in X" injection). Each entry is
+// { id, label, prompt } — `prompt` is the human language name the prompt-side
+// wiring uses for "Always respond in <prompt>." Keep `system` first.
+export const PROFILE_LANGUAGES = Object.freeze([
+    { id: 'system', label: 'System (locale)', prompt: null },
+    { id: 'en', label: 'English', prompt: 'English' },
+    { id: 'ko', label: '한국어', prompt: 'Korean (한국어)' },
+    { id: 'ja', label: '日本語', prompt: 'Japanese (日本語)' },
+    { id: 'zh-Hans', label: '中文（简体）', prompt: 'Simplified Chinese (简体中文)' },
+    { id: 'zh-Hant', label: '中文（繁體）', prompt: 'Traditional Chinese (繁體中文)' },
+    { id: 'es', label: 'Español', prompt: 'Spanish (Español)' },
+    { id: 'fr', label: 'Français', prompt: 'French (Français)' },
+    { id: 'de', label: 'Deutsch', prompt: 'German (Deutsch)' },
+    { id: 'pt', label: 'Português', prompt: 'Portuguese (Português)' },
+    { id: 'ru', label: 'Русский', prompt: 'Russian (Русский)' },
+    { id: 'it', label: 'Italiano', prompt: 'Italian (Italiano)' },
+    { id: 'vi', label: 'Tiếng Việt', prompt: 'Vietnamese (Tiếng Việt)' },
+    { id: 'th', label: 'ภาษาไทย', prompt: 'Thai (ภาษาไทย)' },
+    { id: 'id', label: 'Bahasa Indonesia', prompt: 'Indonesian (Bahasa Indonesia)' },
+    { id: 'hi', label: 'हिन्दी', prompt: 'Hindi (हिन्दी)' },
+    { id: 'ar', label: 'العربية', prompt: 'Arabic (العربية)' },
+    { id: 'tr', label: 'Türkçe', prompt: 'Turkish (Türkçe)' },
+    { id: 'pl', label: 'Polski', prompt: 'Polish (Polski)' },
+    { id: 'nl', label: 'Nederlands', prompt: 'Dutch (Nederlands)' },
+    { id: 'uk', label: 'Українська', prompt: 'Ukrainian (Українська)' },
+]);
+
+const PROFILE_LANGUAGE_IDS = new Set(PROFILE_LANGUAGES.map((lang) => lang.id));
+const PROFILE_TITLE_MAX = 64;
+
+// Resolve a stored profile (or raw config fragment) into a stable shape:
+//   { title: string, language: <valid id> }
+// Unknown language ids fall back to 'system'; titles are trimmed/capped.
+export function normalizeProfileConfig(value = {}) {
+    const raw = value && typeof value === 'object' ? value : {};
+    const title = String(raw.title ?? raw.name ?? '').trim().slice(0, PROFILE_TITLE_MAX);
+    const requested = String(raw.language ?? raw.lang ?? 'system').trim();
+    const language = PROFILE_LANGUAGE_IDS.has(requested) ? requested : 'system';
+    return { title, language };
+}
+
+// Look up the catalog entry for a stored language id (defaults to 'system').
+export function profileLanguageEntry(languageId) {
+    const id = String(languageId || 'system');
+    return PROFILE_LANGUAGES.find((lang) => lang.id === id) || PROFILE_LANGUAGES[0];
+}
+
 // Map short Anthropic family labels to the full model ids used by the API.
 // Honors ANTHROPIC_DEFAULT_{OPUS|SONNET|HAIKU}_MODEL env overrides.
 const ANTHROPIC_FAMILY_MODEL = Object.freeze({
@@ -57,14 +102,37 @@ function resolveAnthropicFamilyModel(family) {
     return ANTHROPIC_FAMILY_MODEL[key] || null;
 }
 
+// Canonical maintenance defaults. Single source of truth — imported by
+// llm/index.mjs and setup-server.mjs so UI/runtime cannot drift from config.
+//
+// Each maintenance slot stores its model route DIRECTLY ({provider, model}) —
+// parity with `agents.<role>`. The old shape stored a preset NAME string (e.g.
+// "haiku") that had to be looked up in the config.presets array; that
+// indirection is the legacy path. agent-dispatch.resolveMaintenanceRoute still
+// accepts a legacy name string for backward compatibility, but new configs and
+// these defaults use the direct route. loadConfig() migrates any stored string
+// slot to a route on read (see migrateMaintenanceRoutes). The cycle1/2/3 memory
+// agents share ONE `memory` route via the `maintKey: 'memory'` override on
+// their hidden-role entries.
+const _HAIKU_ROUTE = Object.freeze({
+    provider: 'anthropic-oauth',
+    model: resolveAnthropicFamilyModel('haiku'),
+});
+export const DEFAULT_MAINTENANCE = Object.freeze({
+    explore: { ..._HAIKU_ROUTE },
+    memory: { ..._HAIKU_ROUTE },
+    scheduler: { ..._HAIKU_ROUTE },
+    webhook: { ..._HAIKU_ROUTE },
+});
+
 // Seed presets keyed by preset.name so workflow/maintenance references stay
 // consistent with the resolve-by-name lookup in presetKey().
 export const DEFAULT_PRESETS = Object.freeze([
-    Object.freeze({ id: 'haiku', name: 'HAIKU', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('haiku'), tools: 'full' }),
-    Object.freeze({ id: 'sonnet-mid', name: 'SONNET MID', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'medium', tools: 'full' }),
-    Object.freeze({ id: 'sonnet-high', name: 'SONNET HIGH', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'high', tools: 'full' }),
-    Object.freeze({ id: 'opus-mid', name: 'OPUS MID', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'medium', tools: 'full' }),
-    Object.freeze({ id: 'opus-high', name: 'OPUS HIGH', type: 'bridge', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'high', tools: 'full' }),
+    Object.freeze({ id: 'haiku', name: 'HAIKU', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('haiku'), tools: 'full' }),
+    Object.freeze({ id: 'sonnet-mid', name: 'SONNET MID', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'medium', tools: 'full' }),
+    Object.freeze({ id: 'sonnet-high', name: 'SONNET HIGH', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('sonnet'), effort: 'high', tools: 'full' }),
+    Object.freeze({ id: 'opus-mid', name: 'OPUS MID', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'medium', tools: 'full' }),
+    Object.freeze({ id: 'opus-high', name: 'OPUS HIGH', type: 'agent', provider: 'anthropic-oauth', model: resolveAnthropicFamilyModel('opus'), effort: 'high', tools: 'full' }),
 ]);
 function buildDefaultConfig(options = {}) {
     const detectCredentials = options.detectCredentials !== false;
@@ -77,18 +145,16 @@ function buildDefaultConfig(options = {}) {
             apiKey: apiKey || undefined,
         };
     }
-    // OAuth provider detection delegates to each provider module so the
-    // canonical credential loader (loadTokens / loadCredentials) is the
-    // single source of truth. WebSocket transport is on by default —
+    // OAuth provider detection uses lightweight credential probes so config
+    // load does not import provider runtimes or SDKs. WebSocket transport is on by default —
     // measured ~96% cross-session cache hit with delta payloads. Users who
     // need to force SSE (e.g. a corporate proxy blocking WSS) can set
     // `websocket: false` in mixdog-config.json (agent.providers.openai-oauth).
     providers['openai-oauth'] = { enabled: detectCredentials ? hasOpenAIOAuthCredentials() : false, websocket: true };
     providers['anthropic-oauth'] = { enabled: detectCredentials ? hasAnthropicOAuthCredentials() : false };
-    // Grok CLI OAuth ("Grok Build"). Like the other OAuth entries it is not
+    // Grok OAuth ("Grok Build"). Like the other OAuth entries it is not
     // stored in mixdog-config.json — enabled at runtime from the presence of
-    // either token source (own store or ~/.grok/auth.json) via
-    // hasGrokOAuthCredentials().
+    // Mixdog-owned credentials.
     providers['grok-oauth'] = { enabled: detectCredentials ? hasGrokOAuthCredentials() : false };
     // Local providers — opt-in via setup UI after HTTP ping confirms server is running
     providers.ollama = { enabled: false, baseURL: 'http://localhost:11434/v1' };
@@ -100,10 +166,65 @@ function hasKeys(value) {
     return !!value && typeof value === 'object' && !Array.isArray(value) && Object.keys(value).length > 0;
 }
 
+function normalizeSearchRoute(route) {
+    if (!route || typeof route !== 'object' || Array.isArray(route))
+        return null;
+    const provider = normalizeAgentProviderId(route.provider);
+    const model = String(route.model || '').trim();
+    if (!provider || !model)
+        return null;
+    const out = { provider, model };
+    const effort = String(route.effort || '').trim();
+    if (effort)
+        out.effort = effort;
+    if (route.fast === true)
+        out.fast = true;
+    const toolType = String(route.toolType || '').trim();
+    if (toolType)
+        out.toolType = toolType;
+    return out;
+}
+
+// Migrate stored maintenance slots from the legacy preset-NAME string shape to
+// the direct {provider, model} route shape. A slot value that is already a
+// route object is normalized (provider/model/effort/fast only); a string value
+// is resolved against the config.presets array (the legacy lookup) and rewritten
+// to a route. Unresolvable strings are dropped so the DEFAULT_MAINTENANCE route
+// fills the slot. `presets` is the normalized preset array for legacy lookup.
+function migrateMaintenanceRoutes(rawMaint, presets) {
+    const out = {};
+    const list = Array.isArray(presets) ? presets : [];
+    for (const [slot, value] of Object.entries(rawMaint || {})) {
+        if (value && typeof value === 'object' && !Array.isArray(value)) {
+            const provider = normalizeAgentProviderId(value.provider);
+            const model = String(value.model || '').trim();
+            if (provider && model) {
+                const route = { provider, model };
+                const effort = String(value.effort || '').trim();
+                if (effort) route.effort = effort;
+                if (value.fast === true) route.fast = true;
+                out[slot] = route;
+            }
+            continue;
+        }
+        const name = String(value || '').trim();
+        if (!name) continue;
+        const preset = list.find(p => p && (p.id === name || p.name === name));
+        if (preset && preset.provider && preset.model) {
+            const route = { provider: preset.provider, model: preset.model };
+            if (preset.effort) route.effort = preset.effort;
+            if (preset.fast === true) route.fast = true;
+            out[slot] = route;
+        }
+        // Unresolvable legacy name → dropped; DEFAULT_MAINTENANCE route fills it.
+    }
+    return out;
+}
+
 // Persist the agent section. `build` receives the section value read INSIDE
 // the file lock (current on-disk state) and returns the full replacement.
 // Building from `current` rather than a snapshot taken before the lock keeps
-// the whole-section save linearizable: a concurrent writer (each Claude Code
+// the whole-section save linearizable: a concurrent writer (each host-agent
 // session runs its own server under MIXDOG_MULTI_INSTANCE) that lands between
 // our read and write is rebased onto, not silently clobbered (lost-update).
 function persistAgentConfig(build) {
@@ -169,7 +290,7 @@ export function loadConfig(options = {}) {
                 migratedMaintenance = true;
             }
             // Self-ref guard: mcpServers.mixdog / mcpServers["trib-plugin"]
-            // would self-spawn through the in-process tool bridge. Strip on
+            // would self-spawn through the in-process tool adapter. Strip on
             // ingress so user-edited configs cannot brick the agent boot.
             const mcpServers = (raw.mcpServers && typeof raw.mcpServers === 'object') ? { ...raw.mcpServers } : {};
             if (mcpServers['mixdog'] || mcpServers['trib-plugin']) {
@@ -239,22 +360,28 @@ export function loadConfig(options = {}) {
                 .filter(p => p.id !== 'workflow-search');
             const workflowRoutes = raw.workflowRoutes && typeof raw.workflowRoutes === 'object' ? { ...raw.workflowRoutes } : {};
             delete workflowRoutes.search;
+            // Migrate legacy preset-name maintenance slots to direct routes,
+            // then overlay onto the route-shaped defaults.
+            const migratedMaint = migrateMaintenanceRoutes(rawMaint, normalizedPresets);
             return {
                 providers: mergedProviders,
                 mcpServers,
                 presets: normalizedPresets,
                 default: raw.default || null,
-                maintenance: { ...DEFAULT_MAINTENANCE, ...rawMaint },
+                maintenance: { ...DEFAULT_MAINTENANCE, ...migratedMaint },
                 workflowRoutes,
+                searchRoute: normalizeSearchRoute(raw.searchRoute),
                 fastModels: raw.fastModels && typeof raw.fastModels === 'object' ? raw.fastModels : {},
                 modelSettings: raw.modelSettings && typeof raw.modelSettings === 'object' ? raw.modelSettings : {},
                 onboarding: raw.onboarding && typeof raw.onboarding === 'object' ? raw.onboarding : {},
                 agents: raw.agents && typeof raw.agents === 'object' ? raw.agents : {},
                 workflow: raw.workflow && typeof raw.workflow === 'object' ? { active: String(raw.workflow.active || 'default') } : { active: 'default' },
                 agentMaintenance: { enabled: true, interval: '1h', ...raw.agentMaintenance },
+                profile: normalizeProfileConfig(raw.profile),
                 autoClear: { enabled: true, idleMs: 60 * 60 * 1000, ...raw.autoClear },
+                compaction: raw.compaction && typeof raw.compaction === 'object' ? { ...raw.compaction } : {},
                 trajectory: { enabled: true, ...raw.trajectory },
-                bridge: raw.bridge && typeof raw.bridge === 'object' ? raw.bridge : {},
+                runtime: raw.runtime && typeof raw.runtime === 'object' ? raw.runtime : {},
                 shell: raw.shell && typeof raw.shell === 'object' ? raw.shell : {},
             };
         }
@@ -268,15 +395,18 @@ export function loadConfig(options = {}) {
         default: null,
         maintenance: { ...DEFAULT_MAINTENANCE },
         workflowRoutes: {},
+        searchRoute: null,
         fastModels: {},
         modelSettings: {},
         onboarding: {},
         agents: {},
         workflow: { active: 'default' },
         agentMaintenance: { enabled: true, interval: '1h' },
+        profile: normalizeProfileConfig(null),
         autoClear: { enabled: true, idleMs: 60 * 60 * 1000 },
+        compaction: {},
         trajectory: { enabled: true },
-        bridge: {},
+        runtime: {},
         shell: {},
     };
 }
@@ -293,8 +423,8 @@ export function loadConfig(options = {}) {
  * maintenance/...) are replaced from the passed snapshot (last-writer-wins);
  * only unmanaged keys are rebased on the in-lock current. Safe only for a
  * caller holding a fresh full config. For a single-field change, patch in-lock
- * via persistAgentConfig((current) => ({ ...current, <field> })) — see
- * setDefaultPreset — so a concurrent instance's edits are not reverted.
+ * via persistAgentConfig((current) => ({ ...current, <field> })) so a
+ * concurrent instance's edits are not reverted.
  */
 export function saveConfig(config) {
     // Strip ephemeral defaults from providers but preserve any unknown
@@ -339,20 +469,23 @@ export function saveConfig(config) {
         default: config.default || null,
         maintenance: config.maintenance || {},
         workflowRoutes,
+        searchRoute: normalizeSearchRoute(config.searchRoute),
         fastModels: config.fastModels || {},
         modelSettings: config.modelSettings || {},
         onboarding: config.onboarding || {},
         agents: config.agents || {},
         workflow: config.workflow || { active: 'default' },
         agentMaintenance: config.agentMaintenance || {},
+        profile: normalizeProfileConfig(config.profile),
         autoClear: config.autoClear || {},
+        compaction: config.compaction || {},
         trajectory: config.trajectory || {},
-        bridge: config.bridge || {},
+        runtime: config.runtime || {},
         shell: config.shell || {},
     }));
 }
 // --- Preset helpers ---
-// preset shape: { id, name, type: 'bridge', provider, model, effort?, fast?, tools? }
+// preset shape: { id, name, type: 'agent', provider, model, effort?, fast?, tools? }
 const AGENT_PROVIDER_ALIASES = Object.freeze({
     'openai-api': 'openai',
     'gemini-api': 'gemini',
@@ -377,7 +510,7 @@ function normalizePreset(preset) {
     const model = String(preset.model || '').trim();
     const provider = normalizeAgentProviderId(preset.provider);
     if (!name || !model || !provider) return null;
-    const out = { id, name, type: 'bridge', provider, model };
+    const out = { id, name, type: 'agent', provider, model };
     if (preset.effort)
         out.effort = String(preset.effort).trim();
     if (preset.fast === true && FAST_CAPABLE_PRESET_PROVIDERS.has(provider))
@@ -413,34 +546,20 @@ export function listPresets(config) {
 // (both cache shards are identical there), while swapping the model itself
 // legitimately needs a fresh session (cache shard is model-specific). Two
 // presets mapping to the same (provider, model) therefore collapse into
-// one Bridge session, so opus-mid / opus-max no longer fragment the pool.
+// one Agent session, so opus-mid / opus-max no longer fragment the pool.
 //
-//   bridge lane: "bridge:<agentId>:<provider>:<model>"  — per Sub role
-//   other lane:  "bridge:<provider>:<model>"            — shared utility
+//   agent lane: "agent:<agentId>:<provider>:<model>"  — per Sub role
+//   other lane: "agent:<provider>:<model>"            — shared utility
 export function resolveRuntimeSpec(preset, ctx) {
-    const lane = ctx.lane || 'bridge';
+    const lane = ctx.lane || 'agent';
     const provider = String(preset?.provider || '').trim() || 'unknown';
     const model = String(preset?.model || '').trim() || '_';
     let scopeKey;
-    if (lane === 'bridge') {
-        if (!ctx.agentId) throw new Error('bridge lane requires agentId');
-        scopeKey = `bridge:${ctx.agentId}:${provider}:${model}`;
+    if (lane === 'agent') {
+        if (!ctx.agentId) throw new Error('agent lane requires agentId');
+        scopeKey = `agent:${ctx.agentId}:${provider}:${model}`;
     } else {
-        scopeKey = `bridge:${provider}:${model}`;
+        scopeKey = `agent:${provider}:${model}`;
     }
     return { lane, scopeKey, reuse: true, preset };
 }
-
-export function setDefaultPreset(config, key) {
-    const preset = getPreset(config, key);
-    if (!preset)
-        throw new Error(`preset "${key}" not found`);
-    const nextDefault = presetKey(preset);
-    // Patch only `default` under the file lock. saveConfig(config) would
-    // rewrite the whole agent section from this possibly-stale snapshot and
-    // could revert a concurrent instance's preset edits; an in-lock single
-    // field patch cannot.
-    persistAgentConfig((current) => ({ ...current, default: nextDefault }));
-    config.default = nextDefault;
-    return preset;
-}