groundswell 0.0.1 → 0.0.2

package/src/__tests__/unit/observable.test.ts

@@ -0,0 +1,321 @@
+import { describe, it, expect, vi, beforeEach } from 'vitest';
+import { Observable, ObservableLogger } from '../../utils/observable';
+
+describe('Observable', () => {
+  describe('with logger injection', () => {
+    let mockLogger: ObservableLogger;
+
+    beforeEach(() => {
+      mockLogger = {
+        error: vi.fn(),
+      };
+    });
+
+    it('should log subscriber next() errors via logger', () => {
+      const observable = new Observable<number>(mockLogger);
+      const testError = new Error('Next error');
+
+      const throwingSubscriber = {
+        next: () => {
+          throw testError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.next(42);
+
+      expect(mockLogger.error).toHaveBeenCalledWith('Observable subscriber error', {
+        error: testError,
+      });
+    });
+
+    it('should log subscriber error() errors via logger', () => {
+      const observable = new Observable<number>(mockLogger);
+      const testError = new Error('Error handler failed');
+      const handlerError = new Error('Handler threw');
+
+      const throwingSubscriber = {
+        error: () => {
+          throw handlerError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.error(testError);
+
+      expect(mockLogger.error).toHaveBeenCalledWith('Observable error handler failed', {
+        error: handlerError,
+      });
+    });
+
+    it('should log subscriber complete() errors via logger', () => {
+      const observable = new Observable<number>(mockLogger);
+      const completeError = new Error('Complete handler failed');
+
+      const throwingSubscriber = {
+        complete: () => {
+          throw completeError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.complete();
+
+      expect(mockLogger.error).toHaveBeenCalledWith('Observable complete handler failed', {
+        error: completeError,
+      });
+    });
+
+    it('should continue notifying other subscribers after one throws', () => {
+      const observable = new Observable<number>(mockLogger);
+      const testError = new Error('First subscriber error');
+
+      const results: number[] = [];
+
+      const throwingSubscriber = {
+        next: () => {
+          throw testError;
+        },
+      };
+
+      const workingSubscriber = {
+        next: (value: number) => {
+          results.push(value);
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.subscribe(workingSubscriber);
+      observable.next(42);
+
+      expect(results).toEqual([42]);
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should handle multiple throwing subscribers', () => {
+      const observable = new Observable<number>(mockLogger);
+      const error1 = new Error('Error 1');
+      const error2 = new Error('Error 2');
+
+      const throwingSubscriber1 = {
+        next: () => {
+          throw error1;
+        },
+      };
+
+      const throwingSubscriber2 = {
+        next: () => {
+          throw error2;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber1);
+      observable.subscribe(throwingSubscriber2);
+      observable.next(42);
+
+      expect(mockLogger.error).toHaveBeenCalledTimes(2);
+      expect(mockLogger.error).toHaveBeenNthCalledWith(1, 'Observable subscriber error', {
+        error: error1,
+      });
+      expect(mockLogger.error).toHaveBeenNthCalledWith(2, 'Observable subscriber error', {
+        error: error2,
+      });
+    });
+  });
+
+  describe('without logger (fallback)', () => {
+    it('should fall back to console.error when no logger provided', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const observable = new Observable<number>();
+      const testError = new Error('Next error');
+
+      const throwingSubscriber = {
+        next: () => {
+          throw testError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.next(42);
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable subscriber error', testError);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should fall back to console.error for error() method', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const observable = new Observable<number>();
+      const handlerError = new Error('Handler threw');
+
+      const throwingSubscriber = {
+        error: () => {
+          throw handlerError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.error(new Error('Original error'));
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable error handler failed', handlerError);
+      consoleErrorSpy.mockRestore();
+    });
+
+    it('should fall back to console.error for complete() method', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const observable = new Observable<number>();
+      const completeError = new Error('Complete threw');
+
+      const throwingSubscriber = {
+        complete: () => {
+          throw completeError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+      observable.complete();
+
+      expect(consoleErrorSpy).toHaveBeenCalledWith('Observable complete handler failed', completeError);
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('backward compatibility', () => {
+    it('should work without any constructor arguments', () => {
+      const observable = new Observable<number>();
+      const results: number[] = [];
+
+      const subscriber = {
+        next: (value: number) => {
+          results.push(value);
+        },
+      };
+
+      observable.subscribe(subscriber);
+      observable.next(1);
+      observable.next(2);
+      observable.next(3);
+
+      expect(results).toEqual([1, 2, 3]);
+    });
+
+    it('should support subscribe/unsubscribe cycle', () => {
+      const observable = new Observable<number>();
+      const results: number[] = [];
+
+      const subscriber = {
+        next: (value: number) => {
+          results.push(value);
+        },
+      };
+
+      const subscription = observable.subscribe(subscriber);
+      observable.next(1);
+      subscription.unsubscribe();
+      observable.next(2);
+
+      expect(results).toEqual([1]);
+    });
+
+    it('should report subscriber count correctly', () => {
+      const observable = new Observable<number>();
+
+      const subscriber1 = { next: () => {} };
+      const subscriber2 = { next: () => {} };
+
+      expect(observable.subscriberCount).toBe(0);
+
+      const sub1 = observable.subscribe(subscriber1);
+      expect(observable.subscriberCount).toBe(1);
+
+      const sub2 = observable.subscribe(subscriber2);
+      expect(observable.subscriberCount).toBe(2);
+
+      sub1.unsubscribe();
+      expect(observable.subscriberCount).toBe(1);
+
+      sub2.unsubscribe();
+      expect(observable.subscriberCount).toBe(0);
+    });
+
+    it('should clear subscribers on complete', () => {
+      const observable = new Observable<number>();
+      const subscriber = { next: () => {}, complete: () => {} };
+
+      observable.subscribe(subscriber);
+      expect(observable.subscriberCount).toBe(1);
+
+      observable.complete();
+      expect(observable.subscriberCount).toBe(0);
+    });
+  });
+
+  describe('error isolation', () => {
+    let mockLogger: ObservableLogger;
+
+    beforeEach(() => {
+      mockLogger = {
+        error: vi.fn(),
+      };
+    });
+
+    it('should not propagate errors outside try-catch', () => {
+      const observable = new Observable<number>(mockLogger);
+      const testError = new Error('Subscriber error');
+
+      const throwingSubscriber = {
+        next: () => {
+          throw testError;
+        },
+      };
+
+      observable.subscribe(throwingSubscriber);
+
+      // This should not throw
+      expect(() => {
+        observable.next(42);
+      }).not.toThrow();
+
+      expect(mockLogger.error).toHaveBeenCalled();
+    });
+
+    it('should handle undefined optional callbacks', () => {
+      const consoleErrorSpy = vi.spyOn(console, 'error').mockImplementation(() => {});
+      const observable = new Observable<number>();
+
+      const subscriberWithMissingCallbacks = {
+        // next is undefined
+        // error is undefined
+        // complete is undefined
+      };
+
+      observable.subscribe(subscriberWithMissingCallbacks);
+
+      // Should not throw when callbacks are undefined
+      expect(() => {
+        observable.next(42);
+        observable.error(new Error('test'));
+        observable.complete();
+      }).not.toThrow();
+
+      consoleErrorSpy.mockRestore();
+    });
+  });
+
+  describe('ObservableLogger interface', () => {
+    it('should match WorkflowLogger.error() signature', () => {
+      const mockLogger: ObservableLogger = {
+        error: vi.fn(),
+      };
+
+      const observable = new Observable<number>(mockLogger);
+
+      // Test the signature matches: error(message: string, data?: unknown): void
+      mockLogger.error('test message');
+      mockLogger.error('test message', { key: 'value' });
+      mockLogger.error('test message', { error: new Error('test') });
+      mockLogger.error('test message', undefined);
+
+      expect(mockLogger.error).toHaveBeenCalledTimes(4);
+    });
+  });
+});

package/src/__tests__/unit/tree-debugger-incremental.test.ts

@@ -0,0 +1,170 @@
+import { describe, it, expect } from 'vitest';
+import { Workflow, WorkflowTreeDebugger } from '../../index.js';
+
+class IncrementalTestWorkflow extends Workflow {
+  async run(): Promise<void> {
+    this.setStatus('completed');
+  }
+}
+
+describe('Incremental Node Map Updates', () => {
+  it('childDetached removes entire subtree (node + descendants)', () => {
+    const root = new IncrementalTestWorkflow('Root');
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
+    const child2 = new IncrementalTestWorkflow('Child2', root);
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+
+    // Verify all nodes are initially in the map
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+    expect(debugger_.getNode(child1.id)).toBe(child1.getNode());
+    expect(debugger_.getNode(grandchild.id)).toBe(grandchild.getNode());
+    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
+    expect(debugger_.getStats().totalNodes).toBe(4);
+
+    // Detach child1 (should remove child1 + grandchild)
+    root.detachChild(child1);
+
+    // Verify child1 and grandchild are removed
+    expect(debugger_.getNode(child1.id)).toBeUndefined();
+    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
+
+    // Verify root and child2 are still present
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
+
+    // Verify total node count decreased by 2
+    expect(debugger_.getStats().totalNodes).toBe(2);
+  });
+
+  it('childDetached on already-removed node is no-op', () => {
+    const root = new IncrementalTestWorkflow('Root');
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+    expect(debugger_.getStats().totalNodes).toBe(3);
+
+    // Detach child1
+    root.detachChild(child1);
+    expect(debugger_.getStats().totalNodes).toBe(1);
+    expect(debugger_.getNode(child1.id)).toBeUndefined();
+    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
+
+    // Simulate the edge case where nodeMap still has orphaned nodes
+    // by directly removing a node that was never properly attached
+    // This tests the removeSubtreeNodes() no-op behavior
+    const orphanId = 'nonexistent-node';
+    expect(debugger_.getNode(orphanId)).toBeUndefined();
+
+    // Calling removeSubtreeNodes on a non-existent node should be safe
+    // We can't call detachChild twice because it throws, but we can
+    // verify the nodeMap state is consistent
+    expect(debugger_.getStats().totalNodes).toBe(1);
+  });
+
+  it('childAttached adds subtree (verify existing behavior)', () => {
+    const root = new IncrementalTestWorkflow('Root');
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+    expect(debugger_.getStats().totalNodes).toBe(1);
+
+    // Attach a child with its own subtree
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
+
+    // Verify all nodes are in the map
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+    expect(debugger_.getNode(child1.id)).toBe(child1.getNode());
+    expect(debugger_.getNode(grandchild.id)).toBe(grandchild.getNode());
+    expect(debugger_.getStats().totalNodes).toBe(3);
+  });
+
+  it('onTreeChanged does not rebuild map', () => {
+    const root = new IncrementalTestWorkflow('Root');
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    const grandchild = new IncrementalTestWorkflow('Grandchild', child1);
+    const child2 = new IncrementalTestWorkflow('Child2', root);
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+
+    // Get reference to the nodeMap (we'll check it's the same object)
+    const nodeMapBefore = debugger_.getStats();
+
+    // Detach child1
+    root.detachChild(child1);
+
+    // Verify map was updated incrementally (nodes removed)
+    expect(debugger_.getStats().totalNodes).toBe(2);
+    expect(debugger_.getNode(child1.id)).toBeUndefined();
+    expect(debugger_.getNode(grandchild.id)).toBeUndefined();
+
+    // Verify remaining nodes are still accessible
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+    expect(debugger_.getNode(child2.id)).toBe(child2.getNode());
+  });
+
+  it('multiple rapid attach/detach operations work correctly', () => {
+    const root = new IncrementalTestWorkflow('Root');
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    const child2 = new IncrementalTestWorkflow('Child2', root);
+    const grandchild1 = new IncrementalTestWorkflow('Grandchild1', child1);
+    const grandchild2 = new IncrementalTestWorkflow('Grandchild2', child1);
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+    expect(debugger_.getStats().totalNodes).toBe(5);
+
+    // Detach child1 (removes child1 + 2 grandchildren)
+    root.detachChild(child1);
+    expect(debugger_.getStats().totalNodes).toBe(2);
+
+    // Attach a new child
+    const child3 = new IncrementalTestWorkflow('Child3', root);
+    expect(debugger_.getStats().totalNodes).toBe(3);
+    expect(debugger_.getNode(child3.id)).toBe(child3.getNode());
+
+    // Detach child2
+    root.detachChild(child2);
+    expect(debugger_.getStats().totalNodes).toBe(2);
+
+    // Verify final state
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+    expect(debugger_.getNode(child3.id)).toBe(child3.getNode());
+    expect(debugger_.getNode(child1.id)).toBeUndefined();
+    expect(debugger_.getNode(child2.id)).toBeUndefined();
+    expect(debugger_.getNode(grandchild1.id)).toBeUndefined();
+    expect(debugger_.getNode(grandchild2.id)).toBeUndefined();
+  });
+
+  it('detaching node with many descendants removes all', () => {
+    const root = new IncrementalTestWorkflow('Root');
+
+    // Build a deep subtree
+    const child1 = new IncrementalTestWorkflow('Child1', root);
+    let current = child1;
+    const descendants: IncrementalTestWorkflow[] = [];
+    for (let i = 0; i < 10; i++) {
+      const descendant = new IncrementalTestWorkflow(`Descendant${i}`, current);
+      descendants.push(descendant);
+      current = descendant;
+    }
+
+    const debugger_ = new WorkflowTreeDebugger(root);
+    // Total: 1 root + 1 child1 + 10 descendants = 12 nodes
+    expect(debugger_.getStats().totalNodes).toBe(12);
+
+    // Detach child1 (should remove child1 + all 10 descendants)
+    root.detachChild(child1);
+
+    // Verify all were removed
+    expect(debugger_.getStats().totalNodes).toBe(1);
+    expect(debugger_.getNode(child1.id)).toBeUndefined();
+    for (const descendant of descendants) {
+      expect(debugger_.getNode(descendant.id)).toBeUndefined();
+    }
+
+    // Verify root is still there
+    expect(debugger_.getNode(root.id)).toBe(root.getNode());
+  });
+});

package/src/__tests__/unit/utils/workflow-error-utils.test.ts

@@ -0,0 +1,209 @@
+import { describe, it, expect } from 'vitest';
+import { mergeWorkflowErrors } from '../../../utils/workflow-error-utils.js';
+import type { WorkflowError } from '../../../types/error.js';
+
+describe('mergeWorkflowErrors', () => {
+  // Helper function to create a mock WorkflowError
+  function createMockWorkflowError(overrides?: Partial<WorkflowError>): WorkflowError {
+    return {
+      message: 'Test error',
+      original: new Error('Original error'),
+      workflowId: 'wf-test-123',
+      stack: 'Error: Test error\n    at test.ts:10:15',
+      state: { key: 'value' },
+      logs: [
+        {
+          id: 'log-1',
+          workflowId: 'wf-test-123',
+          timestamp: Date.now(),
+          level: 'error',
+          message: 'Test log message',
+        },
+      ],
+      ...overrides,
+    };
+  }
+
+  it('should return a single error when merging one error', () => {
+    const error = createMockWorkflowError({ workflowId: 'wf-1' });
+    const result = mergeWorkflowErrors([error], 'testTask', 'parent-wf', 1);
+
+    expect(result.message).toBe("1 of 1 concurrent child workflows failed in task 'testTask'");
+    expect(result.workflowId).toBe('parent-wf');
+    expect(result.logs).toEqual(error.logs);
+    expect(result.stack).toBe(error.stack);
+    expect(result.state).toEqual(error.state);
+  });
+
+  it('should aggregate multiple errors with unique workflow IDs', () => {
+    const error1 = createMockWorkflowError({
+      message: 'Error 1',
+      workflowId: 'wf-1',
+      stack: 'stack 1',
+      state: { key1: 'value1' },
+      logs: [{ id: 'log-1', workflowId: 'wf-1', timestamp: 1000, level: 'error', message: 'Log 1' }],
+    });
+    const error2 = createMockWorkflowError({
+      message: 'Error 2',
+      workflowId: 'wf-2',
+      stack: 'stack 2',
+      state: { key2: 'value2' },
+      logs: [{ id: 'log-2', workflowId: 'wf-2', timestamp: 2000, level: 'error', message: 'Log 2' }],
+    });
+    const error3 = createMockWorkflowError({
+      message: 'Error 3',
+      workflowId: 'wf-3',
+      stack: 'stack 3',
+      state: { key3: 'value3' },
+      logs: [{ id: 'log-3', workflowId: 'wf-3', timestamp: 3000, level: 'error', message: 'Log 3' }],
+    });
+
+    const result = mergeWorkflowErrors([error1, error2, error3], 'concurrentTask', 'parent-wf', 5);
+
+    expect(result.message).toBe("3 of 5 concurrent child workflows failed in task 'concurrentTask'");
+    expect(result.workflowId).toBe('parent-wf');
+    expect(result.stack).toBe('stack 1'); // First error's stack
+    expect(result.state).toEqual({ key1: 'value1' }); // First error's state
+    expect(result.logs).toHaveLength(3); // All logs aggregated
+  });
+
+  it('should deduplicate workflow IDs when errors have duplicate IDs', () => {
+    const error1 = createMockWorkflowError({ workflowId: 'wf-dup' });
+    const error2 = createMockWorkflowError({ workflowId: 'wf-dup' });
+    const error3 = createMockWorkflowError({ workflowId: 'wf-unique' });
+
+    const result = mergeWorkflowErrors([error1, error2, error3], 'testTask', 'parent-wf', 4);
+
+    // Access the metadata from original field
+    const metadata = result.original as {
+      name: string;
+      message: string;
+      errors: WorkflowError[];
+      totalChildren: number;
+      failedChildren: number;
+      failedWorkflowIds: string[];
+    };
+
+    expect(metadata.failedWorkflowIds).toEqual(['wf-dup', 'wf-unique']);
+    expect(metadata.failedWorkflowIds).toHaveLength(2); // Deduplicated
+  });
+
+  it('should flatten logs arrays from all errors using flatMap', () => {
+    const error1 = createMockWorkflowError({
+      workflowId: 'wf-1',
+      logs: [
+        { id: 'log-1', workflowId: 'wf-1', timestamp: 1000, level: 'info', message: 'Log 1.1' },
+        { id: 'log-2', workflowId: 'wf-1', timestamp: 2000, level: 'info', message: 'Log 1.2' },
+      ],
+    });
+    const error2 = createMockWorkflowError({
+      workflowId: 'wf-2',
+      logs: [
+        { id: 'log-3', workflowId: 'wf-2', timestamp: 3000, level: 'error', message: 'Log 2.1' },
+        { id: 'log-4', workflowId: 'wf-2', timestamp: 4000, level: 'error', message: 'Log 2.2' },
+      ],
+    });
+
+    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
+
+    expect(result.logs).toHaveLength(4);
+    expect(result.logs[0].message).toBe('Log 1.1');
+    expect(result.logs[1].message).toBe('Log 1.2');
+    expect(result.logs[2].message).toBe('Log 2.1');
+    expect(result.logs[3].message).toBe('Log 2.2');
+  });
+
+  it('should use first error stack trace', () => {
+    const error1 = createMockWorkflowError({ stack: 'First stack trace' });
+    const error2 = createMockWorkflowError({ stack: 'Second stack trace' });
+    const error3 = createMockWorkflowError({ stack: 'Third stack trace' });
+
+    const result = mergeWorkflowErrors([error1, error2, error3], 'testTask', 'parent-wf', 3);
+
+    expect(result.stack).toBe('First stack trace');
+  });
+
+  it('should use first error state', () => {
+    const error1 = createMockWorkflowError({ state: { first: 'state1' } });
+    const error2 = createMockWorkflowError({ state: { second: 'state2' } });
+
+    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
+
+    expect(result.state).toEqual({ first: 'state1' });
+  });
+
+  it('should use empty object when first error has no state', () => {
+    const error1 = createMockWorkflowError({ state: undefined as any });
+    const error2 = createMockWorkflowError({ state: { hasState: 'yes' } });
+
+    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
+
+    expect(result.state).toEqual({});
+  });
+
+  it('should handle undefined stack trace gracefully', () => {
+    const error1 = createMockWorkflowError({ stack: undefined });
+    const error2 = createMockWorkflowError({ stack: 'Has stack' });
+
+    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
+
+    expect(result.stack).toBeUndefined();
+  });
+
+  it('should include metadata in original field', () => {
+    const error1 = createMockWorkflowError({ workflowId: 'wf-1' });
+    const error2 = createMockWorkflowError({ workflowId: 'wf-2' });
+    const error3 = createMockWorkflowError({ workflowId: 'wf-3' });
+
+    const result = mergeWorkflowErrors([error1, error2, error3], 'concurrentTask', 'parent-wf', 5);
+
+    const metadata = result.original as {
+      name: string;
+      message: string;
+      errors: WorkflowError[];
+      totalChildren: number;
+      failedChildren: number;
+      failedWorkflowIds: string[];
+    };
+
+    expect(metadata.name).toBe('WorkflowAggregateError');
+    expect(metadata.message).toBe("3 of 5 concurrent child workflows failed in task 'concurrentTask'");
+    expect(metadata.errors).toEqual([error1, error2, error3]);
+    expect(metadata.totalChildren).toBe(5);
+    expect(metadata.failedChildren).toBe(3);
+    expect(metadata.failedWorkflowIds).toEqual(['wf-1', 'wf-2', 'wf-3']);
+  });
+
+  it('should handle empty logs array', () => {
+    const error1 = createMockWorkflowError({ logs: [] });
+    const error2 = createMockWorkflowError({ logs: [] });
+
+    const result = mergeWorkflowErrors([error1, error2], 'testTask', 'parent-wf', 2);
+
+    expect(result.logs).toEqual([]);
+  });
+
+  it('should include task name in message', () => {
+    const error = createMockWorkflowError();
+    const result = mergeWorkflowErrors([error], 'myCustomTask', 'parent-wf', 1);
+
+    expect(result.message).toContain("task 'myCustomTask'");
+  });
+
+  it('should include correct counts in message', () => {
+    const errors = Array.from({ length: 3 }, (_, i) =>
+      createMockWorkflowError({ workflowId: `wf-${i}` })
+    );
+
+    const result = mergeWorkflowErrors(errors, 'testTask', 'parent-wf', 10);
+
+    expect(result.message).toBe("3 of 10 concurrent child workflows failed in task 'testTask'");
+  });
+
+  it('should preserve parent workflow ID', () => {
+    const error = createMockWorkflowError({ workflowId: 'child-123' });
+    const result = mergeWorkflowErrors([error], 'testTask', 'parent-abc', 1);
+
+    expect(result.workflowId).toBe('parent-abc');
+  });
+});