fix(swarm-engine): resolve latest PR review comments

Author: bb-connor

apps/workbench/src/features/swarm/hooks/__tests__/use-engine-board-bridge.test.ts

@@ -428,7 +428,7 @@ describe("useEngineBoardBridge", () => {
     }
   });
 
-  it("maps created tasks from engine status updates instead of forcing them to running", () => {
+  it("maps task and unknown engine statuses safely", () => {
     const events = new TypedEventEmitter<SwarmEngineEventMap>();
     const engine = {
       getState: () => makeEngineState(),
@@ -477,6 +477,17 @@ describe("useEngineBoardBridge", () => {
       expect(
         useSwarmBoardStore.getState().nodes.find((node) => node.data.taskId === "tsk_1")?.data.status,
       ).toBe("completed");
+
+      act(() => {
+        events.emit("agent.status_changed", {
+          agentId: "agt_pool_1",
+          newStatus: "draining",
+        } as any);
+      });
+
+      expect(
+        useSwarmBoardStore.getState().nodes.find((node) => node.id === "agt_pool_1")?.data.status,
+      ).toBe("idle");
     } finally {
       unmount();
     }

apps/workbench/src/features/swarm/hooks/use-engine-board-bridge.ts

@@ -46,7 +46,7 @@ function mapEngineStatus(engineStatus: string): SessionStatus {
     case "evaluating":
       return "evaluating";
     default:
-      return "running";
+      return "idle";
   }
 }
 

apps/workbench/src/features/swarm/stores/workbench-guard-evaluator.ts

@@ -94,12 +94,6 @@ function buildScenarioCategory(
   switch (action.actionType) {
     case "file_access":
       return "benign";
-    case "file_write":
-    case "network_egress":
-    case "shell_command":
-    case "mcp_tool_call":
-    case "patch_apply":
-    case "user_input":
     default:
       return "edge_case";
   }

packages/swarm-engine/src/consensus/consensus.test.ts

@@ -241,7 +241,7 @@ describe("RaftConsensus", () => {
     );
   });
 
-  it("threshold resolution emits consensus.resolved", async () => {
+  it("threshold resolution emits consensus.resolved only after quorum is met", async () => {
     const resolved: ConsensusResolvedEvent[] = [];
     events.on("consensus.resolved", (e) => resolved.push(e));
 
@@ -250,12 +250,21 @@ describe("RaftConsensus", () => {
     raft.initialize();
     await new Promise((r) => setTimeout(r, 200));
 
-    raft.propose({ action: "commit" });
-    // Leader auto-voted (1 vote). Need 2 of 3 for 0.66 threshold.
-    // ceil(3 * 0.66) = 1.98 -> floor = 1, so 1 vote might be enough?
-    // Actually Math.floor(3 * 0.66) = Math.floor(1.98) = 1
-    // 1 >= 1 is true, so it should resolve immediately
-    expect(resolved.length).toBeGreaterThanOrEqual(1);
+    const proposal = raft.propose({ action: "commit" });
+    expect(resolved).toHaveLength(0);
+
+    const voteMap = (raft as any).proposalVotes.get(proposal.id) as Map<string, unknown>;
+    voteMap.set("node-2", {
+      voterId: "node-2",
+      approve: true,
+      confidence: 1.0,
+      timestamp: Date.now(),
+    });
+
+    proposal.votes = Array.from(voteMap.values()) as any;
+    (raft as any).checkConsensus(proposal.id);
+
+    expect(resolved).toHaveLength(1);
     expect(resolved[0]!.result.approved).toBe(true);
     expect(resolved[0]!.kind).toBe("consensus.resolved");
     expect(resolved[0]!.result.receipt).toBeNull();

packages/swarm-engine/src/consensus/raft.ts

@@ -468,7 +468,7 @@ export class RaftConsensus {
       (v) => v.approve,
     ).length;
 
-    const quorum = Math.floor(totalVoters * this.config.threshold);
+    const quorum = Math.max(1, Math.ceil(totalVoters * this.config.threshold));
 
     if (approvingVotes >= quorum) {
       proposal.status = "accepted";

packages/swarm-engine/src/memory/memory.test.ts

@@ -6,7 +6,7 @@
  * namespace scoping, tag search, TTL expiration, guarded writes.
  */
 
-import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { describe, it, expect, beforeEach, afterEach, vi } from "vitest";
 import { HnswLite, cosineSimilarity } from "./hnsw.js";
 import { KnowledgeGraph } from "./graph.js";
 import type { Entity, Relation } from "./graph.js";
@@ -259,6 +259,7 @@ describe("shared", () => {
 
   afterEach(() => {
     memory.dispose();
+    vi.restoreAllMocks();
   });
 
   it("store + get roundtrip", async () => {
@@ -323,6 +324,40 @@ describe("shared", () => {
     expect(resultsA).toHaveLength(1);
     expect(resultsB).toHaveLength(1);
   });
+
+  it("opens IndexedDB and persists entries when enableIdb is true", async () => {
+    const close = vi.fn();
+    const openSpy = vi
+      .spyOn(IdbBackend.prototype, "open")
+      .mockImplementation(async function mockOpen(this: IdbBackend) {
+        (this as any).db = { close } as IDBDatabase;
+        return true;
+      });
+    const putSpy = vi.spyOn(IdbBackend.prototype, "put").mockResolvedValue();
+
+    const idbMemory = new SharedMemory(events, {
+      dimensions: 3,
+      enableIdb: true,
+      idbName: "test-memory",
+      guardEvaluator: makeAllowEvaluator(),
+    });
+
+    try {
+      const stored = await idbMemory.store("ns", "persisted", { data: "hello" });
+      expect(stored).toBe(true);
+      expect(openSpy).toHaveBeenCalledOnce();
+      expect(putSpy).toHaveBeenCalledWith(
+        "ns:persisted",
+        expect.objectContaining({
+          namespace: "ns",
+          value: { data: "hello" },
+          _key: "ns:persisted",
+        }),
+      );
+    } finally {
+      idbMemory.dispose();
+    }
+  });
 });
 
 // ---------------------------------------------------------------------------

packages/swarm-engine/src/memory/shared-memory.ts

@@ -48,6 +48,7 @@ export class SharedMemory {
   private readonly hnsw: HnswLite;
   private readonly graph: KnowledgeGraph;
   private readonly idb: IdbBackend | null;
+  private readonly idbReady: Promise<boolean> | null;
   private readonly data = new Map<string, MemoryEntry>();
 
   constructor(
@@ -61,8 +62,10 @@ export class SharedMemory {
 
     if (config?.enableIdb) {
       this.idb = new IdbBackend(config.idbName ?? "swarm-memory");
+      this.idbReady = this.idb.open();
     } else {
       this.idb = null;
+      this.idbReady = null;
     }
   }
 
@@ -112,8 +115,11 @@ export class SharedMemory {
       this.hnsw.add(compositeKey, options.vector);
     }
 
-    if (this.idb?.isAvailable) {
-      await this.idb.put(compositeKey, { ...entry, vector: undefined });
+    if (this.idb && this.idbReady) {
+      await this.idbReady;
+      if (this.idb.isAvailable) {
+        await this.idb.put(compositeKey, { ...entry, vector: undefined });
+      }
     }
 
     this.events.emit("memory.store", {

packages/swarm-engine/src/topology.test.ts

@@ -475,6 +475,25 @@ describe("TopologyManager - role index", () => {
     manager.addNode("a1", "worker");
     expect(manager.getNodesByRole("queen")).toEqual([]);
   });
+
+  it("keeps role indexes and cached leader-role lookups in sync on role updates", () => {
+    const { manager } = makeManager({ type: "hybrid" });
+    manager.addNode("q", "queen");
+    manager.addNode("c", "coordinator");
+    manager.addNode("w", "worker");
+
+    manager.updateNode("q", { role: "worker" });
+    manager.updateNode("c", { role: "worker" });
+    manager.updateNode("w", { role: "coordinator" });
+
+    expect(manager.getQueen()).toBeUndefined();
+    expect(manager.getNodesByRole("queen")).toEqual([]);
+    expect(manager.getCoordinator()?.agentId).toBe("w");
+    expect(manager.getNodesByRole("coordinator").map((node) => node.agentId)).toEqual(["w"]);
+    expect(
+      manager.getNodesByRole("worker").map((node) => node.agentId).sort(),
+    ).toEqual(["c", "q"]);
+  });
 });
 
 // ============================================================================

packages/swarm-engine/src/topology.ts

@@ -173,7 +173,11 @@ export class TopologyManager {
       throw new Error(`Node ${agentId} not found`);
     }
 
-    if (updates.role !== undefined) node.role = updates.role;
+    if (updates.role !== undefined && updates.role !== node.role) {
+      this.removeFromRoleIndex({ ...node });
+      node.role = updates.role;
+      this.addToRoleIndex(node);
+    }
     if (updates.status !== undefined) node.status = updates.status;
     if (updates.connections !== undefined) {
       node.connections = updates.connections;