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

package/src/ai-chat-provider.ts

@@ -16,18 +16,17 @@ 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';
+import type { CreateTaskInput, TaskFilter } from './bot/task-types.js';
+import type { CreateProfileInput } from './bot/profile-types.js';
 
 interface AiChatToolContext {
   workspacePath: string;
@@ -79,16 +78,22 @@ const toolHandlers: Record<
       const record = store.get(args.id as string);
       return record ? JSON.stringify(record, null, 2) : `No run found matching "${args.id}"`;
     }
+    const taskId = args.taskId as string | undefined;
+    const botId = args.botId as string | undefined;
     const records = store.list({
       outcome: args.outcome as 'completed' | 'failed' | 'error' | 'skipped' | undefined,
       workflowFile: args.workflowFile as string | undefined,
       limit: (args.limit as number | undefined) ?? 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 as string | undefined;
+    const _botId = args.botId as string | undefined;
     let sinceTs: number | undefined;
     if (args.since) {
       const spec = args.since as string;
@@ -103,6 +108,7 @@ const toolHandlers: Record<
         if (!isNaN(ts)) 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 as string | undefined });
     return JSON.stringify(summary, null, 2);
   },
@@ -121,180 +127,33 @@ const toolHandlers: Record<
     return JSON.stringify(result, null, 2);
   },
 
-  async fw_weaver_bot(args, ctx) {
-    // Resolve bot from registry if botId is provided
-    const botId = args.botId as string | undefined;
-    let registryWorkflowFile: string | undefined;
-
-    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 as string,
-      mode: (args.mode as string) ?? 'create',
-      targets: args.targets as string[] | undefined,
-      options: {
-        template: args.template as string | undefined,
-        dryRun: args.dryRun as boolean | undefined,
-        autoApprove: (args.autoApprove as boolean | undefined) ?? false,
-      },
-    };
-    const packRoot = new URL('..', import.meta.url);
-    let workflowPath: string;
-    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<void>(() => {}); // 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 as boolean | undefined,
-      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({
-      command: args.command as 'pause' | 'resume' | 'cancel' | 'redirect' | 'queue',
-      payload: args.payload as string | undefined,
+  async fw_weaver_steer(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const botId = args.botId as string;
+    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 as string,
+      payload: args.payload as Record<string, unknown> | undefined,
       timestamp: Date.now(),
-    });
-    return `Steering command sent: ${args.command}`;
+    }, null, 2), 'utf-8');
+    return JSON.stringify({ sent: true, botId, command: 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 as string, 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 as string);
-        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 as string, args.priority as number);
-        return reordered ? `Reordered ${args.id} to priority ${args.priority}` : `Not found: ${args.id}`;
-      }
-      default:
-        return `Unknown action: ${args.action}`;
-    }
-  },
-
-  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: Record<string, unknown>, ctx: AiChatToolContext) {
+    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) {
@@ -378,179 +237,6 @@ const toolHandlers: Record<
     return JSON.stringify(result, null, 2);
   },
 
-  async fw_weaver_session(args, ctx) {
-    const action = args.action as string;
-
-    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 as number) ?? 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) {
 
 
@@ -623,8 +309,276 @@ const toolHandlers: Record<
     const ejected = registry.eject(id, newFilePath);
     return JSON.stringify({ ejected, id, filePath: newFilePath });
   },
+
+  // ---------------------------------------------------------------------------
+  // Task CRUD tools (Swarm)
+  // ---------------------------------------------------------------------------
+
+  async fw_weaver_task_create(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const input: CreateTaskInput = {
+      title: args.title as string,
+      description: (args.description as string) ?? '',
+      priority: args.priority as number | undefined,
+      parentId: args.parentId as string | undefined,
+      dependsOn: args.dependsOn as string[] | undefined,
+      budgetTokens: args.budgetTokens as number | undefined,
+      budgetCost: args.budgetCost as number | undefined,
+      timeoutMs: args.timeoutMs as number | undefined,
+      maxAttempts: args.maxAttempts as number | undefined,
+      createdBy: 'ai',
+      assignedProfile: args.assignedProfile as string | undefined,
+      complexity: args.complexity as CreateTaskInput['complexity'],
+      subtasks: args.subtasks as CreateTaskInput['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: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const tasks = await store.list({
+      status: args.status as TaskFilter['status'],
+      parentId: args.parentId as string | undefined,
+      botId: args.botId as string | undefined,
+      limit: args.limit as number | undefined,
+    });
+    return JSON.stringify(tasks, null, 2);
+  },
+
+  async fw_weaver_task_get(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const task = await store.get(args.id as string);
+    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: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const { id, ...patch } = args;
+    const task = await store.update(id as string, patch);
+    return JSON.stringify(task, null, 2);
+  },
+
+  async fw_weaver_task_cancel(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const task = await store.update(args.id as string, { status: 'cancelled' });
+    return JSON.stringify({ cancelled: true, task });
+  },
+
+  async fw_weaver_task_retry(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const store = new TaskStore(ctx.workspacePath);
+    const task = await store.get(args.id as string);
+    if (!task) return JSON.stringify({ error: 'Task not found' });
+    const updated = await store.update(args.id as string, {
+      status: 'pending',
+      attempt: 0,
+    });
+    return JSON.stringify({ retried: true, task: updated });
+  },
+
+  // ---------------------------------------------------------------------------
+  // Swarm control tools
+  // ---------------------------------------------------------------------------
+
+  async fw_weaver_swarm_start(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    await controller.start({
+      maxConcurrent: args.maxConcurrent as number | undefined,
+      sessionBudgetTokens: args.sessionBudgetTokens as number | undefined,
+      sessionBudgetCost: args.sessionBudgetCost as number | undefined,
+    });
+    return JSON.stringify(controller.getStatus(), null, 2);
+  },
+
+  async fw_weaver_swarm_pause(_args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    await controller.pause();
+    return JSON.stringify(controller.getStatus(), null, 2);
+  },
+
+  async fw_weaver_swarm_stop(_args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    await controller.stop();
+    return JSON.stringify(controller.getStatus(), null, 2);
+  },
+
+  async fw_weaver_swarm_status(_args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    return JSON.stringify(controller.getStatus(), null, 2);
+  },
+
+  async fw_weaver_swarm_config(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    controller.configure({
+      maxConcurrent: args.maxConcurrent as number | undefined,
+      workspaceBudgetTokens: args.workspaceBudgetTokens as number | undefined,
+      workspaceBudgetCost: args.workspaceBudgetCost as number | undefined,
+      sessionBudgetTokens: args.sessionBudgetTokens as number | undefined,
+      sessionBudgetCost: args.sessionBudgetCost as number | undefined,
+      autoRetry: args.autoRetry as boolean | undefined,
+      maxAttemptsDefault: args.maxAttemptsDefault as number | undefined,
+    });
+    return JSON.stringify(controller.getStatus(), null, 2);
+  },
+
+  async fw_weaver_swarm_events(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const log = new SwarmEventLog(ctx.workspacePath);
+    const offset = (args.offset as number) ?? 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: Record<string, unknown>, ctx: AiChatToolContext) {
+    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: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    const profileStore = controller.getProfileStore();
+    const input: CreateProfileInput = {
+      name: args.name as string,
+      botId: args.botId as string,
+      capabilities: args.capabilities as CreateProfileInput['capabilities'],
+      preferences: {
+        costStrategy: (args.costStrategy as 'frugal' | 'balanced' | 'performance') ?? 'balanced',
+        maxCostPerRun: args.maxCostPerRun as number | undefined,
+        maxCostPerTask: args.maxCostPerTask as number | undefined,
+        requireApproval: args.requireApproval as boolean | undefined,
+        instructions: args.instructions as string | undefined,
+      },
+      maxInstances: args.maxInstances as number | undefined,
+      description: args.description as string | undefined,
+      icon: args.icon as string | undefined,
+      color: args.color as string | undefined,
+    };
+    const profile = profileStore.create(input);
+    return JSON.stringify(profile, null, 2);
+  },
+
+  async fw_weaver_profile_update(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    const profileStore = controller.getProfileStore();
+    const { id, ...rest } = args;
+
+    // Build a typed patch from the remaining args
+    const patch: Record<string, unknown> = {};
+    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 as string, patch);
+    return JSON.stringify(profile, null, 2);
+  },
+
+  async fw_weaver_profile_delete(args: Record<string, unknown>, ctx: AiChatToolContext) {
+    const controller = SwarmController.getInstance(ctx.workspacePath);
+    const profileStore = controller.getProfileStore();
+    const deleted = profileStore.delete(args.id as string);
+    return JSON.stringify({ deleted });
+  },
+
+  // ---------------------------------------------------------------------------
+  // Orchestrator tools
+  // ---------------------------------------------------------------------------
+
+  async fw_weaver_orchestrator_status(_args: Record<string, unknown>, ctx: AiChatToolContext) {
+    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: Record<string, unknown>, ctx: AiChatToolContext) {
+    const hint = args.hint as string;
+    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: Array<{ hint: string; timestamp: number }> = [];
+    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: string,
+  args: Record<string, unknown>,
+  projectDir: string,
+): Promise<{ result: string; isError: boolean }> {
+  const handler = toolHandlers[toolName];
+  if (!handler) {
+    return { result: `Unknown weaver tool: ${toolName}`, isError: true };
+  }
+  try {
+    const ctx: AiChatToolContext = { 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
 // ---------------------------------------------------------------------------
@@ -635,16 +589,7 @@ export default {
     args: Record<string, unknown>,
     context: AiChatToolContext,
   ): Promise<AiChatToolResult> {
-    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(
@@ -668,20 +613,35 @@ export default {
       // 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:
-
-- \`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
+      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
+
+**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
@@ -690,6 +650,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,
     });
@@ -740,7 +710,7 @@ Proactively offer these when relevant.`,
       }
     }
 
-    // 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);
@@ -750,13 +720,50 @@ 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;
   },
 };