@markus-global/cli 0.8.5 → 0.9.0-rc.0

package/dist/commands/start.js

@@ -3,7 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { createRequire } from 'node:module';
 import { allTemplateDirs, resolveTemplatesDir, resolveWebUiDir } from '../paths.js';
-import { loadConfig, getDefaultConfigPath, createLogger, closeRuntimeLogger, checkForUpdate, userId, TRIAGE_MAX_TOKENS, TRIAGE_TEMPERATURE, TRIAGE_ALLOWED_TOOLS, } from '@markus/shared';
+import { loadConfig, saveConfig, getDefaultConfigPath, createLogger, closeRuntimeLogger, checkForUpdate, userId, PROVIDERS, } from '@markus/shared';
 import { AgentManager, LLMRouter, LLMLogger, ModelCatalogService, RoleLoader, createDefaultSkillRegistry, ExternalAgentGateway, } from '@markus/core';
 import { OrganizationService, TaskService, APIServer, HITLService, BillingService, LicenseService, TelemetryService, AuditService, ProjectService, RequirementService, KnowledgeService, FileKnowledgeStore, DeliverableService, ReportService, TrustService, ArchiveService, StaleDetector, ScheduledTaskRunner, initStorage, searchRegistries, installSkill, WorkflowService, WorkflowRunner, WorkflowScheduler, } from '@markus/org-manager';
 import { MessageRouter, FeishuAdapter, WebUIAdapter } from '@markus/comms';
@@ -40,128 +40,134 @@ export async function createServices(config) {
     const providerConfigs = {};
     let defaultProvider = config.llm.defaultProvider;
     const llmTimeoutMs = Number(process.env['LLM_TIMEOUT_MS']) || config.llm.timeoutMs || undefined;
-    const anthropicKey = config.llm.providers['anthropic']?.apiKey ?? process.env['ANTHROPIC_API_KEY'];
-    if (anthropicKey) {
-        providerConfigs['anthropic'] = {
-            provider: 'anthropic',
-            model: config.llm.providers['anthropic']?.model ?? config.llm.defaultModel,
-            apiKey: anthropicKey,
-            timeoutMs: llmTimeoutMs,
-        };
-    }
-    const openaiKey = config.llm.providers['openai']?.apiKey ?? process.env['OPENAI_API_KEY'];
-    if (openaiKey) {
-        providerConfigs['openai'] = {
-            provider: 'openai',
-            model: config.llm.providers['openai']?.model ?? process.env['OPENAI_MODEL'] ?? 'gpt-5.4',
-            apiKey: openaiKey,
-            timeoutMs: llmTimeoutMs,
-        };
-    }
-    const siliconflowKey = config.llm.providers['siliconflow']?.apiKey ?? process.env['SILICONFLOW_API_KEY'];
-    if (siliconflowKey) {
-        providerConfigs['siliconflow'] = {
-            provider: 'siliconflow',
-            model: config.llm.providers['siliconflow']?.model ?? process.env['SILICONFLOW_MODEL'] ?? 'Qwen/Qwen3.5-35B-A3B',
-            apiKey: siliconflowKey,
-            baseUrl: config.llm.providers['siliconflow']?.baseUrl ??
-                process.env['SILICONFLOW_BASE_URL'] ??
-                'https://api.siliconflow.cn/v1',
-            timeoutMs: llmTimeoutMs,
-        };
-        if (config.llm.defaultProvider === 'siliconflow') {
-            defaultProvider = 'siliconflow';
+    const providerMeta = new Map(PROVIDERS.map((p) => [p.id, p]));
+    const envPrefix = (id) => id.toUpperCase().replace(/-/g, '_');
+    // Markus Cloud — OpenRouter member key only (chat + search).
+    const markusCfg = config.llm.providers['markus'] ?? {};
+    const markusOrKey = markusCfg.apiKey?.startsWith('sk-or-')
+        ? markusCfg.apiKey
+        : (markusCfg.apiKey && !/^markus[_-]/i.test(markusCfg.apiKey) ? markusCfg.apiKey : '');
+    if (markusOrKey) {
+        const cfgBaseUrl = markusCfg.baseUrl ?? '';
+        const markusOrBase = (cfgBaseUrl && !/localhost:8787|127\.0\.0\.1:8787|workers\.dev|markus-proxy/i.test(cfgBaseUrl))
+            ? cfgBaseUrl
+            : 'https://openrouter.ai/api/v1';
+        let markusModelsUrl = markusCfg.modelsUrl ?? process.env['MARKUS_MODELS_URL'] ?? '';
+        const hubBase = (config.hub?.url || process.env['MARKUS_HUB_URL'] || '').replace(/\/+$/, '');
+        if (!markusModelsUrl && hubBase) {
+            markusModelsUrl = `${hubBase}/api/models/live/markus`;
         }
-    }
-    const siliconflowIntlKey = config.llm.providers['siliconflow-intl']?.apiKey ?? process.env['SILICONFLOW_INTL_API_KEY'];
-    if (siliconflowIntlKey) {
-        providerConfigs['siliconflow-intl'] = {
-            provider: 'siliconflow',
-            model: config.llm.providers['siliconflow-intl']?.model ?? process.env['SILICONFLOW_INTL_MODEL'] ?? 'Qwen/Qwen3.5-35B-A3B',
-            apiKey: siliconflowIntlKey,
-            baseUrl: config.llm.providers['siliconflow-intl']?.baseUrl ??
-                process.env['SILICONFLOW_INTL_BASE_URL'] ??
-                'https://api-st.siliconflow.cn/v1',
-            timeoutMs: llmTimeoutMs,
-        };
-        if (config.llm.defaultProvider === 'siliconflow-intl') {
-            defaultProvider = 'siliconflow-intl';
+        if (markusModelsUrl && hubBase) {
+            try {
+                const mu = new URL(markusModelsUrl);
+                const hu = new URL(hubBase.includes('://') ? hubBase : `http://${hubBase}`);
+                if (mu.host !== hu.host) {
+                    markusModelsUrl = `${hubBase}/api/models/live/markus`;
+                }
+            }
+            catch { /* keep */ }
         }
-    }
-    const minimaxKey = config.llm.providers['minimax']?.apiKey ?? process.env['MINIMAX_API_KEY'];
-    if (minimaxKey) {
-        providerConfigs['minimax'] = {
-            provider: 'openai',
-            model: config.llm.providers['minimax']?.model ?? process.env['MINIMAX_MODEL'] ?? 'MiniMax-M3',
-            apiKey: minimaxKey,
-            baseUrl: config.llm.providers['minimax']?.baseUrl ??
-                process.env['MINIMAX_BASE_URL'] ??
-                'https://api.minimax.io/v1',
-            timeoutMs: llmTimeoutMs,
-        };
-        if (config.llm.defaultProvider === 'minimax') {
-            defaultProvider = 'minimax';
+        const prev = markusCfg;
+        const needPersist = (markusModelsUrl && markusModelsUrl !== (prev.modelsUrl ?? ''))
+            || (markusOrBase && markusOrBase !== (prev.baseUrl ?? ''))
+            || (markusOrKey && markusOrKey !== (prev.apiKey ?? ''))
+            || !!(prev.subscriptionKey || prev.proxyUrl);
+        if (needPersist) {
+            try {
+                saveConfig({
+                    llm: {
+                        providers: {
+                            markus: {
+                                apiKey: markusOrKey,
+                                baseUrl: markusOrBase,
+                                ...(markusModelsUrl ? { modelsUrl: markusModelsUrl } : {}),
+                                ...(prev.model ? { model: prev.model } : {}),
+                            },
+                        },
+                    },
+                });
+                log.info('Persisted Markus OpenRouter credentials', {
+                    modelsUrl: markusModelsUrl,
+                    baseUrl: markusOrBase,
+                    hasOrKey: true,
+                });
+            }
+            catch (err) {
+                log.warn('Failed to persist Markus config', { error: String(err) });
+            }
         }
-    }
-    const minimaxCnKey = config.llm.providers['minimax-cn']?.apiKey ?? process.env['MINIMAX_CN_API_KEY'];
-    if (minimaxCnKey) {
-        providerConfigs['minimax-cn'] = {
-            provider: 'openai',
-            model: config.llm.providers['minimax-cn']?.model ?? process.env['MINIMAX_CN_MODEL'] ?? 'MiniMax-M3',
-            apiKey: minimaxCnKey,
-            baseUrl: config.llm.providers['minimax-cn']?.baseUrl ??
-                process.env['MINIMAX_CN_BASE_URL'] ??
-                'https://api.minimaxi.com/v1',
-            timeoutMs: llmTimeoutMs,
-        };
-        if (config.llm.defaultProvider === 'minimax-cn') {
-            defaultProvider = 'minimax-cn';
+        process.env['MARKUS_OPENROUTER_KEY'] = markusOrKey;
+        process.env['MARKUS_OPENROUTER_BASE'] = markusOrBase;
+        delete process.env['MARKUS_SUBSCRIPTION_KEY'];
+        delete process.env['MARKUS_PROXY_URL'];
+        delete process.env['MARKUS_SEARCH_URL'];
+        if (markusModelsUrl && !process.env['MARKUS_MODELS_URL']) {
+            process.env['MARKUS_MODELS_URL'] = markusModelsUrl;
         }
-    }
-    const openrouterKey = config.llm.providers['openrouter']?.apiKey ?? process.env['OPENROUTER_API_KEY'];
-    if (openrouterKey) {
-        providerConfigs['openrouter'] = {
-            provider: 'openrouter',
-            model: config.llm.providers['openrouter']?.model ?? process.env['OPENROUTER_MODEL'] ?? 'xiaomi/mimo-v2-pro',
-            apiKey: openrouterKey,
-            baseUrl: config.llm.providers['openrouter']?.baseUrl ??
-                process.env['OPENROUTER_BASE_URL'] ??
-                'https://openrouter.ai/api/v1',
+        providerConfigs['markus'] = {
+            provider: 'markus',
+            model: markusCfg.model ?? '',
+            apiKey: markusOrKey,
+            baseUrl: markusOrBase,
+            ...(markusModelsUrl ? { modelsUrl: markusModelsUrl } : {}),
             timeoutMs: llmTimeoutMs,
         };
-        if (config.llm.defaultProvider === 'openrouter') {
-            defaultProvider = 'openrouter';
-        }
     }
-    const zaiKey = config.llm.providers['zai']?.apiKey ?? process.env['ZAI_API_KEY'];
-    if (zaiKey) {
-        providerConfigs['zai'] = {
-            provider: 'zai',
-            model: config.llm.providers['zai']?.model ?? process.env['ZAI_MODEL'] ?? 'glm-5.1',
-            apiKey: zaiKey,
-            baseUrl: config.llm.providers['zai']?.baseUrl ??
-                process.env['ZAI_BASE_URL'] ??
-                'https://api.z.ai/api/paas/v4',
-            timeoutMs: llmTimeoutMs,
-        };
-        if (config.llm.defaultProvider === 'zai') {
-            defaultProvider = 'zai';
+    else if (config.llm.defaultProvider === 'markus') {
+        log.warn('Markus Cloud AI is set as the default provider but no OpenRouter member key is configured. ' +
+            'Sign in to Markus Hub to obtain credentials.');
+    }
+    // Load every provider from markus.json (+ env fallbacks). Previously only a
+    // hardcoded subset was wired on boot, so Google/Ollama/DashScope/custom
+    // providers saved via Settings vanished after restart (#244).
+    const candidateNames = new Set([
+        ...Object.keys(config.llm.providers ?? {}),
+        ...PROVIDERS.map((p) => p.id),
+    ]);
+    candidateNames.delete('markus');
+    for (const name of candidateNames) {
+        const cfg = config.llm.providers[name] ?? {};
+        const meta = providerMeta.get(name);
+        const prefix = envPrefix(name);
+        if (name === 'ollama') {
+            const baseUrl = cfg.baseUrl
+                ?? process.env['OLLAMA_BASE_URL']
+                ?? meta?.baseUrl;
+            const model = cfg.model
+                ?? process.env['OLLAMA_MODEL']
+                ?? meta?.defaultModel
+                ?? 'llama3';
+            if (baseUrl || cfg.model || process.env['OLLAMA_BASE_URL']) {
+                providerConfigs['ollama'] = {
+                    provider: 'ollama',
+                    model,
+                    ...(baseUrl ? { baseUrl } : {}),
+                    timeoutMs: llmTimeoutMs,
+                };
+            }
+            continue;
         }
-    }
-    const deepseekKey = config.llm.providers['deepseek']?.apiKey ?? process.env['DEEPSEEK_API_KEY'];
-    if (deepseekKey) {
-        providerConfigs['deepseek'] = {
-            provider: 'deepseek',
-            model: config.llm.providers['deepseek']?.model ?? process.env['DEEPSEEK_MODEL'] ?? 'deepseek-v4-flash',
-            apiKey: deepseekKey,
-            baseUrl: config.llm.providers['deepseek']?.baseUrl ??
-                process.env['DEEPSEEK_BASE_URL'] ??
-                'https://api.deepseek.com',
+        const apiKey = cfg.apiKey
+            ?? (meta ? process.env[meta.envKey] : undefined)
+            ?? process.env[`${prefix}_API_KEY`];
+        if (!apiKey)
+            continue;
+        const model = cfg.model
+            ?? process.env[`${prefix}_MODEL`]
+            ?? meta?.defaultModel
+            ?? (name === 'anthropic' ? config.llm.defaultModel : undefined)
+            ?? '';
+        const baseUrl = cfg.baseUrl
+            ?? process.env[`${prefix}_BASE_URL`]
+            ?? meta?.baseUrl;
+        providerConfigs[name] = {
+            // Name may be a known LLMProvider or a custom OpenAI-compatible id.
+            provider: name,
+            model,
+            apiKey,
+            ...(baseUrl ? { baseUrl } : {}),
             timeoutMs: llmTimeoutMs,
         };
-        if (config.llm.defaultProvider === 'deepseek') {
-            defaultProvider = 'deepseek';
-        }
     }
     // If the configured default provider has no API key, fall back to the first available one
     if (!providerConfigs[defaultProvider]) {
@@ -474,6 +480,20 @@ async function startServerCore(config, values, opts) {
     if (config.integrations?.search?.bochaApiKey && !process.env['BOCHA_API_KEY']) {
         process.env['BOCHA_API_KEY'] = config.integrations.search.bochaApiKey;
     }
+    // Markus-hosted search (OpenRouter member key): opt-out + BYOK disable list.
+    if (config.integrations?.search?.useMarkusHosted === false) {
+        process.env['MARKUS_SEARCH_ENABLED'] = '0';
+    }
+    if (config.integrations?.search?.markusSearchModel) {
+        process.env['MARKUS_SEARCH_OR_MODEL'] = config.integrations.search.markusSearchModel;
+    }
+    {
+        const s = config.integrations?.search ?? {};
+        const disabled = ['serper', 'tavily', 'bing', 'google', 'serpapi', 'brave', 'exa', 'bocha']
+            .filter(id => s[`${id}Enabled`] === false);
+        if (disabled.length)
+            process.env['SEARCH_DISABLED_PROVIDERS'] = disabled.join(',');
+    }
     const apiPort = Number(values['port']) || config.server.apiPort;
     const { orgService, taskService, agentManager, llmRouter, skillRegistry, hitlService, billingService, licenseService, telemetryService, auditService, bootstrapOwnerId, } = await createServices(config);
     progress?.complete(3, 'SQLite storage initialised');
@@ -673,17 +693,40 @@ async function startServerCore(config, values, opts) {
         if (builtinTeamsDir && existsSync(builtinTeamsDir)) {
             builderService.setBuiltinTeamTemplatesDir(builtinTeamsDir);
         }
+        builderService.ensureArtifactDirs();
         agentManager.setBuilderService(builderService);
     }
     const hubClient = apiServer.getHubClient();
     if (hubClient) {
         agentManager.setHubClient(hubClient);
     }
-    // Wire team/agent update callbacks for manager tools
+    // Wire team/agent update callbacks for manager + secretary tools
     agentManager.setTeamUpdater(async (teamId, data) => {
         const team = await orgService.updateTeam(teamId, data);
         return { id: teamId, name: team.name, description: team.description };
     });
+    agentManager.setTeamCreator(async (orgId, name, description) => {
+        const team = await orgService.createTeam(orgId, name, description);
+        // Same event POST /api/teams emits — Team Chat sidebar refreshes without a full page reload.
+        apiServer.getWSBroadcaster()?.broadcast({
+            type: 'chat:group_created',
+            payload: {
+                chatId: `group:${team.id}`,
+                name: team.name,
+                creatorId: '',
+                creatorName: '',
+                teamId: team.id,
+            },
+            timestamp: new Date().toISOString(),
+        });
+        return { id: team.id, name: team.name, description: team.description };
+    });
+    agentManager.setOrgTeamLister((orgId) => orgService.listTeams(orgId).map(t => ({
+        id: t.id,
+        name: t.name,
+        description: t.description,
+        memberAgentIds: t.memberAgentIds,
+    })));
     if (storage) {
         agentManager.setAgentConfigPersister(async (agentId, data) => {
             await storage.agentRepo.updateConfig(agentId, data);
@@ -717,6 +760,7 @@ async function startServerCore(config, values, opts) {
             targetUserId: ownerUserId,
             options: opts.options,
             allowFreeform: opts.allowFreeform,
+            questions: opts.questions,
             details: { priority: opts.priority, taskId: opts.relatedTaskId, taskTitle },
         });
     });
@@ -733,6 +777,16 @@ async function startServerCore(config, values, opts) {
             metadata: opts.metadata,
         });
     });
+    // Seed autonomous-run locale/timezone from the owner's stored preferences.
+    try {
+        const ownerIdentity = orgService.resolveHumanIdentity(ownerUserId);
+        if (ownerIdentity && (ownerIdentity.locale || ownerIdentity.timezone)) {
+            agentManager.setRuntimeViewerContext({ locale: ownerIdentity.locale, timezone: ownerIdentity.timezone });
+        }
+    }
+    catch (e) {
+        log.warn('Failed to seed runtime viewer context from owner preferences', { error: String(e) });
+    }
     // Ensure every agent has a main session on startup, then persist activity logs to it
     if (storage?.chatSessionRepo) {
         // Migrate legacy assistant messages that lack segments metadata
@@ -795,6 +849,42 @@ async function startServerCore(config, values, opts) {
                 log.warn('Failed to persist activity log', { agentId, error: String(e) });
             }
         });
+        // Heartbeat interval changed (by an agent via set_heartbeat_interval, or any
+        // in-process update): persist the new value so it survives restart.
+        agentManager.getEventBus().on('agent:heartbeat-interval-changed', async (evt) => {
+            const { agentId, intervalMs } = evt;
+            try {
+                await storage.agentRepo.updateConfig(agentId, { heartbeatIntervalMs: intervalMs });
+            }
+            catch (e) {
+                log.warn('Failed to persist heartbeat interval change', { agentId, error: String(e) });
+            }
+        });
+        // Team Chat right-panel open/collapse — deliver to the interacting user's UI.
+        agentManager.getEventBus().on('agent:ui-layout', (evt) => {
+            const event = evt;
+            try {
+                const payload = {
+                    agentId: event.agentId,
+                    action: event.action,
+                    ...(event.panel ? { panel: event.panel } : {}),
+                };
+                const wsEvent = {
+                    type: 'ui:right_panel',
+                    payload,
+                    timestamp: new Date().toISOString(),
+                };
+                if (event.targetUserId) {
+                    ws.sendToUser(event.targetUserId, wsEvent);
+                }
+                else {
+                    ws.broadcast(wsEvent);
+                }
+            }
+            catch (e) {
+                log.warn('Failed to broadcast ui-layout event', { agentId: event.agentId, error: String(e) });
+            }
+        });
         // notify_user: persist as regular chat message + WS broadcast + notification bell
         agentManager.getEventBus().on('agent:notify-user', async (evt) => {
             const { agentId, title, body, priority, taskId, requirementId, targetUserId } = evt;
@@ -1061,15 +1151,30 @@ async function startServerCore(config, values, opts) {
             durationMs: event.durationMs,
             success: event.success,
             detail: event.detail,
+            metadata: {
+                cost: event.cost ?? 0,
+                cuCost: event.cuCost,
+                provider: event.provider,
+                inputTokens: event.inputTokens,
+                outputTokens: event.outputTokens,
+            },
         });
         if (event.tokensUsed && event.type === 'llm_request') {
-            auditService.recordLLMUsage('default', agentId, Math.floor(event.tokensUsed * 0.7), Math.ceil(event.tokensUsed * 0.3));
+            const inputTok = event.inputTokens ?? Math.floor(event.tokensUsed * 0.7);
+            const outputTok = event.outputTokens ?? Math.ceil(event.tokensUsed * 0.3);
+            auditService.recordLLMUsage('default', agentId, inputTok, outputTok);
             billingService.recordUsage({
                 orgId: 'default',
                 agentId,
                 type: 'llm_tokens',
                 amount: event.tokensUsed,
-                metadata: { action: event.action },
+                metadata: {
+                    action: event.action,
+                    cuCost: event.cuCost,
+                    provider: event.provider,
+                    inputTokens: event.inputTokens,
+                    outputTokens: event.outputTokens,
+                },
             });
         }
         if (event.type === 'tool_call') {
@@ -1082,17 +1187,6 @@ async function startServerCore(config, values, opts) {
             });
         }
     });
-    billingService.setToolCallsTodayProvider(() => {
-        let total = 0;
-        for (const a of agentManager.listAgents()) {
-            try {
-                total += agentManager.getAgent(a.id).getUsageStats().toolCallsToday;
-            }
-            catch { /* not loaded */ }
-        }
-        return total;
-    });
-    agentManager.setToolCallLimitChecker(() => billingService.checkLimit('default', 'tool_call'));
     // Wire agent state changes to DB persistence + WS broadcast
     if (storage) {
         agentManager.setStateChangeHandler(async (agentId, state) => {
@@ -1282,27 +1376,11 @@ async function startServerCore(config, values, opts) {
                         }
                     },
                 });
-                // Wire TriageJudge — used as fallback when full-session deliberation
-                // (delegate.performDeliberation) is not triggered or returns null.
-                const triageProvider = agent.config.llmConfig?.modelMode === 'custom'
-                    ? agent.config.llmConfig.primary : undefined;
-                const triageSystemPrompt = 'You are a mailbox triage assistant. Output ONLY a single JSON object — no explanation, no markdown fences, no <think> tags. Start your response with {';
-                const triageCacheSegments = [{ content: triageSystemPrompt, cacheBreakpoint: true }];
-                agent.getAttentionController().setTriageJudge(async (prompt) => {
-                    const response = await llmRouter.chat({
-                        messages: [
-                            { role: 'system', content: triageSystemPrompt },
-                            { role: 'user', content: prompt },
-                        ],
-                        systemCacheSegments: triageCacheSegments,
-                        temperature: TRIAGE_TEMPERATURE,
-                        maxTokens: TRIAGE_MAX_TOKENS,
-                    }, triageProvider);
-                    return response.content;
-                });
                 // Wire LLM interrupt judge — evaluates whether to preempt current
                 // work when a new message arrives (e.g. "stop publishing", "pause that task").
                 // Only called when heuristics return 'continue' for ambiguous cases.
+                const triageProvider = agent.config.llmConfig?.modelMode === 'custom'
+                    ? agent.config.llmConfig.primary : undefined;
                 const interruptSystemPrompt = 'You are an attention interrupt judge. Decide whether to interrupt current work for a new incoming message. Reply with ONLY one word: continue, preempt, cancel, merge, or defer. Use "preempt" to pause (resume later) and "cancel" to permanently stop current work.';
                 const interruptCacheSegments = [{ content: interruptSystemPrompt, cacheBreakpoint: true }];
                 agent.getAttentionController().setLLMJudge(async (prompt) => {
@@ -1313,47 +1391,15 @@ async function startServerCore(config, values, opts) {
                         ],
                         systemCacheSegments: interruptCacheSegments,
                         temperature: 0.1,
-                        maxTokens: 32,
+                        // No maxTokens cap: a tight cap (e.g. 32) is fully consumed by a
+                        // reasoning model's hidden reasoning, leaving content empty so the
+                        // judge always degrades to 'continue'. The router fills the model's
+                        // real limit; the one-word answer stops the generation naturally.
                     }, triageProvider);
                     const raw = response.content.trim().toLowerCase();
                     const valid = ['continue', 'preempt', 'cancel', 'merge', 'defer'];
                     return valid.includes(raw) ? raw : 'continue';
                 });
-                // Wire triage chat function (fallback mini tool loop, used when
-                // performDeliberation is not available or deliberation is disabled).
-                // The attention controller prefers full-session deliberation via
-                // delegate.performDeliberation when available.
-                agent.getAttentionController().setTriageChatFn(async (messages, tools) => {
-                    const llmTools = tools?.map(t => ({
-                        name: t.name,
-                        description: t.description,
-                        inputSchema: t.inputSchema,
-                    }));
-                    const response = await llmRouter.chat({
-                        messages: messages,
-                        tools: llmTools,
-                        temperature: TRIAGE_TEMPERATURE,
-                        maxTokens: TRIAGE_MAX_TOKENS,
-                    }, triageProvider);
-                    return { content: response.content, toolCalls: response.toolCalls, reasoningContent: response.reasoningContent };
-                });
-                // Wire read-only triage tools from the agent's tool set
-                const triageToolMap = new Map();
-                const agentTools = agent.getTools();
-                for (const toolName of TRIAGE_ALLOWED_TOOLS) {
-                    const handler = agentTools.get(toolName);
-                    if (handler) {
-                        triageToolMap.set(toolName, {
-                            name: handler.name,
-                            description: handler.description,
-                            inputSchema: handler.inputSchema,
-                            execute: handler.execute.bind(handler),
-                        });
-                    }
-                }
-                if (triageToolMap.size > 0) {
-                    agent.getAttentionController().setTriageTools(triageToolMap);
-                }
             }
             catch { /* agent not found */ }
         };