groundswell 0.0.1 → 0.0.2

package/src/__tests__/integration/workflow-reparenting.test.ts

@@ -0,0 +1,303 @@
+/**
+ * Integration Test: Reparenting Observer Propagation
+ *
+ * Validates that observer propagation correctly updates when a child
+ * workflow is reparented from one parent to another.
+ *
+ * Pattern 7 (from bug_fix_tasks.json):
+ * "Observer propagation should update after reparenting.
+ *  Events from child should only reach new parent's observers."
+ */
+
+import { describe, it, expect } from 'vitest';
+import {
+  Workflow,
+  WorkflowObserver,
+  WorkflowEvent,
+  WorkflowTreeDebugger,
+} from '../../index.js';
+
+/**
+ * SimpleWorkflow class for testing
+ * Pattern from: src/__tests__/unit/workflow.test.ts:4-11
+ */
+class SimpleWorkflow extends Workflow {
+  async run(): Promise<string> {
+    this.setStatus('running');
+    this.setStatus('completed');
+    return 'done';
+  }
+}
+
+describe('Integration: Reparenting Observer Propagation', () => {
+  it('should update observer propagation after reparenting', () => {
+    // ============================================================
+    // PHASE 1: Setup - Create parent1, parent2, and child
+    // ============================================================
+    // ARRANGE: Create two root workflows (both have parent = null)
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+
+    // ARRANGE: Create child attached to parent1 (via constructor)
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // ASSERT: Verify initial state
+    expect(child.parent).toBe(parent1);
+    expect(parent1.children).toContain(child);
+    expect(parent2.children).not.toContain(child);
+
+    // ============================================================
+    // PHASE 2: Verify parent1 observer receives events
+    // ============================================================
+    // ARRANGE: Create observer for parent1
+    const parent1Events: WorkflowEvent[] = [];
+
+    const parent1Observer: WorkflowObserver = {
+      onLog: () => {}, // Empty - not testing logs
+      onEvent: (event) => parent1Events.push(event), // Capture events
+      onStateUpdated: () => {}, // Empty - not testing state updates
+      onTreeChanged: () => {}, // Empty - not testing tree changes
+    };
+
+    // ACT: Attach observer to parent1 (must be root workflow)
+    parent1.addObserver(parent1Observer);
+
+    // ACT: Child emits event (triggers treeUpdated via setStatus)
+    // PATTERN: setStatus() emits treeUpdated event
+    parent1Events.length = 0; // Clear any construction events
+    child.setStatus('running');
+
+    // ASSERT: Verify parent1 observer received the event
+    const parent1ReceivedEvent = parent1Events.find(
+      (e) => e.type === 'treeUpdated'
+    );
+    expect(parent1ReceivedEvent).toBeDefined();
+
+    // ============================================================
+    // PHASE 3: Reparent child from parent1 to parent2
+    // ============================================================
+    // ARRANGE: Create observer for parent2
+    const parent2Events: WorkflowEvent[] = [];
+
+    const parent2Observer: WorkflowObserver = {
+      onLog: () => {},
+      onEvent: (event) => parent2Events.push(event),
+      onStateUpdated: () => {},
+      onTreeChanged: () => {},
+    };
+
+    // ACT: Reparent using detach + attach pattern
+    // CRITICAL: Must detach before attaching to new parent
+    parent1.detachChild(child);
+    parent2.attachChild(child);
+    parent2.addObserver(parent2Observer);
+
+    // ASSERT: Verify reparenting succeeded
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toContain(child);
+    expect(parent1.children).not.toContain(child);
+
+    // ============================================================
+    // PHASE 4: Verify parent2 observer receives events after reparenting
+    // ============================================================
+    // ACT: Clear events to isolate post-reparenting behavior
+    parent1Events.length = 0;
+    parent2Events.length = 0;
+
+    // ACT: Child emits event again
+    child.setStatus('completed');
+
+    // ASSERT: Verify parent2 observer received the event
+    const parent2ReceivedEvent = parent2Events.find(
+      (e) => e.type === 'treeUpdated'
+    );
+    expect(parent2ReceivedEvent).toBeDefined();
+
+    // ============================================================
+    // PHASE 5: CRITICAL VALIDATION - parent1 observer does NOT receive events
+    // ============================================================
+    // ASSERT: Verify parent1 observer did NOT receive the post-reparenting event
+    const parent1DidNotReceive = parent1Events.find(
+      (e) => e.type === 'treeUpdated'
+    );
+    expect(parent1DidNotReceive).toBeUndefined();
+
+    // ASSERT: Verify event count for parent1 is zero
+    expect(parent1Events.length).toBe(0);
+  });
+
+  it('should handle multiple reparenting cycles correctly', () => {
+    // ARRANGE: Create three potential parents
+    const parentA = new SimpleWorkflow('ParentA');
+    const parentB = new SimpleWorkflow('ParentB');
+    const parentC = new SimpleWorkflow('ParentC');
+
+    // ARRANGE: Create child and observers for each parent
+    const child = new SimpleWorkflow('Child', parentA);
+
+    const eventsA: WorkflowEvent[] = [];
+    const eventsB: WorkflowEvent[] = [];
+    const eventsC: WorkflowEvent[] = [];
+
+    const createObserver = (eventsArray: WorkflowEvent[]): WorkflowObserver => ({
+      onLog: () => {},
+      onEvent: (e) => eventsArray.push(e),
+      onStateUpdated: () => {},
+      onTreeChanged: () => {},
+    });
+
+    parentA.addObserver(createObserver(eventsA));
+    parentB.addObserver(createObserver(eventsB));
+    parentC.addObserver(createObserver(eventsC));
+
+    // ACT & ASSERT: Cycle 1 - A -> B
+    eventsA.length = 0;
+    child.setStatus('running');
+    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(true);
+
+    parentA.detachChild(child);
+    parentB.attachChild(child);
+
+    eventsA.length = 0;
+    eventsB.length = 0;
+    child.setStatus('completed');
+    expect(eventsB.some((e) => e.type === 'treeUpdated')).toBe(true);
+    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(false);
+
+    // ACT & ASSERT: Cycle 2 - B -> C
+    parentB.detachChild(child);
+    parentC.attachChild(child);
+
+    eventsB.length = 0;
+    eventsC.length = 0;
+    child.setStatus('running');
+    expect(eventsC.some((e) => e.type === 'treeUpdated')).toBe(true);
+    expect(eventsB.some((e) => e.type === 'treeUpdated')).toBe(false);
+
+    // ACT & ASSERT: Cycle 3 - C -> A (return to original)
+    parentC.detachChild(child);
+    parentA.attachChild(child);
+
+    eventsC.length = 0;
+    eventsA.length = 0;
+    child.setStatus('completed');
+    expect(eventsA.some((e) => e.type === 'treeUpdated')).toBe(true);
+    expect(eventsC.some((e) => e.type === 'treeUpdated')).toBe(false);
+  });
+
+  it('should verify tree consistency after reparenting using debugger', () => {
+    // ============================================================
+    // PHASE 1: Setup - Create parent1, parent2, and child
+    // ============================================================
+    // ARRANGE: Create two root workflows
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+
+    // ARRANGE: Create child attached to parent1 (via constructor)
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // ARRANGE: Create debugger attached to parent1
+    const parent1Debugger = new WorkflowTreeDebugger(parent1);
+
+    // ASSERT: Verify initial tree structure
+    expect(child.parent).toBe(parent1);
+    expect(parent1.children).toContain(child);
+    expect(parent2.children).not.toContain(child);
+
+    // ASSERT: Verify debugger sees initial structure
+    const initialTree = parent1Debugger.getTree();
+    expect(initialTree.name).toBe('Parent1');
+    expect(initialTree.children.length).toBe(1);
+    expect(initialTree.children[0].name).toBe('Child');
+
+    // ============================================================
+    // PHASE 2: Reparenting operation
+    // ============================================================
+    // ACT: Reparent child from parent1 to parent2
+    parent1.detachChild(child);
+    parent2.attachChild(child);
+
+    // ASSERT: Verify basic reparenting succeeded
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toContain(child);
+    expect(parent1.children).not.toContain(child);
+
+    // ============================================================
+    // PHASE 3: Verify workflow tree structure
+    // ============================================================
+    // ASSERT: Verify child.parent points to new parent
+    expect(child.parent).toBe(parent2);
+
+    // ASSERT: Verify new parent.children includes child
+    expect(parent2.children).toContain(child);
+
+    // ASSERT: Verify old parent.children does NOT include child
+    expect(parent1.children).not.toContain(child);
+
+    // ============================================================
+    // PHASE 4: Verify node tree structure using debugger
+    // ============================================================
+    // NOTE: parent1Debugger is still attached to parent1, so it shows parent1's tree
+    // Create debugger for parent2 to see the new tree structure
+    const parent2Debugger = new WorkflowTreeDebugger(parent2);
+
+    // ASSERT: Verify debugger can find child node
+    const childNode = parent2Debugger.getNode(child.id);
+    expect(childNode).toBeDefined();
+    expect(childNode?.name).toBe('Child');
+
+    // ASSERT: Verify child's node parent is parent2's node (node tree mirrors workflow tree)
+    const parent2NodeDirect = parent2.getNode();
+    expect(childNode?.parent).toBe(parent2NodeDirect);
+
+    // ASSERT: Verify parent2's node children includes child's node
+    const parent2Node = parent2Debugger.getNode(parent2.id);
+    const childNodeDirect = child.getNode();
+    expect(parent2Node?.children).toContain(childNodeDirect);
+
+    // ASSERT: Verify parent1's node children does NOT include child's node
+    const parent1Node = parent1Debugger.getNode(parent1.id);
+    expect(parent1Node?.children).not.toContain(childNodeDirect);
+
+    // ============================================================
+    // PHASE 5: Visual validation using toTreeString()
+    // ============================================================
+    // ACT: Get tree string for visual debugging
+    const parent2TreeString = parent2Debugger.toTreeString();
+
+    // ASSERT: Verify tree structure in ASCII representation
+    expect(parent2TreeString).toContain('Parent2');
+    expect(parent2TreeString).toContain('Child');
+    expect(parent2TreeString).toContain('└──'); // Tree connector symbol
+
+    // ============================================================
+    // PHASE 6: Statistical validation
+    // ============================================================
+    const parent2Stats = parent2Debugger.getStats();
+    expect(parent2Stats.totalNodes).toBe(2); // parent2 + child = 2
+
+    // ============================================================
+    // CRITICAL VALIDATION: 1:1 Tree Mirror Invariant
+    // ============================================================
+    // Verify workflow tree and node tree are perfectly synchronized
+    // This is the core invariant that must be maintained
+
+    // Workflow tree state:
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toEqual([child]);
+    expect(parent1.children).toEqual([]);
+
+    // Node tree state (via getNode() method):
+    const childNodeFinal = child.getNode();
+    const parent2NodeFinal = parent2.getNode();
+    const parent1NodeFinal = parent1.getNode();
+
+    expect(childNodeFinal.parent).toBe(parent2NodeFinal);
+    expect(parent2NodeFinal.children).toEqual([childNodeFinal]);
+    expect(parent1NodeFinal.children).toEqual([]);
+
+    // Cross-verification: debugger lookup matches direct access
+    expect(parent2Debugger.getNode(child.id)).toBe(childNodeFinal);
+    expect(parent2Debugger.getNode(parent2.id)).toBe(parent2NodeFinal);
+  });
+});

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

@@ -9,6 +9,7 @@ import {
   type AgentExecutionContext,
 } from '../../core/context.js';
 import type { WorkflowNode, WorkflowEvent } from '../../types/index.js';
+import { Workflow, WorkflowObserver, ObservedState } from '../../index.js';
 
 describe('AgentExecutionContext', () => {
   const createMockNode = (name: string): WorkflowNode => ({
@@ -136,3 +137,81 @@ describe('AgentExecutionContext', () => {
     expect(events[0].type).toBe('stepStart');
   });
 });
+
+describe('WorkflowContext', () => {
+  // Test workflow class with @ObservedState decorated fields
+  class StatefulTestWorkflow extends Workflow {
+    @ObservedState()
+    stepCount: number = 0;
+
+    @ObservedState({ redact: true })
+    apiKey: string = 'secret-key-123';
+
+    @ObservedState({ hidden: true })
+    internalCounter: number = 42;
+  }
+
+  it('should capture state and logs in step() error handler', async () => {
+    // Arrange: Create observer to capture error events
+    const events: WorkflowEvent[] = [];
+
+    const observer: WorkflowObserver = {
+      onLog: () => {},
+      onEvent: (event) => events.push(event),
+      onStateUpdated: () => {},
+      onTreeChanged: () => {},
+    };
+
+    // Arrange: Create workflow with @ObservedState fields using functional executor
+    const workflow = new StatefulTestWorkflow(
+      { name: 'StepErrorTest' },
+      async (ctx) => {
+        // Modify @ObservedState fields on the workflow instance
+        (workflow as any).stepCount = 5;
+        (workflow as any).apiKey = 'updated-key';
+        (workflow as any).internalCounter = 99;
+
+        // Execute a step that will fail - THIS TRIGGERS WorkflowContext.step() ERROR HANDLER
+        await ctx.step('failing-step', async () => {
+          throw new Error('Test error from step');
+        });
+      }
+    );
+
+    // Act: Attach observer and trigger error
+    workflow.addObserver(observer);
+    await expect(workflow.run()).rejects.toThrow('Test error from step');
+
+    // Assert: Verify error event was emitted
+    const errorEvents = events.filter((e) => e.type === 'error');
+    expect(errorEvents.length).toBeGreaterThanOrEqual(1);
+
+    // Assert: Verify error structure
+    const errorEvent = errorEvents[0];
+    expect(errorEvent.error).toBeDefined();
+    expect(errorEvent.error.message).toBe('Test error from step');
+
+    // Assert: Verify @ObservedState fields were captured in state
+    expect(errorEvent.error.state).toBeDefined();
+    expect(typeof errorEvent.error.state).toBe('object');
+
+    // Assert: Verify public field value is captured
+    expect(errorEvent.error.state.stepCount).toBe(5);
+
+    // Assert: Verify redacted field shows '***'
+    expect(errorEvent.error.state.apiKey).toBe('***');
+
+    // Assert: Verify hidden field is NOT in state
+    expect('internalCounter' in errorEvent.error.state).toBe(false);
+
+    // Assert: Verify logs array is present (may be empty)
+    expect(errorEvent.error.logs).toBeDefined();
+    expect(Array.isArray(errorEvent.error.logs)).toBe(true);
+
+    // Assert: Verify workflow status
+    expect(workflow.status).toBe('failed');
+
+    // Assert: Verify workflowId is captured
+    expect(errorEvent.error.workflowId).toBe(workflow.id);
+  });
+});

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

@@ -0,0 +1,293 @@
+import { describe, it, expect } from 'vitest';
+import { Workflow } from '../../core/workflow';
+import type { LogEntry } from '../../types/logging';
+
+describe('WorkflowLogger.child()', () => {
+  describe('with Partial<LogEntry> containing parentLogId', () => {
+    it('should create child logger with parentLogId from Partial<LogEntry>', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child({ parentLogId: 'parent-123' });
+          childLogger.info('Child message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(1);
+      expect(workflow.node.logs[0].parentLogId).toBe('parent-123');
+      expect(workflow.node.logs[0].message).toBe('Child message');
+    });
+
+    it('should handle parentLogId with special characters', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child({ parentLogId: 'parent-with-dashes-and_underscores' });
+          childLogger.info('Test');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs[0].parentLogId).toBe('parent-with-dashes-and_underscores');
+    });
+  });
+
+  describe('with Partial<LogEntry> containing id field', () => {
+    it('should not use id field as parentLogId', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // id field should NOT be used as parentLogId
+          const childLogger = this.logger.child({ id: 'custom-id' });
+          childLogger.info('Test message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      // parentLogId is undefined because implementation only checks input.parentLogId
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+      expect(workflow.node.logs[0].message).toBe('Test message');
+    });
+
+    it('should handle both id and parentLogId fields', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // parentLogId should be used, not id
+          const childLogger = this.logger.child({ id: 'custom-id', parentLogId: 'correct-parent' });
+          childLogger.info('Test');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs[0].parentLogId).toBe('correct-parent');
+    });
+  });
+
+  describe('with empty Partial<LogEntry>', () => {
+    it('should create child logger with undefined parentLogId from empty object', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child({});
+          childLogger.info('Child log with empty parent metadata');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(1);
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+      expect(workflow.node.logs[0].message).toBe('Child log with empty parent metadata');
+    });
+  });
+
+  describe('with string parameter (backward compatibility)', () => {
+    it('should create child logger with parentLogId from string', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child('parent-id-123');
+          childLogger.info('Child message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(1);
+      expect(workflow.node.logs[0].parentLogId).toBe('parent-id-123');
+      expect(workflow.node.logs[0].message).toBe('Child message');
+    });
+
+    it('should create child logger with parentLogId from string containing parentLogId', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // String value is used directly as parentLogId
+          const childLogger = this.logger.child('log-abc-123');
+          childLogger.warn('Warning message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs[0].parentLogId).toBe('log-abc-123');
+      expect(workflow.node.logs[0].level).toBe('warn');
+    });
+  });
+
+  describe('with empty string', () => {
+    it('should create child logger with undefined parentLogId from empty string', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child('');
+          childLogger.info('Child log with empty parent');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(1);
+      // Empty string is falsy, so parentLogId becomes undefined in log entry
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+    });
+  });
+
+  describe('child logger with different log levels', () => {
+    it.each([
+      { level: 'debug', method: 'debug' as const },
+      { level: 'info', method: 'info' as const },
+      { level: 'warn', method: 'warn' as const },
+      { level: 'error', method: 'error' as const },
+    ])('should log at $level level with child logger', async ({ level, method }) => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child({ parentLogId: 'parent-123' });
+          childLogger[method](`Test ${level} message`);
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs[0].level).toBe(level);
+      expect(workflow.node.logs[0].parentLogId).toBe('parent-123');
+      expect(workflow.node.logs[0].message).toBe(`Test ${level} message`);
+    });
+
+    it('should support logging with data parameter at all levels', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          const childLogger = this.logger.child({ parentLogId: 'parent-data' });
+
+          childLogger.debug('Debug message', { debugData: true });
+          childLogger.info('Info message', { infoData: 123 });
+          childLogger.warn('Warn message', { warnData: 'warning' });
+          childLogger.error('Error message', { errorData: { code: 500 } });
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(4);
+      expect(workflow.node.logs[0].data).toEqual({ debugData: true });
+      expect(workflow.node.logs[1].data).toEqual({ infoData: 123 });
+      expect(workflow.node.logs[2].data).toEqual({ warnData: 'warning' });
+      expect(workflow.node.logs[3].data).toEqual({ errorData: { code: 500 } });
+    });
+  });
+
+  describe('parent-child log hierarchy', () => {
+    it('should maintain parent-child relationship in log entries', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // Log from parent logger
+          this.logger.info('Parent message');
+
+          // Get the parent log entry ID
+          const parentLogId = this.node.logs[0].id;
+
+          // Create child logger with that ID
+          const childLogger = this.logger.child({ parentLogId });
+          childLogger.info('Child message');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      // Verify hierarchy
+      expect(workflow.node.logs.length).toBe(2);
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined(); // Root log
+      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id); // Child log
+      expect(workflow.node.logs[0].message).toBe('Parent message');
+      expect(workflow.node.logs[1].message).toBe('Child message');
+    });
+
+    it('should support multi-level nesting with child loggers', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // Root log
+          this.logger.info('Root message');
+          const rootLogId = this.node.logs[0].id;
+
+          // First level child
+          const child1 = this.logger.child({ parentLogId: rootLogId });
+          child1.info('Level 1 child');
+          const level1LogId = this.node.logs[1].id;
+
+          // Second level child
+          const child2 = this.logger.child({ parentLogId: level1LogId });
+          child2.info('Level 2 child');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(3);
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
+      expect(workflow.node.logs[2].parentLogId).toBe(workflow.node.logs[1].id);
+    });
+
+    it('should support string-based parent-child hierarchy', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // Log from parent
+          this.logger.info('Parent log');
+          const parentLogId = this.node.logs[0].id;
+
+          // Create child using string parentLogId (backward compatibility)
+          const childLogger = this.logger.child(parentLogId);
+          childLogger.info('Child log');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(2);
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
+    });
+
+    it('should allow multiple child loggers from same parent', async () => {
+      class TestWorkflow extends Workflow {
+        async run() {
+          // Parent log
+          this.logger.info('Parent');
+          const parentLogId = this.node.logs[0].id;
+
+          // Multiple children from same parent
+          const child1 = this.logger.child({ parentLogId });
+          child1.info('First child');
+
+          const child2 = this.logger.child({ parentLogId });
+          child2.info('Second child');
+
+          const child3 = this.logger.child({ parentLogId });
+          child3.info('Third child');
+        }
+      }
+
+      const workflow = new TestWorkflow();
+      await workflow.run();
+
+      expect(workflow.node.logs.length).toBe(4);
+      expect(workflow.node.logs[0].parentLogId).toBeUndefined();
+
+      // All children should have the same parent
+      expect(workflow.node.logs[1].parentLogId).toBe(workflow.node.logs[0].id);
+      expect(workflow.node.logs[2].parentLogId).toBe(workflow.node.logs[0].id);
+      expect(workflow.node.logs[3].parentLogId).toBe(workflow.node.logs[0].id);
+    });
+  });
+});