skimpyclaw 0.3.14 → 0.4.0

package/dist/orchestrator.js

@@ -1,676 +0,0 @@
-// Orchestrator: multi-phase task decomposition and parallel execution engine
-import { homedir } from 'os';
-import { join } from 'path';
-import { existsSync, mkdirSync, appendFileSync, readFileSync } from 'fs';
-import { runAgentTurn, buildSystemPrompt } from './agent.js';
-import { getToolDefinitions, ORCHESTRATOR_TOOLS } from './tools.js';
-import { getCurrentModel } from './gateway.js';
-import { ensureAgentSetup } from './subagent.js';
-// --- Constants ---
-const ORCH_DIR = join(homedir(), '.skimpyclaw', 'orchestrations');
-const MAX_WORKERS = 3;
-const POLL_INTERVAL_MS = 2000;
-// --- Module-level state ---
-const activeSessions = new Map();
-let currentPlanningSession = null;
-let deliverMessage = null;
-let orchTaskCounter = 0;
-let orchWorkerCounter = 0;
-let planningComplete = false;
-function ensureOrchDir() {
-    if (!existsSync(ORCH_DIR)) {
-        mkdirSync(ORCH_DIR, { recursive: true });
-    }
-}
-function getSessionPath(sessionId) {
-    return join(ORCH_DIR, `${sessionId}.jsonl`);
-}
-function appendEvent(sessionId, event) {
-    ensureOrchDir();
-    const full = {
-        ...event,
-        timestamp: new Date().toISOString(),
-        sessionId,
-    };
-    appendFileSync(getSessionPath(sessionId), JSON.stringify(full) + '\n', 'utf-8');
-}
-/**
- * Reconstruct a session from its JSONL event log.
- * Returns null if the session file doesn't exist.
- */
-export function loadSession(sessionId) {
-    const path = getSessionPath(sessionId);
-    if (!existsSync(path))
-        return null;
-    const lines = readFileSync(path, 'utf-8').trim().split('\n').filter(Boolean);
-    let session = null;
-    for (const line of lines) {
-        const event = JSON.parse(line);
-        switch (event.type) {
-            case 'session_created':
-                session = event.data.session;
-                break;
-            case 'task_created':
-                if (session) {
-                    session.tasks.push(event.data.task);
-                }
-                break;
-            case 'task_started':
-                if (session) {
-                    const task = session.tasks.find(t => t.id === event.data.taskId);
-                    if (task) {
-                        task.status = 'running';
-                        task.workerId = event.data.workerId;
-                        task.startedAt = event.timestamp;
-                    }
-                }
-                break;
-            case 'task_completed':
-                if (session) {
-                    const task = session.tasks.find(t => t.id === event.data.taskId);
-                    if (task) {
-                        task.status = 'completed';
-                        task.result = event.data.result;
-                        task.completedAt = event.timestamp;
-                    }
-                }
-                break;
-            case 'task_failed':
-                if (session) {
-                    const task = session.tasks.find(t => t.id === event.data.taskId);
-                    if (task) {
-                        task.status = 'failed';
-                        task.error = event.data.error;
-                        task.completedAt = event.timestamp;
-                    }
-                }
-                break;
-            case 'phase_changed':
-                if (session) {
-                    session.status = event.data.phase;
-                }
-                break;
-            case 'message_sent':
-                if (session) {
-                    session.messages.push(event.data.message);
-                }
-                break;
-            case 'session_completed':
-                if (session) {
-                    session.status = 'completed';
-                    session.finalResult = event.data.finalResult;
-                    session.completedAt = event.timestamp;
-                }
-                break;
-            case 'session_failed':
-                if (session) {
-                    session.status = 'failed';
-                    session.error = event.data.error;
-                    session.completedAt = event.timestamp;
-                }
-                break;
-        }
-    }
-    return session;
-}
-// ORCHESTRATOR_TOOLS is imported from tools.ts to avoid circular deps
-// (tools.ts defines them, orchestrator.ts uses them in planning phase)
-// --- Initialization ---
-export function initOrchestrationSystem(deliverFn) {
-    deliverMessage = deliverFn;
-    console.log('[orchestrator] System initialized');
-}
-// --- Session Management ---
-export function getActiveOrchestrations() {
-    return [...activeSessions.values()].filter(s => s.status !== 'completed' && s.status !== 'failed');
-}
-export function getOrchestration(id) {
-    return activeSessions.get(id) || loadSession(id);
-}
-export function listRecentOrchestrations(limit = 10) {
-    return [...activeSessions.values()]
-        .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime())
-        .slice(0, limit);
-}
-export function setCurrentPlanningSession(session) {
-    currentPlanningSession = session;
-}
-export function getCurrentPlanningSession() {
-    return currentPlanningSession;
-}
-// --- Orchestrator Tool Execution ---
-export function executeOrchestratorTool(name, input) {
-    switch (name) {
-        case 'CreateTask': {
-            if (!currentPlanningSession) {
-                return 'Error: No active planning session.';
-            }
-            const { title, description, agentType, dependsOn } = input;
-            if (!title || !description || !agentType) {
-                return 'Error: title, description, and agentType are required.';
-            }
-            if (!['coding', 'research', 'general'].includes(agentType)) {
-                return `Error: Invalid agentType "${agentType}". Must be coding, research, or general.`;
-            }
-            orchTaskCounter++;
-            const taskId = `ot${orchTaskCounter}`;
-            // Resolve dependsOn — accept any reasonable reference format:
-            // "ot1", "1", "task-1", "task_1", "#1" all resolve to the first created task
-            const deps = (dependsOn || []).map((ref) => {
-                // Already a valid task ID?
-                if (currentPlanningSession.tasks.some(t => t.id === ref))
-                    return ref;
-                // Extract number from reference and map to task by creation order
-                const numMatch = ref.match(/(\d+)/);
-                if (numMatch) {
-                    const idx = parseInt(numMatch[1], 10) - 1; // 1-based to 0-based
-                    if (idx >= 0 && idx < currentPlanningSession.tasks.length) {
-                        return currentPlanningSession.tasks[idx].id;
-                    }
-                }
-                return ref; // Pass through — will be caught by validation below
-            });
-            // Validate resolved deps
-            const existingIds = new Set(currentPlanningSession.tasks.map(t => t.id));
-            const invalidDeps = deps.filter(id => !existingIds.has(id));
-            if (invalidDeps.length > 0) {
-                orchTaskCounter--; // Roll back counter
-                const validIds = currentPlanningSession.tasks.map((t, i) => `${t.id} (task ${i + 1}: "${t.title}")`).join(', ') || '(none yet)';
-                return `Error: Could not resolve dependsOn references: ${invalidDeps.join(', ')}. Existing tasks: ${validIds}`;
-            }
-            const task = {
-                id: taskId,
-                sessionId: currentPlanningSession.id,
-                title,
-                description,
-                status: 'pending',
-                dependsOn: deps,
-                createdAt: new Date().toISOString(),
-            };
-            currentPlanningSession.tasks.push(task);
-            appendEvent(currentPlanningSession.id, {
-                type: 'task_created',
-                data: { task },
-            });
-            const taskNum = currentPlanningSession.tasks.length;
-            return `Task ${taskNum} created (id: ${taskId}): "${title}" [${agentType}], depends on: [${deps.join(', ') || 'none'}]`;
-        }
-        case 'FinishPlanning': {
-            if (!currentPlanningSession) {
-                return 'Error: No active planning session.';
-            }
-            planningComplete = true;
-            const taskCount = currentPlanningSession.tasks.length;
-            return `Planning complete. ${taskCount} task(s) created. Execution will begin.`;
-        }
-        case 'GetTaskStatus': {
-            if (!currentPlanningSession) {
-                return 'Error: No active planning session.';
-            }
-            const tasks = currentPlanningSession.tasks;
-            if (tasks.length === 0)
-                return 'No tasks created yet.';
-            const summary = tasks.map(t => {
-                const deps = t.dependsOn.length > 0 ? ` (depends on: ${t.dependsOn.join(', ')})` : '';
-                return `- ${t.id}: [${t.status}] ${t.title}${deps}`;
-            });
-            return summary.join('\n');
-        }
-        default:
-            return `Error: Unknown orchestrator tool "${name}"`;
-    }
-}
-// --- Main Entry Point ---
-export function startOrchestration(prompt, chatId, config, modelOverride) {
-    const sessionId = `orch_${Date.now()}`;
-    const model = modelOverride || getCurrentModel();
-    const session = {
-        id: sessionId,
-        prompt,
-        status: 'planning',
-        model,
-        chatId,
-        tasks: [],
-        workers: [],
-        messages: [],
-        createdAt: new Date().toISOString(),
-        startedAt: new Date().toISOString(),
-    };
-    activeSessions.set(sessionId, session);
-    appendEvent(sessionId, {
-        type: 'session_created',
-        data: { session },
-    });
-    // Fire and forget — run all phases async
-    runOrchestration(session, config).catch(err => {
-        console.error(`[orchestrator] Unhandled error in ${sessionId}:`, err);
-        session.status = 'failed';
-        session.error = err instanceof Error ? err.message : String(err);
-        session.completedAt = new Date().toISOString();
-        appendEvent(sessionId, {
-            type: 'session_failed',
-            data: { error: session.error },
-        });
-        if (deliverMessage) {
-            deliverMessage(chatId, `❌ Orchestration ${sessionId} failed:\n\n${session.error}`).catch(() => { });
-        }
-    });
-    return session;
-}
-// --- Phase Runner ---
-async function runOrchestration(session, config) {
-    const { chatId } = session;
-    try {
-        // Phase 1: Planning
-        if (deliverMessage) {
-            await deliverMessage(chatId, `🎯 Orchestration started: planning phase...\n\nPrompt: ${session.prompt}`);
-        }
-        await planPhase(session, config);
-        if (session.tasks.length === 0) {
-            throw new Error('Planning phase produced no tasks');
-        }
-        if (deliverMessage) {
-            const taskList = session.tasks
-                .map(t => `  ${t.id}: ${t.title}`)
-                .join('\n');
-            await deliverMessage(chatId, `📋 Plan created (${session.tasks.length} tasks):\n${taskList}\n\nStarting execution...`);
-        }
-        // Phase 2: Execution
-        session.status = 'executing';
-        appendEvent(session.id, { type: 'phase_changed', data: { phase: 'executing' } });
-        await executePhase(session, config);
-        // Check for failures
-        const failedTasks = session.tasks.filter(t => t.status === 'failed');
-        if (failedTasks.length > 0 && session.tasks.every(t => t.status === 'failed' || t.status === 'completed')) {
-            // Some failed but execution is over — continue to synthesis with partial results
-            if (deliverMessage) {
-                await deliverMessage(chatId, `⚠️ Execution complete with ${failedTasks.length} failure(s). Synthesizing results...`);
-            }
-        }
-        else if (deliverMessage) {
-            await deliverMessage(chatId, `✅ All tasks complete. Synthesizing results...`);
-        }
-        // Phase 3: Synthesis
-        session.status = 'synthesizing';
-        appendEvent(session.id, { type: 'phase_changed', data: { phase: 'synthesizing' } });
-        await synthesizePhase(session, config);
-        // Done
-        session.status = 'completed';
-        session.completedAt = new Date().toISOString();
-        appendEvent(session.id, {
-            type: 'session_completed',
-            data: { finalResult: session.finalResult },
-        });
-        if (deliverMessage) {
-            await deliverMessage(chatId, `🏁 Orchestration complete!\n\n${session.finalResult || '(no result)'}`);
-        }
-    }
-    catch (err) {
-        session.status = 'failed';
-        session.error = err instanceof Error ? err.message : String(err);
-        session.completedAt = new Date().toISOString();
-        appendEvent(session.id, {
-            type: 'session_failed',
-            data: { error: session.error },
-        });
-        if (deliverMessage) {
-            await deliverMessage(chatId, `❌ Orchestration failed:\n\n${session.error}`);
-        }
-    }
-}
-// --- Phase 1: Planning ---
-async function planPhase(session, config) {
-    console.log(`[orchestrator] Planning phase for ${session.id}`);
-    // Set module-level state so orchestrator tools can access the session
-    currentPlanningSession = session;
-    planningComplete = false;
-    try {
-        // Ensure coordinator agent exists
-        ensureAgentSetup('general', config);
-        const systemPrompt = buildSystemPrompt('general');
-        const planningPrompt = `You are an orchestration coordinator. Your job is to break down a complex task into subtasks that can be executed by specialized agents.
-
-Available agent types:
-- coding: For code writing, file manipulation, bash commands, and technical tasks
-- research: For investigation, reading files, and information gathering
-- general: For miscellaneous tasks
-
-You have these tools:
-- CreateTask: Create a subtask with title, description, agentType, and optional dependsOn (array of task IDs)
-- FinishPlanning: Call when all tasks are created
-- GetTaskStatus: Check current task list
-
-Rules:
-1. Break the task into 2-8 focused subtasks
-2. Each task description should be self-contained (the worker won't see the original prompt)
-3. Use dependsOn to specify ordering when one task needs results from another
-4. Minimize dependencies to maximize parallel execution
-5. Call FinishPlanning when done
-
-Task to decompose:
-${session.prompt}`;
-        const messages = [
-            { role: 'system', content: systemPrompt },
-            { role: 'user', content: planningPrompt },
-        ];
-        const toolConfig = {
-            enabled: true,
-            allowedPaths: [join(homedir(), '.skimpyclaw')],
-            maxIterations: 30,
-            bashTimeout: 15000,
-        };
-        // Get base tools and append orchestrator tools
-        const baseDefs = await getToolDefinitions(toolConfig);
-        const allTools = [...baseDefs, ...ORCHESTRATOR_TOOLS];
-        const chatOptions = { model: session.model, thinking: 'medium' };
-        // Use chatWithTools directly, but we need to handle orchestrator tools ourselves.
-        // Instead, we call the Anthropic API loop manually via chatWithTools pattern.
-        // Since chatWithTools resolves tools internally via getToolDefinitions, we need
-        // a different approach: call chatWithTools but intercept orchestrator tool calls
-        // through the executeTool function in tools.ts.
-        //
-        // Simplest approach: replicate a minimal tool loop here for planning only.
-        await planningToolLoop(messages, chatOptions, config, toolConfig, allTools);
-    }
-    finally {
-        currentPlanningSession = null;
-        planningComplete = false;
-    }
-}
-/**
- * Minimal Anthropic tool loop for the planning phase.
- * Routes orchestrator tools to executeOrchestratorTool, others to executeTool.
- */
-async function planningToolLoop(messages, chatOptions, config, toolConfig, toolDefs) {
-    // Dynamic import to avoid circular deps at module level
-    const Anthropic = (await import('@anthropic-ai/sdk')).default;
-    const { resolveModel, buildSystemParam } = await import('./agent.js');
-    const { executeTool } = await import('./tools.js');
-    let resolvedModel = resolveModel(chatOptions.model, config);
-    // planningToolLoop uses the Anthropic SDK directly, so it can only handle Claude models.
-    // If the current model is non-Anthropic (e.g. gpt-*, codex), fall back to Sonnet.
-    if (!resolvedModel.includes('claude')) {
-        const fallback = config.models?.aliases?.['claude-think'] || 'claude-sonnet-4-5-20250929';
-        console.log(`[orchestrator:plan] Non-Anthropic model "${chatOptions.model}" detected, falling back to "${fallback}" for planning`);
-        resolvedModel = resolveModel(fallback, config);
-    }
-    // Strip provider prefix
-    const slashIdx = resolvedModel.indexOf('/');
-    const modelId = slashIdx > 0 ? resolvedModel.slice(slashIdx + 1) : resolvedModel;
-    const maxIterations = toolConfig.maxIterations || 30;
-    const systemMessage = messages.find(m => m.role === 'system');
-    const systemParam = buildSystemParam(systemMessage?.content);
-    const apiMessages = messages
-        .filter(m => m.role !== 'system')
-        .map(m => ({ role: m.role, content: m.content }));
-    // We need the anthropic client — import from agent.ts won't expose it.
-    // Use the same approach as chatWithTools: instantiate via config.
-    // Actually, chatWithTools uses the module-level anthropicClient. We can't access it.
-    // Alternative: use chat() with tool_use by calling the Anthropic SDK directly.
-    // But we don't have the client. Let's use a workaround: create a temporary client
-    // using the same config.
-    const anthropicConfig = config.models.providers.anthropic;
-    if (!anthropicConfig?.apiKey && !anthropicConfig?.authToken) {
-        throw new Error('Anthropic provider not configured');
-    }
-    const opts = {};
-    if (anthropicConfig.authToken) {
-        opts.apiKey = null;
-        opts.authToken = anthropicConfig.authToken;
-        opts.defaultHeaders = {
-            'accept': 'application/json',
-            'anthropic-dangerous-direct-browser-access': 'true',
-            'anthropic-beta': 'claude-code-20250219,oauth-2025-04-20,interleaved-thinking-2025-05-14,fine-grained-tool-streaming-2025-05-14',
-            'user-agent': 'claude-cli/2.1.2 (external, cli)',
-            'x-app': 'cli',
-        };
-        opts.dangerouslyAllowBrowser = true;
-    }
-    else if (anthropicConfig.apiKey) {
-        opts.apiKey = anthropicConfig.apiKey;
-    }
-    const client = new Anthropic(opts);
-    const orchToolNames = new Set(ORCHESTRATOR_TOOLS.map(t => t.name));
-    for (let i = 0; i < maxIterations; i++) {
-        if (planningComplete) {
-            console.log('[orchestrator] Planning complete signal received');
-            break;
-        }
-        const params = {
-            model: modelId,
-            max_tokens: 8192,
-            messages: apiMessages,
-            tools: toolDefs,
-        };
-        if (systemParam)
-            params.system = systemParam;
-        if (chatOptions.thinking && chatOptions.thinking !== 'none') {
-            const budgetTokens = { low: 2048, medium: 8192, high: 16384 };
-            const budget = budgetTokens[chatOptions.thinking] || 2048;
-            params.thinking = { type: 'enabled', budget_tokens: budget };
-            params.max_tokens = Math.max(params.max_tokens, budget + 4096);
-        }
-        console.log(`[orchestrator:plan] Iteration ${i + 1}/${maxIterations}`);
-        const response = await client.messages.create(params);
-        // If no tool use, planning is done
-        if (response.stop_reason !== 'tool_use') {
-            const textBlocks = response.content.filter((c) => c.type === 'text');
-            return textBlocks.map((b) => b.text).join('\n');
-        }
-        // Add assistant response
-        apiMessages.push({ role: 'assistant', content: response.content });
-        // Execute tools
-        const toolResults = [];
-        for (const block of response.content) {
-            if (block.type !== 'tool_use')
-                continue;
-            const inputStr = JSON.stringify(block.input).slice(0, 200);
-            console.log(`[orchestrator:plan] -> ${block.name}(${inputStr})`);
-            let result;
-            if (orchToolNames.has(block.name)) {
-                result = executeOrchestratorTool(block.name, block.input);
-            }
-            else {
-                result = await executeTool(block.name, block.input, toolConfig);
-            }
-            console.log(`[orchestrator:plan] <- ${result.slice(0, 200)}`);
-            toolResults.push({
-                type: 'tool_result',
-                tool_use_id: block.id,
-                content: result,
-            });
-        }
-        apiMessages.push({ role: 'user', content: toolResults });
-    }
-    return '';
-}
-// --- Phase 2: Execution ---
-async function executePhase(session, config) {
-    console.log(`[orchestrator] Execution phase for ${session.id} (${session.tasks.length} tasks)`);
-    const activeWorkers = new Map();
-    while (true) {
-        // Check if all tasks are terminal
-        const allDone = session.tasks.every(t => t.status === 'completed' || t.status === 'failed');
-        if (allDone)
-            break;
-        // Check for deadlock: remaining tasks all have unresolvable dependencies
-        const pendingTasks = session.tasks.filter(t => t.status === 'pending');
-        const runningTasks = session.tasks.filter(t => t.status === 'running');
-        if (pendingTasks.length > 0 && runningTasks.length === 0 && activeWorkers.size === 0) {
-            // Check if any pending task can ever be unblocked
-            const canUnblock = pendingTasks.some(t => {
-                return t.dependsOn.every(depId => {
-                    const dep = session.tasks.find(d => d.id === depId);
-                    return dep && dep.status === 'completed';
-                });
-            });
-            if (!canUnblock) {
-                throw new Error(`Deadlock: ${pendingTasks.length} tasks blocked with no running workers. Failed dependencies may be preventing progress.`);
-            }
-        }
-        // Find unblocked pending tasks
-        const unblocked = pendingTasks.filter(t => {
-            return t.dependsOn.every(depId => {
-                const dep = session.tasks.find(d => d.id === depId);
-                return dep && dep.status === 'completed';
-            });
-        });
-        // Assign unblocked tasks to workers (up to MAX_WORKERS)
-        for (const task of unblocked) {
-            if (activeWorkers.size >= MAX_WORKERS)
-                break;
-            // Create worker
-            orchWorkerCounter++;
-            const workerId = `w${orchWorkerCounter}`;
-            // Determine agent type from the task — stored during planning via CreateTask
-            // We need to figure out the agentType. The orchestrator tool stores it...
-            // Actually, OrchTask doesn't have an agentType field. We'll default to 'general'
-            // and look for hints in the task title/description.
-            const agentType = inferAgentType(task);
-            const worker = {
-                id: workerId,
-                sessionId: session.id,
-                agentType,
-                status: 'busy',
-                currentTaskId: task.id,
-                createdAt: new Date().toISOString(),
-            };
-            session.workers.push(worker);
-            task.status = 'running';
-            task.workerId = workerId;
-            task.startedAt = new Date().toISOString();
-            appendEvent(session.id, {
-                type: 'task_started',
-                data: { taskId: task.id, workerId },
-            });
-            console.log(`[orchestrator] Assigned ${task.id} ("${task.title}") to worker ${workerId} (${agentType})`);
-            // Launch worker
-            const workerPromise = runWorkerTask(session, task, worker, config)
-                .then(() => {
-                task.status = 'completed';
-                task.completedAt = new Date().toISOString();
-                worker.status = 'stopped';
-                appendEvent(session.id, {
-                    type: 'task_completed',
-                    data: { taskId: task.id, result: task.result },
-                });
-                console.log(`[orchestrator] Task ${task.id} completed by ${workerId}`);
-                if (deliverMessage) {
-                    deliverMessage(session.chatId, `✅ Task ${task.id} ("${task.title}") completed`).catch(() => { });
-                }
-            })
-                .catch(err => {
-                task.status = 'failed';
-                task.error = err instanceof Error ? err.message : String(err);
-                task.completedAt = new Date().toISOString();
-                worker.status = 'stopped';
-                appendEvent(session.id, {
-                    type: 'task_failed',
-                    data: { taskId: task.id, error: task.error },
-                });
-                console.error(`[orchestrator] Task ${task.id} failed:`, task.error);
-                if (deliverMessage) {
-                    deliverMessage(session.chatId, `❌ Task ${task.id} ("${task.title}") failed: ${task.error}`).catch(() => { });
-                }
-            })
-                .finally(() => {
-                activeWorkers.delete(workerId);
-            });
-            activeWorkers.set(workerId, workerPromise);
-        }
-        // Wait for at least one worker to finish, or poll timeout
-        if (activeWorkers.size > 0) {
-            await Promise.race([
-                ...activeWorkers.values(),
-                new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS)),
-            ]);
-        }
-        else {
-            // No workers running, nothing to assign — wait briefly
-            await new Promise(resolve => setTimeout(resolve, POLL_INTERVAL_MS));
-        }
-    }
-}
-/**
- * Infer agent type from task metadata.
- * The planning phase CreateTask stores agentType in the task description as a hint.
- * We parse it or default to 'general'.
- */
-function inferAgentType(task) {
-    const desc = (task.title + ' ' + task.description).toLowerCase();
-    if (desc.includes('[coding]') || desc.includes('write code') || desc.includes('implement') || desc.includes('create file')) {
-        return 'coding';
-    }
-    if (desc.includes('[research]') || desc.includes('research') || desc.includes('investigate') || desc.includes('find out')) {
-        return 'research';
-    }
-    return 'general';
-}
-// --- Worker Execution ---
-async function runWorkerTask(session, task, worker, config) {
-    // Build context from completed dependency tasks
-    const depContext = task.dependsOn
-        .map(id => session.tasks.find(t => t.id === id))
-        .filter((t) => !!t && !!t.result)
-        .map(t => `## Output from "${t.title}":\n${t.result}`)
-        .join('\n\n');
-    const prompt = depContext
-        ? `${task.description}\n\n---\nContext from completed prerequisite tasks:\n${depContext}`
-        : task.description;
-    const toolConfig = {
-        enabled: true,
-        allowedPaths: [join(homedir(), '.skimpyclaw')],
-        maxIterations: 100,
-        bashTimeout: 30000,
-    };
-    // Ensure agent directory exists
-    ensureAgentSetup(worker.agentType, config);
-    const result = await runAgentTurn(worker.agentType, prompt, config, session.model, toolConfig, undefined, {
-        channel: 'orchestrator',
-        sessionId: session.id,
-        metadata: { taskId: task.id, workerId: worker.id },
-    });
-    task.result = result;
-}
-// --- Phase 3: Synthesis ---
-async function synthesizePhase(session, config) {
-    console.log(`[orchestrator] Synthesis phase for ${session.id}`);
-    // Build a summary of all task results
-    const taskSummaries = session.tasks.map(t => {
-        const status = t.status === 'completed' ? '✅' : '❌';
-        const output = t.status === 'completed' ? t.result : `Error: ${t.error}`;
-        return `## ${status} Task ${t.id}: ${t.title}\n\n${output || '(no output)'}`;
-    });
-    const synthesisPrompt = `You are synthesizing the results of a multi-task orchestration.
-
-Original request:
-${session.prompt}
-
----
-
-Task results:
-
-${taskSummaries.join('\n\n---\n\n')}
-
----
-
-Provide a clear, comprehensive response to the original request based on all task results above. If any tasks failed, note what couldn't be completed and why.`;
-    // Ensure agent exists
-    ensureAgentSetup('general', config);
-    const result = await runAgentTurn('general', synthesisPrompt, config, session.model, undefined, // No tools needed for synthesis
-    undefined, {
-        channel: 'orchestrator',
-        sessionId: session.id,
-        metadata: { phase: 'synthesis' },
-    });
-    session.finalResult = result;
-}
-// --- Testing ---
-export function resetForTesting() {
-    activeSessions.clear();
-    currentPlanningSession = null;
-    deliverMessage = null;
-    orchTaskCounter = 0;
-    orchWorkerCounter = 0;
-    planningComplete = false;
-}

package/dist/providers/openai.d.ts

@@ -1,10 +0,0 @@
-import OpenAI from 'openai';
-import type { ProviderChatParams, ProviderToolChatParams, ToolChatResult } from './types.js';
-export declare function addOpenAIClient(name: string, client: OpenAI): void;
-export declare function getOpenAIClient(name: string): OpenAI | undefined;
-export declare function hasOpenAIClient(name: string): boolean;
-export declare function clearOpenAIClients(): void;
-export declare function resetOpenAIProviderState(): void;
-export declare function isOpenAIAvailable(provider: string): boolean;
-export declare function chatOpenAI(params: ProviderChatParams, provider: string): Promise<string>;
-export declare function chatWithToolsOpenAI(params: ProviderToolChatParams, provider: string): Promise<ToolChatResult>;