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

package/dist/bot/swarm-controller.js

@@ -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)`.
  */
@@ -15,10 +16,14 @@ import { RunStore } from './run-store.js';
 import { EventLog } from './event-log.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';
 // ---------------------------------------------------------------------------
 // Constants
 // ---------------------------------------------------------------------------
-const BOT_LOOP_SLEEP_MS = 2000;
+const DISPATCH_LOOP_SLEEP_MS = 2000;
 const SWARM_STATE_FILE = 'swarm.json';
 // ---------------------------------------------------------------------------
 // SwarmController
@@ -30,11 +35,18 @@ export class SwarmController {
     statePath;
     taskStore;
     eventLog;
+    orchestrator;
+    instanceManager;
+    profileStore;
     state;
-    /** Active bot loop abort controllers (one per spawned loop). */
-    botAborts = new Map();
-    /** Promises for active bot loops (resolved when the loop exits). */
-    botLoopPromises = new Map();
+    /** Abort controller for the single dispatch loop. */
+    dispatchAbort = null;
+    /** Promise for the dispatch loop (resolved when the loop exits). */
+    dispatchLoopPromise = null;
+    /** Promises for currently executing tasks (instanceId -> Promise). */
+    executionPromises = new Map();
+    /** Map of profileId -> BotRegistration for workflow execution. */
+    profileBotMap = new Map();
     // -----------------------------------------------------------------------
     // Singleton
     // -----------------------------------------------------------------------
@@ -59,8 +71,16 @@ 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();
     }
     // -----------------------------------------------------------------------
@@ -82,27 +102,39 @@ export class SwarmController {
         // Discover bots from registry
         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() {
         if (this.state.status !== 'running')
@@ -110,34 +142,39 @@ export class SwarmController {
         this.state.status = 'paused';
         this._persist();
         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() {
         if (this.state.status === 'idle')
             return;
         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() {
-        return { ...this.state, bots: { ...this.state.bots } };
+        // Sync instances from InstanceManager before returning
+        this._syncInstancesState();
+        return { ...this.state, instances: { ...this.state.instances } };
     }
     configure(config) {
         if (config.maxConcurrent !== undefined)
@@ -160,12 +197,11 @@ export class SwarmController {
     // Crash recovery
     // -----------------------------------------------------------------------
     async recover() {
-        // 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);
             }
         }
         // Reset in-progress tasks
@@ -186,18 +222,18 @@ export class SwarmController {
         }
         // Reset swarm status to idle
         this.state.status = 'idle';
+        this._syncInstancesState();
         this._persist();
     }
     // -----------------------------------------------------------------------
     // Token/cost recording
     // -----------------------------------------------------------------------
-    recordTokenUsage(botId, _taskId, tokensUsed, cost) {
-        // Update bot slot
-        const slot = this.state.bots[botId];
-        if (slot) {
-            slot.tokensUsed += tokensUsed;
-            slot.cost += cost;
+    recordTokenUsage(instanceId, _taskId, tokensUsed, cost) {
+        // 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;
         this.state.budgets.session.usedCost += cost;
@@ -211,41 +247,53 @@ 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
+    // -----------------------------------------------------------------------
+    getProfileStore() {
+        return this.profileStore;
+    }
+    getInstanceManager() {
+        return this.instanceManager;
+    }
+    getOrchestrator() {
+        return this.orchestrator;
+    }
+    getOrchestratorStatus() {
+        const decisions = this.orchestrator.getDecisionLog();
+        const stats = {
+            totalDecisions: decisions.length,
+            assignmentsByMethod: {},
+        };
+        for (const d of decisions) {
+            stats.assignmentsByMethod[d.method] = (stats.assignmentsByMethod[d.method] ?? 0) + 1;
+        }
+        return { decisions, stats };
+    }
+    // -----------------------------------------------------------------------
+    // Dispatch loop
     // -----------------------------------------------------------------------
-    _spawnBotLoop(bot) {
+    _startDispatchLoop() {
         const abort = new AbortController();
-        this.botAborts.set(bot.id, abort);
-        const loopPromise = this._botLoop(bot, abort.signal).catch(() => {
-            // Swallow errors in bot loops — they self-heal on next iteration
+        this.dispatchAbort = abort;
+        this.dispatchLoopPromise = this._dispatchLoop(abort.signal).catch(() => {
+            // Swallow errors in dispatch loop — self-heals on next cycle
         });
-        this.botLoopPromises.set(bot.id, loopPromise);
     }
-    async _botLoop(bot, signal) {
-        const botId = bot.id;
+    async _dispatchLoop(signal) {
         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);
+                await this._sleep(DISPATCH_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);
-                continue;
-            }
-            // Budget check — before claiming a task
+            // Budget check before routing
             if (this._isBudgetExceeded()) {
                 this.state.status = 'paused';
                 this._persist();
@@ -256,86 +304,131 @@ 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;
-            let runId;
-            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 = {
-                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);
-            // Record token usage
-            this.recordTokenUsage(botId, task.id, tokensUsed, costUsed);
-            // Update stats
-            if (result.success) {
-                this.state.tasksCompleted += 1;
+            const input = {
+                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,
+            };
+            // Route
+            const output = await this.orchestrator.route(input);
+            // 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);
+                }
+            }
+            // 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
+                }
+            }
+            // 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 {
-                this.state.tasksFailed += 1;
+                await this._sleep(DISPATCH_LOOP_SLEEP_MS, signal);
             }
-            // 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 },
-            });
-            // Reset bot slot
-            this._updateSlot(botId, { status: 'idle', currentTaskId: undefined, currentRunId: undefined });
-            // Post-completion budget check
+            // 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-cycle budget check
             if (this._isBudgetExceeded()) {
                 this.state.status = 'paused';
                 this._persist();
@@ -346,10 +439,84 @@ export class SwarmController {
                 });
                 break;
             }
+            this._syncInstancesState();
             this._persist();
         }
-        // Mark bot as stopped when loop exits
-        this._updateSlot(botId, { status: 'stopped', currentTaskId: undefined, currentRunId: undefined });
+    }
+    // -----------------------------------------------------------------------
+    // Task execution
+    // -----------------------------------------------------------------------
+    async _executeTask(instanceId, taskId, runId, bot, profile) {
+        const startTime = Date.now();
+        let result;
+        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 = {
+            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();
     }
     // -----------------------------------------------------------------------
     // Budget checks
@@ -368,11 +535,22 @@ export class SwarmController {
             return true;
         return false;
     }
+    /** Calculate remaining budget across session and workspace. */
+    _remainingBudget(sessionLimit, sessionUsed, workspaceLimit, workspaceUsed) {
+        const remaining = [];
+        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
     // -----------------------------------------------------------------------
-    async _checkSteering(botId) {
-        const steerPath = path.join(this.weaverDir, `steer-${botId}.json`);
+    async _checkSteering(instanceId) {
+        const steerPath = path.join(this.weaverDir, `steer-${instanceId}.json`);
         try {
             if (!fs.existsSync(steerPath))
                 return;
@@ -381,29 +559,27 @@ export class SwarmController {
             const command = JSON.parse(raw);
             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
     // -----------------------------------------------------------------------
-    _updateSlot(botId, patch) {
-        const slot = this.state.bots[botId];
-        if (!slot)
-            return;
-        Object.assign(slot, patch);
-        this._persist();
+    _syncInstancesState() {
+        const allInstances = this.instanceManager.listAll();
+        // Build instances record
+        this.state.instances = {};
+        for (const inst of allInstances) {
+            this.state.instances[inst.instanceId] = inst;
+        }
     }
     // -----------------------------------------------------------------------
     // State persistence
@@ -412,7 +588,10 @@ export class SwarmController {
         try {
             if (fs.existsSync(this.statePath)) {
                 const raw = fs.readFileSync(this.statePath, 'utf-8');
-                return JSON.parse(raw);
+                const data = JSON.parse(raw);
+                if (!data.instances)
+                    data.instances = {};
+                return data;
             }
         }
         catch { /* corrupt file — use defaults */ }
@@ -421,7 +600,7 @@ export class SwarmController {
     _defaultState() {
         return {
             status: 'idle',
-            bots: {},
+            instances: {},
             maxConcurrent: 3,
             budgets: {
                 workspace: { limitTokens: 0, usedTokens: 0, limitCost: 0, usedCost: 0 },
@@ -441,7 +620,9 @@ export class SwarmController {
             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);
+        }
     }
     // -----------------------------------------------------------------------
     // Utilities