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): make running-worker cancellation terminal (#4457)

ordinary being533e17e0b15f
diff --git a/v3/@claude-flow/swarm/__tests__/worker-dispatch-cancellation.test.ts b/v3/@claude-flow/swarm/__tests__/worker-dispatch-cancellation.test.ts
new file mode 100644
index 0000000000..6689e36a33
--- /dev/null
+++ b/v3/@claude-flow/swarm/__tests__/worker-dispatch-cancellation.test.ts
@@ -0,0 +1,71 @@
+/**
+ * Cancelling a running WorkerDispatchService worker must be terminal.
+ *
+ * The placeholder executors cannot be aborted mid-flight, so cancel() marks the
+ * worker cancelled and keeps its concurrency slot until the executor settles.
+ * Previously executeWorker() unconditionally overwrote the status with
+ * 'completed' and emitted worker:completed after cancel(), and cancel()
+ * released the slot immediately so a second worker could exceed maxConcurrent.
+ */
+
+import { describe, expect, it } from 'vitest';
+// Import the TS source explicitly: src/workers/worker-dispatch.js is a stale
+// tracked build artifact that would otherwise shadow the implementation.
+import { WorkerDispatchService } from '../src/workers/worker-dispatch.ts';
+
+describe('WorkerDispatchService running-worker cancellation', () => {
+ it('keeps a cancelled worker cancelled and does not release its slot early', async () => {
+ const service = new WorkerDispatchService({ maxConcurrent: 1 });
+ const completed: string[] = [];
+ const failed: string[] = [];
+ const cancelled: string[] = [];
+
+ service.on('worker:completed', ({ workerId }: { workerId: string }) => completed.push(workerId));
+ service.on('worker:failed', ({ workerId }: { workerId: string }) => failed.push(workerId));
+ service.on('worker:cancelled', ({ workerId }: { workerId: string }) => cancelled.push(workerId));
+
+ let firstStartedResolve!: (workerId: string) => void;
+ const firstStarted = new Promise<string>(resolve => {
+ firstStartedResolve = resolve;
+ });
+ service.once('worker:started', ({ workerId }: { workerId: string }) => firstStartedResolve(workerId));
+
+ const sessionId = 'cancel-running-session';
+ const firstId = await service.dispatch('ultralearn', 'first', sessionId);
+ expect(await firstStarted).toBe(firstId);
+
+ const cancelledAt = Date.now();
+ expect(await service.cancel(firstId)).toBe(true);
+ expect(service.getWorker(firstId)?.status).toBe('cancelled');
+
+ // maxConcurrent is 1. The second worker must not start until the cancelled
+ // worker's in-flight executor has settled; baseline released the slot in
+ // cancel() and started this one immediately.
+ let secondStartedResolve!: (startedAt: number) => void;
+ const secondStarted = new Promise<number>(resolve => {
+ secondStartedResolve = resolve;
+ });
+ service.once('worker:started', ({ workerId }: { workerId: string }) => {
+ if (workerId !== firstId) secondStartedResolve(Date.now());
+ });
+
+ const secondId = await service.dispatch('preload', 'second', sessionId);
+ const secondDone = new Promise<void>(resolve => {
+ service.once('worker:completed', ({ workerId }: { workerId: string }) => {
+ if (workerId === secondId) resolve();
+ });
+ });
+
+ const secondStartedAt = await secondStarted;
+ expect(secondStartedAt - cancelledAt).toBeGreaterThanOrEqual(10);
+ await secondDone;
+
+ const first = service.getWorker(firstId);
+ expect(first?.status).toBe('cancelled');
+ expect(first?.phase).toBe('cancelled');
+ expect(first?.result).toBeUndefined();
+ expect(completed).not.toContain(firstId);
+ expect(failed).not.toContain(firstId);
+ expect(cancelled).toContain(firstId);
+ });
+});
diff --git a/v3/@claude-flow/swarm/src/workers/worker-dispatch.ts b/v3/@claude-flow/swarm/src/workers/worker-dispatch.ts
index 40d5084239..5f32a3193d 100644
--- a/v3/@claude-flow/swarm/src/workers/worker-dispatch.ts
+++ b/v3/@claude-flow/swarm/src/workers/worker-dispatch.ts
@@ -500,11 +500,17 @@ export class WorkerDispatchService extends EventEmitter {
if (worker.status === 'running') {
worker.status = 'cancelled';
+ worker.phase = 'cancelled';
worker.completedAt = new Date();
- this.running.delete(workerId);
+ // Keep the id in `running` until its executor actually settles: the
+ // placeholder executors cannot be aborted mid-flight, so releasing the
+ // concurrency slot here would let another worker start while this one is
+ // still doing work. The finally block in executeWorker() releases it.
this.emit('worker:cancelled', { workerId });
} else if (worker.status === 'pending') {
worker.status = 'cancelled';
+ worker.phase = 'cancelled';
+ worker.completedAt = new Date();
this.queue = this.queue.filter(q => q.id !== workerId);
this.emit('worker:cancelled', { workerId });
}
@@ -608,6 +614,14 @@ export class WorkerDispatchService extends EventEmitter {
// Execute based on trigger type
const result = await this.executeWorkerByTrigger(worker);
+ // cancel() may have marked this worker while its executor was in
+ // flight. Never overwrite that terminal state with 'completed' or emit a
+ // second terminal event for a worker the caller already cancelled.
+ if (this.isCancelled(worker)) {
+ worker.phase = 'cancelled';
+ return;
+ }
+
worker.status = 'completed';
worker.completedAt = new Date();
worker.result = result;
@@ -620,6 +634,11 @@ export class WorkerDispatchService extends EventEmitter {
duration: worker.completedAt.getTime() - worker.startedAt.getTime(),
});
} catch (error) {
+ if (this.isCancelled(worker)) {
+ worker.phase = 'cancelled';
+ return;
+ }
+
worker.status = 'failed';
worker.completedAt = new Date();
worker.error = error as Error;
@@ -1054,6 +1073,14 @@ export class WorkerDispatchService extends EventEmitter {
return `worker_${trigger}_${++this.idCounter}_${Date.now().toString(36)}`;
}
+ /**
+ * Read cancellation through a helper so TypeScript does not narrow the
+ * status to 'running' across the executor await; cancel() can mutate it.
+ */
+ private isCancelled(worker: WorkerInstance): boolean {
+ return worker.status === 'cancelled';
+ }
+
private getPriorityValue(priority: 'low' | 'normal' | 'high' | 'critical'): number {
const priorities = { low: 1, normal: 2, high: 3, critical: 4 };
return priorities[priority];