@synergenius/flow-weaver-pack-weaver 0.9.59 → 0.9.77

package/dist/ai-chat-provider.js

@@ -15,17 +15,15 @@ import { runWorkflow } from './bot/runner.js';
 import { RunStore } from './bot/run-store.js';
 import { CostStore } from './bot/cost-store.js';
 import { EventLog } from './bot/event-log.js';
-import { SessionStore } from './bot/session-state.js';
-import { TaskQueue } from './bot/task-queue.js';
-import { SteeringController } from './bot/steering.js';
 import { defaultRegistry, discoverProviders } from './bot/provider-registry.js';
 import { runRegistry } from './bot/run-registry.js';
 import { ProjectModelStore } from './bot/project-model.js';
 import { InsightEngine } from './bot/insight-engine.js';
 import { buildSystemPrompt } from './bot/system-prompt.js';
 import { BotRegistry } from './bot/bot-registry.js';
-/** Throttle orphan recovery to max once per 30s. */
-let lastOrphanRecoveryTime = 0;
+import { TaskStore } from './bot/task-store.js';
+import { SwarmController } from './bot/swarm-controller.js';
+import { SwarmEventLog } from './bot/swarm-event-log.js';
 // ---------------------------------------------------------------------------
 // Tool handlers — reuse the same logic as MCP tools
 // ---------------------------------------------------------------------------
@@ -48,15 +46,21 @@ const toolHandlers = {
             const record = store.get(args.id);
             return record ? JSON.stringify(record, null, 2) : `No run found matching "${args.id}"`;
         }
+        const taskId = args.taskId;
+        const botId = args.botId;
         const records = store.list({
             outcome: args.outcome,
             workflowFile: args.workflowFile,
             limit: args.limit ?? 20,
+            taskId,
+            botId,
         });
         return records.length === 0 ? 'No runs recorded yet.' : JSON.stringify(records, null, 2);
     },
     async fw_weaver_costs(args) {
         const store = new CostStore();
+        const _taskId = args.taskId;
+        const _botId = args.botId;
         let sinceTs;
         if (args.since) {
             const spec = args.since;
@@ -73,6 +77,7 @@ const toolHandlers = {
                     sinceTs = ts;
             }
         }
+        // TODO: pass taskId/botId to CostStore once it supports per-task/per-bot filtering
         const summary = store.summarize({ since: sinceTs, model: args.model });
         return JSON.stringify(summary, null, 2);
     },
@@ -89,170 +94,33 @@ const toolHandlers = {
         }));
         return JSON.stringify(result, null, 2);
     },
-    async fw_weaver_bot(args, ctx) {
-        // Resolve bot from registry if botId is provided
+    async fw_weaver_steer(args, ctx) {
         const botId = args.botId;
-        let registryWorkflowFile;
-        if (botId) {
-            const registry = new BotRegistry(ctx.workspacePath);
-            const bot = registry.get(botId);
-            if (!bot) {
-                return JSON.stringify({ error: `Bot '${botId}' not found` });
-            }
-            const validation = registry.validate(botId);
-            if (!validation.valid) {
-                return JSON.stringify({ error: `Bot '${botId}' is invalid: ${validation.error}` });
-            }
-            registryWorkflowFile = path.isAbsolute(bot.filePath)
-                ? bot.filePath
-                : path.join(ctx.workspacePath, bot.filePath);
-        }
-        const task = {
-            instruction: args.task,
-            mode: args.mode ?? 'create',
-            targets: args.targets,
-            options: {
-                template: args.template,
-                dryRun: args.dryRun,
-                autoApprove: args.autoApprove ?? false,
-            },
-        };
-        const packRoot = new URL('..', import.meta.url);
-        let workflowPath;
-        if (registryWorkflowFile) {
-            workflowPath = registryWorkflowFile;
-        }
-        else {
-            workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
-            if (!fs.existsSync(workflowPath)) {
-                workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
-            }
-        }
-        const projectDir = ctx.workspacePath || process.cwd();
-        const runId = RunStore.newId();
-        const eventLog = new EventLog(runId);
-        // Clean up old event logs
-        EventLog.cleanup();
-        // Fire-and-forget: start workflow in background, events stream via EventLog
-        eventLog.emit({ type: 'bot-started', timestamp: Date.now(), data: { instruction: task.instruction, mode: task.mode, runId } });
-        // Register in run registry BEFORE calling runWorkflow to prevent the race condition
-        // where fw_weaver_events self-healing sees the run as dead and writes .done prematurely.
-        // The runner's finally block will remove it when execution actually completes.
-        const earlyPromise = new Promise(() => { }); // placeholder, replaced by runner
-        runRegistry.register(runId, { file: workflowPath, startedAt: new Date().toISOString(), promise: earlyPromise });
-        // Use timeout-auto approval so the UI can show the approval card
-        // and the file-based decision flow works
-        const useAutoApprove = task.options?.autoApprove === true;
-        const runPromise = runWorkflow(workflowPath, {
-            runId,
-            params: { taskJson: JSON.stringify(task), projectDir },
-            dryRun: args.dryRun,
-            config: useAutoApprove ? undefined : { provider: 'auto', approval: { mode: 'timeout-auto', timeoutSeconds: 300 } },
-            eventLog,
-        }).catch((err) => {
-            try {
-                eventLog.done();
-            }
-            catch { /* already done */ }
-            console.error('[weaver-bot] Background execution failed:', err);
-        }).finally(() => {
-            // Ensure registry is cleaned up even if runner's finally didn't run
-            runRegistry.remove(runId);
-        });
-        void runPromise;
-        return JSON.stringify({ runId, instruction: task.instruction, status: 'started' });
-    },
-    async fw_weaver_steer(args) {
-        const controller = new SteeringController();
-        await controller.write({
+        if (!botId)
+            return JSON.stringify({ error: 'botId required' });
+        const weaverDir = path.join(ctx.workspacePath, '.weaver');
+        fs.mkdirSync(weaverDir, { recursive: true });
+        const steerPath = path.join(weaverDir, `steer-${botId}.json`);
+        fs.writeFileSync(steerPath, JSON.stringify({
             command: args.command,
             payload: args.payload,
             timestamp: Date.now(),
-        });
-        return `Steering command sent: ${args.command}`;
-    },
-    async fw_weaver_queue(args) {
-        const queue = new TaskQueue();
-        switch (args.action) {
-            case 'add': {
-                if (!args.task)
-                    return 'Error: task instruction required';
-                const { id, duplicate } = await queue.add({ instruction: args.task, priority: 0 });
-                return duplicate ? `Task already queued (${id})` : `Task added: ${id}`;
-            }
-            case 'list':
-                return JSON.stringify(await queue.list(), null, 2);
-            case 'clear': {
-                const count = await queue.clear();
-                return `Cleared ${count} task(s)`;
-            }
-            case 'remove': {
-                if (!args.id)
-                    return 'Error: task ID required';
-                const removed = await queue.remove(args.id);
-                return removed ? `Removed ${args.id}` : `Not found: ${args.id}`;
-            }
-            case 'reorder': {
-                if (!args.id)
-                    return 'Error: task ID required';
-                if (args.priority === undefined)
-                    return 'Error: priority required';
-                const reordered = await queue.reorder(args.id, args.priority);
-                return reordered ? `Reordered ${args.id} to priority ${args.priority}` : `Not found: ${args.id}`;
-            }
-            default:
-                return `Unknown action: ${args.action}`;
-        }
+        }, null, 2), 'utf-8');
+        return JSON.stringify({ sent: true, botId, command: args.command });
     },
-    async fw_weaver_status() {
-        const store = new SessionStore();
-        const state = store.load();
-        if (!state) {
-            return JSON.stringify({ status: 'no active session' }, null, 2);
-        }
-        // Startup cleanup: on first call after process restart, the registry is empty.
-        // If session.json claims 'executing' but nothing is in the registry, heal it.
-        if (!runRegistry.startupCleanupDone) {
-            runRegistry.markStartupCleanupDone();
-            if (state.status !== 'idle' && runRegistry.size === 0) {
-                // Orphaned session from a previous process — heal it
-                const orphanRunId = state.currentRunId;
-                if (orphanRunId) {
-                    try {
-                        new EventLog(orphanRunId).done();
-                    }
-                    catch { /* non-fatal */ }
-                }
-                await store.update({ status: 'idle', currentTask: null, currentRunId: null });
-            }
-        }
-        // Self-heal orphaned queue tasks: whenever session is idle and no runs are active,
-        // reset any 'running' queue tasks back to 'pending'.
-        // Throttled to max once per 30s to avoid excessive file I/O from polling.
-        if (state.status === 'idle' && runRegistry.size === 0) {
-            const now = Date.now();
-            if (now - lastOrphanRecoveryTime > 30_000) {
-                lastOrphanRecoveryTime = now;
-                try {
-                    const queue = new TaskQueue();
-                    await queue.recoverOrphans(new Set(runRegistry.activeRunIds()));
-                }
-                catch { /* non-fatal */ }
-            }
-        }
-        // Check if the current run is actually alive in the registry
-        const currentRunId = state.currentRunId ?? null;
-        const alive = currentRunId ? runRegistry.isAlive(currentRunId) : state.status === 'idle' ? null : runRegistry.size > 0;
-        // Self-heal: if status says executing but run is dead, clean up
-        if (currentRunId && alive === false && state.status !== 'idle') {
-            try {
-                new EventLog(currentRunId).done();
-            }
-            catch { /* non-fatal */ }
-            await store.update({ status: 'idle', currentTask: null, currentRunId: null });
-            return JSON.stringify({ ...state, status: 'idle', currentTask: null, currentRunId: null, alive: false }, null, 2);
-        }
-        return JSON.stringify({ ...state, alive }, null, 2);
+    async fw_weaver_status(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const state = controller.getStatus();
+        return JSON.stringify({
+            swarmStatus: state.status,
+            activeBots: Object.values(state.instances).filter(i => i.status === 'executing').length,
+            totalBots: Object.keys(state.instances).length,
+            tasksCompleted: state.tasksCompleted,
+            tasksFailed: state.tasksFailed,
+            totalTokensUsed: state.totalTokensUsed,
+            totalCost: state.totalCost,
+            budgets: state.budgets,
+        }, null, 2);
     },
     async fw_weaver_events(args) {
         const runId = args.runId;
@@ -324,156 +192,6 @@ const toolHandlers = {
         });
         return JSON.stringify(result, null, 2);
     },
-    async fw_weaver_session(args, ctx) {
-        const action = args.action;
-        const store = new SessionStore();
-        if (action === 'status') {
-            const state = store.load();
-            if (!state)
-                return JSON.stringify({ status: 'no active session' });
-            const crid = state.currentRunId ?? null;
-            const alive = crid ? runRegistry.isAlive(crid) : null;
-            return JSON.stringify({ ...state, alive }, null, 2);
-        }
-        if (action === 'stop') {
-            const controller = new SteeringController();
-            await controller.write({ command: 'cancel', timestamp: Date.now() });
-            await store.update({ status: 'idle', currentTask: null });
-            return JSON.stringify({ stopped: true });
-        }
-        if (action === 'start') {
-            const queue = new TaskQueue();
-            const tasks = await queue.list();
-            const pending = tasks.filter(t => t.status === 'pending');
-            if (pending.length === 0) {
-                return JSON.stringify({ error: 'No pending tasks in queue' });
-            }
-            const maxTasks = args.maxTasks ?? pending.length;
-            const sessionId = RunStore.newId().slice(0, 8);
-            const sessionLog = new EventLog(`session-${sessionId}`);
-            // Create session state (save, not update — update requires existing file)
-            await store.save({
-                sessionId,
-                status: 'executing',
-                currentTask: null,
-                completedTasks: 0,
-                totalCost: 0,
-                startedAt: Date.now(),
-                lastActivity: Date.now(),
-            });
-            sessionLog.emit({ type: 'session:started', timestamp: Date.now(), data: {
-                    sessionId, queueSize: pending.length, maxTasks,
-                } });
-            const projectDir = ctx.workspacePath || process.cwd();
-            const packRoot = new URL('..', import.meta.url);
-            let workflowPath = fileURLToPath(new URL('src/workflows/weaver-bot.ts', packRoot));
-            if (!fs.existsSync(workflowPath)) {
-                workflowPath = fileURLToPath(new URL('dist/workflows/weaver-bot.js', packRoot));
-            }
-            // Process tasks sequentially in background
-            (async () => {
-                let completed = 0;
-                let failed = 0;
-                try {
-                    for (let i = 0; i < Math.min(maxTasks, pending.length); i++) {
-                        const task = pending[i];
-                        // Check for cancel signal
-                        try {
-                            const ctrl = new SteeringController();
-                            const signal = await ctrl.check();
-                            if (signal?.command === 'cancel') {
-                                sessionLog.emit({ type: 'session:cancelled', timestamp: Date.now() });
-                                break;
-                            }
-                        }
-                        catch { /* non-fatal */ }
-                        const runId = RunStore.newId();
-                        const taskLog = new EventLog(runId);
-                        // Mark task as running in the queue
-                        try {
-                            await queue.markRunning(task.id);
-                        }
-                        catch { /* non-fatal */ }
-                        await store.update({
-                            status: 'executing',
-                            currentTask: task.instruction,
-                            currentRunId: runId,
-                            lastActivity: Date.now(),
-                        });
-                        sessionLog.emit({ type: 'session:task-start', timestamp: Date.now(), data: {
-                                taskId: runId, instruction: task.instruction, index: i, total: Math.min(maxTasks, pending.length),
-                            } });
-                        taskLog.emit({ type: 'bot-started', timestamp: Date.now(), data: {
-                                instruction: task.instruction, mode: 'create', runId,
-                            } });
-                        // Register in run registry BEFORE calling runWorkflow to prevent
-                        // fw_weaver_events self-healing from writing premature .done
-                        runRegistry.register(runId, { file: workflowPath, startedAt: new Date().toISOString(), promise: Promise.resolve() });
-                        try {
-                            const result = await runWorkflow(workflowPath, {
-                                runId,
-                                params: {
-                                    taskJson: JSON.stringify({
-                                        instruction: task.instruction,
-                                        mode: 'create',
-                                        options: { autoApprove: false },
-                                    }),
-                                    projectDir,
-                                },
-                                config: { provider: 'auto', approval: { mode: 'timeout-auto', timeoutSeconds: 300 } },
-                                eventLog: taskLog,
-                            });
-                            const success = result.success;
-                            completed += success ? 1 : 0;
-                            failed += success ? 0 : 1;
-                            sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
-                                    taskId: runId, outcome: result.outcome, duration: result.executionTime,
-                                    cost: result.cost?.totalCost,
-                                } });
-                            // Mark task in queue
-                            try {
-                                await queue.remove(task.id);
-                            }
-                            catch { /* non-fatal */ }
-                        }
-                        catch (err) {
-                            failed++;
-                            sessionLog.emit({ type: 'session:task-complete', timestamp: Date.now(), data: {
-                                    taskId: runId, outcome: 'error', error: String(err),
-                                } });
-                        }
-                        await store.update({
-                            completedTasks: completed + failed,
-                            currentRunId: null,
-                            lastActivity: Date.now(),
-                        });
-                    }
-                    sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
-                            reason: 'complete', completed, failed, total: completed + failed,
-                        } });
-                }
-                catch (err) {
-                    console.error('[weaver-session] Session failed:', err);
-                    sessionLog.emit({ type: 'session:ended', timestamp: Date.now(), data: {
-                            reason: 'error', error: String(err),
-                        } });
-                }
-                finally {
-                    // GUARANTEED: session log finalized and state reset, even on crash
-                    try {
-                        sessionLog.done();
-                    }
-                    catch { /* already done */ }
-                    try {
-                        await store.update({ status: 'idle', currentTask: null, currentRunId: null });
-                    }
-                    catch { /* non-fatal */ }
-                }
-            })();
-            return JSON.stringify({ started: true, sessionId, taskCount: Math.min(maxTasks, pending.length) });
-        }
-        return JSON.stringify({ error: `Unknown action: ${action}` });
-    },
     async fw_weaver_insights(args, ctx) {
         const projectDir = args.projectDir || ctx.workspacePath;
         const pms = new ProjectModelStore(projectDir);
@@ -539,23 +257,261 @@ const toolHandlers = {
         const ejected = registry.eject(id, newFilePath);
         return JSON.stringify({ ejected, id, filePath: newFilePath });
     },
+    // ---------------------------------------------------------------------------
+    // Task CRUD tools (Swarm)
+    // ---------------------------------------------------------------------------
+    async fw_weaver_task_create(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const input = {
+            title: args.title,
+            description: args.description ?? '',
+            priority: args.priority,
+            parentId: args.parentId,
+            dependsOn: args.dependsOn,
+            budgetTokens: args.budgetTokens,
+            budgetCost: args.budgetCost,
+            timeoutMs: args.timeoutMs,
+            maxAttempts: args.maxAttempts,
+            createdBy: 'ai',
+            assignedProfile: args.assignedProfile,
+            complexity: args.complexity,
+            subtasks: args.subtasks,
+        };
+        const task = await store.create(input);
+        const subtasks = task.isParent ? await store.getSubtasks(task.id) : [];
+        return JSON.stringify({ task, subtasks }, null, 2);
+    },
+    async fw_weaver_task_list(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const tasks = await store.list({
+            status: args.status,
+            parentId: args.parentId,
+            botId: args.botId,
+            limit: args.limit,
+        });
+        return JSON.stringify(tasks, null, 2);
+    },
+    async fw_weaver_task_get(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const task = await store.get(args.id);
+        if (!task)
+            return JSON.stringify({ error: 'Task not found' });
+        const subtasks = task.isParent ? await store.getSubtasks(task.id) : [];
+        return JSON.stringify({ task, subtasks }, null, 2);
+    },
+    async fw_weaver_task_update(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const { id, ...patch } = args;
+        const task = await store.update(id, patch);
+        return JSON.stringify(task, null, 2);
+    },
+    async fw_weaver_task_cancel(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const task = await store.update(args.id, { status: 'cancelled' });
+        return JSON.stringify({ cancelled: true, task });
+    },
+    async fw_weaver_task_retry(args, ctx) {
+        const store = new TaskStore(ctx.workspacePath);
+        const task = await store.get(args.id);
+        if (!task)
+            return JSON.stringify({ error: 'Task not found' });
+        const updated = await store.update(args.id, {
+            status: 'pending',
+            attempt: 0,
+        });
+        return JSON.stringify({ retried: true, task: updated });
+    },
+    // ---------------------------------------------------------------------------
+    // Swarm control tools
+    // ---------------------------------------------------------------------------
+    async fw_weaver_swarm_start(args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        await controller.start({
+            maxConcurrent: args.maxConcurrent,
+            sessionBudgetTokens: args.sessionBudgetTokens,
+            sessionBudgetCost: args.sessionBudgetCost,
+        });
+        return JSON.stringify(controller.getStatus(), null, 2);
+    },
+    async fw_weaver_swarm_pause(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        await controller.pause();
+        return JSON.stringify(controller.getStatus(), null, 2);
+    },
+    async fw_weaver_swarm_stop(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        await controller.stop();
+        return JSON.stringify(controller.getStatus(), null, 2);
+    },
+    async fw_weaver_swarm_status(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        return JSON.stringify(controller.getStatus(), null, 2);
+    },
+    async fw_weaver_swarm_config(args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        controller.configure({
+            maxConcurrent: args.maxConcurrent,
+            workspaceBudgetTokens: args.workspaceBudgetTokens,
+            workspaceBudgetCost: args.workspaceBudgetCost,
+            sessionBudgetTokens: args.sessionBudgetTokens,
+            sessionBudgetCost: args.sessionBudgetCost,
+            autoRetry: args.autoRetry,
+            maxAttemptsDefault: args.maxAttemptsDefault,
+        });
+        return JSON.stringify(controller.getStatus(), null, 2);
+    },
+    async fw_weaver_swarm_events(args, ctx) {
+        const log = new SwarmEventLog(ctx.workspacePath);
+        const offset = args.offset ?? 0;
+        const events = log.tail(offset);
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const done = controller.getStatus().status === 'idle';
+        return JSON.stringify({ events, done });
+    },
+    // ---------------------------------------------------------------------------
+    // Profile CRUD tools
+    // ---------------------------------------------------------------------------
+    async fw_weaver_profile_list(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const profileStore = controller.getProfileStore();
+        const instanceManager = controller.getInstanceManager();
+        const profiles = profileStore.list();
+        const enriched = profiles.map(p => ({
+            ...p,
+            activeInstances: instanceManager.listByProfile(p.id).filter(i => i.status === 'executing').length,
+            idleInstances: instanceManager.findIdle(p.id).length,
+            totalInstances: instanceManager.listByProfile(p.id).length,
+        }));
+        return JSON.stringify(enriched, null, 2);
+    },
+    async fw_weaver_profile_create(args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const profileStore = controller.getProfileStore();
+        const input = {
+            name: args.name,
+            botId: args.botId,
+            capabilities: args.capabilities,
+            preferences: {
+                costStrategy: args.costStrategy ?? 'balanced',
+                maxCostPerRun: args.maxCostPerRun,
+                maxCostPerTask: args.maxCostPerTask,
+                requireApproval: args.requireApproval,
+                instructions: args.instructions,
+            },
+            maxInstances: args.maxInstances,
+            description: args.description,
+            icon: args.icon,
+            color: args.color,
+        };
+        const profile = profileStore.create(input);
+        return JSON.stringify(profile, null, 2);
+    },
+    async fw_weaver_profile_update(args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const profileStore = controller.getProfileStore();
+        const { id, ...rest } = args;
+        // Build a typed patch from the remaining args
+        const patch = {};
+        if (rest.name !== undefined)
+            patch.name = rest.name;
+        if (rest.description !== undefined)
+            patch.description = rest.description;
+        if (rest.icon !== undefined)
+            patch.icon = rest.icon;
+        if (rest.color !== undefined)
+            patch.color = rest.color;
+        if (rest.capabilities !== undefined)
+            patch.capabilities = rest.capabilities;
+        if (rest.maxInstances !== undefined)
+            patch.maxInstances = rest.maxInstances;
+        if (rest.minInstances !== undefined)
+            patch.minInstances = rest.minInstances;
+        if (rest.costStrategy !== undefined || rest.maxCostPerRun !== undefined || rest.maxCostPerTask !== undefined || rest.requireApproval !== undefined || rest.instructions !== undefined) {
+            patch.preferences = {
+                ...(rest.costStrategy !== undefined && { costStrategy: rest.costStrategy }),
+                ...(rest.maxCostPerRun !== undefined && { maxCostPerRun: rest.maxCostPerRun }),
+                ...(rest.maxCostPerTask !== undefined && { maxCostPerTask: rest.maxCostPerTask }),
+                ...(rest.requireApproval !== undefined && { requireApproval: rest.requireApproval }),
+                ...(rest.instructions !== undefined && { instructions: rest.instructions }),
+            };
+        }
+        const profile = profileStore.update(id, patch);
+        return JSON.stringify(profile, null, 2);
+    },
+    async fw_weaver_profile_delete(args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const profileStore = controller.getProfileStore();
+        const deleted = profileStore.delete(args.id);
+        return JSON.stringify({ deleted });
+    },
+    // ---------------------------------------------------------------------------
+    // Orchestrator tools
+    // ---------------------------------------------------------------------------
+    async fw_weaver_orchestrator_status(_args, ctx) {
+        const controller = SwarmController.getInstance(ctx.workspacePath);
+        const { decisions, stats } = controller.getOrchestratorStatus();
+        const instanceManager = controller.getInstanceManager();
+        const allInstances = instanceManager.listAll();
+        return JSON.stringify({
+            recentDecisions: decisions.slice(-20),
+            routingStats: stats,
+            activeInstances: allInstances.filter(i => i.status === 'executing').length,
+            totalInstances: allInstances.length,
+        }, null, 2);
+    },
+    async fw_weaver_orchestrator_hint(args, ctx) {
+        const hint = args.hint;
+        if (!hint)
+            return JSON.stringify({ error: 'hint is required' });
+        const weaverDir = path.join(ctx.workspacePath, '.weaver');
+        fs.mkdirSync(weaverDir, { recursive: true });
+        const hintsPath = path.join(weaverDir, 'orchestrator-hints.json');
+        let hints = [];
+        try {
+            if (fs.existsSync(hintsPath)) {
+                const raw = fs.readFileSync(hintsPath, 'utf-8');
+                const parsed = JSON.parse(raw);
+                if (Array.isArray(parsed))
+                    hints = parsed;
+            }
+        }
+        catch { /* corrupt file — start fresh */ }
+        hints.push({ hint, timestamp: Date.now() });
+        fs.writeFileSync(hintsPath, JSON.stringify(hints, null, 2), 'utf-8');
+        return JSON.stringify({ stored: true });
+    },
 };
 // ---------------------------------------------------------------------------
+// Shared handler — used by both ai-chat-provider and mcp-tools
+// ---------------------------------------------------------------------------
+/**
+ * Execute a weaver tool by name. Shared core for ai-chat-provider and MCP.
+ *
+ * @param toolName  One of the fw_weaver_* tool names
+ * @param args      Tool arguments (as parsed from the caller)
+ * @param projectDir  Workspace / project directory
+ * @returns The JSON-serialised result string
+ */
+export async function handleWeaverTool(toolName, args, projectDir) {
+    const handler = toolHandlers[toolName];
+    if (!handler) {
+        return { result: `Unknown weaver tool: ${toolName}`, isError: true };
+    }
+    try {
+        const ctx = { workspacePath: projectDir, userId: 'mcp' };
+        const result = await handler(args, ctx);
+        return { result, isError: false };
+    }
+    catch (err) {
+        return { result: err instanceof Error ? err.message : String(err), isError: true };
+    }
+}
+// ---------------------------------------------------------------------------
 // Provider implementation
 // ---------------------------------------------------------------------------
 export default {
     async executeTool(name, args, context) {
-        const handler = toolHandlers[name];
-        if (!handler) {
-            return { result: `Unknown weaver tool: ${name}`, isError: true };
-        }
-        try {
-            const result = await handler(args, context);
-            return { result, isError: false };
-        }
-        catch (err) {
-            return { result: err instanceof Error ? err.message : String(err), isError: true };
-        }
+        return handleWeaverTool(name, args, context.workspacePath);
     },
     async getSystemPromptSections(context) {
         const sections = [];
@@ -575,20 +531,35 @@ export default {
         catch {
             // system-prompt module not available — skip
         }
-        // Weaver-specific capabilities beyond core Flow Weaver tools
+        // Weaver-specific capabilities — swarm-aware tool listing
         sections.push({
             id: 'weaver-capabilities',
             title: 'Weaver Capabilities',
-            content: `Beyond standard Flow Weaver tools, you also have:
+            content: `Beyond standard Flow Weaver tools, you have swarm-based task and bot management:
+
+**Task Management:**
+- \`fw_weaver_task_create\`: Create tasks (with optional subtasks via \`subtasks\` array, \`^prev\` shorthand for dependency chaining, \`assignedProfile\` to target specific profiles)
+- \`fw_weaver_task_list\`: List tasks (filter by status, parentId, botId)
+- \`fw_weaver_task_get\`: Get task details including subtasks and context
+- \`fw_weaver_task_update\`: Update task fields (title, description, priority, status)
+- \`fw_weaver_task_cancel\`: Cancel a pending or running task
+- \`fw_weaver_task_retry\`: Reset a failed task back to pending for retry
 
-- \`fw_weaver_bot\`: Autonomous workflow creation/modification from natural language tasks (supports \`botId\` to run registered bots)
-- \`fw_weaver_steer\`: Control running bots (pause, resume, cancel, redirect)
-- \`fw_weaver_status\`: Current bot session state
-- \`fw_weaver_queue\`: Background task queue management
+**Swarm Control:**
+- \`fw_weaver_swarm_start\`: Start the swarm (spawns bot loops that claim and execute tasks)
+- \`fw_weaver_swarm_pause\`: Pause all bot loops (tasks finish current step, then wait)
+- \`fw_weaver_swarm_stop\`: Stop the swarm gracefully
+- \`fw_weaver_swarm_status\`: Full swarm state with per-bot details
+- \`fw_weaver_swarm_config\`: Configure max concurrency, budgets, auto-retry
+- \`fw_weaver_swarm_events\`: Stream swarm-level events for live updates
+
+**Bot & Workflow:**
+- \`fw_weaver_steer\`: Send steering command to a specific bot (requires \`botId\`) — pause, resume, cancel
+- \`fw_weaver_status\`: Quick swarm status summary
 - \`fw_weaver_run\`: Execute any workflow directly
 - \`fw_weaver_insights\`: Project health, trust level, cost summary, recommendations
-- \`fw_weaver_costs\`: Token usage and cost breakdown
-- \`fw_weaver_history\`: Past workflow execution history
+- \`fw_weaver_costs\`: Token usage and cost breakdown (supports \`taskId\`/\`botId\` filters)
+- \`fw_weaver_history\`: Past workflow execution history (supports \`taskId\`/\`botId\` filters)
 - \`fw_weaver_providers\`: Available AI providers
 - \`fw_weaver_genesis\`: Self-evolution cycle for workflows
 - \`fw_weaver_list_bots\`: List all registered bots with validation status
@@ -597,6 +568,16 @@ export default {
 - \`fw_weaver_validate_bot\`: Validate a bot's file and export
 - \`fw_weaver_eject_bot\`: Mark a bot as ejected with a new file path
 
+**Profiles & Orchestrator:**
+- \`fw_weaver_profile_list\`: List all bot profiles with capabilities, instances, and routing info
+- \`fw_weaver_profile_create\`: Create a new bot profile with free-form capabilities (name + description pairs) and preferences (costStrategy, maxCostPerRun, maxCostPerTask, requireApproval, instructions)
+- \`fw_weaver_profile_update\`: Update a bot profile's capabilities, preferences, or scaling config
+- \`fw_weaver_profile_delete\`: Delete a bot profile
+- \`fw_weaver_orchestrator_status\`: Get orchestrator routing status — recent decisions, stats, active instances
+- \`fw_weaver_orchestrator_hint\`: Provide a routing hint to influence orchestrator decisions
+
+**Workflow:** To delegate work, create tasks with \`fw_weaver_task_create\`, then start the swarm with \`fw_weaver_swarm_start\`. The orchestrator automatically routes tasks to the best available bot instance based on free-form capability matching. Use \`fw_weaver_steer\` with a \`botId\` to control individual bots. Use \`fw_weaver_profile_create\` to create specialized profiles with capabilities (name + description pairs) and preferences (costStrategy, maxCostPerRun, instructions), then route tasks via \`assignedProfile\`.
+
 Proactively offer these when relevant.`,
             priority: 15,
         });
@@ -641,7 +622,7 @@ Proactively offer these when relevant.`,
                 // InsightEngine not available — skip
             }
         }
-        // Registered bots
+        // Registered bots — swarm-aware: instruct AI to use task_create, not fw_weaver_bot
         if (context.workspacePath) {
             try {
                 const registry = new BotRegistry(context.workspacePath);
@@ -651,13 +632,48 @@ Proactively offer these when relevant.`,
                     sections.push({
                         id: 'registered-bots',
                         title: 'Registered Bots',
-                        content: `The user has registered bot workflows. To run a bot, use \`fw_weaver_bot\` with \`botId\` parameter.\n\n${botLines}`,
+                        content: `The user has registered bot workflows available for swarm execution. To assign work, use \`fw_weaver_task_create\` with \`assignedProfile\` to route tasks to the right profile.\n\n${botLines}`,
                         priority: 25,
                     });
                 }
             }
             catch { /* non-fatal */ }
         }
+        // Bot profiles — capabilities, scaling, routing info
+        if (context.workspacePath) {
+            try {
+                const controller = SwarmController.getInstance(context.workspacePath);
+                const profileStore = controller.getProfileStore();
+                const profiles = profileStore.list();
+                if (profiles.length > 0) {
+                    const profileLines = profiles.map(p => `- ${p.name} (${p.id}): capabilities=[${p.capabilities.map(c => c.name).join(', ')}], maxInstances=${p.maxInstances}, costStrategy=${p.preferences.costStrategy}`).join('\n');
+                    sections.push({
+                        id: 'bot-profiles',
+                        title: 'Bot Profiles',
+                        content: `${profileLines}\n\nUse fw_weaver_profile_create to create new profiles. Use fw_weaver_task_create with assignedProfile to route tasks to the right profiles.`,
+                        priority: 22,
+                    });
+                }
+            }
+            catch { /* non-fatal */ }
+        }
+        // Swarm status — include if swarm is active
+        if (context.workspacePath) {
+            try {
+                const controller = SwarmController.getInstance(context.workspacePath);
+                const swarmState = controller.getStatus();
+                if (swarmState.status !== 'idle') {
+                    const activeInstances = Object.values(swarmState.instances).filter(i => i.status === 'executing').length;
+                    sections.push({
+                        id: 'swarm-status',
+                        title: 'Swarm Status',
+                        content: `The swarm is currently **${swarmState.status}** with ${activeInstances} active instance(s) out of ${Object.keys(swarmState.instances).length} total. Tasks completed: ${swarmState.tasksCompleted}, failed: ${swarmState.tasksFailed}. Total cost: $${swarmState.totalCost.toFixed(4)}, tokens: ${swarmState.totalTokensUsed}.`,
+                        priority: 12,
+                    });
+                }
+            }
+            catch { /* non-fatal */ }
+        }
         return sections;
     },
 };