scalix 0.0.1 → 1.1.0

package/dist/tool-helper.js

@@ -0,0 +1,97 @@
+export function tool(def) {
+    return def;
+}
+export function zodToJsonSchema(schema) {
+    return convertZod(schema);
+}
+function convertZod(schema) {
+    if (!schema || !schema._def)
+        return { type: 'object' };
+    const def = schema._def;
+    const typeName = def.typeName;
+    switch (typeName) {
+        case 'ZodObject': {
+            const shape = def.shape?.() ?? def.shape ?? {};
+            const properties = {};
+            const required = [];
+            for (const [key, value] of Object.entries(shape)) {
+                const prop = convertZod(value);
+                const isOptional = value?._def?.typeName === 'ZodOptional';
+                if (!isOptional)
+                    required.push(key);
+                properties[key] = prop;
+            }
+            const result = { type: 'object', properties };
+            if (required.length > 0)
+                result.required = required;
+            return result;
+        }
+        case 'ZodString': {
+            const result = { type: 'string' };
+            if (def.description)
+                result.description = def.description;
+            for (const check of def.checks ?? []) {
+                if (check.kind === 'min')
+                    result.minLength = check.value;
+                if (check.kind === 'max')
+                    result.maxLength = check.value;
+                if (check.kind === 'url')
+                    result.format = 'uri';
+            }
+            return result;
+        }
+        case 'ZodNumber': {
+            const result = { type: 'number' };
+            if (def.description)
+                result.description = def.description;
+            for (const check of def.checks ?? []) {
+                if (check.kind === 'min')
+                    result.minimum = check.value;
+                if (check.kind === 'max')
+                    result.maximum = check.value;
+            }
+            return result;
+        }
+        case 'ZodBoolean':
+            return { type: 'boolean', ...(def.description ? { description: def.description } : {}) };
+        case 'ZodArray': {
+            const result = { type: 'array', items: convertZod(def.type) };
+            if (def.description)
+                result.description = def.description;
+            return result;
+        }
+        case 'ZodOptional': {
+            const inner = convertZod(def.innerType);
+            if (def.description)
+                inner.description = def.description;
+            return inner;
+        }
+        case 'ZodDefault':
+            return convertZod(def.innerType);
+        case 'ZodEnum':
+            return { type: 'string', enum: def.values };
+        case 'ZodRecord': {
+            const result = { type: 'object', additionalProperties: convertZod(def.valueType) };
+            return result;
+        }
+        case 'ZodUnion':
+        case 'ZodDiscriminatedUnion': {
+            const options = def.options ?? [];
+            const schemas = options.map((o) => convertZod(o));
+            return schemas.length === 1 ? schemas[0] : { anyOf: schemas };
+        }
+        case 'ZodLiteral': {
+            const v = def.value;
+            return { type: typeof v === 'number' ? 'number' : typeof v === 'boolean' ? 'boolean' : 'string', const: v };
+        }
+        case 'ZodNullable': {
+            const inner = convertZod(def.innerType);
+            return { ...inner, nullable: true };
+        }
+        case 'ZodEffects':
+        case 'ZodPipeline':
+            return convertZod(def.schema ?? def.innerType);
+        default:
+            return { type: 'string' };
+    }
+}

package/dist/tool-selector.js

@@ -0,0 +1,77 @@
+const CORE_TOOL_NAMES = new Set([
+    'read_file',
+    'write_file',
+    'run_command',
+    'list_files',
+    'edit_file',
+    'search_files',
+    'find_files',
+    'todo_write',
+    'monitor',
+]);
+const CONTEXT_PATTERNS = [
+    [/\b(search|find|grep|look\s+for|where)\b/i, /search|find|grep/],
+    [/\b(git|commit|diff|branch|push|pull|merge|rebase)\b/i, /git/],
+    [/\b(web|url|http|fetch|browse|search\s+online|internet)\b/i, /web|fetch/],
+    [/\b(file|read|write|edit|create|open|save)\b/i, /file|read|write|edit/],
+    [/\b(tree|structure|directory|folder|layout|project)\b/i, /tree|list|find/],
+    [/\b(math|calc|compute|formula|equation)\b/i, /calc/],
+    [/\b(time|date|now|today|clock)\b/i, /time/],
+    [/\b(line|lines|range|portion|section)\b/i, /lines|read/],
+    [/\b(notebook|ipynb)\b|\.ipynb/i, /notebook/],
+    [/\b(sub[\s_-]?agent|delegate|parallel|spawn)\b/i, /agent/],
+    [/\b(task|todo|plan|track|progress)\b/i, /todo/],
+    [/\b(background|process|pid|monitor)\b/i, /monitor/],
+    [/\b(run|exec|shell|command|terminal|bash|script)\b/i, /run_command/],
+    [/\b(mcp|server|connect|sse|integration)\b/i, /mcp/],
+];
+function extractKeywords(text) {
+    const words = text.toLowerCase()
+        .replace(/[^a-z0-9_\s]/g, ' ')
+        .split(/\s+/)
+        .filter((w) => w.length > 2);
+    return new Set(words);
+}
+export class ToolSelector {
+    toolIndex = [];
+    index(tools) {
+        this.toolIndex = tools.map((t) => {
+            const name = t.function?.name ?? t.name ?? '';
+            const description = t.function?.description ?? t.description ?? '';
+            const keywords = extractKeywords(`${name} ${description}`);
+            return { tool: t, name, keywords, isCore: CORE_TOOL_NAMES.has(name) };
+        });
+    }
+    select(query, recentToolNames = [], maxTools = 64) {
+        if (this.toolIndex.length <= maxTools) {
+            return this.toolIndex.map((t) => t.tool);
+        }
+        const queryKeywords = extractKeywords(query);
+        const recentSet = new Set(recentToolNames);
+        const scored = this.toolIndex.map((info) => {
+            let score = 0;
+            if (info.isCore)
+                score += 10;
+            if (recentSet.has(info.name))
+                score += 5;
+            for (const kw of queryKeywords) {
+                if (info.keywords.has(kw))
+                    score += 2;
+                for (const tk of info.keywords) {
+                    if (tk.includes(kw) || kw.includes(tk))
+                        score += 1;
+                }
+            }
+            for (const [queryPattern, namePattern] of CONTEXT_PATTERNS) {
+                if (queryPattern.test(query) && namePattern.test(info.name))
+                    score += 3;
+            }
+            return { info, score };
+        });
+        scored.sort((a, b) => b.score - a.score);
+        return scored.slice(0, maxTools).map((s) => s.info.tool);
+    }
+    getToolNames() {
+        return this.toolIndex.map((t) => t.name);
+    }
+}

package/dist/tools-advanced.js

@@ -0,0 +1,487 @@
+import { tool } from './tool-helper.js';
+import { z } from 'zod';
+import fs from 'node:fs/promises';
+import { sandboxPath } from './sandbox.js';
+import { backgroundProcesses } from './tools.js';
+import { spawnSubAgent, spawnParallelAgents } from './sub-agent.js';
+import { logger } from './logger.js';
+import { TOOL_DEFAULTS } from './constants.js';
+import { DEFAULT_LIMITS } from './settings.js';
+import { AgentRegistry } from './agent-registry.js';
+import { TaskBoard } from './task-board.js';
+import { getAgentDefinitions, isBuiltInAgentType } from './agent-definitions.js';
+let _limits = DEFAULT_LIMITS;
+export function setAdvancedToolLimits(limits) { _limits = limits; }
+const BUILT_IN_INSTRUCTIONS = {
+    plan: 'You are a planning assistant. Analyze the codebase and design an implementation approach. Be thorough and specific.',
+    explore: 'You are a code exploration assistant. Search and read files to answer questions. Be concise and factual.',
+    general: 'You are a focused assistant with full capabilities. Complete the task efficiently. You can spawn sub-agents if needed.',
+};
+async function resolveAgentType(subagentType) {
+    const agentType = subagentType || 'general';
+    if (isBuiltInAgentType(agentType)) {
+        const isReadOnly = agentType === 'explore' || agentType === 'plan';
+        return {
+            toolLevel: isReadOnly ? 'read-only' : 'all',
+            isReadOnly,
+            instructions: BUILT_IN_INSTRUCTIONS[agentType] || BUILT_IN_INSTRUCTIONS.general,
+            maxSteps: agentType === 'explore' ? _limits.exploreMaxSteps : _limits.subAgentMaxSteps,
+            allowSpawning: true,
+        };
+    }
+    const definitions = await getAgentDefinitions(process.cwd());
+    const def = definitions.get(agentType);
+    if (!def) {
+        throw new Error(`Unknown agent type "${agentType}". Built-in types: general, explore, plan. Check .scalix/agents/ for custom definitions.`);
+    }
+    return {
+        toolLevel: def.tools,
+        isReadOnly: def.tools === 'read-only',
+        instructions: def.instructions,
+        maxSteps: def.maxSteps ?? _limits.subAgentMaxSteps,
+        model: def.model,
+        allowSpawning: def.allowSpawning ?? true,
+        description: def.description,
+    };
+}
+let currentTodos = [];
+export function getTodos() {
+    return [...currentTodos];
+}
+export function clearTodos() {
+    currentTodos = [];
+}
+// ─── Todo Write Tool ───
+export const todoWriteTool = tool({
+    name: 'todo_write',
+    description: 'Create or update a task list for tracking multi-step work. Each call replaces the entire list. Use to plan, track progress, and show completed work.',
+    inputSchema: z.object({
+        todos: z.array(z.object({
+            id: z.string().min(1).max(50).describe('Unique task ID'),
+            task: z.string().min(1).max(500).describe('Task description'),
+            status: z.enum(['pending', 'in_progress', 'completed']).describe('Task status'),
+        })).describe('The complete task list (replaces previous)'),
+    }),
+    execute: async ({ todos }) => {
+        currentTodos = todos.map((t) => ({ id: t.id, task: t.task, status: t.status }));
+        const pending = currentTodos.filter(t => t.status === 'pending').length;
+        const inProgress = currentTodos.filter(t => t.status === 'in_progress').length;
+        const completed = currentTodos.filter(t => t.status === 'completed').length;
+        const activeTask = currentTodos.find(t => t.status === 'in_progress');
+        return {
+            success: true,
+            total: currentTodos.length,
+            pending,
+            inProgress,
+            completed,
+            activeForm: activeTask?.id ?? null,
+            todos: currentTodos,
+        };
+    },
+});
+function textToNotebookSource(text) {
+    if (!text)
+        return [];
+    const lines = text.split('\n');
+    return lines.map((l, i) => i < lines.length - 1 ? l + '\n' : l);
+}
+export const notebookEditTool = tool({
+    name: 'notebook_edit',
+    description: 'Edit Jupyter notebooks (.ipynb). Add, edit, delete, or move cells.',
+    inputSchema: z.object({
+        notebook_path: z.string().min(1).max(500).describe('Path to the .ipynb file'),
+        command: z.enum(['add_cell', 'edit_cell', 'delete_cell', 'move_cell']).describe('Operation to perform'),
+        cell_type: z.enum(['code', 'markdown']).optional().describe('Cell type (for add_cell)'),
+        cell_number: z.number().min(0).optional().describe('Cell index (0-based)'),
+        new_source: z.string().max(TOOL_DEFAULTS.maxNotebookSource).optional().describe('New cell content'),
+        position: z.number().min(0).optional().describe('Target position (for move_cell or add_cell insertion point)'),
+    }),
+    execute: async ({ notebook_path, command, cell_type, cell_number, new_source, position }) => {
+        try {
+            const safePath = sandboxPath(notebook_path);
+            const stat = await fs.stat(safePath);
+            if (stat.size > TOOL_DEFAULTS.readFileMaxSize) {
+                return { error: `Notebook too large (${Math.round(stat.size / 1024 / 1024)}MB). Max: ${Math.round(TOOL_DEFAULTS.readFileMaxSize / 1024 / 1024)}MB.` };
+            }
+            const raw = await fs.readFile(safePath, 'utf-8');
+            const notebook = JSON.parse(raw);
+            if (notebook.nbformat !== 4) {
+                return { error: `Unsupported notebook format: nbformat ${notebook.nbformat}` };
+            }
+            if (!Array.isArray(notebook.cells)) {
+                return { error: 'Invalid notebook: cells is not an array' };
+            }
+            const cells = notebook.cells;
+            switch (command) {
+                case 'add_cell': {
+                    const resolvedType = cell_type || 'code';
+                    if (resolvedType !== 'code' && resolvedType !== 'markdown' && resolvedType !== 'raw') {
+                        return { error: `Invalid cell_type: "${resolvedType}". Must be "code", "markdown", or "raw".` };
+                    }
+                    const newCell = {
+                        cell_type: resolvedType,
+                        source: textToNotebookSource(new_source || ''),
+                        metadata: {},
+                        ...(resolvedType === 'code' ? { outputs: [], execution_count: null } : {}),
+                    };
+                    const insertAt = position !== undefined ? Math.min(position, cells.length) : cells.length;
+                    cells.splice(insertAt, 0, newCell);
+                    break;
+                }
+                case 'edit_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
+                    }
+                    if (new_source === undefined) {
+                        return { error: 'new_source is required for edit_cell' };
+                    }
+                    cells[cell_number].source = textToNotebookSource(new_source);
+                    if (cells[cell_number].cell_type === 'code') {
+                        cells[cell_number].outputs = [];
+                        cells[cell_number].execution_count = null;
+                    }
+                    break;
+                }
+                case 'delete_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
+                    }
+                    cells.splice(cell_number, 1);
+                    break;
+                }
+                case 'move_cell': {
+                    if (cell_number === undefined || cell_number < 0 || cell_number >= cells.length) {
+                        return { error: `Invalid cell_number: ${cell_number}. Notebook has ${cells.length} cells.` };
+                    }
+                    const [cell] = cells.splice(cell_number, 1);
+                    const maxPos = cells.length;
+                    const targetPos = position !== undefined ? Math.min(position, maxPos) : maxPos;
+                    cells.splice(targetPos, 0, cell);
+                    break;
+                }
+            }
+            notebook.cells = cells;
+            await fs.writeFile(safePath, JSON.stringify(notebook, null, 1) + '\n', 'utf-8');
+            return { success: true, command, totalCells: cells.length, path: notebook_path };
+        }
+        catch (error) {
+            return { error: error.message };
+        }
+    },
+});
+// ─── Monitor Tool ───
+export const monitorTool = tool({
+    name: 'monitor',
+    description: 'Check output and status of a background process started by run_command with run_in_background. Returns buffered stdout/stderr and process status.',
+    inputSchema: z.object({
+        pid: z.number().describe('Process ID returned by run_command'),
+    }),
+    execute: async ({ pid }) => {
+        const proc = backgroundProcesses.get(pid);
+        if (!proc) {
+            return { error: `No background process found with PID ${pid}. It may have already been cleaned up.` };
+        }
+        const isRunning = proc.exitCode === null;
+        const elapsed = Math.round((Date.now() - proc.startedAt) / 1000);
+        const stdout = proc.stdout.slice(proc.lastRead);
+        const stderr = proc.stderr.slice(proc.lastStderrRead ?? 0);
+        proc.lastRead = proc.stdout.length;
+        proc.lastStderrRead = proc.stderr.length;
+        const result = {
+            pid,
+            command: proc.command,
+            status: isRunning ? 'running' : 'exited',
+            exitCode: proc.exitCode,
+            elapsed: `${elapsed}s`,
+            stdout: stdout || '(no new output)',
+            stderr,
+        };
+        if (!isRunning) {
+            backgroundProcesses.delete(pid);
+        }
+        return result;
+    },
+});
+let parentAgentConfig = null;
+export function setAgentToolConfig(config) {
+    parentAgentConfig = config;
+}
+function resolveAgentConfig(context) {
+    if (context?.agentConfig)
+        return context.agentConfig;
+    return parentAgentConfig;
+}
+export const agentTool = tool({
+    name: 'agent',
+    description: `Spawn agents for complex tasks. Supports multiple actions:
+- spawn (default): Create a sub-agent to handle a task independently. Sub-agents have full tool access including spawning further agents.
+- message: Send a message to another active agent by ID.
+- spawn_parallel: Spawn multiple agents in parallel. Returns results from all agents.
+- list_agents: List all active and completed agents with their status and resource usage.`,
+    inputSchema: z.object({
+        prompt: z.string().min(1).max(10000).optional().describe('The task for the sub-agent (required for spawn)'),
+        description: z.string().min(1).max(100).optional().describe('Short description of the task (3-5 words)'),
+        subagent_type: z.string().max(50).optional().describe('Agent type: general (full access), explore (read-only), plan (read-only analysis), or a custom type from .scalix/agents/'),
+        model: z.string().max(100).optional().describe('Model override for the sub-agent'),
+        action: z.enum(['spawn', 'message', 'spawn_parallel', 'list_agents']).optional().describe('Action to perform (default: spawn)'),
+        target_agent_id: z.string().optional().describe('Target agent ID for message action'),
+        message_content: z.string().max(5000).optional().describe('Message content for message action'),
+        parallel_tasks: z.array(z.object({
+            prompt: z.string().min(1).max(10000),
+            description: z.string().min(1).max(100),
+            subagent_type: z.string().max(50).optional(),
+            model: z.string().max(100).optional(),
+        })).optional().describe('Array of tasks for spawn_parallel action'),
+    }),
+    execute: async (args, context) => {
+        const config = resolveAgentConfig(context);
+        const agentId = context?.agentId;
+        const action = args.action || 'spawn';
+        switch (action) {
+            case 'list_agents': {
+                const registry = AgentRegistry.getInstance();
+                const active = registry.listActive();
+                const summary = registry.getUsageSummary();
+                return {
+                    activeAgents: active.length,
+                    totalTokens: summary.totalTokens,
+                    tree: registry.getAgentTree(),
+                    agents: summary.byAgent,
+                };
+            }
+            case 'message': {
+                if (!args.target_agent_id || !args.message_content) {
+                    return { error: 'target_agent_id and message_content are required for message action' };
+                }
+                const registry = AgentRegistry.getInstance();
+                const result = registry.sendMessage(agentId || 'unknown', args.target_agent_id, args.message_content);
+                if ('error' in result)
+                    return result;
+                return { success: true, messageId: result.id, to: args.target_agent_id };
+            }
+            case 'spawn_parallel': {
+                if (!config) {
+                    return { error: 'Agent tool not configured. Parent agent config not set.' };
+                }
+                if (!args.parallel_tasks || args.parallel_tasks.length === 0) {
+                    return { error: 'parallel_tasks array is required for spawn_parallel action' };
+                }
+                const tasks = await Promise.all(args.parallel_tasks.map(async (task) => {
+                    let resolved;
+                    try {
+                        resolved = await resolveAgentType(task.subagent_type);
+                    }
+                    catch (err) {
+                        return { error: `Invalid agent type "${task.subagent_type}": ${err.message}` };
+                    }
+                    const effectiveModel = task.model || resolved.model;
+                    const subPermissionMode = resolved.isReadOnly ? 'plan' : (config.permissionMode ?? 'default');
+                    const subConfirmToolCall = resolved.isReadOnly ? undefined : config.confirmToolCall;
+                    return {
+                        prompt: task.prompt,
+                        description: task.description,
+                        options: {
+                            model: effectiveModel,
+                            tools: resolved.toolLevel,
+                            permissionMode: subPermissionMode,
+                            confirmToolCall: subConfirmToolCall,
+                            allowAgentTool: resolved.allowSpawning,
+                            parentAgentId: agentId,
+                            agentDescription: task.description,
+                            maxSteps: resolved.maxSteps,
+                            instructions: resolved.instructions,
+                            timeout: _limits.agentToolTimeoutMs,
+                        },
+                    };
+                }));
+                const validTasks = tasks.filter((t) => !t.error);
+                const errorTasks = tasks.filter((t) => t.error);
+                if (validTasks.length === 0) {
+                    return { error: 'All parallel tasks failed validation', details: errorTasks };
+                }
+                logger.info('Spawning parallel agents', { count: validTasks.length, skipped: errorTasks.length });
+                const results = await spawnParallelAgents(config, validTasks);
+                const allResults = [
+                    ...errorTasks.map((t, i) => ({
+                        index: i,
+                        description: t.error,
+                        status: 'failed',
+                        error: t.error,
+                    })),
+                    ...results.map((r, i) => {
+                        if (r.status === 'fulfilled') {
+                            return {
+                                index: errorTasks.length + i,
+                                description: validTasks[i].description,
+                                status: 'completed',
+                                response: r.value.response,
+                                model: r.value.model,
+                                steps: r.value.steps,
+                                tokens: r.value.tokenEstimate,
+                                agentId: r.value.agentId,
+                            };
+                        }
+                        return {
+                            index: errorTasks.length + i,
+                            description: validTasks[i].description,
+                            status: 'failed',
+                            error: r.reason?.message || String(r.reason),
+                        };
+                    }),
+                ];
+                return {
+                    total: allResults.length,
+                    results: allResults,
+                };
+            }
+            case 'spawn':
+            default: {
+                if (!config) {
+                    return { error: 'Agent tool not configured. Parent agent config not set.' };
+                }
+                if (!args.prompt) {
+                    return { error: 'prompt is required for spawn action' };
+                }
+                if (!args.description) {
+                    return { error: 'description is required for spawn action' };
+                }
+                let resolved;
+                try {
+                    resolved = await resolveAgentType(args.subagent_type);
+                }
+                catch (err) {
+                    return { error: err.message };
+                }
+                const effectiveModel = args.model || resolved.model;
+                if (effectiveModel && !config.models.includes(effectiveModel)) {
+                    return { error: `Unknown model "${effectiveModel}". Available: ${config.models.join(', ')}` };
+                }
+                let subPermissionMode = resolved.isReadOnly ? 'plan' : (config.permissionMode ?? 'default');
+                let subConfirmToolCall;
+                if (!resolved.isReadOnly) {
+                    subConfirmToolCall = config.confirmToolCall;
+                }
+                logger.info('Spawning sub-agent', {
+                    description: args.description,
+                    type: args.subagent_type || 'general',
+                    permissionMode: subPermissionMode,
+                });
+                try {
+                    const result = await spawnSubAgent(config, args.prompt, {
+                        model: effectiveModel,
+                        tools: resolved.toolLevel,
+                        permissionMode: subPermissionMode,
+                        confirmToolCall: subConfirmToolCall,
+                        allowAgentTool: resolved.allowSpawning,
+                        parentAgentId: agentId,
+                        agentDescription: args.description,
+                        maxSteps: resolved.maxSteps,
+                        instructions: resolved.instructions,
+                        timeout: _limits.agentToolTimeoutMs,
+                    });
+                    return {
+                        description: args.description,
+                        response: result.response,
+                        model: result.model,
+                        steps: result.steps,
+                        tokenEstimate: result.tokenEstimate,
+                        agentId: result.agentId,
+                    };
+                }
+                catch (error) {
+                    return { error: `Sub-agent failed: ${error.message}` };
+                }
+            }
+        }
+    },
+});
+// ─── Send Message Tool ───
+export const sendMessageTool = tool({
+    name: 'send_message',
+    description: 'Send a message to another active agent by ID. Use this for inter-agent communication and coordination.',
+    inputSchema: z.object({
+        to: z.string().min(1).describe('Target agent ID'),
+        content: z.string().min(1).max(5000).describe('Message content'),
+    }),
+    execute: async ({ to, content }, context) => {
+        const from = context?.agentId || 'unknown';
+        const registry = AgentRegistry.getInstance();
+        const result = registry.sendMessage(from, to, content);
+        if ('error' in result)
+            return result;
+        return { success: true, messageId: result.id, to, from };
+    },
+});
+// ─── Task Board Tools ───
+export const taskCreateTool = tool({
+    name: 'task_create',
+    description: 'Create a new task on the shared task board. Tasks can be claimed and worked on by any agent.',
+    inputSchema: z.object({
+        title: z.string().min(1).max(200).describe('Task title'),
+        description: z.string().max(2000).optional().describe('Detailed task description'),
+    }),
+    execute: async ({ title, description }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const task = board.create(agentId, title, description);
+        return { success: true, task };
+    },
+});
+export const taskClaimTool = tool({
+    name: 'task_claim',
+    description: 'Claim an open task from the shared task board. Only open tasks can be claimed.',
+    inputSchema: z.object({
+        taskId: z.string().min(1).describe('Task ID to claim'),
+    }),
+    execute: async ({ taskId }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const result = board.claim(taskId, agentId);
+        if ('error' in result)
+            return result;
+        return { success: true, task: result };
+    },
+});
+export const taskUpdateTool = tool({
+    name: 'task_update',
+    description: 'Update a task\'s status or result on the shared task board. Use to mark tasks as in_progress, completed, or failed.',
+    inputSchema: z.object({
+        taskId: z.string().min(1).describe('Task ID to update'),
+        status: z.enum(['in_progress', 'completed', 'failed']).optional().describe('New task status'),
+        result: z.string().max(5000).optional().describe('Task result or output'),
+    }),
+    execute: async ({ taskId, status, result }, context) => {
+        const agentId = context?.agentId || 'unknown';
+        const board = TaskBoard.getInstance();
+        const updated = board.update(taskId, agentId, { status, result });
+        if ('error' in updated)
+            return updated;
+        return { success: true, task: updated };
+    },
+});
+export const taskListTool = tool({
+    name: 'task_list',
+    description: 'List tasks from the shared task board. Optionally filter by status or assignee.',
+    inputSchema: z.object({
+        status: z.enum(['open', 'claimed', 'in_progress', 'completed', 'failed']).optional().describe('Filter by status'),
+        assignee: z.string().optional().describe('Filter by assignee agent ID'),
+    }),
+    execute: async ({ status, assignee }) => {
+        const board = TaskBoard.getInstance();
+        const tasks = board.list({ status, assignee });
+        const stats = board.getStats();
+        return { tasks, stats };
+    },
+});
+// ─── Export ───
+export const advancedTools = [
+    todoWriteTool,
+    notebookEditTool,
+    monitorTool,
+    agentTool,
+    sendMessageTool,
+    taskCreateTool,
+    taskClaimTool,
+    taskUpdateTool,
+    taskListTool,
+];