🌊 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
TypeScript agentic-aiagentic-frameworkagentic-workflowagentsai-agentsai-assistantai-skillsautonomous-agentsclaudecodexdsh-pluginharnessmcp-servermulti-agentmulti-agent-systemsnpmskillsswarmswarm-intelligencetypescript
fix(swarm): cancel queued subscriber delivery at shutdown (#4233)
Rudy Mizrahi Celekli0793f9624808
diff --git a/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.ts b/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.tsnew file mode 100644index 0000000000..991b7462fe--- /dev/null+++ b/v3/@claude-flow/swarm/__tests__/message-bus.shutdown-boundary.test.ts@@ -0,0 +1,67 @@+import { afterEach, describe, expect, it } from 'vitest';+import { createMessageBus, type MessageBus } from '../src/message-bus.js';++const nextTurn = () => new Promise<void>((resolve) => setImmediate(resolve));+const message = (to: string) => ({+ type: 'direct' as const,+ from: 'sender',+ to,+ payload: {},+ priority: 'normal' as const,+ requiresAck: false,+ ttlMs: 60_000,+});++let bus: MessageBus;+afterEach(async () => { await bus.shutdown(); });++describe('MessageBus shutdown delivery boundary', () => {+ it('does not invoke a queued subscriber after shutdown has completed', async () => {+ bus = createMessageBus({ processingIntervalMs: 5000 });+ await bus.initialize();+ const observed: string[] = [];+ bus.subscribe('target', () => { observed.push('subscriber side effect'); });+ bus.on('shutdown', () => { observed.push('shutdown'); });+ bus.on('message.delivered', () => { observed.push('delivered'); });+ await bus.send(message('target'));+ // Drain the dispatch pass while its subscriber callbacks remain queued.+ await nextTurn();+ await bus.shutdown();+ await nextTurn();+ expect(observed).toEqual(['shutdown']);+ });++ it('does not revive callbacks from the old lifecycle when immediately reinitialized', async () => {+ bus = createMessageBus({ processingIntervalMs: 5000 });+ await bus.initialize();+ let oldSubscriber = 0;+ let newSubscriber = 0;+ bus.subscribe('target', () => { oldSubscriber++; });+ await bus.send(message('target'));+ await nextTurn();+ await bus.shutdown();+ await bus.initialize();+ bus.subscribe('target', () => { newSubscriber++; });+ await bus.send(message('target'));+ await nextTurn();+ await nextTurn();+ expect(oldSubscriber).toBe(0);+ expect(newSubscriber).toBe(1);+ });++ it('cancels the other queued subscriber when the first subscriber shuts down the bus', async () => {+ bus = createMessageBus({ processingIntervalMs: 5000 });+ await bus.initialize();+ const observed: string[] = [];+ bus.subscribe('first', () => {+ observed.push('first');+ void bus.shutdown();+ });+ bus.subscribe('second', () => { observed.push('second'); });+ await bus.send(message('first'));+ await bus.send(message('second'));+ await nextTurn();+ await nextTurn();+ expect(observed).toEqual(['first']);+ });+});diff --git a/v3/@claude-flow/swarm/src/message-bus.ts b/v3/@claude-flow/swarm/src/message-bus.tsindex 9745c0928f..910e2db8ca 100644--- a/v3/@claude-flow/swarm/src/message-bus.ts+++ b/v3/@claude-flow/swarm/src/message-bus.ts@@ -229,6 +229,7 @@ export class MessageBus extends EventEmitter implements IMessageBus {private statsInterval?: NodeJS.Timeout;private processScheduled: boolean = false;private isShutdown: boolean = false;+ private deliveryImmediates: Set<NodeJS.Immediate> = new Set();private messageCounter: number = 0;private stats: MessageBusStats;private startTime: Date = new Date();@@ -292,6 +293,12 @@ export class MessageBus extends EventEmitter implements IMessageBus {}this.retryTimers.clear();+ // Queue draining schedules subscriber callbacks separately. Cancel those+ // pending callbacks too, including across a later initialize() call.+ // A subscriber that is already running is not interrupted.+ for (const delivery of this.deliveryImmediates) clearImmediate(delivery);+ this.deliveryImmediates.clear();+if (this.processingInterval) {clearInterval(this.processingInterval);this.processingInterval = undefined;@@ -537,8 +544,10 @@ export class MessageBus extends EventEmitter implements IMessageBus {this.pendingAcks.set(message.id, { message, timeout });}- // Deliver asynchronously- setImmediate(() => {+ // Deliver asynchronously; shutdown owns and cancels pending handles.+ const delivery = setImmediate(() => {+ this.deliveryImmediates.delete(delivery);+ if (this.isShutdown) return;try {subscription.callback(message);this.emit('message.delivered', {@@ -549,6 +558,7 @@ export class MessageBus extends EventEmitter implements IMessageBus {this.handleDeliveryError(message, entry, error as Error, subscription.agentId);}});+ this.deliveryImmediates.add(delivery);} catch (error) {this.handleDeliveryError(message, entry, error as Error, subscription.agentId);}