@synergenius/flow-weaver-pack-weaver 0.9.62 → 0.9.78

package/src/bot/swarm-controller.ts

@@ -1,8 +1,9 @@
 /**
  * SwarmController — multi-bot orchestrator for the Weaver Swarm.
  *
- * Manages concurrent async bot loops, budget enforcement, crash recovery,
- * dependency resolution, and state persistence.
+ * Uses a centralized orchestrator dispatch loop instead of per-bot pull loops.
+ * The Orchestrator routes pending tasks to the best available bot instance,
+ * the InstanceManager handles scaling, and the ProfileStore persists profiles.
  *
  * Singleton per workspace via `SwarmController.getInstance(projectDir)`.
  */
@@ -18,6 +19,11 @@ import { EventLog } from './event-log.js';
 import { runRegistry } from './run-registry.js';
 import { runWorkflow } from './runner.js';
 import { buildTaskPrompt } from './task-prompt-builder.js';
+import { Orchestrator } from './orchestrator.js';
+import { AIRouterImpl } from './ai-router.js';
+import { InstanceManager } from './instance-manager.js';
+import { ProfileStore } from './profile-store.js';
+import type { BotProfile, BotInstance, OrchestratorInput, OrchestratorDecision } from './profile-types.js';
 import type { Task, RunSummary } from './task-types.js';
 import type { WorkflowResult } from './types.js';
 
@@ -25,17 +31,6 @@ import type { WorkflowResult } from './types.js';
 // Types
 // ---------------------------------------------------------------------------
 
-export interface BotSlot {
-  botId: string;
-  botName: string;
-  status: 'idle' | 'executing' | 'paused' | 'stopped';
-  currentTaskId?: string;
-  currentRunId?: string;
-  startedAt?: string;
-  tokensUsed: number;
-  cost: number;
-}
-
 export interface SwarmBudgets {
   workspace: { limitTokens: number; usedTokens: number; limitCost: number; usedCost: number };
   session: { limitTokens: number; usedTokens: number; limitCost: number; usedCost: number };
@@ -45,7 +40,8 @@ export interface SwarmState {
   status: 'idle' | 'running' | 'paused' | 'stopping';
   startedAt?: string;
 
-  bots: Record<string, BotSlot>;
+  /** Active bot instances managed by InstanceManager. */
+  instances: Record<string, BotInstance>;
   maxConcurrent: number;
 
   budgets: SwarmBudgets;
@@ -80,7 +76,7 @@ export interface SwarmStartConfig {
 // Constants
 // ---------------------------------------------------------------------------
 
-const BOT_LOOP_SLEEP_MS = 2000;
+const DISPATCH_LOOP_SLEEP_MS = 2000;
 const SWARM_STATE_FILE = 'swarm.json';
 
 // ---------------------------------------------------------------------------
@@ -95,13 +91,21 @@ export class SwarmController {
   private readonly statePath: string;
   private readonly taskStore: TaskStore;
   private readonly eventLog: SwarmEventLog;
+  private readonly orchestrator: Orchestrator;
+  private readonly instanceManager: InstanceManager;
+  private readonly profileStore: ProfileStore;
 
   private state: SwarmState;
 
-  /** Active bot loop abort controllers (one per spawned loop). */
-  private botAborts = new Map<string, AbortController>();
-  /** Promises for active bot loops (resolved when the loop exits). */
-  private botLoopPromises = new Map<string, Promise<void>>();
+  /** Abort controller for the single dispatch loop. */
+  private dispatchAbort: AbortController | null = null;
+  /** Promise for the dispatch loop (resolved when the loop exits). */
+  private dispatchLoopPromise: Promise<void> | null = null;
+  /** Promises for currently executing tasks (instanceId -> Promise). */
+  private executionPromises = new Map<string, Promise<void>>();
+
+  /** Map of profileId -> BotRegistration for workflow execution. */
+  private profileBotMap = new Map<string, BotRegistration>();
 
   // -----------------------------------------------------------------------
   // Singleton
@@ -129,9 +133,19 @@ export class SwarmController {
     this.statePath = path.join(this.weaverDir, SWARM_STATE_FILE);
     this.taskStore = new TaskStore(projectDir);
     this.eventLog = new SwarmEventLog(projectDir);
+    this.orchestrator = new Orchestrator({ aiRouter: new AIRouterImpl(projectDir) });
+    this.instanceManager = new InstanceManager();
+    this.profileStore = new ProfileStore(projectDir);
 
     // Load persisted state or create default
     this.state = this._loadState();
+
+    // Crash recovery: no dispatch loop survives a process restart, so reset
+    // any stale active status back to idle so start() is not short-circuited.
+    if (this.state.status === 'running' || this.state.status === 'paused' || this.state.status === 'stopping') {
+      this.state.status = 'idle';
+    }
+
     this._persist();
   }
 
@@ -155,30 +169,48 @@ export class SwarmController {
     const registry = new BotRegistry(this.projectDir);
     const bots = registry.list();
 
-    // Reset bot slots — bots beyond maxConcurrent start as 'stopped'
-    this.state.bots = {};
-    for (let i = 0; i < bots.length; i++) {
-      const bot = bots[i]!;
-      this.state.bots[bot.id] = {
-        botId: bot.id,
-        botName: bot.name,
-        status: i < this.state.maxConcurrent ? 'idle' : 'stopped',
-        tokensUsed: 0,
-        cost: 0,
-      };
+    // Ensure default profiles exist for all registered bots
+    this.profileStore.ensureDefaultProfiles(
+      bots.map((b) => ({ id: b.id, name: b.name, icon: b.icon, color: b.color })),
+    );
+
+    // Load profiles and build profile-to-bot mapping
+    const profiles = this.profileStore.list();
+    this.profileBotMap.clear();
+    for (const profile of profiles) {
+      const bot = bots.find((b) => b.id === profile.botId);
+      if (bot) this.profileBotMap.set(profile.id, bot);
     }
 
+    // Stop any existing instances
+    this.instanceManager.stopAll();
+
+    // Spawn initial instances per profile (up to maxConcurrent total)
+    let totalSpawned = 0;
+    for (const profile of profiles) {
+      if (totalSpawned >= this.state.maxConcurrent) break;
+
+      // Spawn at least minInstances, or 1 if minInstances is 0
+      const toSpawn = Math.max(profile.minInstances, 1);
+      const clamped = Math.min(toSpawn, this.state.maxConcurrent - totalSpawned);
+
+      for (let i = 0; i < clamped; i++) {
+        this.instanceManager.spawn(profile);
+        totalSpawned++;
+      }
+    }
+
+    // Populate state fields
+    this._syncInstancesState();
+
     this.state.status = 'running';
     this.state.startedAt = new Date().toISOString();
     this._persist();
 
     this.eventLog.emit({ type: 'swarm-started', timestamp: Date.now() });
 
-    // Spawn bot loops (up to maxConcurrent)
-    const botsToSpawn = bots.slice(0, this.state.maxConcurrent);
-    for (const bot of botsToSpawn) {
-      this._spawnBotLoop(bot);
-    }
+    // Start the centralized dispatch loop
+    this._startDispatchLoop();
   }
 
   async pause(): Promise<void> {
@@ -189,7 +221,7 @@ export class SwarmController {
 
     this.eventLog.emit({ type: 'swarm-paused', timestamp: Date.now() });
 
-    // Bots will check the paused status and wind down after their current task
+    // The dispatch loop will check paused status and skip routing
   }
 
   async stop(): Promise<void> {
@@ -198,33 +230,40 @@ export class SwarmController {
     this.state.status = 'stopping';
     this._persist();
 
-    // Signal all bot loops to stop
-    for (const [, abort] of this.botAborts) {
-      abort.abort();
+    // Signal the dispatch loop to stop
+    if (this.dispatchAbort) {
+      this.dispatchAbort.abort();
     }
 
-    // Wait for all bot loops to finish
-    const loopPromises = Array.from(this.botLoopPromises.values());
-    await Promise.allSettled(loopPromises);
-
-    // Mark all bots as stopped
-    for (const slot of Object.values(this.state.bots)) {
-      slot.status = 'stopped';
-      slot.currentTaskId = undefined;
-      slot.currentRunId = undefined;
+    // Wait for the dispatch loop to finish
+    if (this.dispatchLoopPromise) {
+      await this.dispatchLoopPromise;
     }
 
+    // Wait for all running executions to finish
+    const execPromises = Array.from(this.executionPromises.values());
+    await Promise.allSettled(execPromises);
+
+    // Stop all instances
+    this.instanceManager.stopAll();
+
+    // Update state
+    this._syncInstancesState();
+
     this.state.status = 'idle';
     this._persist();
 
-    this.botAborts.clear();
-    this.botLoopPromises.clear();
+    this.dispatchAbort = null;
+    this.dispatchLoopPromise = null;
+    this.executionPromises.clear();
 
     this.eventLog.emit({ type: 'swarm-stopped', timestamp: Date.now() });
   }
 
   getStatus(): SwarmState {
-    return { ...this.state, bots: { ...this.state.bots } };
+    // Sync instances from InstanceManager before returning
+    this._syncInstancesState();
+    return { ...this.state, instances: { ...this.state.instances } };
   }
 
   configure(config: SwarmConfig): void {
@@ -243,12 +282,11 @@ export class SwarmController {
   // -----------------------------------------------------------------------
 
   async recover(): Promise<void> {
-    // Reset all bots to idle
-    for (const slot of Object.values(this.state.bots)) {
-      if (slot.status === 'executing') {
-        slot.status = 'idle';
-        slot.currentTaskId = undefined;
-        slot.currentRunId = undefined;
+    // Reset all instances to idle
+    const allInstances = this.instanceManager.listAll();
+    for (const inst of allInstances) {
+      if (inst.status === 'executing') {
+        this.instanceManager.markIdle(inst.instanceId, false);
       }
     }
 
@@ -270,6 +308,7 @@ export class SwarmController {
 
     // Reset swarm status to idle
     this.state.status = 'idle';
+    this._syncInstancesState();
     this._persist();
   }
 
@@ -277,13 +316,11 @@ export class SwarmController {
   // Token/cost recording
   // -----------------------------------------------------------------------
 
-  recordTokenUsage(botId: string, _taskId: string, tokensUsed: number, cost: number): void {
-    // Update bot slot
-    const slot = this.state.bots[botId];
-    if (slot) {
-      slot.tokensUsed += tokensUsed;
-      slot.cost += cost;
-    }
+  recordTokenUsage(instanceId: string, _taskId: string, tokensUsed: number, cost: number): void {
+    // Update instance in InstanceManager
+    try {
+      this.instanceManager.recordUsage(instanceId, tokensUsed, cost);
+    } catch { /* instance may not exist if stopped */ }
 
     // Update session budgets
     this.state.budgets.session.usedTokens += tokensUsed;
@@ -302,49 +339,63 @@ export class SwarmController {
     this.eventLog.emit({
       type: 'budget-updated',
       timestamp: Date.now(),
-      data: { botId, tokensUsed, cost },
+      data: { botId: instanceId, tokensUsed, cost },
     });
   }
 
   // -----------------------------------------------------------------------
-  // Bot loop
+  // Orchestrator accessors
   // -----------------------------------------------------------------------
 
-  private _spawnBotLoop(bot: BotRegistration): void {
+  getProfileStore(): ProfileStore {
+    return this.profileStore;
+  }
+
+  getInstanceManager(): InstanceManager {
+    return this.instanceManager;
+  }
+
+  getOrchestrator(): Orchestrator {
+    return this.orchestrator;
+  }
+
+  getOrchestratorStatus(): { decisions: OrchestratorDecision[]; stats: { totalDecisions: number; assignmentsByMethod: Record<string, number> } } {
+    const decisions = this.orchestrator.getDecisionLog();
+    const stats = {
+      totalDecisions: decisions.length,
+      assignmentsByMethod: {} as Record<string, number>,
+    };
+    for (const d of decisions) {
+      stats.assignmentsByMethod[d.method] = (stats.assignmentsByMethod[d.method] ?? 0) + 1;
+    }
+    return { decisions, stats };
+  }
+
+  // -----------------------------------------------------------------------
+  // Dispatch loop
+  // -----------------------------------------------------------------------
+
+  private _startDispatchLoop(): void {
     const abort = new AbortController();
-    this.botAborts.set(bot.id, abort);
+    this.dispatchAbort = abort;
 
-    const loopPromise = this._botLoop(bot, abort.signal).catch(() => {
-      // Swallow errors in bot loops — they self-heal on next iteration
+    this.dispatchLoopPromise = this._dispatchLoop(abort.signal).catch(() => {
+      // Swallow errors in dispatch loop — self-heals on next cycle
     });
-    this.botLoopPromises.set(bot.id, loopPromise);
   }
 
-  private async _botLoop(bot: BotRegistration, signal: AbortSignal): Promise<void> {
-    const botId = bot.id;
-
+  private async _dispatchLoop(signal: AbortSignal): Promise<void> {
     while (!signal.aborted) {
       // Check if swarm is still running
       if (this.state.status === 'stopping' || this.state.status === 'idle') break;
 
-      // Check if paused
+      // Check if paused — sleep and try again
       if (this.state.status === 'paused') {
-        this._updateSlot(botId, { status: 'paused' });
-        await this._sleep(BOT_LOOP_SLEEP_MS, signal);
-        continue;
-      }
-
-      // Check per-bot steering
-      await this._checkSteering(botId);
-
-      // Check if this bot is individually paused
-      const slot = this.state.bots[botId];
-      if (slot?.status === 'paused') {
-        await this._sleep(BOT_LOOP_SLEEP_MS, signal);
+        await this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
         continue;
       }
 
-      // Budget check — before claiming a task
+      // Budget check before routing
       if (this._isBudgetExceeded()) {
         this.state.status = 'paused';
         this._persist();
@@ -356,100 +407,139 @@ export class SwarmController {
         break;
       }
 
-      // Claim next task
-      const task = await this.taskStore.claimNext(botId);
-      if (!task) {
-        this._updateSlot(botId, { status: 'idle', currentTaskId: undefined, currentRunId: undefined });
-        await this._sleep(BOT_LOOP_SLEEP_MS, signal);
-        continue;
+      // Check instance-level steering
+      const allInstances = this.instanceManager.listAll();
+      for (const inst of allInstances) {
+        await this._checkSteering(inst.instanceId);
       }
 
-      // Execute the task
-      this._updateSlot(botId, { status: 'executing', currentTaskId: task.id });
-      this.eventLog.emit({
-        type: 'task-claimed',
-        timestamp: Date.now(),
-        data: { botId, taskId: task.id, taskTitle: task.title },
+      // Collect pending tasks (and all tasks for dependency checks)
+      const pendingTasks = await this.taskStore.list({ status: ['pending', 'failed'] });
+      const allTasks = await this.taskStore.list();
+      const routableTasks = pendingTasks.filter((t) => {
+        // Skip parent tasks
+        if (t.isParent) return false;
+        // Skip tasks that have exhausted retries
+        if (t.status === 'failed' && t.attempt >= t.maxAttempts) return false;
+        // Skip tasks over per-task budget
+        if (t.budgetTokens !== undefined && t.tokensUsed >= t.budgetTokens) return false;
+        if (t.budgetCost !== undefined && t.costUsed >= t.budgetCost) return false;
+        // Skip tasks whose dependencies are not all done
+        if (t.dependsOn && t.dependsOn.length > 0) {
+          const allDepsDone = t.dependsOn.every((depId) => {
+            const dep = allTasks.find((d) => d.id === depId);
+            return dep && dep.status === 'done';
+          });
+          if (!allDepsDone) return false;
+        }
+        return true;
       });
 
-      let result: WorkflowResult;
-      let runId: string;
-      const startTime = Date.now();
-
-      try {
-        runId = RunStore.newId();
-        this._updateSlot(botId, { currentRunId: runId });
-
-        // Build prompt from task context
-        const parentTask = task.parentId ? await this.taskStore.get(task.parentId) : null;
-        const siblingTasks = task.parentId ? await this.taskStore.getSubtasks(task.parentId) : [];
-        const prompt = buildTaskPrompt(task, parentTask, siblingTasks);
-
-        // Create per-run event log
-        const runEventLog = new EventLog(runId);
-
-        // Execute workflow
-        result = await runWorkflow(bot.filePath, {
-          runId,
-          taskId: task.id,
-          botId,
-          params: { taskJson: prompt, projectDir: this.projectDir },
-          eventLog: runEventLog,
-        });
-
-        runEventLog.done();
-      } catch (err) {
-        result = {
-          success: false,
-          summary: (err instanceof Error ? err.message : String(err)),
-          outcome: 'error',
-        };
-        runId = runId! ?? 'error-' + Date.now();
+      if (routableTasks.length === 0) {
+        await this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
+        continue;
       }
 
-      const durationMs = Date.now() - startTime;
-
-      // Extract run summary
-      const tokensUsed = (result.cost?.totalInputTokens ?? 0) + (result.cost?.totalOutputTokens ?? 0);
-      const costUsed = result.cost?.totalCost ?? 0;
-
-      const runSummary: RunSummary = {
-        runId: runId!,
-        botId,
-        outcome: result.success ? 'success' : 'failed',
-        summary: result.summary || (result.success ? 'Completed' : 'Failed'),
-        filesModified: [],
-        error: result.success ? undefined : (result.summary || 'Unknown error'),
-        durationMs,
-        tokensUsed,
-        cost: costUsed,
+      // Build orchestrator input
+      const profiles = this.profileStore.list();
+      const instances = this.instanceManager.listAll();
+      const { workspace, session } = this.state.budgets;
+
+      const budgetRemaining = {
+        tokens: this._remainingBudget(session.limitTokens, session.usedTokens, workspace.limitTokens, workspace.usedTokens),
+        cost: this._remainingBudget(session.limitCost, session.usedCost, workspace.limitCost, workspace.usedCost),
       };
 
-      // Release task
-      const releaseStatus = result.success ? 'done' : 'failed';
-      await this.taskStore.release(task.id, releaseStatus, runSummary);
+      const input: OrchestratorInput = {
+        pendingTasks: routableTasks.map((t) => ({
+          id: t.id,
+          title: t.title,
+          description: t.description,
+          priority: t.priority,
+          complexity: t.complexity ?? 'moderate',
+          assignedProfile: t.assignedProfile,
+          context: {
+            runSummaries: t.context.runSummaries.map((rs) => ({
+              outcome: rs.outcome,
+              botId: rs.botId,
+            })),
+          },
+        })),
+        profiles,
+        instances,
+        budgetRemaining,
+      };
 
-      // Record token usage
-      this.recordTokenUsage(botId, task.id, tokensUsed, costUsed);
+      // Route
+      const output = await this.orchestrator.route(input);
 
-      // Update stats
-      if (result.success) {
-        this.state.tasksCompleted += 1;
-      } else {
-        this.state.tasksFailed += 1;
+      // Apply scale actions
+      for (const sa of output.scaleActions) {
+        const profile = profiles.find((p) => p.id === sa.profileId);
+        if (profile) {
+          this.instanceManager.scaleTo(profile, sa.targetInstances);
+        }
       }
 
-      // Emit task event
-      this.eventLog.emit({
-        type: result.success ? 'task-done' : 'task-failed',
-        timestamp: Date.now(),
-        data: { botId, taskId: task.id, taskTitle: task.title, outcome: runSummary.outcome },
-      });
+      // Apply assignments
+      for (const assignment of output.assignments) {
+        const profile = profiles.find((p) => p.id === assignment.profileId);
+        const bot = this.profileBotMap.get(assignment.profileId);
+        if (!profile || !bot) continue;
+
+        try {
+          // Assign task in TaskStore
+          await this.taskStore.assignToInstance(assignment.taskId, assignment.instanceId, assignment.profileId);
+
+          // Mark instance as executing and store runId on task for live streaming
+          const runId = RunStore.newId();
+          this.instanceManager.markExecuting(assignment.instanceId, assignment.taskId, runId);
+          await this.taskStore.update(assignment.taskId, { currentRunId: runId });
+
+          // Sync state for dashboard
+          this._syncInstancesState();
+          this._persist();
+
+          this.eventLog.emit({
+            type: 'task-claimed',
+            timestamp: Date.now(),
+            data: { botId: assignment.instanceId, taskId: assignment.taskId, profileId: assignment.profileId, method: assignment.method },
+          });
+
+          // Spawn execution (non-blocking)
+          const execPromise = this._executeTask(assignment.instanceId, assignment.taskId, runId, bot, profile).catch(() => {
+            // errors handled inside _executeTask
+          });
+          this.executionPromises.set(assignment.instanceId, execPromise);
+        } catch {
+          // Assignment failed (task may have been grabbed by another cycle) — skip
+        }
+      }
 
-      // Reset bot slot
-      this._updateSlot(botId, { status: 'idle', currentTaskId: undefined, currentRunId: undefined });
+      // Wait for completions via Promise.race with a sleep timeout
+      if (this.executionPromises.size > 0) {
+        const sleepPromise = this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
+        await Promise.race([
+          Promise.race(Array.from(this.executionPromises.values())),
+          sleepPromise,
+        ]);
+      } else {
+        await this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
+      }
+
+      // Clean up completed execution promises
+      for (const [instanceId, promise] of this.executionPromises) {
+        // Check if resolved by racing with an immediately resolved promise
+        const result = await Promise.race([
+          promise.then(() => 'done'),
+          Promise.resolve('pending'),
+        ]);
+        if (result === 'done') {
+          this.executionPromises.delete(instanceId);
+        }
+      }
 
-      // Post-completion budget check
+      // Post-cycle budget check
       if (this._isBudgetExceeded()) {
         this.state.status = 'paused';
         this._persist();
@@ -461,11 +551,102 @@ export class SwarmController {
         break;
       }
 
+      this._syncInstancesState();
       this._persist();
     }
+  }
+
+  // -----------------------------------------------------------------------
+  // Task execution
+  // -----------------------------------------------------------------------
+
+  private async _executeTask(
+    instanceId: string,
+    taskId: string,
+    runId: string,
+    bot: BotRegistration,
+    profile: BotProfile,
+  ): Promise<void> {
+    const startTime = Date.now();
+    let result: WorkflowResult;
 
-    // Mark bot as stopped when loop exits
-    this._updateSlot(botId, { status: 'stopped', currentTaskId: undefined, currentRunId: undefined });
+    try {
+      const task = await this.taskStore.get(taskId);
+      if (!task) throw new Error(`Task not found: ${taskId}`);
+
+      // Build prompt from task context
+      const parentTask = task.parentId ? await this.taskStore.get(task.parentId) : null;
+      const siblingTasks = task.parentId ? await this.taskStore.getSubtasks(task.parentId) : [];
+      const prompt = buildTaskPrompt(task, parentTask, siblingTasks, profile.preferences);
+
+      // Create per-run event log
+      const runEventLog = new EventLog(runId);
+
+      // Execute workflow
+      result = await runWorkflow(bot.filePath, {
+        runId,
+        taskId,
+        botId: instanceId,
+        config: { provider: 'auto' },
+        params: { taskJson: prompt, projectDir: this.projectDir },
+        eventLog: runEventLog,
+      });
+
+      runEventLog.done();
+    } catch (err) {
+      result = {
+        success: false,
+        summary: (err instanceof Error ? err.message : String(err)),
+        outcome: 'error',
+      };
+    }
+
+    const durationMs = Date.now() - startTime;
+
+    // Extract run summary
+    const tokensUsed = Math.max(0, (result.cost?.totalInputTokens ?? 0) + (result.cost?.totalOutputTokens ?? 0));
+    const costUsed = Math.max(0, result.cost?.totalCost ?? 0);
+
+    const runSummary: RunSummary = {
+      runId,
+      botId: instanceId,
+      outcome: result.success ? 'success' : 'failed',
+      summary: result.summary || (result.success ? 'Completed' : 'Failed'),
+      filesModified: [],
+      error: result.success ? undefined : (result.summary || 'Unknown error'),
+      durationMs,
+      tokensUsed,
+      cost: costUsed,
+    };
+
+    // Release task
+    const releaseStatus = result.success ? 'done' : 'failed';
+    await this.taskStore.release(taskId, releaseStatus, runSummary);
+
+    // Record token usage
+    this.recordTokenUsage(instanceId, taskId, tokensUsed, costUsed);
+
+    // Update stats
+    if (result.success) {
+      this.state.tasksCompleted += 1;
+    } else {
+      this.state.tasksFailed += 1;
+    }
+
+    // Mark instance as idle
+    try {
+      this.instanceManager.markIdle(instanceId, result.success);
+    } catch { /* instance may have been stopped */ }
+
+    // Emit task event
+    this.eventLog.emit({
+      type: result.success ? 'task-done' : 'task-failed',
+      timestamp: Date.now(),
+      data: { botId: instanceId, taskId, outcome: runSummary.outcome },
+    });
+
+    this._syncInstancesState();
+    this._persist();
   }
 
   // -----------------------------------------------------------------------
@@ -486,12 +667,26 @@ export class SwarmController {
     return false;
   }
 
+  /** Calculate remaining budget across session and workspace. */
+  private _remainingBudget(
+    sessionLimit: number,
+    sessionUsed: number,
+    workspaceLimit: number,
+    workspaceUsed: number,
+  ): number {
+    const remaining: number[] = [];
+    if (sessionLimit > 0) remaining.push(sessionLimit - sessionUsed);
+    if (workspaceLimit > 0) remaining.push(workspaceLimit - workspaceUsed);
+    if (remaining.length === 0) return Number.MAX_SAFE_INTEGER;
+    return Math.min(...remaining);
+  }
+
   // -----------------------------------------------------------------------
   // Steering
   // -----------------------------------------------------------------------
 
-  private async _checkSteering(botId: string): Promise<void> {
-    const steerPath = path.join(this.weaverDir, `steer-${botId}.json`);
+  private async _checkSteering(instanceId: string): Promise<void> {
+    const steerPath = path.join(this.weaverDir, `steer-${instanceId}.json`);
     try {
       if (!fs.existsSync(steerPath)) return;
       const raw = fs.readFileSync(steerPath, 'utf-8');
@@ -500,29 +695,29 @@ export class SwarmController {
 
       switch (command.command) {
         case 'pause':
-          this._updateSlot(botId, { status: 'paused' });
-          this.eventLog.emit({ type: 'bot-paused', timestamp: Date.now(), data: { botId } });
+          this.eventLog.emit({ type: 'bot-paused', timestamp: Date.now(), data: { botId: instanceId } });
           break;
         case 'resume':
-          this._updateSlot(botId, { status: 'idle' });
           break;
         case 'cancel':
-          // The current run will complete and then the bot won't pick up new tasks while stopping
-          this._updateSlot(botId, { status: 'stopped' });
+          this.instanceManager.stop(instanceId);
           break;
       }
     } catch { /* steer file read error — skip */ }
   }
 
   // -----------------------------------------------------------------------
-  // Slot management
+  // State sync — instances field
   // -----------------------------------------------------------------------
 
-  private _updateSlot(botId: string, patch: Partial<BotSlot>): void {
-    const slot = this.state.bots[botId];
-    if (!slot) return;
-    Object.assign(slot, patch);
-    this._persist();
+  private _syncInstancesState(): void {
+    const allInstances = this.instanceManager.listAll();
+
+    // Build instances record
+    this.state.instances = {};
+    for (const inst of allInstances) {
+      this.state.instances[inst.instanceId] = inst;
+    }
   }
 
   // -----------------------------------------------------------------------
@@ -533,7 +728,9 @@ export class SwarmController {
     try {
       if (fs.existsSync(this.statePath)) {
         const raw = fs.readFileSync(this.statePath, 'utf-8');
-        return JSON.parse(raw) as SwarmState;
+        const data = JSON.parse(raw) as SwarmState;
+        if (!data.instances) data.instances = {};
+        return data;
       }
     } catch { /* corrupt file — use defaults */ }
     return this._defaultState();
@@ -542,7 +739,7 @@ export class SwarmController {
   private _defaultState(): SwarmState {
     return {
       status: 'idle',
-      bots: {},
+      instances: {},
       maxConcurrent: 3,
       budgets: {
         workspace: { limitTokens: 0, usedTokens: 0, limitCost: 0, usedCost: 0 },
@@ -562,7 +759,9 @@ export class SwarmController {
       const tmpPath = this.statePath + '.tmp';
       fs.writeFileSync(tmpPath, JSON.stringify(this.state, null, 2), 'utf-8');
       fs.renameSync(tmpPath, this.statePath);
-    } catch { /* non-fatal persistence error */ }
+    } catch (err) {
+      console.error('[swarm] Failed to persist state:', err instanceof Error ? err.message : err);
+    }
   }
 
   // -----------------------------------------------------------------------