groundswell 0.0.2 → 0.0.3

package/src/__tests__/unit/workflow-emitEvent-childDetached.test.ts

@@ -1,153 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow, WorkflowObserver, WorkflowEvent } from '../../index.js';
-
-class SimpleWorkflow extends Workflow {
-  async run(): Promise<string> {
-    this.setStatus('running');
-    this.setStatus('completed');
-    return 'done';
-  }
-}
-
-describe('emitEvent() - childDetached Tree Update Events', () => {
-  it('should call onTreeChanged() when childDetached event is emitted', () => {
-    // Arrange: Create parent with observer tracking callbacks
-    const parent = new SimpleWorkflow('Parent');
-    const events: WorkflowEvent[] = [];
-    const treeChanges: any[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: (e) => events.push(e),
-      onStateUpdated: () => {},
-      onTreeChanged: (root) => treeChanges.push(root),
-    };
-
-    parent.addObserver(observer);
-
-    // Act: Detach child (which emits childDetached event)
-    const child = new SimpleWorkflow('Child', parent);
-    events.length = 0; // Clear attachChild events
-    treeChanges.length = 0; // Clear attachChild tree changes
-
-    parent.detachChild(child);
-
-    // Assert: Verify childDetached event was emitted
-    const detachEvent = events.find((e) => e.type === 'childDetached');
-    expect(detachEvent).toBeDefined();
-    expect(detachEvent?.type === 'childDetached' && detachEvent.parentId).toBe(parent.id);
-
-    // CRITICAL ASSERTION: onTreeChanged() must be called
-    expect(treeChanges.length).toBe(1);
-    expect(treeChanges[0]).toBe(parent.getNode()); // Receives root node
-  });
-
-  it('should call onEvent() before onTreeChanged() for childDetached', () => {
-    // Arrange: Track call order
-    const parent = new SimpleWorkflow('Parent');
-    const callOrder: string[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: () => callOrder.push('onEvent'),
-      onStateUpdated: () => {},
-      onTreeChanged: () => callOrder.push('onTreeChanged'),
-    };
-
-    parent.addObserver(observer);
-
-    // Act
-    const child = new SimpleWorkflow('Child', parent);
-    callOrder.length = 0; // Clear attachChild call order
-    parent.detachChild(child);
-
-    // Assert: Verify order
-    expect(callOrder).toEqual(['onEvent', 'onTreeChanged']);
-  });
-
-  it('should include childDetached in tree update event types', () => {
-    // This test verifies the implementation at the code level
-    // Access the emitEvent method and verify it triggers onTreeChanged for childDetached
-    const workflow = new SimpleWorkflow('Test');
-
-    // Access private emitEvent method for testing
-    const emitEvent = (workflow as any).emitEvent.bind(workflow);
-
-    // Track if onTreeChanged was called
-    let onTreeChangedCalled = false;
-    const mockObserver = {
-      onLog: () => {},
-      onEvent: () => {},
-      onStateUpdated: () => {},
-      onTreeChanged: () => { onTreeChangedCalled = true; },
-    };
-
-    // Mock getRootObservers to return test observer
-    (workflow as any).getRootObservers = () => [mockObserver];
-
-    // Emit childDetached event
-    emitEvent({
-      type: 'childDetached',
-      parentId: workflow.id,
-      childId: 'test-child-id',
-    });
-
-    // Assert: onTreeChanged should be called
-    expect(onTreeChangedCalled).toBe(true);
-  });
-
-  it('should pass correct root node to onTreeChanged() after detach', () => {
-    // Arrange: Create multi-level tree
-    const root = new SimpleWorkflow('Root');
-    const parent = new SimpleWorkflow('Parent', root);
-    const child = new SimpleWorkflow('Child', parent);
-
-    const treeChangedRoots: any[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: () => {},
-      onStateUpdated: () => {},
-      onTreeChanged: (rootNode) => treeChangedRoots.push(rootNode),
-    };
-
-    root.addObserver(observer);
-
-    // Clear events from tree construction
-    treeChangedRoots.length = 0;
-
-    // Act: Detach child from parent
-    parent.detachChild(child);
-
-    // Assert: onTreeChanged should receive root node (from root workflow)
-    expect(treeChangedRoots.length).toBe(1);
-    expect(treeChangedRoots[0]).toBe(root.getNode());
-  });
-
-  it('should trigger onTreeChanged for both attach and detach operations', () => {
-    // Arrange: Track tree changes
-    const parent = new SimpleWorkflow('Parent');
-    const treeChanges: any[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: () => {},
-      onStateUpdated: () => {},
-      onTreeChanged: (root) => treeChanges.push({ operation: 'treeChanged', root }),
-    };
-
-    parent.addObserver(observer);
-
-    // Act 1: Attach child
-    const child = new SimpleWorkflow('Child', parent);
-    const attachCount = treeChanges.length;
-
-    // Act 2: Detach child
-    treeChanges.length = 0; // Clear to only track detach
-    parent.detachChild(child);
-
-    // Assert: Both attach and detach should trigger onTreeChanged
-    expect(treeChanges.length).toBe(1);
-    expect(treeChanges[0].root).toBe(parent.getNode());
-  });
-});

package/src/__tests__/unit/workflow-isDescendantOf.test.ts

@@ -1,180 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { Workflow } from "../../core/workflow.js";
-
-/**
- * Test suite for public isDescendantOf() API.
- *
- * These tests verify that the isDescendantOf() method is publicly accessible
- * without requiring (as any) type casting, following the P1.M3.T4.S2 PRP
- * implementation for making this method public.
- */
-describe("Workflow.isDescendantOf() - Public API", () => {
-  describe("Public API Accessibility", () => {
-    it("should be publicly accessible without casting to any", () => {
-      const root = new Workflow("root");
-      const child = new Workflow("child", root);
-
-      // This should work without (as any) cast - verifies public visibility
-      const result = child.isDescendantOf(root);
-
-      expect(result).toBe(true);
-    });
-
-    it("should return true for direct parent relationship", () => {
-      const root = new Workflow("root");
-      const child = new Workflow("child", root);
-
-      const result = child.isDescendantOf(root);
-
-      expect(result).toBe(true);
-    });
-
-    it("should return true for nested descendant relationship", () => {
-      const root = new Workflow("root");
-      const level1 = new Workflow("level1", root);
-      const level2 = new Workflow("level2", level1);
-      const level3 = new Workflow("level3", level2);
-
-      expect(level1.isDescendantOf(root)).toBe(true);
-      expect(level2.isDescendantOf(root)).toBe(true);
-      expect(level3.isDescendantOf(root)).toBe(true);
-      expect(level3.isDescendantOf(level1)).toBe(true);
-    });
-
-    it("should return false for unrelated workflows", () => {
-      const tree1 = new Workflow("tree1");
-      const tree2 = new Workflow("tree2");
-
-      const result = tree1.isDescendantOf(tree2);
-
-      expect(result).toBe(false);
-    });
-
-    it("should return false when checking root against descendant", () => {
-      const root = new Workflow("root");
-      const child = new Workflow("child", root);
-
-      const result = root.isDescendantOf(child);
-
-      expect(result).toBe(false);
-    });
-
-    it("should return false for root checking itself", () => {
-      const root = new Workflow("root");
-
-      const result = root.isDescendantOf(root);
-
-      expect(result).toBe(false);
-    });
-  });
-
-  describe("Use Case: Hierarchy Validation", () => {
-    it("should support validating workflow belongs to specific hierarchy", () => {
-      const productionRoot = new Workflow("production-root");
-      const stagingRoot = new Workflow("staging-root");
-
-      const prodWorkflow = new Workflow("prod-workflow", productionRoot);
-      const stagingWorkflow = new Workflow("staging-workflow", stagingRoot);
-
-      expect(prodWorkflow.isDescendantOf(productionRoot)).toBe(true);
-      expect(prodWorkflow.isDescendantOf(stagingRoot)).toBe(false);
-      expect(stagingWorkflow.isDescendantOf(stagingRoot)).toBe(true);
-      expect(stagingWorkflow.isDescendantOf(productionRoot)).toBe(false);
-    });
-  });
-
-  describe("Use Case: Circular Reference Prevention", () => {
-    it("should support validation before attaching to prevent circular references", () => {
-      const root = new Workflow("root");
-      const child = new Workflow("child", root);
-      const grandchild = new Workflow("grandchild", child);
-
-      // grandchild should NOT be attachable to root (would create cycle)
-      expect(grandchild.isDescendantOf(root)).toBe(true);
-
-      // Unrelated workflow should be attachable
-      const unrelated = new Workflow("unrelated");
-      expect(unrelated.isDescendantOf(root)).toBe(false);
-    });
-  });
-
-  describe("Use Case: Conditional Logic Based on Ancestry", () => {
-    it("should support conditional execution based on hierarchy position", () => {
-      const productionRoot = new Workflow("production-root");
-      const developmentRoot = new Workflow("development-root");
-
-      const prodBatch = new Workflow("prod-batch", productionRoot);
-      const devBatch = new Workflow("dev-batch", developmentRoot);
-
-      // Simulate conditional logic
-      const isInProduction = prodBatch.isDescendantOf(productionRoot);
-      const isProductionWorkflow = devBatch.isDescendantOf(productionRoot);
-
-      expect(isInProduction).toBe(true);
-      expect(isProductionWorkflow).toBe(false);
-    });
-  });
-
-  describe("Edge Cases", () => {
-    it("should handle workflows with no parent", () => {
-      const orphan = new Workflow("orphan");
-      const root = new Workflow("root");
-
-      const result = orphan.isDescendantOf(root);
-
-      expect(result).toBe(false);
-    });
-
-    it("should handle sibling relationships correctly", () => {
-      const root = new Workflow("root");
-      const sibling1 = new Workflow("sibling1", root);
-      const sibling2 = new Workflow("sibling2", root);
-
-      // Siblings are not descendants of each other
-      expect(sibling1.isDescendantOf(sibling2)).toBe(false);
-      expect(sibling2.isDescendantOf(sibling1)).toBe(false);
-    });
-
-    it("should handle complex multi-level hierarchies", () => {
-      const root = new Workflow("root");
-      const branch1 = new Workflow("branch1", root);
-      const branch2 = new Workflow("branch2", root);
-      const leaf1a = new Workflow("leaf1a", branch1);
-      const leaf1b = new Workflow("leaf1b", branch1);
-      const leaf2a = new Workflow("leaf2a", branch2);
-
-      // All leafs should be descendants of root
-      expect(leaf1a.isDescendantOf(root)).toBe(true);
-      expect(leaf1b.isDescendantOf(root)).toBe(true);
-      expect(leaf2a.isDescendantOf(root)).toBe(true);
-
-      // Leaf1a should not be descendant of branch2
-      expect(leaf1a.isDescendantOf(branch2)).toBe(false);
-
-      // Leaf2a should not be descendant of branch1
-      expect(leaf2a.isDescendantOf(branch1)).toBe(false);
-    });
-  });
-
-  describe("Edge Cases: Circular Reference Detection", () => {
-    it("should throw error when circular reference is detected", () => {
-      // Arrange: Create parent and child workflows with circular reference
-      const parent = new Workflow("Parent");
-      const child = new Workflow("Child", parent);
-      const unrelated = new Workflow("Unrelated");
-
-      // Act: Create circular reference manually
-      // This simulates a bug or malicious input that creates a cycle
-      // Normal attachChild() prevents this, so we bypass normal safeguards
-      parent.parent = child;
-
-      // Assert: isDescendantOf should throw error for circular reference
-      // We use 'unrelated' as the ancestor to force traversal through the cycle
-      // If we used 'child', the method would return true immediately before
-      // detecting the cycle (since child === child at first iteration)
-      expect(() => parent.isDescendantOf(unrelated)).toThrow(
-        "Circular parent-child relationship detected",
-      );
-    });
-  });
-});

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

@@ -1,357 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { Workflow, WorkflowObserver, WorkflowNode, LogEntry, WorkflowEvent, ObservedState, getObservedState } from '../../index.js';
-
-class SimpleWorkflow extends Workflow {
-  async run(): Promise<string> {
-    this.setStatus('running');
-    this.logger.info('Running simple workflow');
-    this.setStatus('completed');
-    return 'done';
-  }
-}
-
-describe('Workflow Name Validation', () => {
-  it('should reject empty string name', () => {
-    expect(() => new SimpleWorkflow('')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should reject whitespace-only name (spaces)', () => {
-    expect(() => new SimpleWorkflow('   ')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should reject whitespace-only name (tabs)', () => {
-    expect(() => new SimpleWorkflow('\t\t')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should reject whitespace-only name (newlines)', () => {
-    expect(() => new SimpleWorkflow('\n\n')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should reject whitespace-only name (mixed whitespace)', () => {
-    expect(() => new SimpleWorkflow('  \t\n  ')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should reject name exceeding 100 characters', () => {
-    const longName = 'a'.repeat(101);
-    expect(() => new SimpleWorkflow(longName)).toThrow('Workflow name cannot exceed 100 characters');
-  });
-
-  it('should accept name with exactly 100 characters', () => {
-    const exactly100 = 'a'.repeat(100);
-    const wf = new SimpleWorkflow(exactly100);
-    expect(wf.getNode().name).toBe(exactly100);
-    expect(wf.getNode().name.length).toBe(100);
-  });
-
-  it('should accept valid names with leading/trailing whitespace', () => {
-    const wf1 = new SimpleWorkflow('  MyWorkflow  ');
-    expect(wf1.getNode().name).toBe('  MyWorkflow  ');
-
-    const wf2 = new SimpleWorkflow('\tValidName\t');
-    expect(wf2.getNode().name).toBe('\tValidName\t');
-  });
-
-  it('should use class name when name is undefined', () => {
-    const wf = new SimpleWorkflow();
-    expect(wf.getNode().name).toBe('SimpleWorkflow');
-  });
-
-  it('should use class name when name is null', () => {
-    const wf = new SimpleWorkflow(null as any);
-    expect(wf.getNode().name).toBe('SimpleWorkflow');
-  });
-
-  it('should validate both constructor patterns - class-based with empty name', () => {
-    expect(() => new SimpleWorkflow('')).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should validate both constructor patterns - functional with empty name', () => {
-    expect(() => new Workflow({ name: '' }, async () => {})).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should validate both constructor patterns - functional with whitespace name', () => {
-    expect(() => new Workflow({ name: '   ' }, async () => {})).toThrow('Workflow name cannot be empty or whitespace only');
-  });
-
-  it('should validate both constructor patterns - functional with name exceeding 100 characters', () => {
-    const longName = 'a'.repeat(101);
-    expect(() => new Workflow({ name: longName }, async () => {})).toThrow('Workflow name cannot exceed 100 characters');
-  });
-
-  it('should accept valid name in functional pattern', () => {
-    const wf = new Workflow({ name: 'ValidFunctionalWorkflow' }, async () => 'done');
-    expect(wf.getNode().name).toBe('ValidFunctionalWorkflow');
-  });
-});
-
-describe('Workflow', () => {
-  it('should create with unique id', () => {
-    const wf1 = new SimpleWorkflow();
-    const wf2 = new SimpleWorkflow();
-    expect(wf1.id).not.toBe(wf2.id);
-  });
-
-  it('should use class name as default name', () => {
-    const wf = new SimpleWorkflow();
-    expect(wf.getNode().name).toBe('SimpleWorkflow');
-  });
-
-  it('should use custom name when provided', () => {
-    const wf = new SimpleWorkflow('CustomName');
-    expect(wf.getNode().name).toBe('CustomName');
-  });
-
-  it('should start with idle status', () => {
-    const wf = new SimpleWorkflow();
-    expect(wf.status).toBe('idle');
-    expect(wf.getNode().status).toBe('idle');
-  });
-
-  it('should attach child to parent', () => {
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    expect(child.parent).toBe(parent);
-    expect(parent.children).toContain(child);
-    expect(parent.getNode().children).toContain(child.getNode());
-  });
-
-  it('should emit logs to observers', async () => {
-    const wf = new SimpleWorkflow();
-    const logs: LogEntry[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: (entry) => logs.push(entry),
-      onEvent: () => {},
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    wf.addObserver(observer);
-    await wf.run();
-
-    expect(logs.length).toBeGreaterThan(0);
-    expect(logs[0].message).toBe('Running simple workflow');
-  });
-
-  it('should emit childAttached event', () => {
-    const parent = new SimpleWorkflow('Parent');
-    const events: WorkflowEvent[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: (event) => events.push(event),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    parent.addObserver(observer);
-    const child = new SimpleWorkflow('Child', parent);
-
-    const attachEvent = events.find((e) => e.type === 'childAttached');
-    expect(attachEvent).toBeDefined();
-    expect(attachEvent?.type === 'childAttached' && attachEvent.parentId).toBe(parent.id);
-  });
-
-  it('should capture state and logs in functional workflow error', async () => {
-    // Arrange: Create observer to capture events
-    const events: WorkflowEvent[] = [];
-
-    const observer: WorkflowObserver = {
-      onLog: () => {},
-      onEvent: (event) => events.push(event),
-      onStateUpdated: () => {},
-      onTreeChanged: () => {},
-    };
-
-    // Arrange: Create functional workflow with a step that throws an error
-    const workflow = new Workflow<void>(
-      { name: 'ErrorCaptureTest' },
-      async (ctx) => {
-        // Execute a step that will fail
-        await ctx.step('failing-step', async () => {
-          throw new Error('Test error from step');
-        });
-      }
-    );
-
-    // Act: Attach observer and run workflow
-    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 logs array was captured (even if empty for step errors)
-    expect(errorEvent.error.logs).toBeDefined();
-    expect(Array.isArray(errorEvent.error.logs)).toBe(true);
-
-    // Assert: Verify state was captured (may be empty object for pure functional workflows)
-    expect(errorEvent.error.state).toBeDefined();
-    expect(typeof errorEvent.error.state).toBe('object');
-
-    // Assert: Verify workflow status
-    expect(workflow.status).toBe('failed');
-
-    // Assert: Verify workflowId is captured
-    expect(errorEvent.error.workflowId).toBe(workflow.id);
-  });
-
-  it('should capture @ObservedState fields in workflow error state', async () => {
-    // Test workflow class with @ObservedState decorated fields
-    // Using functional pattern (executor) so error events are emitted via runFunctional()
-    class StatefulWorkflowClass extends Workflow {
-      @ObservedState()
-      stepCount: number = 0;
-
-      @ObservedState({ redact: true })
-      apiKey: string = 'secret-key-123';
-
-      @ObservedState({ hidden: true })
-      internalCounter: number = 42;
-    }
-
-    // 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 pattern
-    const workflow = new StatefulWorkflowClass(
-      { name: 'StatefulErrorTest' },
-      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
-        await ctx.step('failing-step', async () => {
-          throw new Error('Error after state update');
-        });
-      }
-    );
-
-    // Act: Attach observer and trigger error
-    workflow.addObserver(observer);
-    await expect(workflow.run()).rejects.toThrow('Error after state update');
-
-    // 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('Error after state update');
-
-    // Assert: Verify @ObservedState fields were captured
-    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);
-  });
-
-  it('should detect circular parent relationship', () => {
-    // Arrange: Create parent and child workflows
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Act: Create circular reference manually
-    // This simulates a bug or malicious input that creates a cycle
-    parent.parent = child;
-
-    // Assert: getRoot() should throw error for circular reference
-    // Note: getRoot() is protected, so we cast to any to access it
-    expect(() => (parent as any).getRoot()).toThrow(
-      'Circular parent-child relationship detected'
-    );
-  });
-
-  it('should detect circular relationship in getRootObservers', () => {
-    // Arrange: Create parent and child workflows
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Act: Create circular reference manually
-    // This simulates a bug or malicious input that creates a cycle
-    parent.parent = child;
-
-    // Assert: getRootObservers() should throw error for circular reference
-    // Note: getRootObservers() is private, so we cast to any to access it
-    expect(() => (parent as any).getRootObservers()).toThrow(
-      'Circular parent-child relationship detected'
-    );
-  });
-
-  it('should throw error when duplicate attachment attempted', () => {
-    // Arrange: Create parent and child workflows with first attachment
-    const parent = new SimpleWorkflow('Parent');
-    const child = new SimpleWorkflow('Child', parent);
-
-    // Act & Assert: Second attachment attempt should throw error
-    expect(() => parent.attachChild(child)).toThrow(
-      'Child already attached to this workflow'
-    );
-  });
-
-  it('should emit treeUpdated event when status changes', () => {
-    // Arrange: Create workflow instance
-    const wf = new SimpleWorkflow();
-
-    // Arrange: Create arrays to track event emissions and callback invocations
-    const events: WorkflowEvent[] = [];
-    const treeChangedCalls: WorkflowNode[] = [];
-
-    // Arrange: Create observer with callbacks
-    const observer: WorkflowObserver = {
-      onLog: () => {},  // Empty - not testing logs
-      onEvent: (event) => events.push(event),  // Capture events
-      onStateUpdated: () => {},  // Empty - not testing state updates
-      onTreeChanged: (root) => treeChangedCalls.push(root),  // Capture tree changes
-    };
-
-    // Act: Attach observer and trigger status change
-    wf.addObserver(observer);
-    wf.setStatus('running');
-
-    // Assert: Verify treeUpdated event was emitted
-    const treeUpdatedEvent = events.find((e) => e.type === 'treeUpdated');
-    expect(treeUpdatedEvent).toBeDefined();
-
-    // Assert: Verify event payload contains root node (type narrowing for discriminated union)
-    expect(treeUpdatedEvent?.type === 'treeUpdated' && treeUpdatedEvent.root).toBe(wf.getNode());
-
-    // Assert: Verify onTreeChanged callback was invoked with root node
-    expect(treeChangedCalls).toHaveLength(1);
-    expect(treeChangedCalls[0]).toBe(wf.getNode());
-  });
-});