@kinqs/brainrouter-cli 0.3.7 → 0.3.8

package/dist/cli/ink/toolFormat.js

@@ -11,7 +11,7 @@
  *
  * — one-line, identity-revealing, no JSON. These helpers do the same
  * mapping for our built-in LOCAL_TOOLS (cli/../agent/agent.ts) + MCP
- * tool names (which carry an `mcp__<server>__` namespace prefix that
+ * tool names (which carry an `mcp_<server>_` namespace prefix that
  * the user doesn't care about).
  *
  * Reference for the convention: claude-code transcripts (see
@@ -28,10 +28,12 @@
  *     → "Bash(npm test)"
  *   formatToolCall('grep_search', { query: 'authenticate', path: '.' })
  *     → 'Grep("authenticate")'
- *   formatToolCall('mcp__brainrouter__memory_search', { q: 'auth' })
+ *   formatToolCall('mcp_brainrouter_memory_search', { q: 'auth' })
  *     → 'MemorySearch("auth")'
  *   formatToolCall('spawn_agent', { role: 'researcher', prompt: '...' })
  *     → 'Spawn(researcher, "...")'
+ *   formatToolCall('task_agent', { role: 'reviewer', prompt: '...' })
+ *     → 'Task(reviewer, "...")'
  */
 export function formatToolCall(name, args) {
     const safeArgs = args ?? {};
@@ -69,6 +71,18 @@ export function formatToolCall(name, args) {
             const task = truncateOneLine(safeArgs.prompt ?? '', 50);
             return `Spawn(${role}${label}, "${task}")`;
         }
+        case 'task_agent': {
+            const role = String(safeArgs.role ?? safeArgs.agentId ?? 'agent');
+            const label = safeArgs.label ? ` [${safeArgs.label}]` : '';
+            const task = truncateOneLine(safeArgs.prompt ?? '', 50);
+            return `Task(${role}${label}, "${task}")`;
+        }
+        case 'delegate_agent': {
+            const role = String(safeArgs.role ?? safeArgs.agentId ?? 'agent');
+            const label = safeArgs.label ? ` [${safeArgs.label}]` : '';
+            const task = truncateOneLine(safeArgs.prompt ?? '', 50);
+            return `Delegate(${role}${label}, "${task}")`;
+        }
         case 'spawn_agents': {
             const agents = Array.isArray(safeArgs.agents) ? safeArgs.agents : [];
             const roles = agents.map((a) => String(a?.role ?? 'agent')).join(', ');
@@ -89,23 +103,35 @@ export function formatToolCall(name, args) {
     // No args, or no string args — just show the name.
     return `${pretty}()`;
 }
+// Server ids registered at boot. MCP server names may contain underscores
+// (`my_server`), so a naive `^mcp_[^_]+_(.+)$` regex would mis-strip
+// `mcp_my_server_memory_search` to `server_memory_search`. Callers that
+// know the live server inventory register it here so `stripMcpPrefix` can
+// match the longest known id first.
+let knownMcpServerIds = [];
+export function setKnownMcpServerIds(ids) {
+    knownMcpServerIds = [...ids].sort((a, b) => b.length - a.length);
+}
 /**
- * Strip the `mcp__<server>__` or `mcp_<server>_` namespace prefix from MCP tool
- * names. Server ids may contain underscores (e.g. `my_server`), so the
- * double-underscore form uses a lazy match. Both prefix conventions are in use
- * across the multi-MCP codepaths until naming is unified.
- *   `mcp__brainrouter__memory_search` → `memory_search`
- *   `mcp__my_server__memory_search`    → `memory_search`
- *   `mcp_brainrouter_memory_search`    → `memory_search`
+ * Strip the `mcp_<server>_` namespace prefix from MCP tool names. As of
+ * 0.3.8-R5 the pool normalises to single-underscore at the boundary, so
+ * downstream call-sites only ever see this shape.
+ *   `mcp_brainrouter_memory_search` → `memory_search`
+ *   `mcp_my_server_memory_search`   → `memory_search` (when `my_server`
+ *                                     is registered via `setKnownMcpServerIds`)
  */
 export function stripMcpPrefix(name) {
-    const dbl = name.match(/^mcp__.+?__(.+)$/);
-    if (dbl)
-        return dbl[1];
-    const sgl = name.match(/^mcp_[^_]+_(.+)$/);
-    if (sgl)
-        return sgl[1];
-    return name;
+    if (!name.startsWith('mcp_'))
+        return name;
+    const rest = name.slice('mcp_'.length);
+    for (const id of knownMcpServerIds) {
+        if (rest.startsWith(`${id}_`))
+            return rest.slice(id.length + 1);
+    }
+    // Fallback when no server ids are registered (test fixtures, early boot):
+    // assume the server id has no underscores.
+    const idx = rest.indexOf('_');
+    return idx >= 0 ? rest.slice(idx + 1) : name;
 }
 /**
  * Convert snake_case to PascalCase for readable display names.

package/dist/cli/repl.d.ts

@@ -10,7 +10,7 @@ import type { ReplContext } from './commands/_context.js';
  * The Ink chat REPL (cli/ink/runChat.tsx) consumes this same list for its
  * inline slash palette so both surfaces stay in lockstep as new commands land.
  */
-export declare const SLASH_COMMANDS: readonly ["/help", "/status", "/workspace", "/where", "/tools", "/skills", "/plan", "/transcript", "/doctor", "/config", "/diff", "/commit", "/clear", "/compact", "/exit", "/quit", "/roles", "/agents", "/agent", "/spawn", "/wait", "/spec", "/feature-dev", "/grill-me", "/review", "/implement-plan", "/skill", "/workflow", "/workflows", "/approve", "/memory", "/recall", "/briefing", "/scenes", "/working", "/forget", "/init", "/login", "/sessions", "/resume", "/model", "/mcp", "/goal", "/copy", "/fork", "/rename", "/permissions", "/hooks", "/hookify", "/loop", "/continue", "/auto-review", "/vim", "/statusline", "/quiet", "/handover", "/explain", "/trace", "/failed", "/verify", "/audit", "/export", "/import", "/persona", "/skill-hints", "/diagnostics", "/tokens", "/watch", "/yolo", "/mode", "/review-policy", "/sandbox", "/kill", "/theme", "/title", "/personality", "/effort", "/new", "/side", "/btw", "/raw", "/feedback", "/rollout", "/ps", "/stop", "/logout", "/apps", "/plugins", "/experimental", "/memories", "/debug-config", "/mention", "/keymap", "/ide"];
+export declare const SLASH_COMMANDS: readonly ["/help", "/status", "/workspace", "/where", "/tools", "/skills", "/plan", "/transcript", "/doctor", "/config", "/diff", "/commit", "/clear", "/compact", "/exit", "/quit", "/roles", "/agents", "/agent", "/spawn", "/wait", "/spec", "/feature-dev", "/grill-me", "/review", "/implement-plan", "/skill", "/workflow", "/workflows", "/approve", "/memory", "/recall", "/briefing", "/scenes", "/working", "/forget", "/init", "/login", "/sessions", "/resume", "/model", "/mcp", "/goal", "/copy", "/fork", "/rename", "/permissions", "/hooks", "/hookify", "/loop", "/schedule", "/continue", "/auto-review", "/vim", "/statusline", "/quiet", "/release-notes", "/handover", "/explain", "/trace", "/failed", "/verify", "/audit", "/export", "/import", "/persona", "/skill-hints", "/diagnostics", "/tokens", "/watch", "/yolo", "/mode", "/review-policy", "/sandbox", "/kill", "/theme", "/title", "/personality", "/effort", "/new", "/side", "/btw", "/raw", "/feedback", "/rollout", "/ps", "/stop", "/logout", "/apps", "/plugins", "/experimental", "/memories", "/debug-config", "/mention", "/keymap", "/ide"];
 export declare function renderHelp(category?: string): void;
 /**
  * Look up a one-line description for a slash command by walking the

package/dist/cli/repl.js

@@ -15,6 +15,8 @@ import { tryHandleMcpCommand } from './commands/mcp.js';
 import { tryHandleInitCommand } from './commands/init.js';
 import { tryHandleConfigCommand } from './commands/config.js';
 import { tryHandleLoginCommand } from './commands/login.js';
+import { tryHandleScheduleCommand } from './commands/schedule.js';
+import { tryHandleReleaseNotesCommand } from './commands/releaseNotes.js';
 /**
  * All slash commands the REPL recognizes. Used for tab autocomplete and for
  * the readline completer. Keep alphabetically grouped roughly by surface area.
@@ -29,8 +31,8 @@ export const SLASH_COMMANDS = [
     '/spec', '/feature-dev', '/grill-me', '/review', '/implement-plan', '/skill', '/workflow', '/workflows', '/approve',
     '/memory', '/recall', '/briefing', '/scenes', '/working', '/forget',
     '/init', '/login', '/sessions', '/resume', '/model', '/mcp',
-    '/goal', '/copy', '/fork', '/rename', '/permissions', '/hooks', '/hookify', '/loop',
-    '/continue', '/auto-review', '/vim', '/statusline', '/quiet',
+    '/goal', '/copy', '/fork', '/rename', '/permissions', '/hooks', '/hookify', '/loop', '/schedule',
+    '/continue', '/auto-review', '/vim', '/statusline', '/quiet', '/release-notes',
     '/handover', '/explain', '/trace', '/failed', '/verify', '/audit',
     '/export', '/import', '/persona', '/skill-hints', '/diagnostics',
     '/tokens', '/watch', '/yolo', '/mode', '/review-policy', '/sandbox', '/kill',
@@ -173,6 +175,7 @@ const HELP_CATEGORIES = [
             { cmd: '/apps  /plugins', desc: 'List workspace skills and plugin folders' },
             { cmd: '/feedback [message]', desc: 'Append feedback entry' },
             { cmd: '/experimental [on|off]', desc: 'Toggle experimental features' },
+            { cmd: '/release-notes [version|list]', desc: 'Show changelog for current (or specified) CLI version' },
         ],
     },
 ];
@@ -263,6 +266,10 @@ export async function handleSlashCommand(command, args, agent, mcpClient, config
         return;
     if (await tryHandleWorkflowCommand(cmdCtx))
         return;
+    if (await tryHandleScheduleCommand(cmdCtx))
+        return;
+    if (await tryHandleReleaseNotesCommand(cmdCtx))
+        return;
     if (await tryHandleObsCommand(cmdCtx))
         return;
     if (await tryHandleOrchestrationCommand(cmdCtx))

package/dist/config/config.d.ts

@@ -26,7 +26,7 @@ export interface ServerConfig {
     identity?: 'brainrouter' | 'third-party';
 }
 export interface LLMConfig {
-    provider: 'openai';
+    provider: 'openai' | 'anthropic';
     apiKey: string;
     model: string;
     endpoint?: string;

package/dist/index.js

@@ -84,6 +84,7 @@ import chalk from 'chalk';
 import { loadConfig, loadOrInitConfig, saveConfig, getConfigPath } from './config/config.js';
 import { McpClientWrapper } from './runtime/mcpClient.js';
 import { McpClientPool, selectMcpServerIds } from './runtime/mcpPool.js';
+import { setKnownMcpServerIds } from './cli/ink/toolFormat.js';
 import { Agent } from './agent/agent.js';
 import { runChat } from './cli/ink/runChat.js';
 import { applyWorkspaceRoot, findWorkspaceRoot } from './config/workspace.js';
@@ -100,7 +101,7 @@ const program = new Command();
 program
     .name('brainrouter')
     .description('BrainRouter CLI — Premium interactive terminal-based agent client.')
-    .version('0.3.7');
+    .version('0.3.8');
 // Chat Command (default)
 program
     .command('chat', { isDefault: true })
@@ -197,6 +198,10 @@ program
     // comment); the banner's per-server row is the success signal.
     const mcpClient = new McpClientPool();
     const statuses = await mcpClient.connectAll(targetServers, llm, { timeoutMs: 5_000 });
+    // Register live server ids for Ink tool-name display so multi-word
+    // server names (e.g. `my_server`) don't get mis-stripped by the
+    // single-underscore prefix regex.
+    setKnownMcpServerIds(mcpClient.getServerIds());
     const failures = statuses.filter((s) => s.status === 'failed');
     if (failures.length === statuses.length) {
         // Every server failed — equivalent to the pre-0.3.7 "MCP
@@ -302,6 +307,10 @@ program
         llm.model = options.model;
     const mcpClient = new McpClientPool();
     const statuses = await mcpClient.connectAll(targetServers, llm, { timeoutMs: 5_000 });
+    // Register live server ids for Ink tool-name display so multi-word
+    // server names (e.g. `my_server`) don't get mis-stripped by the
+    // single-underscore prefix regex.
+    setKnownMcpServerIds(mcpClient.getServerIds());
     const allFailed = statuses.length > 0 && statuses.every((s) => s.status === 'failed');
     if (allFailed) {
         const summary = statuses.map((s) => `${s.serverId}: ${s.error ?? 'unknown'}`).join('; ');

package/dist/memory/briefing.js

@@ -1,5 +1,5 @@
 import { redactText } from '../state/sessionStore.js';
-import { callMcpTool } from '../runtime/mcpUtils.js';
+import { callMcpTool, hasMcpTool } from '../runtime/mcpUtils.js';
 /**
  * Run pre-turn memory queries in parallel and assemble a compact briefing block.
  * This is the System-1 entry point: every turn pays a small fixed cost to ask
@@ -11,13 +11,13 @@ export async function buildMemoryBriefing(inputs) {
     const maxChars = inputs.maxCharsPerSource ?? 4000;
     const toolNames = new Set(mcpTools.map((t) => t.name));
     const tasks = [];
-    if (toolNames.has('memory_recall')) {
+    if (hasMcpTool(toolNames, 'memory_recall')) {
         tasks.push(callSafe('memory_recall', { sessionKey, query, activeSkill }, mcpClient, maxChars, extractRecords));
     }
-    if (toolNames.has('memory_working_context')) {
+    if (hasMcpTool(toolNames, 'memory_working_context')) {
         tasks.push(callSafe('memory_working_context', { sessionKey, workspacePath: workspaceRoot }, mcpClient, maxChars));
     }
-    if (toolNames.has('memory_task_state') && !inputs.hasActiveGoal) {
+    if (hasMcpTool(toolNames, 'memory_task_state') && !inputs.hasActiveGoal) {
         tasks.push(callSafe('memory_task_state', { query }, mcpClient, maxChars));
     }
     const results = await Promise.all(tasks);

package/dist/orchestration/tools.d.ts

@@ -31,13 +31,26 @@ export interface OrchestrationContext {
     launchCwd: string;
     /** Called when a child output got offloaded — chars beyond preview that didn't land in parent context. */
     recordOffload?: (charsAvoided: number) => void;
-    /** Called when the child agent emits a tool call, for live observability. */
-    onChildToolEvent?: (event: {
+    /**
+     * Paired child tool lifecycle callbacks. Fire from the child agent's
+     * onToolStart / onToolEnd so the parent's REPL can render explicit
+     * "child began X" / "child finished X" rows in the scrollback — without
+     * these, long child runs look like the parent has frozen (roadmap §3).
+     */
+    onChildToolStart?: (event: {
+        childId: string;
+        role: string;
+        tool: string;
+        args: Record<string, any>;
+    }) => void;
+    onChildToolEnd?: (event: {
         childId: string;
         role: string;
         tool: string;
         ok: boolean;
         summary: string;
+        preview?: string;
+        durationMs: number;
     }) => void;
     /**
      * Called when a child agent's runTurn ends — success, fail, or empty answer.
@@ -117,6 +130,86 @@ export declare function createSpawnAgentTool(): {
         required: string[];
     };
 };
+export declare function createTaskAgentTool(): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            label: {
+                type: string;
+                description: string;
+            };
+            access: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            timeoutMs: {
+                type: string;
+                description: string;
+            };
+            seedRecordIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function createDelegateAgentTool(): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: {
+            role: {
+                type: string;
+                description: string;
+            };
+            agentId: {
+                type: string;
+                description: string;
+            };
+            prompt: {
+                type: string;
+                description: string;
+            };
+            label: {
+                type: string;
+                description: string;
+            };
+            access: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            seedRecordIds: {
+                type: string;
+                items: {
+                    type: string;
+                };
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
 export declare function createListAgentsTool(): {
     name: string;
     description: string;

package/dist/orchestration/tools.js

@@ -55,7 +55,16 @@ export function extractChildPreview(output, maxChars) {
     const tail = maxChars - head - 6; // 6 chars for the `\n...\n` divider
     return output.slice(0, head) + '\n…\n' + output.slice(-tail);
 }
+// Default wait/timeout for foreground delegation. Mirrors wait_agent's
+// historical 120 s default so task_agent and spawn_agent({ wait: true })
+// behave identically when no explicit timeoutMs is passed. Only used inside
+// handleTaskAgent (call-time); kept out of the schema-creator bodies to
+// avoid the ESM circular-import TDZ between tools.ts and agent.ts (agent.ts
+// constructs the LOCAL_TOOLS array eagerly at module load).
+const DEFAULT_TASK_AGENT_TIMEOUT_MS = 120_000;
 const ORCHESTRATION_TOOL_NAMES = new Set([
+    'task_agent',
+    'delegate_agent',
     'spawn_agent',
     'spawn_agents',
     'list_agents',
@@ -122,6 +131,54 @@ export function createSpawnAgentTool() {
         },
     };
 }
+export function createTaskAgentTool() {
+    return {
+        name: 'task_agent',
+        description: 'Run one foreground child agent for a bounded task and wait for its result. ' +
+            'Returns the completed child output, failure, or an explicit timeout envelope. Prefer this over spawn_agent({ wait: true }) for foreground delegation.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'One of: explorer, architect, reviewer, worker, verifier. Prefer agentId for custom definitions.' },
+                agentId: { type: 'string', description: 'Registry id of the agent definition. Takes precedence over role when both are provided.' },
+                prompt: { type: 'string', description: 'The bounded task prompt for the child agent.' },
+                label: { type: 'string', description: 'Optional short label for the child run.' },
+                access: { type: 'string', enum: ['read', 'write', 'shell'], description: 'Override the role default access mode. Default: role default.' },
+                timeoutMs: { type: 'integer', description: 'Optional timeout in milliseconds. Default 120000.' },
+                seedRecordIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional BrainRouter memory record IDs that the parent already recalled.',
+                },
+            },
+            required: ['prompt'],
+        },
+    };
+}
+export function createDelegateAgentTool() {
+    return {
+        name: 'delegate_agent',
+        description: 'Start one background child agent and keep working in the parent turn. ' +
+            'Non-blocking — there is no `timeoutMs`; the child runs until it finishes or is cancelled. ' +
+            'Returns a running child id plus a reminder to continue useful work; call wait_agent later when the result is needed.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                role: { type: 'string', description: 'One of: explorer, architect, reviewer, worker, verifier. Prefer agentId for custom definitions.' },
+                agentId: { type: 'string', description: 'Registry id of the agent definition. Takes precedence over role when both are provided.' },
+                prompt: { type: 'string', description: 'The bounded task prompt for the child agent.' },
+                label: { type: 'string', description: 'Optional short label for the child run.' },
+                access: { type: 'string', enum: ['read', 'write', 'shell'], description: 'Override the role default access mode. Default: role default.' },
+                seedRecordIds: {
+                    type: 'array',
+                    items: { type: 'string' },
+                    description: 'Optional BrainRouter memory record IDs that the parent already recalled.',
+                },
+            },
+            required: ['prompt'],
+        },
+    };
+}
 export function createListAgentsTool() {
     return {
         name: 'list_agents',
@@ -225,6 +282,10 @@ export function createRouteAgentTool() {
 }
 export async function executeOrchestrationTool(name, args, ctx) {
     switch (name) {
+        case 'task_agent':
+            return await handleTaskAgent(args, ctx);
+        case 'delegate_agent':
+            return await handleDelegateAgent(args, ctx);
         case 'spawn_agent':
             return await handleSpawn(args, ctx);
         case 'spawn_agents':
@@ -245,6 +306,31 @@ export async function executeOrchestrationTool(name, args, ctx) {
             throw new Error(`Unknown orchestration tool: ${name}`);
     }
 }
+async function handleTaskAgent(args, ctx) {
+    return await handleSpawn({ ...args, wait: true, timeoutMs: args?.timeoutMs ?? DEFAULT_TASK_AGENT_TIMEOUT_MS }, ctx);
+}
+async function handleDelegateAgent(args, ctx) {
+    const spawned = await handleSpawn({ ...args, wait: false }, ctx);
+    let parsed;
+    try {
+        const value = JSON.parse(spawned);
+        if (value && typeof value === 'object' && !Array.isArray(value))
+            parsed = value;
+    }
+    catch {
+        // not JSON; fall through to verbatim propagation
+    }
+    // If handleSpawn returned an error string or a non-object payload (no id to
+    // attach next-step semantics to), propagate it verbatim — wrapping it in
+    // { raw, nextAction } would hide the failure from the model and prevent the
+    // child-drain guardrail from finding a child id to wait on.
+    if (!parsed || typeof parsed.id !== 'string')
+        return spawned;
+    return JSON.stringify({
+        ...parsed,
+        nextAction: 'continue working in the parent turn; call wait_agent when this child output is needed',
+    }, null, 2);
+}
 async function handleSpawnBatch(args, ctx) {
     const list = Array.isArray(args?.agents) ? args.agents : [];
     if (list.length === 0)
@@ -396,16 +482,32 @@ async function handleSpawn(args, ctx) {
     updateSession(ctx.workspaceRoot, record.id, { status: 'running' });
     const promise = (async () => {
         try {
+            // Track per-tool start times so the paired onChildToolEnd carries a
+            // real duration — the REPL renders this on the child's end row.
+            const childToolStarts = new Map();
             const output = await childAgent.runTurn(prompt, {
                 onStatusUpdate: () => { },
-                onToolStart: () => { },
+                onToolStart: (tool, args) => {
+                    childToolStarts.set(tool, Date.now());
+                    ctx.onChildToolStart?.({
+                        childId: record.id,
+                        role: role.name,
+                        tool,
+                        args: args ?? {},
+                    });
+                },
                 onToolEnd: (tool, result) => {
-                    ctx.onChildToolEvent?.({
+                    const startedAt = childToolStarts.get(tool);
+                    childToolStarts.delete(tool);
+                    const durationMs = startedAt ? Date.now() - startedAt : 0;
+                    ctx.onChildToolEnd?.({
                         childId: record.id,
                         role: role.name,
                         tool,
                         ok: result.success,
                         summary: result.summary,
+                        preview: result.preview,
+                        durationMs,
                     });
                 },
             });
@@ -506,12 +608,25 @@ async function handleWait(args, ctx) {
     const promise = runningPromises.get(id);
     if (promise) {
         let timedOut = false;
+        let timeout;
         await Promise.race([
             promise,
-            new Promise((resolve) => setTimeout(() => { timedOut = true; resolve(); }, timeoutMs)),
+            new Promise((resolve) => {
+                timeout = setTimeout(() => { timedOut = true; resolve(); }, timeoutMs);
+            }),
         ]);
+        if (timeout)
+            clearTimeout(timeout);
         if (timedOut) {
-            return JSON.stringify({ id, status: 'timeout' }, null, 2);
+            const record = getSession(ctx.workspaceRoot, id);
+            return JSON.stringify({
+                id,
+                status: 'timeout',
+                childStatus: record?.status ?? 'unknown',
+                role: record?.role,
+                label: record?.label,
+                summary: record ? formatSessionSummary(record) : `No child session with id ${id}.`,
+            }, null, 2);
         }
     }
     const record = getSession(ctx.workspaceRoot, id);

package/dist/prompt/systemPrompt.js

@@ -77,9 +77,9 @@ function clarifyOverlay(activeSkill) {
 function isBrainOnline(connectedTools) {
     if (!connectedTools)
         return true;
-    // Match bare `memory_recall`, double-underscore `mcp__<server>__memory_recall`,
-    // and single-underscore `mcp_<server>_memory_recall` (both prefix conventions
-    // are in use across the multi-MCP codepaths until naming is unified).
+    // Match bare `memory_recall` and the canonical single-underscore prefixed
+    // form `mcp_<server>_memory_recall` (pool normalises any legacy
+    // double-underscore emissions at the boundary — 0.3.8-R5).
     return connectedTools.some((tool) => tool === 'memory_recall' ||
         (tool.startsWith('mcp_') && tool.endsWith('memory_recall')));
 }
@@ -127,7 +127,8 @@ export function buildSystemPrompt(context) {
         brainOnline ? memoryFirstSection() : brainOfflineNotice(),
         '',
         '## Multi-agent orchestration',
-        '- Delegate parallel, bounded work via `spawn_agent` (one) or `spawn_agents` (batch). Roles: explorer (read-only investigation), architect (design alternatives), reviewer (code review), worker (write access), verifier (tests/checks). Omit `role` in `spawn_agents` to auto-route from the leading verb; use `route_agent` for a dry run.',
+        '- Delegation order: direct answer → direct tool → `task_agent` for needed child results → `delegate_agent` when you can keep working. `spawn_agent` / `spawn_agents` are low-level compatibility/batch tools.',
+        '- Roles: explorer, architect, reviewer, worker, verifier. Omit `role` in `spawn_agents` to auto-route from the leading verb; use `route_agent` for a dry run.',
         '- Fan-out triggers: phrasings like "everything", "all", "in 1 go", "in parallel", "thoroughly", "comprehensive", "across the codebase" → ALWAYS `spawn_agents` with ≥3 children. One tool call + "what next?" is NOT acceptable for those prompts.',
         '- Use `wait_agent` / `wait_agents` to drain before yielding. Synthesize child outputs in your own words — never claim work is done just because a child returned.',
         '',

package/dist/runtime/anthropicAdapter.d.ts

@@ -0,0 +1,100 @@
+import type { LLMConfig } from '../config/config.js';
+import type { EffortLevel } from '../state/preferencesStore.js';
+/**
+ * Route to the native adapter when the profile is Anthropic AND the
+ * endpoint hostname is `api.anthropic.com`, OR the explicit
+ * `BRAINROUTER_ANTHROPIC_NATIVE=1` override is set (for vended /
+ * reverse-proxied endpoints that still speak the native shape).
+ *
+ * Anything else — including `provider:'anthropic'` pointed at an
+ * OpenAI-compat gateway — stays on the existing OpenAI path so we
+ * don't break the OpenRouter / Anthropic-compat-shim flows.
+ */
+export declare function shouldUseAnthropicNative(config: LLMConfig, env?: NodeJS.ProcessEnv): boolean;
+export interface AnthropicBuildOptions {
+    effort?: EffortLevel;
+    cacheEnabled?: boolean;
+    maxTokens?: number;
+    thinkingBudgetTokens?: number;
+}
+interface AnthropicMessage {
+    role: 'user' | 'assistant';
+    content: any[];
+}
+interface AnthropicTool {
+    name: string;
+    description: string;
+    input_schema: any;
+    cache_control?: {
+        type: 'ephemeral';
+    };
+}
+export interface AnthropicRequestPayload {
+    model: string;
+    max_tokens: number;
+    system?: any;
+    messages: AnthropicMessage[];
+    tools?: AnthropicTool[];
+    thinking?: {
+        type: 'enabled';
+        budget_tokens: number;
+    };
+}
+/**
+ * Pure transform: BrainRouter chat history (OpenAI shape) →
+ * Anthropic `/v1/messages` request body.
+ *
+ * Invariants enforced here so callers don't need to know the Anthropic
+ * rules:
+ *   - The system message (first message with role:'system') is hoisted
+ *     to the top-level `system` field and dropped from `messages`.
+ *   - Consecutive `tool` role entries are merged into one synthetic
+ *     `user` message whose content is an array of `tool_result` blocks.
+ *   - Assistant messages with `tool_calls` emit a content array that
+ *     interleaves text (when present) and `tool_use` blocks. The
+ *     OpenAI tool_call.id is reused as the Anthropic tool_use.id —
+ *     callers must echo it back on the matching tool_result.
+ */
+export declare function buildAnthropicRequest(config: LLMConfig, messages: any[], tools: any[], options?: AnthropicBuildOptions): AnthropicRequestPayload;
+export interface AnthropicParsedResponse {
+    content: string;
+    toolCalls?: Array<{
+        id: string;
+        type: 'function';
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }>;
+    usage?: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    };
+    thinking?: string;
+}
+/**
+ * Pure transform: Anthropic response body → BrainRouter's internal
+ * `ChatResponse` shape. tool_use blocks become OpenAI-style toolCalls
+ * with the Anthropic id preserved verbatim, and `input` is re-serialized
+ * to the `function.arguments` JSON string the agent loop expects.
+ */
+export declare function parseAnthropicResponse(data: any): AnthropicParsedResponse;
+export interface CallAnthropicOptions extends AnthropicBuildOptions {
+    onThinking?: (text: string) => void;
+}
+export declare function callAnthropic(config: LLMConfig, messages: any[], tools: any[], options?: CallAnthropicOptions): Promise<{
+    content: string;
+    toolCalls: {
+        id: string;
+        type: "function";
+        function: {
+            name: string;
+            arguments: string;
+        };
+    }[] | undefined;
+    usage: {
+        prompt_tokens?: number;
+        completion_tokens?: number;
+    } | undefined;
+}>;
+export {};