@bahulam/code 0.1.11 → 0.1.12

package/src/core/local-agent.mjs

@@ -206,6 +206,11 @@ export class LocalAgent {
         maxTurns = null,
         stagnationDetection = false,
         stagnationThreshold = 3,
+        // Additional tool schemas beyond the built-in set — e.g. plugin
+        // tools a sub-agent node declares. Execution still routes through
+        // the (scoped) toolExecutor; this only makes the schemas visible
+        // to the model.
+        extraToolSchemas = [],
     }) {
         this.apiKey = apiKey;
         this.openRouterKey = openRouterKey;
@@ -218,6 +223,7 @@ export class LocalAgent {
         this.maxTurns = maxTurns || MAX_ITERATIONS;
         this.stagnationDetection = stagnationDetection;
         this.stagnationThreshold = stagnationThreshold;
+        this.extraToolSchemas = Array.isArray(extraToolSchemas) ? extraToolSchemas : [];
         this._cancelled = false;
         this.promptCache = new PromptCache();
     }
@@ -498,7 +504,10 @@ export class LocalAgent {
     }
 
     _buildToolDefs() {
-        return TOOL_SCHEMAS;
+        if (!this.extraToolSchemas.length) return TOOL_SCHEMAS;
+        const names = new Set(TOOL_SCHEMAS.map(t => t.name));
+        const extras = this.extraToolSchemas.filter(t => t?.name && !names.has(t.name));
+        return extras.length ? [...TOOL_SCHEMAS, ...extras] : TOOL_SCHEMAS;
     }
 
     _buildSystemPrompt(context, retrievedContext = null) {

package/src/core/risk-tier.mjs

@@ -63,6 +63,7 @@ const READ_TOOLS = new Set([
   'analyze_code',
   'validate_file', 'validate_structure',
   'agents_list', 'workflow_list',
+  'bahulam_info', 'job_output',
 ]);
 
 const READ_PATH_KEYS = [

package/src/core/stream-client.mjs

@@ -190,17 +190,69 @@ export class BahulamStreamClient {
         this._bundledReady = false;
     }
 
+    _getPluginToolMap() {
+        const tools = new Map();
+        if (!this.pluginRegistry) return tools;
+        for (const tool of this.pluginRegistry.listTools?.() || []) {
+            const name = String(tool.name || '').trim();
+            if (!name || tools.has(name)) continue;
+            tools.set(name, tool);
+        }
+        return tools;
+    }
+
     /**
-     * Get plugin tool schemas for client_tools injection.
-     * @returns {Array<{name: string, description: string, input_schema: object}>}
+     * Plugin tools are intentionally not advertised as primary client_tools.
+     * They are executable by the local callback handler, but the primary model
+     * should reach them by delegating to an agent that declares them.
      */
     _getPluginToolSchemas() {
-        if (!this.pluginRegistry) return [];
-        return this.pluginRegistry.listTools().map(t => ({
-            name: t.name,
-            description: t.description || '',
-            input_schema: t.input_schema || { type: 'object', properties: {} },
-        }));
+        return [];
+    }
+
+    _collectAgentScopedToolRefs(context = {}, clientAgents = []) {
+        const refs = new Map();
+        const pluginTools = this._getPluginToolMap();
+        const addAgent = (agent = {}) => {
+            const slug = String(agent.slug || agent.command || agent.name || '').trim();
+            const tools = Array.isArray(agent.tools) ? agent.tools : [];
+            for (const toolName of tools) {
+                const name = String(toolName || '').trim();
+                if (!name || !pluginTools.has(name)) continue;
+                if (!refs.has(name)) refs.set(name, new Set());
+                if (slug) refs.get(name).add(slug);
+            }
+        };
+
+        for (const agent of clientAgents || []) addAgent(agent);
+        for (const agent of context?.agent_ctx?.available_agents || []) addAgent(agent);
+        for (const agent of context?.available_agents || []) addAgent(agent);
+        if (context?.sub_agent) addAgent(context.sub_agent);
+        return refs;
+    }
+
+    /**
+     * Plugin tool schemas scoped to sub-agents that declare those tools.
+     * This keeps plugin tools out of the primary model's direct tool surface
+     * while still giving delegated/custom/plugin agents the schemas they need.
+     *
+     * @returns {Array<{name: string, description: string, input_schema: object, source_scope: string, plugin_name: string|null, allowed_agents: string[]}>}
+     */
+    _getClientAgentToolSchemas(context = {}, clientAgents = []) {
+        const pluginTools = this._getPluginToolMap();
+        if (!pluginTools.size) return [];
+        const refs = this._collectAgentScopedToolRefs(context, clientAgents);
+        return [...refs.entries()].map(([name, allowedAgents]) => {
+            const tool = pluginTools.get(name) || {};
+            return {
+                name,
+                description: tool.description || '',
+                input_schema: tool.input_schema || { type: 'object', properties: {} },
+                source_scope: 'plugin',
+                plugin_name: tool._plugin_name || tool.plugin_name || null,
+                allowed_agents: [...allowedAgents],
+            };
+        });
     }
 
     /**
@@ -209,13 +261,30 @@ export class BahulamStreamClient {
      */
     _getPluginAgentSchemas() {
         if (!this.pluginRegistry) return [];
-        return this.pluginRegistry.listAgents().map(a => ({
-            slug: a.slug || a.name || '',
-            name: a.name || a.slug || '',
-            role: a.role || 'specialist',
-            description: a.description || '',
-            tools: Array.isArray(a.tools) ? a.tools : [],
-        }));
+        // Only plugin agents admitted to the main-loop registry (settings
+        // plugins.agent_allowlist, or the session plugin in workspace-channel
+        // executors) are advertised. Workspace-scoped plugin agents stay out
+        // of the main-turn payload; without an executor registry, fall back
+        // to advertising everything (legacy behavior).
+        const runnables = this.toolExecutor?.listRunnables?.();
+        const admitted = Array.isArray(runnables)
+            ? new Set(runnables.filter(a => a.source_scope === 'plugin').map(a => a.slug))
+            : null;
+        return this.pluginRegistry.listAgents()
+            .filter(a => !admitted || admitted.has(a.slug || a.name || ''))
+            .map(a => ({
+                slug: a.slug || a.name || '',
+                name: a.name || a.slug || '',
+                role: a.role || 'specialist',
+                description: a.description || '',
+                tools: Array.isArray(a.tools) ? a.tools : [],
+                system_prompt: a.system_prompt || a.systemPrompt || a.prompt || '',
+                model: a.model || null,
+                models: a.models || null,
+                source: a.source || (a._plugin_name ? `plugin:${a._plugin_name}` : 'plugin'),
+                source_scope: 'plugin',
+                plugin_name: a._plugin_name || null,
+            }));
     }
 
     /**
@@ -297,6 +366,8 @@ export class BahulamStreamClient {
         if (clientTools.length > 0) body.client_tools = clientTools;
         const clientAgents = this._getPluginAgentSchemas();
         if (clientAgents.length > 0) body.client_agents = clientAgents;
+        const clientAgentTools = this._getClientAgentToolSchemas(context, clientAgents);
+        if (clientAgentTools.length > 0) body.client_agent_tools = clientAgentTools;
         const requestId = `cli-${_uuidLike()}`;
 
         // daemon cache-guard hook. If BAHULAM_CAPTURE_REQUEST is set to a file
@@ -795,6 +866,7 @@ export class BahulamStreamClient {
         const callId = call_id || request_id;
         const toolName = tool;
         const isInternal = Boolean(data?.internal || data?.sub_agent);
+        const subAgentRunId = data?.run_id || data?.sub_agent_run_id || null;
 
         if (this.verbose) {
             process.stderr.write(`\x1b[2m[tool] ${toolName}(${JSON.stringify(args).slice(0, 80)}...)\x1b[0m\n`);
@@ -812,6 +884,8 @@ export class BahulamStreamClient {
                     _cancelled: true,
                     internal: isInternal,
                     sub_agent: data?.sub_agent || null,
+                    run_id: subAgentRunId,
+                    sub_agent_run_id: subAgentRunId,
                     local_callback: false,
                 },
             };
@@ -823,6 +897,10 @@ export class BahulamStreamClient {
         try {
             result = await this.toolExecutor.execute(toolName, args || {}, {
                 signal: this._toolAbort?.signal,
+                toolCallSource: 'model',
+                internal: isInternal,
+                subAgent: data?.sub_agent || null,
+                subAgentRunId,
             });
         } catch (err) {
             if (err?.name === 'AbortError' || this._cancelled) {
@@ -862,6 +940,8 @@ export class BahulamStreamClient {
                 duration_ms: durationMs,
                 internal: isInternal,
                 sub_agent: data?.sub_agent || null,
+                run_id: subAgentRunId,
+                sub_agent_run_id: subAgentRunId,
                 local_callback: true,
             },
         };

package/src/core/tool-executor.mjs

@@ -23,9 +23,12 @@ import { detectImageFile } from './attachments.mjs';
 import { streamResponse } from './streaming.mjs';
 import { sendApprovalDecision, sendCallback } from './callback-client.mjs';
 import { HookRunner } from '../config/hook-runner.mjs';
+import { loadBahulamSettings } from '../config/settings-loader.mjs';
+import { BUILTIN_AGENTS } from '../terminal/agents.mjs';
 import { buildFileDiff } from './file-diff.mjs';
 import { buildWorkScope } from './work-scope.mjs';
 import { loadDiskMemory, ensureBahulamDir, globalMemoryPath, projectMemoryPath } from './memory-disk.mjs';
+import { backgroundTasks } from './background-tasks.mjs';
 import { resolveLintCommand } from './lint-resolver.mjs';
 import { PluginRegistry } from '../plugins/registry.mjs';
 import { loadPluginTool } from '../plugins/executor.mjs';
@@ -57,6 +60,12 @@ export function createToolExecutor({
     // REPL/headless callers leave this null — state still works, just
     // no reactive pulse.
     stateEmit = null,
+    // Execution channel. 'main' (REPL/headless/CLI): plugin agents are
+    // workspace-scoped and excluded from listings and the agent-context
+    // envelope unless allowlisted in settings plugins.agent_allowlist.
+    // 'workspace' (plugin workspace sessions via agent-relay): the
+    // session plugin's agents are fully available.
+    channel = 'main',
 } = {}) {
     // Cross-session memory cache. Ships in getAgentContext() on every turn,
     // so we need it to be byte-identical when the underlying disk file hasn't
@@ -87,7 +96,7 @@ export function createToolExecutor({
         _memoryCache = { key, facts, digest };
         return _memoryCache;
     }
-    const occRegistry = createToolRegistry();
+    const occRegistry = createToolRegistry({ pluginRegistry, stateEmit });
     const skillTool = occRegistry.get('Skill');
     if (skillTool) skillTool._skillsLoader = skillsLoader;
     const installer = skillInstaller || new SkillInstaller({
@@ -252,6 +261,7 @@ export function createToolExecutor({
             source_scope: agent.source_scope || 'unknown',
             source: agent.source || '',
             content_hash: agent.content_hash || '',
+            runnable: agent.runnable !== false,
         };
     }
 
@@ -306,24 +316,84 @@ export function createToolExecutor({
             .filter(agent => agent.slug);
     }
 
-    function listAvailableAgents() {
+    // Plugin agents are workspace-scoped entities. They enter the
+    // main-loop registry only via an explicit settings allowlist.
+    function pluginAgentAllowlist() {
+        try {
+            const { settings } = loadBahulamSettings({ cwd: process.cwd() });
+            const list = settings?.plugins?.agent_allowlist;
+            return Array.isArray(list) ? list.map(item => String(item)) : [];
+        } catch {
+            return [];
+        }
+    }
+
+    const BUILTIN_RUNNABLES = BUILTIN_AGENTS.map(def => ({
+        slug: def.command,
+        name: def.name,
+        description: def.description || '',
+        role: 'builtin',
+        model: null,
+        models: undefined,
+        tools: [],
+        capabilities: [],
+        domains: [],
+        source_scope: 'builtin',
+        source: 'builtin',
+        content_hash: '',
+        read_only: Boolean(def.readOnly),
+        runnable: true,
+    }));
+
+    // The deterministic sub-agent registry. Resolution precedence:
+    // project agent → global agent → builtin → allowlisted plugin agent.
+    // In workspace-channel executors the session plugin's agents are
+    // runnable without an allowlist entry.
+    function listRunnables() {
         const bySlug = new Map();
         for (const agent of listLocalAgents(process.cwd())) {
-            if (agent.slug && !bySlug.has(agent.slug)) bySlug.set(agent.slug, agent);
+            if (agent.slug && !bySlug.has(agent.slug)) {
+                bySlug.set(agent.slug, { ...agent, runnable: true });
+            }
+        }
+        for (const builtin of BUILTIN_RUNNABLES) {
+            if (!bySlug.has(builtin.slug)) bySlug.set(builtin.slug, builtin);
         }
+        const allowlist = new Set(pluginAgentAllowlist());
         for (const agent of listPluginAgents()) {
-            if (agent.slug && !bySlug.has(agent.slug)) bySlug.set(agent.slug, agent);
+            if (!agent.slug || bySlug.has(agent.slug)) continue;
+            if (channel === 'workspace' || allowlist.has(agent.slug)) {
+                bySlug.set(agent.slug, { ...agent, runnable: true });
+            }
         }
         return [...bySlug.values()];
     }
 
+    // Installed plugin agents NOT admitted to the main-loop registry —
+    // still discoverable (scope:'plugin') but flagged not runnable.
+    function listWorkspaceScopedPluginAgents() {
+        const runnableSlugs = new Set(listRunnables().map(agent => agent.slug));
+        return listPluginAgents()
+            .filter(agent => agent.slug && !runnableSlugs.has(agent.slug))
+            .map(agent => ({ ...agent, runnable: false }));
+    }
+
+    // Agent-context envelope population: the runnable registry minus
+    // builtins (the backend has its own delegation vocabulary for those;
+    // adding them to available_agents would change wire behavior).
+    function listAvailableAgents() {
+        return listRunnables().filter(agent => agent.source_scope !== 'builtin');
+    }
+
     function filterLocalAgents(args = {}) {
         const scope = String(args.scope || '').trim();
-        if (scope && !['project', 'global', 'plugin'].includes(scope)) {
-            throw new Error('scope must be "project", "global", or "plugin"');
+        if (scope && !['project', 'global', 'plugin', 'builtin'].includes(scope)) {
+            throw new Error('scope must be "project", "global", "plugin", or "builtin"');
         }
-        const combined = listAvailableAgents()
-            .filter(agent => !scope || agent.source_scope === scope);
+        const pool = scope === 'plugin'
+            ? [...listRunnables(), ...listWorkspaceScopedPluginAgents()]
+            : listRunnables();
+        const combined = pool.filter(agent => !scope || agent.source_scope === scope);
         return combined.filter(agent => agentMatches(agent, args.query || args.name || ''));
     }
 
@@ -694,13 +764,14 @@ export function createToolExecutor({
     // They are dispatched with lower priority (built-in tools win on name collision).
     const pluginToolMap = new Map(); // name → async handler function
 
-    function registerPluginTool(name, handler) {
+    function registerPluginTool(name, handler, metadata = {}) {
         if (pluginToolMap.has(name)) {
             if (process.env.DEBUG) {
                 console.warn(`Plugin tool "${name}" already registered from another plugin — skipping.`);
             }
             return false;
         }
+        handler._pluginTool = metadata;
         pluginToolMap.set(name, handler);
         return true;
     }
@@ -735,7 +806,7 @@ export function createToolExecutor({
             }
             return false;
         }
-        pluginToolMap.set(qualified, async (args, options = {}) => {
+        const mcpHandler = async (args, options = {}) => {
             // The lazy-state getter matches JS plugin tools so an MCP
             // "wrapper" tool can trivially write its result to the same
             // Shared Blackboard (rare, but useful for cache-and-return).
@@ -765,7 +836,9 @@ export function createToolExecutor({
                     _mcp_server: serverName,
                 };
             }
-        });
+        };
+        mcpHandler._pluginTool = { pluginName, source: 'mcp', serverName, toolName };
+        pluginToolMap.set(qualified, mcpHandler);
         // Track schema for tool-listing surfaces (also help /tools discovery).
         pluginToolMap.get(qualified)._mcp = { pluginName, serverName, toolName, schema: toolSchema };
         return true;
@@ -778,11 +851,11 @@ export function createToolExecutor({
             if (!name || toolMap[name]) continue;
             const pluginName = toolDef._plugin_name || toolDef.plugin_name || null;
             registerPluginTool(name, async (args, options = {}) => {
-                const handler = await loadPluginTool(toolDef._plugin_dir, toolDef.handler);
+                const handler = await loadPluginTool(toolDef._plugin_dir, toolDef.tool);
                 if (!handler) {
                     return {
                         success: false,
-                        output: `Plugin tool handler could not be loaded: ${name}`,
+                        output: `Plugin tool module could not be loaded: ${name}`,
                         _tool: name,
                         _plugin: pluginName,
                     };
@@ -826,15 +899,57 @@ export function createToolExecutor({
                         _plugin: pluginName,
                     };
                 }
-            });
+            }, { pluginName, source: 'plugin' });
         }
     }
 
+    function pluginAgentForTool(toolName, pluginName) {
+        if (!pluginRegistry) return null;
+        return (pluginRegistry.listAgents?.() || []).find(agent => {
+            const agentPlugin = agent._plugin_name
+                || String(agent.source || '').replace(/^plugin:/, '')
+                || null;
+            if (pluginName && agentPlugin && agentPlugin !== pluginName) return false;
+            return Array.isArray(agent.tools) && agent.tools.includes(toolName);
+        }) || null;
+    }
+
+    function primaryModelPluginToolBlock(name, handler, options = {}) {
+        if (!handler?._pluginTool) return null;
+        if (options.toolCallSource !== 'model') return null;
+        if (options.internal || options.subAgent || options.allowPrimaryPluginToolCall) return null;
+
+        const pluginName = handler._pluginTool.pluginName || 'plugin';
+        // Tools-only plugins have no delegation owner: with no agent to
+        // route through, the primary agent uses the tools directly (the
+        // user consented by enabling the plugin). The delegate-only rule
+        // applies only when the plugin ships an owning agent.
+        const pluginShipsAgents = (pluginRegistry?.listAgents?.() || [])
+            .some(agent => (agent._plugin_name || '') === pluginName);
+        if (!pluginShipsAgents) return null;
+
+        const agent = pluginAgentForTool(name, pluginName);
+        const delegateHint = agent?.slug
+            ? `Delegate to the '${agent.slug}' sub-agent instead, or run it explicitly with /run ${agent.slug} "...".`
+            : `Delegate to the plugin's sub-agent instead, or run the plugin agent explicitly.`;
+        return {
+            success: false,
+            output: `Plugin tool '${name}' is scoped to plugin '${pluginName}' and should not be called directly by the primary agent. ${delegateHint}`,
+            _tool: name,
+            _plugin: pluginName,
+            _blocked: true,
+            _requires_agent_delegation: true,
+            _agent: agent?.slug || null,
+        };
+    }
+
     async function executeToolWithHooks(name, args, options = {}) {
         const handler = toolMap[name] || pluginToolMap.get(name);
         if (!handler) {
             return { success: false, output: `Unknown tool: ${name}`, _tool: name };
         }
+        const pluginToolBlock = primaryModelPluginToolBlock(name, handler, options);
+        if (pluginToolBlock) return pluginToolBlock;
         const hooks = hookRunner || new HookRunner({ cwd: process.cwd() });
         try {
             throwIfAborted(options.signal);
@@ -1188,6 +1303,30 @@ export function createToolExecutor({
             args._classification = classification.classification; // 'safe' or 'contained'
             const cwd = await commandCwd(args);
 
+            // Background execution: start via the BackgroundTasks registry
+            // and return immediately. Safety checks above still apply;
+            // results are retrieved with job_output / killed with job_kill.
+            if (args.run_in_background) {
+                const job = backgroundTasks.start({
+                    command: args.command,
+                    cwd,
+                    timeoutMs: args.timeout ? Math.min(Number(args.timeout), 3_600_000) : undefined,
+                    // Deterministic wake-on-finish: completion dispatches the
+                    // named agent through the trigger funnel (chain-guarded).
+                    on_complete: args.on_complete_agent ? {
+                        target: `agent:${String(args.on_complete_agent).trim()}`,
+                        instruction: args.on_complete_instruction || null,
+                    } : null,
+                });
+                return {
+                    success: true,
+                    output: `Background job started: ${job.id} (pid ${job.pid}). `
+                        + `Check progress with job_output {"job_id": "${job.id}"}; stop with job_kill.`,
+                    job_id: job.id,
+                    _tool: 'shell',
+                };
+            }
+
             // Pre-check: if command is rm/unlink, verify targets exist first
             const rmMatch = (args.command || '').match(/^rm\s+(?:-\w+\s+)*(.+)$/);
             if (rmMatch) {
@@ -2118,9 +2257,47 @@ export function createToolExecutor({
         },
 
         // User-defined agents — metadata first, project YAML + backend sync on demand.
+        job_output: async (args = {}) => {
+            const jobId = String(args.job_id || '').trim();
+            if (!jobId) {
+                const jobs = backgroundTasks.list();
+                return {
+                    success: true,
+                    output: jobs.length
+                        ? JSON.stringify({ jobs }, null, 2)
+                        : 'No background jobs in this session.',
+                    jobs,
+                    _tool: 'job_output',
+                };
+            }
+            const job = args.block
+                ? await backgroundTasks.wait(jobId)
+                : backgroundTasks.describe(jobId);
+            if (!job) return { success: false, output: `Unknown job: ${jobId}`, _tool: 'job_output' };
+            const tailLines = Number(args.tail_lines) || 80;
+            const tail = String(job.tail || '').split('\n').slice(-tailLines).join('\n');
+            return {
+                success: true,
+                output: `${job.id} · ${job.status}`
+                    + (job.exit_code != null ? ` (exit ${job.exit_code})` : '')
+                    + ` · ${job.duration_s}s\n${tail}`,
+                job: { ...job, tail: undefined },
+                _tool: 'job_output',
+            };
+        },
+
+        job_kill: async (args = {}) => {
+            const job = backgroundTasks.kill(String(args.job_id || '').trim());
+            if (!job) return { success: false, output: `Unknown job: ${args.job_id}`, _tool: 'job_kill' };
+            return { success: true, output: `${job.id} → ${job.status}`, job, _tool: 'job_kill' };
+        },
+
         agents_list: async (args = {}) => {
             const agents = filterLocalAgents(args).map(compactAgentMetadata);
             const payload = { agents, count: agents.length };
+            if (agents.some(agent => agent.runnable === false)) {
+                payload.note = 'Agents with runnable:false are workspace-scoped plugin agents; add their slug to settings plugins.agent_allowlist to invoke them from the main loop.';
+            }
             return {
                 success: true,
                 output: JSON.stringify(payload, null, 2),
@@ -2151,7 +2328,8 @@ export function createToolExecutor({
                     : null,
                 next_actions: [
                     `Edit ${result.filePath}`,
-                    `Run /agents sync ${result.slug} when ready`,
+                    `Run /run ${result.slug} "<task>" or delegate to it from chat immediately`,
+                    `Optional: /agents sync ${result.slug} to publish it to the backend for account/cloud reuse`,
                 ],
             };
             return {
@@ -2580,6 +2758,21 @@ export function createToolExecutor({
             return results;
         },
 
+        listRunnables,
+
+        // Plugin tool schemas (name/description/input_schema) for callers
+        // that compose model-facing tool lists — e.g. the graph engine's
+        // direct substrate giving a plugin agent its declared tools.
+        listPluginToolSchemas() {
+            if (!pluginRegistry) return [];
+            return (pluginRegistry.listTools?.() || []).map(tool => ({
+                name: tool.name,
+                description: tool.description || '',
+                input_schema: tool.input_schema || { type: 'object', properties: {} },
+                plugin_name: tool._plugin_name || tool.plugin_name || null,
+            })).filter(tool => tool.name);
+        },
+
         getAgentContext() {
             const global = projectRegistry.getGlobalContext();
             const mem = _readMemorySnapshot();
@@ -2609,6 +2802,17 @@ export function createToolExecutor({
                     source: agent.source,
                     spec: agent.spec,
                 })),
+                // Background jobs the model should know about. Stable fields
+                // only (no durations) so the entry — and the prompt cache —
+                // changes on status transitions, not every turn.
+                ...(backgroundTasks.list().length ? {
+                    background_jobs: backgroundTasks.list().map(job => ({
+                        id: job.id,
+                        name: job.name,
+                        status: job.status,
+                        exit_code: job.exit_code,
+                    })),
+                } : {}),
                 available_workflows: listLocalWorkflows(process.cwd()).map(workflow => ({
                     slug: workflow.slug,
                     name: workflow.name,

package/src/local-service/agent-relay.mjs

@@ -617,7 +617,7 @@ export class LocalAgentRelay {
       try { this.emit('plugin_state_changed', evt); }
       catch { /* never let SSE failure break a tool call */ }
     };
-    const toolExecutor = createToolExecutor({ pluginRegistry, stateEmit });
+    const toolExecutor = createToolExecutor({ pluginRegistry, stateEmit, channel: 'workspace' });
     await toolExecutor.waitForAutoRegister?.();
     await toolExecutor.registerProjectRoots?.([this.session.root_path], { forceRefresh: false });