Skip to content

armgit / ruflo

Public Imported from GitHub
0

🌊 The original agent harness. Deploy intelligent multi-player swarms, coordinate autonomous workflows, and build conversational AI systems. Features adaptive memory, self-learning intelligence, federation, vector RAG integration, and native Claude Code / Codex / Hermes and many more Integrated

fix(swarm): remove domain-pool membership when an agent is unregistered

马建彤d151b6139595
diff --git a/v3/@claude-flow/swarm/__tests__/domain-agent-teardown.test.ts b/v3/@claude-flow/swarm/__tests__/domain-agent-teardown.test.ts
new file mode 100644
index 0000000000..8c78f6f949
--- /dev/null
+++ b/v3/@claude-flow/swarm/__tests__/domain-agent-teardown.test.ts
@@ -0,0 +1,114 @@
+/**
+ * Regression: unregisterAgent()/terminateAgent() removed a domain agent from
+ * state/topology/bus/consensus but never from its AgentPool or agentDomainMap.
+ *
+ * The pool then kept advertising the removed id. A later
+ * assignTaskToDomain() acquired it and returned it as the assignee, while
+ * getAgent() was already undefined; handleAgentMessage() drops reports from
+ * unknown agents, so the task could never complete. terminateAgent() also
+ * deleted agentDomainMap before unregisterAgent(), which made the cancel path's
+ * releaseDomainAgent() a no-op and left the slot busy.
+ */
+
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import {
+ UnifiedSwarmCoordinator,
+ createUnifiedSwarmCoordinator,
+} from '../src/unified-coordinator.js';
+
+function createCoordinator(): UnifiedSwarmCoordinator {
+ return createUnifiedSwarmCoordinator({
+ maxAgents: 20,
+ maxTasks: 100,
+ heartbeatIntervalMs: 1000,
+ healthCheckIntervalMs: 2000,
+ taskTimeoutMs: 10000,
+ topology: { type: 'hierarchical', maxAgents: 20 },
+ consensus: {
+ algorithm: 'raft',
+ threshold: 0.66,
+ timeoutMs: 5000,
+ maxRounds: 5,
+ requireQuorum: true,
+ },
+ });
+}
+
+function taskData(name: string) {
+ return {
+ type: 'coding' as const,
+ name,
+ description: name,
+ priority: 'normal' as const,
+ dependencies: [],
+ input: {},
+ timeoutMs: 5000,
+ retries: 0,
+ maxRetries: 3,
+ metadata: {},
+ };
+}
+
+describe('domain agent teardown', () => {
+ let coordinator: UnifiedSwarmCoordinator;
+
+ beforeEach(async () => {
+ coordinator = createCoordinator();
+ await coordinator.initialize();
+ });
+
+ afterEach(async () => {
+ await coordinator.shutdown();
+ });
+
+ it('unregisterAgent removes the agent from its domain pool', async () => {
+ const taskId = await coordinator.submitTask(taskData('active'));
+ const { agentId } = await coordinator.spawnAgent({ type: 'coder', domain: 'core' });
+ expect(await coordinator.assignTaskToDomain(taskId, 'core')).toBe(agentId);
+
+ await coordinator.unregisterAgent(agentId);
+
+ expect(coordinator.getAgent(agentId)).toBeUndefined();
+ expect(coordinator.getDomainPool('core')!.getPoolStats().total).toBe(0);
+ expect(coordinator.getTask(taskId)?.status).toBe('cancelled');
+
+ const next = await coordinator.submitTask(taskData('next'));
+ expect(await coordinator.assignTaskToDomain(next, 'core')).toBeUndefined();
+ expect(coordinator.getTask(next)?.status).toBe('queued');
+ });
+
+ it('terminateAgent removes the agent from its domain pool', async () => {
+ const taskId = await coordinator.submitTask(taskData('active'));
+ const { agentId } = await coordinator.spawnAgent({ type: 'coder', domain: 'core' });
+ expect(await coordinator.assignTaskToDomain(taskId, 'core')).toBe(agentId);
+
+ const result = await coordinator.terminateAgent(agentId, { force: true });
+ expect(result.terminated).toBe(true);
+
+ expect(coordinator.getAgent(agentId)).toBeUndefined();
+ expect(coordinator.getDomainPool('core')!.getPoolStats().total).toBe(0);
+ expect(coordinator.getTask(taskId)?.status).toBe('cancelled');
+
+ const next = await coordinator.submitTask(taskData('next'));
+ expect(await coordinator.assignTaskToDomain(next, 'core')).toBeUndefined();
+ expect(coordinator.getTask(next)?.status).toBe('queued');
+ });
+
+ it('keeps other domain agents usable after one is unregistered', async () => {
+ const first = await coordinator.submitTask(taskData('first'));
+ const firstAgent = await coordinator.spawnAgent({ type: 'coder', domain: 'core' });
+ expect(await coordinator.assignTaskToDomain(first, 'core')).toBe(firstAgent.agentId);
+
+ // Submitted while the only current agent is busy, so it stays queued while
+ // the second agent is added.
+ const queued = await coordinator.submitTask(taskData('queued'));
+ const secondAgent = await coordinator.spawnAgent({ type: 'coder', domain: 'core' });
+
+ await coordinator.unregisterAgent(firstAgent.agentId);
+
+ expect(coordinator.getDomainPool('core')!.getPoolStats().total).toBe(1);
+ expect(await coordinator.assignTaskToDomain(queued, 'core')).toBe(secondAgent.agentId);
+ expect(coordinator.getAgent(secondAgent.agentId)).toBeDefined();
+ expect(coordinator.getTask(queued)?.assignedTo?.id).toBe(secondAgent.agentId);
+ });
+});
diff --git a/v3/@claude-flow/swarm/src/unified-coordinator.ts b/v3/@claude-flow/swarm/src/unified-coordinator.ts
index 95736d9e76..4eaec92013 100644
--- a/v3/@claude-flow/swarm/src/unified-coordinator.ts
+++ b/v3/@claude-flow/swarm/src/unified-coordinator.ts
@@ -363,6 +363,11 @@ export class UnifiedSwarmCoordinator extends EventEmitter implements IUnifiedSwa
return;
}
+ // Detach from the domain pool before cancelling. cancelTask() releases a
+ // pool-owned agent and drains that domain's queue, which must not hand a
+ // new task to an agent that is being removed.
+ await this.detachAgentFromDomain(agentId);
+
// Cancel any assigned tasks
if (agent.currentTask) {
await this.cancelTask(agent.currentTask.id);
@@ -379,6 +384,25 @@ export class UnifiedSwarmCoordinator extends EventEmitter implements IUnifiedSwa
this.emitEvent('agent.left', { agentId });
}
+ /**
+ * Remove a domain agent from its pool and domain map. This is deliberately
+ * separate from unregisterAgent(): cancellation/release paths use the
+ * domain map, so teardown must revoke pool membership first to prevent a
+ * released slot from being re-acquired for the same agent.
+ */
+ private async detachAgentFromDomain(agentId: string): Promise<void> {
+ const domain = this.agentDomainMap.get(agentId);
+ if (!domain) {
+ return;
+ }
+
+ const pool = this.domainPools.get(domain);
+ if (pool) {
+ await pool.remove(agentId);
+ }
+ this.agentDomainMap.delete(agentId);
+ }
+
getAgent(agentId: string): AgentState | undefined {
return this.state.agents.get(agentId);
}
@@ -1856,6 +1880,10 @@ export class UnifiedSwarmCoordinator extends EventEmitter implements IUnifiedSwa
};
}
+ // Detach before the grace period so the pool cannot hand this agent a new
+ // domain task while termination is pending.
+ await this.detachAgentFromDomain(agentId);
+
// If agent has active tasks and not forcing, wait or reassign
let tasksReassigned = 0;
if (agent.currentTask && !options?.force) {
@@ -1874,10 +1902,8 @@ export class UnifiedSwarmCoordinator extends EventEmitter implements IUnifiedSwa
}
}
- // Remove from domain tracking
- this.agentDomainMap.delete(agentId);
-
- // Unregister the agent
+ // Unregister the agent; unregisterAgent() is also idempotent for the
+ // domain detach above.
await this.unregisterAgent(agentId);
this.emitEvent('agent.left', {