groundswell 0.0.1 → 0.0.2

package/plan/001_d3bb02af4886/docs/research/P1M3T1S4/bidirectional-tree-consistency-testing.md

@@ -0,0 +1,1574 @@
+# Research: Testing Bidirectional Consistency Between Dual Tree Structures
+
+**Research Date:** 2026-01-12
+**Task:** P1M3T1S4 - Research external best practices for testing bidirectional consistency
+**Focus:** Workflow instance tree (parent/children) vs WorkflowNode tree (node.parent/node.children)
+
+---
+
+## Executive Summary
+
+This research document compiles best practices for testing bidirectional consistency between dual tree representations. While web search resources were limited due to service constraints, this document synthesizes patterns from:
+
+1. **Existing codebase patterns** (workflow-reparenting.test.ts, tree-mirroring.test.ts, prd-compliance.test.ts)
+2. **Established software engineering principles** for tree data structures
+3. **Testing patterns** from well-known open-source projects
+4. **Academic research** on invariant testing
+
+---
+
+## Table of Contents
+
+1. [Core Testing Patterns](#core-testing-patterns)
+2. [Bidirectional Consistency Validation](#bidirectional-consistency-validation)
+3. [Tree Operation Testing](#tree-operation-testing)
+4. [Invariant Testing Patterns](#invariant-testing-patterns)
+5. [Adversarial Testing Approaches](#adversarial-testing-approaches)
+6. [External Best Practices](#external-best-practices)
+7. [Test Pattern Catalog](#test-pattern-catalog)
+8. [Implementation Checklist](#implementation-checklist)
+
+---
+
+## 1. Core Testing Patterns
+
+### 1.1 The AAA Pattern (Arrange-Act-Assert)
+
+**Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/integration/workflow-reparenting.test.ts`
+
+```typescript
+describe('Bidirectional Consistency', () => {
+  it('should maintain consistency after reparenting', () => {
+    // ============================================================
+    // PHASE 1: ARRANGE - Set up test data
+    // ============================================================
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+    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: ACT - Execute the behavior
+    // ============================================================
+    parent1.detachChild(child);
+    parent2.attachChild(child);
+
+    // ============================================================
+    // PHASE 3: ASSERT - Verify the result
+    // ============================================================
+    // Workflow tree state
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toContain(child);
+    expect(parent1.children).not.toContain(child);
+
+    // Node tree state (dual tree mirror)
+    expect(child.node.parent).toBe(parent2.node);
+    expect(parent2.node.children).toContain(child.node);
+    expect(parent1.node.children).not.toContain(child.node);
+  });
+});
+```
+
+**Key Principles:**
+- Clear phase separation with comments
+- Multiple assertions per phase
+- Cross-tree verification (workflow tree + node tree)
+- State verification before and after operations
+
+### 1.2 Test Naming Conventions
+
+**Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/adversarial/prd-compliance.test.ts`
+
+```typescript
+// Good: Descriptive, action-oriented
+describe('PRD: Perfect 1:1 Tree Mirror Requirement', () => {
+  it('should maintain perfect tree structure in logs and events', async () => {
+    // Test implementation
+  });
+});
+
+// Good: Specific operation tested
+describe('Tree Integrity Tests', () => {
+  it('should prevent attaching child with existing parent', () => {
+    // Test implementation
+  });
+
+  it('should allow attaching child with null parent', () => {
+    // Test implementation
+  });
+});
+```
+
+**Naming Template:**
+- `should [expected behavior]` - for positive cases
+- `should prevent [invalid behavior]` - for negative cases
+- `should maintain [invariant] after [operation]` - for consistency tests
+
+---
+
+## 2. Bidirectional Consistency Validation
+
+### 2.1 The 1:1 Tree Mirror Invariant
+
+**Critical Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/integration/workflow-reparenting.test.ts:280-302`
+
+This is the **core invariant** that must always be maintained:
+
+```typescript
+describe('CRITICAL VALIDATION: 1:1 Tree Mirror Invariant', () => {
+  it('should verify perfect synchronization between trees', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // ============================================================
+    // INVARIANT CHECK: For every relationship in workflow tree,
+    // there must be an equivalent relationship in node tree
+    // ============================================================
+
+    // Workflow tree state:
+    // - child.parent points to parent
+    expect(child.parent).toBe(parent);
+
+    // - parent.children contains child
+    expect(parent.children).toEqual([child]);
+
+    // Node tree state (MUST mirror workflow tree exactly):
+    // - child.node.parent points to parent.node
+    expect(child.node.parent).toBe(parent.node);
+
+    // - parent.node.children contains child.node
+    expect(parent.node.children).toEqual([child.node]);
+
+    // ============================================================
+    // CROSS-VERIFICATION: Debugger lookup matches direct access
+    // ============================================================
+    const debugger = new WorkflowTreeDebugger(parent);
+
+    // Debugger should see same structure
+    expect(debugger.getNode(child.id)).toBe(child.node);
+    expect(debugger.getNode(parent.id)).toBe(parent.node);
+  });
+});
+```
+
+### 2.2 Bidirectional Reference Verification Pattern
+
+**Purpose:** Ensure parent→child and child→parent links are mutually consistent
+
+```typescript
+describe('Bidirectional Reference Verification', () => {
+  /**
+   * Core invariant: If A is B's parent, then:
+   * 1. B must be in A's children list
+   * 2. A must be B's parent reference
+   * 3. Both must be true in BOTH trees (workflow + node)
+   */
+  function verifyBidirectionalLink(
+    parent: Workflow,
+    child: Workflow
+  ): void {
+    // Workflow tree checks
+    expect(child.parent).toBe(parent);
+    expect(parent.children).toContain(child);
+
+    // Node tree checks (must mirror workflow tree)
+    expect(child.node.parent).toBe(parent.node);
+    expect(parent.node.children).toContain(child.node);
+
+    // Verify no orphaned references
+    expect(child.node.parent).toBeDefined();
+    expect(parent.node.children).toHaveLengthGreaterThan(0);
+  }
+
+  it('should maintain bidirectional consistency after attach', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child'); // No parent
+
+    parent.attachChild(child);
+
+    verifyBidirectionalLink(parent, child);
+  });
+
+  it('should maintain bidirectional consistency after detach', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    parent.detachChild(child);
+
+    // Verify complete detachment
+    expect(child.parent).toBeNull();
+    expect(parent.children).not.toContain(child);
+
+    expect(child.node.parent).toBeNull();
+    expect(parent.node.children).not.toContain(child.node);
+  });
+});
+```
+
+### 2.3 Tree-Wide Consistency Validation
+
+**Purpose:** Verify consistency across entire tree hierarchy
+
+```typescript
+describe('Tree-Wide Consistency', () => {
+  /**
+   * Validates entire tree structure for bidirectional consistency
+   * Returns array of inconsistencies found
+   */
+  function validateTreeConsistency(root: Workflow): string[] {
+    const inconsistencies: string[] = [];
+    const visited = new Set<Workflow>();
+
+    function traverse(node: Workflow, depth: number = 0): void {
+      if (visited.has(node)) {
+        inconsistencies.push(`Circular reference at ${node.node.name}`);
+        return;
+      }
+      visited.add(node);
+
+      // Check parent→child consistency
+      if (node.parent) {
+        if (!node.parent.children.includes(node)) {
+          inconsistencies.push(
+            `Orphaned child: ${node.node.name} not in parent's children`
+          );
+        }
+      }
+
+      // Check child→parent consistency
+      node.children.forEach(child => {
+        if (child.parent !== node) {
+          inconsistencies.push(
+            `Mismatched parent: ${child.node.name}.parent !== ${node.node.name}`
+          );
+        }
+
+        // Check node tree mirrors workflow tree
+        if (child.node.parent !== node.node) {
+          inconsistencies.push(
+            `Node tree mismatch: ${child.node.name}.node.parent !== ${node.node.name}.node`
+          );
+        }
+
+        if (!node.node.children.includes(child.node)) {
+          inconsistencies.push(
+            `Node tree orphan: ${child.node.name}.node not in parent's node.children`
+          );
+        }
+
+        traverse(child, depth + 1);
+      });
+    }
+
+    traverse(root);
+    return inconsistencies;
+  }
+
+  it('should maintain consistency across entire tree', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    const inconsistencies = validateTreeConsistency(root);
+
+    expect(inconsistencies).toEqual([]);
+    expect(inconsistencies.length).toBe(0);
+  });
+});
+```
+
+---
+
+## 3. Tree Operation Testing
+
+### 3.1 Attach Operation Testing
+
+**Pattern from:** `/home/dustin/projects/groundswell/plan/docs/bugfix-architecture/implementation_patterns.md:274-313`
+
+```typescript
+describe('attachChild() Bidirectional Consistency', () => {
+  describe('Positive Cases', () => {
+    it('should synchronize both trees on successful attach', () => {
+      const parent = new SimpleWorkflow('Parent');
+      const child = new SimpleWorkflow('Child'); // null parent
+
+      parent.attachChild(child);
+
+      // Workflow tree updated
+      expect(child.parent).toBe(parent);
+      expect(parent.children).toContain(child);
+
+      // Node tree updated (must match)
+      expect(child.node.parent).toBe(parent.node);
+      expect(parent.node.children).toContain(child.node);
+
+      // Verify event emission
+      const events = parent.node.events.filter(e => e.type === 'childAttached');
+      expect(events.length).toBeGreaterThan(0);
+    });
+
+    it('should handle idempotent attach to same parent', () => {
+      const parent = new SimpleWorkflow('Parent');
+      const child = new SimpleWorkflow('Child', parent); // Already attached
+
+      // Should not throw (child.parent === this)
+      parent.attachChild(child);
+
+      // Structure should remain valid
+      expect(parent.children).toEqual([child]);
+      expect(parent.node.children).toEqual([child.node]);
+    });
+  });
+
+  describe('Negative Cases', () => {
+    it('should prevent attaching child with different parent', () => {
+      const parent1 = new SimpleWorkflow('Parent1');
+      const parent2 = new SimpleWorkflow('Parent2');
+      const child = new SimpleWorkflow('Child', parent1);
+
+      // Should throw - child already has parent
+      expect(() => parent2.attachChild(child)).toThrow(/already has a parent/);
+
+      // Trees should remain unchanged
+      expect(child.parent).toBe(parent1);
+      expect(parent1.children).toContain(child);
+      expect(parent2.children).not.toContain(child);
+
+      expect(child.node.parent).toBe(parent1.node);
+      expect(parent1.node.children).toContain(child.node);
+      expect(parent2.node.children).not.toContain(child.node);
+    });
+
+    it('should prevent circular references', () => {
+      const root = new SimpleWorkflow('Root');
+      const child = new SimpleWorkflow('Child', root);
+
+      // Try to create cycle
+      expect(() => {
+        child.attachChild(root as any);
+      }).toThrow(/circular|cycle/i);
+
+      // Verify no corruption occurred
+      expect(root.parent).toBeNull();
+      expect(child.parent).toBe(root);
+    });
+
+    it('should prevent duplicate attachment', () => {
+      const parent = new SimpleWorkflow('Parent');
+      const child = new SimpleWorkflow('Child', parent);
+
+      // Already attached - should throw
+      expect(() => parent.attachChild(child)).toThrow(/already attached/);
+
+      // Verify only one reference exists
+      const childCount = parent.children.filter(c => c === child).length;
+      expect(childCount).toBe(1);
+
+      const nodeChildCount = parent.node.children.filter(c => c === child.node).length;
+      expect(nodeChildCount).toBe(1);
+    });
+  });
+});
+```
+
+### 3.2 Detach Operation Testing
+
+```typescript
+describe('detachChild() Bidirectional Consistency', () => {
+  it('should remove from both trees completely', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    parent.detachChild(child);
+
+    // Workflow tree: both directions cleared
+    expect(child.parent).toBeNull();
+    expect(parent.children).not.toContain(child);
+
+    // Node tree: both directions cleared
+    expect(child.node.parent).toBeNull();
+    expect(parent.node.children).not.toContain(child.node);
+
+    // Verify event emission
+    const events = parent.node.events.filter(e => e.type === 'childDetached');
+    expect(events.length).toBeGreaterThan(0);
+  });
+
+  it('should throw when detaching non-existent child', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child');
+
+    expect(() => parent.detachChild(child)).toThrow(/not attached/);
+  });
+
+  it('should handle multiple children correctly', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child1 = new SimpleWorkflow('Child1', parent);
+    const child2 = new SimpleWorkflow('Child2', parent);
+    const child3 = new SimpleWorkflow('Child3', parent);
+
+    // Detach middle child
+    parent.detachChild(child2);
+
+    // Verify correct structure
+    expect(parent.children).toEqual([child1, child3]);
+    expect(parent.node.children).toEqual([child1.node, child3.node]);
+
+    // Verify detached child is orphaned
+    expect(child2.parent).toBeNull();
+    expect(child2.node.parent).toBeNull();
+
+    // Verify other children unaffected
+    expect(child1.parent).toBe(parent);
+    expect(child3.parent).toBe(parent);
+  });
+});
+```
+
+### 3.3 Reparenting Operation Testing
+
+**Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/integration/workflow-reparenting.test.ts:77-127`
+
+```typescript
+describe('Reparenting Bidirectional Consistency', () => {
+  it('should maintain consistency during reparenting workflow', () => {
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // Verify initial state
+    expect(child.parent).toBe(parent1);
+    expect(parent1.children).toContain(child);
+    expect(child.node.parent).toBe(parent1.node);
+    expect(parent1.node.children).toContain(child.node);
+
+    // Execute reparenting
+    parent1.detachChild(child);
+    parent2.attachChild(child);
+
+    // Verify workflow tree updated
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toContain(child);
+    expect(parent1.children).not.toContain(child);
+
+    // Verify node tree updated (MUST match)
+    expect(child.node.parent).toBe(parent2.node);
+    expect(parent2.node.children).toContain(child.node);
+    expect(parent1.node.children).not.toContain(child.node);
+
+    // Verify no dangling references
+    expect(child.node.parent).toBeDefined();
+    expect(parent2.node.children).toContain(child.node);
+    expect(parent1.node.children).not.toContain(child.node);
+  });
+
+  it('should handle multiple reparenting cycles', () => {
+    const parentA = new SimpleWorkflow('ParentA');
+    const parentB = new SimpleWorkflow('ParentB');
+    const parentC = new SimpleWorkflow('ParentC');
+    const child = new SimpleWorkflow('Child', parentA);
+
+    // Cycle 1: A -> B
+    parentA.detachChild(child);
+    parentB.attachChild(child);
+    expect(child.parent).toBe(parentB);
+    expect(child.node.parent).toBe(parentB.node);
+
+    // Cycle 2: B -> C
+    parentB.detachChild(child);
+    parentC.attachChild(child);
+    expect(child.parent).toBe(parentC);
+    expect(child.node.parent).toBe(parentC.node);
+
+    // Cycle 3: C -> A (back to original)
+    parentC.detachChild(child);
+    parentA.attachChild(child);
+    expect(child.parent).toBe(parentA);
+    expect(child.node.parent).toBe(parentA.node);
+  });
+});
+```
+
+---
+
+## 4. Invariant Testing Patterns
+
+### 4.1 Structural Invariants
+
+**Core invariants that must always hold:**
+
+```typescript
+describe('Tree Structural Invariants', () => {
+  /**
+   * Invariant 1: Acyclicity
+   * No cycles exist (every node has exactly one parent except root)
+   */
+  it('should maintain acyclicity invariant', () => {
+    const root = new SimpleWorkflow('Root');
+    const child = new SimpleWorkflow('Child', root);
+
+    // Try to create cycle
+    expect(() => root.attachChild(child as any)).toThrow();
+
+    // Verify: following parent links eventually reaches null
+    let current: Workflow | null = child;
+    const visited = new Set<Workflow>();
+
+    while (current !== null) {
+      expect(visited.has(current)).toBe(false); // No cycles
+      visited.add(current);
+      current = current.parent;
+    }
+  });
+
+  /**
+   * Invariant 2: Single Root
+   * Exactly one root node exists (parent == null)
+   */
+  it('should maintain single root invariant', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+
+    // Count roots (nodes with null parent)
+    const roots = collectAllNodes(root).filter(n => n.parent === null);
+
+    expect(roots.length).toBe(1);
+    expect(roots[0]).toBe(root);
+  });
+
+  /**
+   * Invariant 3: Connectedness
+   * All nodes are reachable from the root
+   */
+  it('should maintain connectedness invariant', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    const allNodes = collectAllNodes(root);
+    const reachableFromRoot = new Set<Workflow>();
+
+    function traverse(node: Workflow): void {
+      reachableFromRoot.add(node);
+      node.children.forEach(traverse);
+    }
+
+    traverse(root);
+
+    // All nodes should be reachable
+    allNodes.forEach(node => {
+      expect(reachableFromRoot.has(node)).toBe(true);
+    });
+  });
+
+  /**
+   * Invariant 4: Parent-Child Consistency
+   * If A is B's parent, then B must be in A's children list
+   */
+  it('should maintain parent-child consistency invariant', () => {
+    const root = new SimpleWorkflow('Root');
+    const child = new SimpleWorkflow('Child', root);
+
+    // Forward direction: parent knows about child
+    expect(root.children).toContain(child);
+
+    // Reverse direction: child knows about parent
+    expect(child.parent).toBe(root);
+
+    // Both must be true (bidirectional)
+    const forward = root.children.includes(child);
+    const reverse = child.parent === root;
+
+    expect(forward && reverse).toBe(true);
+  });
+
+  /**
+   * Invariant 5: Tree Mirror Consistency
+   * Workflow tree perfectly mirrors node tree
+   */
+  it('should maintain tree mirror invariant', () => {
+    const root = new SimpleWorkflow('Root');
+    const child = new SimpleWorkflow('Child', root);
+
+    // For every workflow tree relationship, node tree must match
+    function verifyMirror(workflowNode: Workflow): void {
+      const node = workflowNode.node;
+
+      // Verify parent relationship
+      if (workflowNode.parent) {
+        expect(node.parent).toBe(workflowNode.parent.node);
+      } else {
+        expect(node.parent).toBeNull();
+      }
+
+      // Verify children relationship
+      expect(node.children.length).toBe(workflowNode.children.length);
+
+      workflowNode.children.forEach((childWorkflow, index) => {
+        expect(node.children[index]).toBe(childWorkflow.node);
+        verifyMirror(childWorkflow);
+      });
+    }
+
+    verifyMirror(root);
+  });
+});
+```
+
+### 4.2 Counting Invariants
+
+```typescript
+describe('Counting Invariants', () => {
+  /**
+   * Invariant: Edge Count
+   * Exactly (n-1) edges for n nodes in a tree
+   */
+  it('should maintain correct edge count', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    const allNodes = collectAllNodes(root);
+
+    // Count edges (each child has exactly one parent edge)
+    let edgeCount = 0;
+    allNodes.forEach(node => {
+      if (node.parent !== null) {
+        edgeCount++;
+      }
+    });
+
+    // Tree with n nodes has exactly n-1 edges
+    expect(edgeCount).toBe(allNodes.length - 1);
+  });
+
+  /**
+   * Invariant: Node Count Consistency
+   * Total nodes = sum of all subtree sizes + 1
+   */
+  it('should maintain consistent node counts', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+
+    function countDescendants(node: Workflow): number {
+      let count = 0;
+      node.children.forEach(child => {
+        count += 1 + countDescendants(child);
+      });
+      return count;
+    }
+
+    const totalNodes = collectAllNodes(root).length;
+    const descendantCount = countDescendants(root);
+
+    expect(totalNodes).toBe(descendantCount + 1); // +1 for root itself
+  });
+});
+```
+
+### 4.3 Depth Invariants
+
+```typescript
+describe('Depth Invariants', () => {
+  /**
+   * Invariant: Depth Consistency
+   * Node depth = parent depth + 1
+   */
+  it('should maintain consistent depths', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    function getDepth(node: Workflow): number {
+      let depth = 0;
+      let current: Workflow | null = node;
+
+      while (current !== null) {
+        depth++;
+        current = current.parent;
+      }
+
+      return depth - 1; // Subtract 1 because we counted the node itself
+    }
+
+    expect(getDepth(root)).toBe(0);
+    expect(getDepth(child1)).toBe(1);
+    expect(getDepth(child2)).toBe(1);
+    expect(getDepth(grandchild)).toBe(2);
+
+    // Verify: child depth = parent depth + 1
+    expect(getDepth(child1)).toBe(getDepth(root) + 1);
+    expect(getDepth(grandchild)).toBe(getDepth(child1) + 1);
+  });
+});
+```
+
+---
+
+## 5. Adversarial Testing Approaches
+
+### 5.1 Manual Mutation Tests
+
+**Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/adversarial/edge-case.test.ts:490-505`
+
+```typescript
+describe('Adversarial: Manual Parent Mutation', () => {
+  it('should detect inconsistency from manual parent mutation', () => {
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // Manually mutate parent (bypassing attachChild)
+    // This simulates a bug or malicious action
+    (child as any).parent = parent2;
+
+    // Now trees are inconsistent:
+    // - workflow tree: child.parent === parent2
+    // - parent1.children: still contains child
+    // - parent2.children: does NOT contain child
+
+    // Detect inconsistency
+    const inconsistencies = validateTreeConsistency(parent1);
+
+    expect(inconsistencies.length).toBeGreaterThan(0);
+    expect(inconsistencies.some(i => i.includes('Mismatched parent'))).toBe(true);
+  });
+
+  it('should prevent manual parent mutation via TypeScript', () => {
+    // TypeScript should prevent this at compile time
+    // But if someone uses 'as any', we need runtime checks
+
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // This should throw in attachChild due to validation
+    const parent2 = new SimpleWorkflow('Parent2');
+
+    expect(() => {
+      (child as any).parent = parent2; // Manual mutation
+      parent2.attachChild(child); // Should detect and throw
+    }).toThrow();
+  });
+});
+```
+
+### 5.2 Circular Reference Detection
+
+**Pattern from:** `/home/dustin/projects/groundswell/plan/docs/research/P1M2T1S4/existing_test_pattern.md:10-24`
+
+```typescript
+describe('Adversarial: Circular References', () => {
+  it('should detect simple circular reference', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // Create circular reference manually
+    parent.parent = child;
+
+    // getRoot() should detect and throw
+    expect(() => (parent as any).getRoot()).toThrow(
+      'Circular parent-child relationship detected'
+    );
+  });
+
+  it('should detect complex circular references', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', child1);
+    const child3 = new SimpleWorkflow('Child3', child2);
+
+    // Try to create cycle: child3 -> root
+    expect(() => {
+      child3.attachChild(root as any);
+    }).toThrow(/circular|cycle/i);
+  });
+
+  it('should prevent cycles in node tree', () => {
+    const root = new SimpleWorkflow('Root');
+    const child = new SimpleWorkflow('Child', root);
+
+    // Try to manually mutate node tree
+    expect(() => {
+      root.node.parent = child.node;
+    }).not.toThrow(); // TypeScript allows with 'as any'
+
+    // But validation should detect it
+    const debugger = new WorkflowTreeDebugger(root);
+
+    // Try to traverse - should detect cycle
+    expect(() => {
+      debugger.toTreeString();
+    }).toThrow(); // Or handle gracefully
+  });
+});
+```
+
+### 5.3 Stress Testing
+
+**Pattern from:** `/home/dustin/projects/groundswell/src/__tests__/adversarial/edge-case.test.ts:262-295`
+
+```typescript
+describe('Adversarial: Stress Tests', () => {
+  it('should handle very deep hierarchies', () => {
+    let lastWorkflow: Workflow | null = null;
+
+    // Create 100 levels deep
+    for (let i = 0; i < 100; i++) {
+      const workflow = new SimpleWorkflow(`Level-${i}`);
+      if (lastWorkflow) {
+        lastWorkflow.attachChild(workflow);
+      }
+      lastWorkflow = workflow;
+    }
+
+    // Verify consistency at each level
+    let current = lastWorkflow;
+    let depth = 0;
+
+    while (current && current.parent) {
+      // Verify bidirectional link at each level
+      expect(current.parent.children).toContain(current);
+      expect(current.node.parent).toBe(current.parent.node);
+
+      depth++;
+      current = current.parent;
+    }
+
+    expect(depth).toBe(99);
+  });
+
+  it('should handle wide hierarchies (many siblings)', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const children: Workflow[] = [];
+
+    // Create 100 children
+    for (let i = 0; i < 100; i++) {
+      const child = new SimpleWorkflow(`Child-${i}`, parent);
+      children.push(child);
+    }
+
+    // Verify all children are correctly attached
+    expect(parent.children.length).toBe(100);
+    expect(parent.node.children.length).toBe(100);
+
+    // Verify each child has correct parent
+    children.forEach(child => {
+      expect(child.parent).toBe(parent);
+      expect(child.node.parent).toBe(parent.node);
+      expect(parent.children).toContain(child);
+      expect(parent.node.children).toContain(child.node);
+    });
+  });
+
+  it('should handle rapid attach/detach cycles', () => {
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // Rapid reparenting
+    for (let i = 0; i < 100; i++) {
+      if (i % 2 === 0) {
+        parent1.detachChild(child);
+        parent2.attachChild(child);
+      } else {
+        parent2.detachChild(child);
+        parent1.attachChild(child);
+      }
+
+      // Verify consistency after each cycle
+      const expectedParent = i % 2 === 0 ? parent2 : parent1;
+      expect(child.parent).toBe(expectedParent);
+      expect(child.node.parent).toBe(expectedParent.node);
+    }
+  });
+});
+```
+
+---
+
+## 6. External Best Practices
+
+### 6.1 DOM Tree API Patterns
+
+**Reference:** [DOM Specification - Tree Concepts](https://dom.spec.whatwg.org/#concept-tree-parent)
+
+The DOM specification provides excellent patterns for tree structure validation:
+
+```typescript
+/**
+ * Pattern: DOM-style Tree Validation
+ * Source: https://dom.spec.whatwg.org/#concept-tree-parent
+ *
+ * Key principles:
+ * 1. Every node (except root) has exactly one parent
+ * 2. Parent-child relationships are bidirectional
+ * 3. Tree structure is maintained through mutation operations
+ */
+describe('DOM-style Tree Validation', () => {
+  it('should follow DOM tree mutation principles', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // DOM principle:appendChild() updates both parent and child
+    // Similar to our attachChild()
+    const newChild = new SimpleWorkflow('NewChild');
+    parent.attachChild(newChild);
+
+    // Verify: parent knows about child (DOM: children list)
+    expect(parent.children.includes(newChild)).toBe(true);
+
+    // Verify: child knows about parent (DOM: parentNode property)
+    expect(newChild.parent).toBe(parent);
+
+    // Verify: node tree mirrors (DOM: ownerDocument relationship)
+    expect(newChild.node.parent).toBe(parent.node);
+  });
+
+  it('should follow DOM removal principles', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // DOM principle: removeChild() updates both parent and child
+    parent.detachChild(child);
+
+    // Verify: parent no longer references child
+    expect(parent.children.includes(child)).toBe(false);
+
+    // Verify: child parent is null (DOM: orphaned node)
+    expect(child.parent).toBeNull();
+
+    // Verify: node tree mirrors
+    expect(child.node.parent).toBeNull();
+  });
+});
+```
+
+### 6.2 React Fiber Tree Patterns
+
+**Reference:** [React Fiber Architecture](https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactFiber.js)
+
+React's Fiber tree maintains dual tree representation (current tree and work-in-progress tree):
+
+```typescript
+/**
+ * Pattern: React-style Dual Tree Consistency
+ * Source: React Fiber Architecture
+ *
+ * Key principles:
+ * 1. Dual tree representations must stay in sync
+ * 2. Changes are batched and applied atomically
+ * 3. Consistency is verified after each operation
+ */
+describe('React Fiber-style Dual Tree', () => {
+  it('should maintain dual tree consistency like React Fiber', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // React Fiber: current tree and work-in-progress tree
+    // Our equivalent: workflow tree and node tree
+
+    // Verify both trees represent same structure
+    function verifyFiberConsistency(workflow: Workflow): void {
+      const fiberNode = workflow.node;
+
+      // Check: parent pointers match
+      if (workflow.parent) {
+        expect(fiberNode.parent).toBe(workflow.parent.node);
+      }
+
+      // Check: child arrays match
+      expect(fiberNode.children.length).toBe(workflow.children.length);
+
+      // Check: each child matches
+      workflow.children.forEach((childWf, index) => {
+        expect(fiberNode.children[index]).toBe(childWf.node);
+        verifyFiberConsistency(childWf);
+      });
+    }
+
+    verifyFiberConsistency(parent);
+  });
+
+  it('should apply changes atomically to both trees', () => {
+    const parent1 = new SimpleWorkflow('Parent1');
+    const parent2 = new SimpleWorkflow('Parent2');
+    const child = new SimpleWorkflow('Child', parent1);
+
+    // React: changes are batched and committed atomically
+    // Our: attachChild/detachChild update both trees
+
+    // Execute reparenting
+    parent1.detachChild(child);
+    parent2.attachChild(child);
+
+    // Verify: both trees updated atomically
+    // (No intermediate state where trees are inconsistent)
+
+    // Workflow tree state
+    expect(child.parent).toBe(parent2);
+    expect(parent2.children).toContain(child);
+
+    // Node tree state (must match exactly)
+    expect(child.node.parent).toBe(parent2.node);
+    expect(parent2.node.children).toContain(child.node);
+
+    // Verify no intermediate state leaked
+    expect(parent1.children).not.toContain(child);
+    expect(parent1.node.children).not.toContain(child.node);
+  });
+});
+```
+
+### 6.3 Property-Based Testing Patterns
+
+**Pattern inspired by:** [Hypothesis](https://hypothesis.works/), [QuickCheck](https://www.cs.tufts.edu/~nr/cs257/archive/john-hughes/quick.pdf))
+
+```typescript
+/**
+ * Pattern: Property-Based Testing for Tree Invariants
+ * Source: QuickCheck, Hypothesis
+ *
+ * Key principles:
+ * 1. Define invariants as properties
+ * 2. Generate random tree structures
+ * 3. Verify invariants hold for all inputs
+ */
+describe('Property-Based Tree Invariants', () => {
+  /**
+   * Property: Tree Round-Trip
+   * If you detach then reattach a child, structure should be valid
+   */
+  it('should satisfy round-trip property', () => {
+    // Arrange: Create random tree structure
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    // Act: Detach and reattach
+    const originalParent = child1.parent;
+    const originalChildren = [...root.children];
+
+    root.detachChild(child1);
+    root.attachChild(child1);
+
+    // Assert: Structure should be consistent
+    expect(child1.parent).toBe(originalParent);
+    expect(root.children).toEqual(originalChildren);
+
+    // Verify both trees
+    expect(child1.node.parent).toBe(originalParent.node);
+    expect(root.node.children).toEqual(originalChildren.map(c => c.node));
+  });
+
+  /**
+   * Property: Idempotence
+   * Calling attachChild twice on same parent should be safe
+   */
+  it('should satisfy idempotence property', () => {
+    const parent = new SimpleWorkflow('Parent');
+    const child = new SimpleWorkflow('Child', parent);
+
+    // Already attached - should not throw (child.parent === this)
+    parent.attachChild(child);
+
+    // Verify structure unchanged
+    expect(parent.children).toEqual([child]);
+    expect(parent.node.children).toEqual([child.node]);
+  });
+
+  /**
+   * Property: Commutativity (for siblings)
+   * Attaching children in different orders should yield same structure
+   */
+  it('should satisfy commutativity property for siblings', () => {
+    const parent = new SimpleWorkflow('Parent');
+
+    // Method 1: Attach in order 1, 2, 3
+    const child1 = new SimpleWorkflow('Child1');
+    const child2 = new SimpleWorkflow('Child2');
+    const child3 = new SimpleWorkflow('Child3');
+
+    parent.attachChild(child1);
+    parent.attachChild(child2);
+    parent.attachChild(child3);
+
+    const structure1 = {
+      children: [...parent.children],
+      nodeChildren: [...parent.node.children],
+    };
+
+    // Clean up
+    parent.detachChild(child1);
+    parent.detachChild(child2);
+    parent.detachChild(child3);
+
+    // Method 2: Attach in order 3, 2, 1
+    parent.attachChild(child3);
+    parent.attachChild(child2);
+    parent.attachChild(child1);
+
+    const structure2 = {
+      children: [...parent.children],
+      nodeChildren: [...parent.node.children],
+    };
+
+    // Verify: Same final structure (order may differ)
+    expect(structure1.children.sort()).toEqual(structure2.children.sort());
+    expect(structure1.nodeChildren.sort()).toEqual(structure2.nodeChildren.sort());
+  });
+});
+```
+
+### 6.4 Academic Research Patterns
+
+**Pattern from:** [Testing Data Structures with Invariants](https://www.cs.princeton.edu/courses/archive/fall09/cos226/lectures/22BalancedTrees.pdf)
+
+```typescript
+/**
+ * Pattern: Academic Invariant Testing
+ * Source: Princeton CS226 - Balanced Trees
+ *
+ * Key principles:
+ * 1. Define invariants formally
+ * 2. Create verification routines
+ * 3. Test invariants before/after operations
+ */
+describe('Academic-Style Invariant Testing', () => {
+  /**
+   * Formal Invariant 1: Tree Size Property
+   * For any node: size(node) = 1 + sum(size(children))
+   */
+  function verifySizeProperty(node: Workflow): boolean {
+    const actualSize = collectAllNodes(node).length;
+
+    let computedSize = 1; // Count self
+    node.children.forEach(child => {
+      computedSize += collectAllNodes(child).length;
+    });
+
+    return actualSize === computedSize;
+  }
+
+  /**
+   * Formal Invariant 2: Unique Parent Property
+   * Every non-root node has exactly one parent
+   */
+  function verifyUniqueParent(root: Workflow): boolean {
+    const allNodes = collectAllNodes(root);
+    const nonRootNodes = allNodes.filter(n => n.parent !== null);
+
+    // Each non-root node should have exactly one parent
+    return nonRootNodes.every(node => {
+      // Has parent
+      if (!node.parent) return false;
+
+      // Parent knows about this child
+      if (!node.parent.children.includes(node)) return false;
+
+      // No other node claims this as child
+      const otherClaimants = allNodes.filter(other =>
+        other !== node.parent && other.children.includes(node)
+      );
+
+      return otherClaimants.length === 0;
+    });
+  }
+
+  /**
+   * Formal Invariant 3: Mirror Property
+   * Workflow tree topology == Node tree topology
+   */
+  function verifyMirrorProperty(root: Workflow): boolean {
+    const workflowNodes = collectAllNodes(root);
+
+    return workflowNodes.every(wfNode => {
+      // Parent relationship mirrors
+      const parentMatches = wfNode.parent
+        ? wfNode.node.parent === wfNode.parent.node
+        : wfNode.node.parent === null;
+
+      // Children relationship mirrors
+      const childrenMatch = wfNode.children.length === wfNode.node.children.length &&
+        wfNode.children.every((child, i) => wfNode.node.children[i] === child.node);
+
+      return parentMatches && childrenMatch;
+    });
+  }
+
+  it('should satisfy all formal invariants', () => {
+    const root = new SimpleWorkflow('Root');
+    const child1 = new SimpleWorkflow('Child1', root);
+    const child2 = new SimpleWorkflow('Child2', root);
+    const grandchild = new SimpleWorkflow('Grandchild', child1);
+
+    // Verify all invariants
+    expect(verifySizeProperty(root)).toBe(true);
+    expect(verifyUniqueParent(root)).toBe(true);
+    expect(verifyMirrorProperty(root)).toBe(true);
+
+    // Perform operation
+    root.detachChild(child1);
+
+    // Verify invariants still hold
+    expect(verifySizeProperty(root)).toBe(true);
+    expect(verifyUniqueParent(root)).toBe(true);
+    expect(verifyMirrorProperty(root)).toBe(true);
+  });
+});
+```
+
+---
+
+## 7. Test Pattern Catalog
+
+### 7.1 Helper Functions
+
+**Reusable utilities for tree consistency testing:**
+
+```typescript
+/**
+ * Helper: Collect all nodes in tree via BFS
+ */
+function collectAllNodes(root: Workflow): Workflow[] {
+  const nodes: Workflow[] = [];
+  const queue: Workflow[] = [root];
+  const visited = new Set<Workflow>();
+
+  while (queue.length > 0) {
+    const node = queue.shift()!;
+
+    if (visited.has(node)) {
+      throw new Error(`Circular reference detected at ${node.node.name}`);
+    }
+
+    visited.add(node);
+    nodes.push(node);
+
+    queue.push(...node.children);
+  }
+
+  return nodes;
+}
+
+/**
+ * Helper: Validate tree-wide bidirectional consistency
+ * Returns array of inconsistency descriptions
+ */
+function validateTreeConsistency(root: Workflow): string[] {
+  const errors: string[] = [];
+  const allNodes = collectAllNodes(root);
+
+  allNodes.forEach(node => {
+    // Check parent→child link
+    if (node.parent) {
+      if (!node.parent.children.includes(node)) {
+        errors.push(
+          `Orphaned child: ${node.node.name} not in parent's children list`
+        );
+      }
+    }
+
+    // Check child→parent links
+    node.children.forEach(child => {
+      if (child.parent !== node) {
+        errors.push(
+          `Mismatched parent: ${child.node.name}.parent !== ${node.node.name}`
+        );
+      }
+
+      // Check node tree mirrors workflow tree
+      if (child.node.parent !== node.node) {
+        errors.push(
+          `Node tree mismatch: ${child.node.name}.node.parent !== ${node.node.name}.node`
+        );
+      }
+
+      if (!node.node.children.includes(child.node)) {
+        errors.push(
+          `Node tree orphan: ${child.node.name}.node not in parent's node.children`
+        );
+      }
+    });
+  });
+
+  return errors;
+}
+
+/**
+ * Helper: Verify bidirectional link between parent and child
+ */
+function verifyBidirectionalLink(parent: Workflow, child: Workflow): void {
+  // Workflow tree
+  expect(child.parent).toBe(parent);
+  expect(parent.children).toContain(child);
+
+  // Node tree
+  expect(child.node.parent).toBe(parent.node);
+  expect(parent.node.children).toContain(child.node);
+}
+
+/**
+ * Helper: Verify complete orphaning after detach
+ */
+function verifyOrphaned(child: Workflow): void {
+  expect(child.parent).toBeNull();
+  expect(child.node.parent).toBeNull();
+}
+
+/**
+ * Helper: Get depth of node in tree
+ */
+function getDepth(node: Workflow): number {
+  let depth = 0;
+  let current: Workflow | null = node;
+
+  while (current !== null) {
+    depth++;
+    current = current.parent;
+  }
+
+  return depth - 1; // Subtract 1 for the node itself
+}
+
+/**
+ * Helper: Verify no circular references exist
+ */
+function verifyNoCycles(root: Workflow): void {
+  const visited = new Set<Workflow>();
+  const allNodes = collectAllNodes(root);
+
+  allNodes.forEach(node => {
+    expect(visited.has(node)).toBe(false);
+    visited.add(node);
+  });
+}
+
+/**
+ * Helper: Verify tree mirror invariant
+ */
+function verifyTreeMirror(workflowRoot: Workflow): void {
+  const allNodes = collectAllNodes(workflowRoot);
+
+  allNodes.forEach(wfNode => {
+    const node = wfNode.node;
+
+    // Verify parent relationship
+    if (wfNode.parent) {
+      expect(node.parent).toBe(wfNode.parent.node);
+    } else {
+      expect(node.parent).toBeNull();
+    }
+
+    // Verify children relationship
+    expect(node.children.length).toBe(wfNode.children.length);
+
+    wfNode.children.forEach((childWf, index) => {
+      expect(node.children[index]).toBe(childWf.node);
+    });
+  });
+}
+```
+
+### 7.2 Test Templates
+
+**Reusable test templates for common scenarios:**
+
+```typescript
+/**
+ * Template: Test bidirectional consistency for tree operation
+ */
+function testOperationConsistency(
+  operation: () => void,
+  beforeState: { roots: number, totalNodes: number },
+  afterState: { roots: number, totalNodes: number }
+): void {
+  // Get initial state
+  const beforeErrors = validateTreeConsistency(/* root */);
+  expect(beforeErrors).toEqual([]);
+
+  // Execute operation
+  operation();
+
+  // Verify final state
+  const afterErrors = validateTreeConsistency(/* root */);
+  expect(afterErrors).toEqual([]);
+}
+
+/**
+ * Template: Test reparenting scenario
+ */
+function testReparentingScenario(
+  setup: () => { oldParent: Workflow, newParent: Workflow, child: Workflow }
+): void {
+  const { oldParent, newParent, child } = setup();
+
+  // Verify initial state
+  verifyBidirectionalLink(oldParent, child);
+
+  // Execute reparenting
+  oldParent.detachChild(child);
+  newParent.attachChild(child);
+
+  // Verify new state
+  verifyBidirectionalLink(newParent, child);
+
+  // Verify old parent no longer has child
+  expect(oldParent.children).not.toContain(child);
+  expect(oldParent.node.children).not.toContain(child.node);
+}
+```
+
+---
+
+## 8. Implementation Checklist
+
+### 8.1 Core Tests to Implement
+
+- [ ] **Bidirectional Link Tests**
+  - [ ] Verify parent→child and child→parent links after attach
+  - [ ] Verify both trees (workflow + node) are synchronized
+  - [ ] Verify link consistency after detach
+  - [ ] Verify link consistency after reparenting
+
+- [ ] **Tree Mirror Tests**
+  - [ ] Verify 1:1 mirror between workflow tree and node tree
+  - [ ] Verify mirror invariant after every operation
+  - [ ] Verify no orphaned nodes in either tree
+  - [ ] Verify no ghost references in either tree
+
+- [ ] **Operation Tests**
+  - [ ] Test attachChild() with valid inputs
+  - [ ] Test attachChild() error cases (existing parent, circular ref, duplicate)
+  - [ ] Test detachChild() with valid inputs
+  - [ ] Test detachChild() error cases (not attached)
+  - [ ] Test reparenting workflow (detach + attach)
+
+- [ ] **Invariant Tests**
+  - [ ] Test acyclicity invariant (no cycles)
+  - [ ] Test single root invariant
+  - [ ] Test connectedness invariant (all nodes reachable)
+  - [ ] Test parent-child consistency invariant
+  - [ ] Test edge count invariant (n-1 edges for n nodes)
+
+- [ ] **Adversarial Tests**
+  - [ ] Test manual parent mutation detection
+  - [ ] Test circular reference detection (simple and complex)
+  - [ ] Test stress scenarios (deep hierarchies, wide hierarchies)
+  - [ ] Test rapid attach/detach cycles
+  - [ ] Test concurrent operations
+
+### 8.2 Test File Organization
+
+```
+src/__tests__/
+├── unit/
+│   └── workflow.test.ts                    # Existing unit tests
+├── integration/
+│   ├── workflow-reparenting.test.ts        # Existing reparenting tests
+│   └── bidirectional-consistency.test.ts   # NEW: Dual tree consistency
+└── adversarial/
+    ├── prd-compliance.test.ts              # Existing PRD compliance
+    ├── edge-case.test.ts                   # Existing edge cases
+    └── tree-invariants.test.ts             # NEW: Invariant testing
+```
+
+### 8.3 Priority Order
+
+**Phase 1: Core Consistency (High Priority)**
+1. Bidirectional link verification tests
+2. Tree mirror invariant tests
+3. Operation-level consistency tests
+
+**Phase 2: Comprehensive Coverage (Medium Priority)**
+4. Tree-wide consistency validation
+5. Invariant testing (acyclicity, connectedness, etc.)
+6. Reparenting scenario tests
+
+**Phase 3: Robustness (Lower Priority)**
+7. Adversarial testing (manual mutations, circular refs)
+8. Stress testing (deep/wide hierarchies)
+9. Property-based testing
+
+---
+
+## 9. Key Takeaways
+
+### 9.1 Critical Invariants
+
+1. **1:1 Tree Mirror**: Workflow tree and node tree must always be perfectly synchronized
+2. **Bidirectional Links**: Parent→child and child→parent references must always match
+3. **Acyclicity**: No circular references in tree structure
+4. **Single Root**: Exactly one root node (parent === null)
+
+### 9.2 Testing Principles
+
+1. **Test Both Trees**: Always verify both workflow tree and node tree
+2. **Test Both Directions**: Verify parent→child AND child→parent
+3. **Test After Every Operation**: Run consistency checks after attach, detach, reparenting
+4. **Use Helpers**: Create reusable helper functions for common validations
+5. **Adversarial Testing**: Test manual mutations and edge cases
+
+### 9.3 Best Practices
+
+1. **AAA Pattern**: Arrange-Act-Assert structure with clear phase comments
+2. **Descriptive Names**: Use `should [expected behavior]` naming convention
+3. **Multiple Assertions**: Verify multiple aspects of consistency
+4. **Cross-Verification**: Use WorkflowTreeDebugger to verify structure
+5. **Property-Based Testing**: Define invariants as properties and verify them
+
+---
+
+## 10. References and Resources
+
+### 10.1 External Documentation
+
+- **DOM Tree Specification**: https://dom.spec.whatwg.org/#concept-tree-parent
+  - Authoritative source on tree mutation semantics
+  - Parent-child relationship management patterns
+
+- **React Fiber Architecture**: https://github.com/facebook/react/blob/main/packages/react-reconciler/src/ReactFiber.js
+  - Dual tree representation patterns
+  - Atomic update strategies
+
+- **QuickCheck Paper**: https://www.cs.tufts.edu/~nr/cs257/archive/john-hughes/quick.pdf
+  - Property-based testing methodology
+  - Invariant definition patterns
+
+- **Princeton CS226 - Balanced Trees**: https://www.cs.princeton.edu/courses/archive/fall09/cos226/lectures/22BalancedTrees.pdf
+  - Formal invariant definition
+  - Tree property verification
+
+### 10.2 Internal Resources
+
+- **Implementation Patterns**: `/home/dustin/projects/groundswell/plan/docs/bugfix-architecture/implementation_patterns.md`
+- **Existing Test Patterns**: `/home/dustin/projects/groundswell/plan/docs/research/P1M2T1S4/existing_test_pattern.md`
+- **Tree Mirroring Tests**: `/home/dustin/projects/groundswell/src/__tests__/integration/tree-mirroring.test.ts`
+- **Reparenting Tests**: `/home/dustin/projects/groundswell/src/__tests__/integration/workflow-reparenting.test.ts`
+- **PRD Compliance Tests**: `/home/dustin/projects/groundswell/src/__tests__/adversarial/prd-compliance.test.ts`
+- **Tree Debugger**: `/home/dustin/projects/groundswell/src/debugger/tree-debugger.ts`
+
+### 10.3 Actionable Patterns
+
+**For immediate application:**
+1. Use `verifyBidirectionalLink()` helper after every tree operation
+2. Run `validateTreeConsistency()` in test teardown
+3. Test both workflow tree AND node tree in all assertions
+4. Add adversarial tests for manual mutations
+5. Implement property-based tests for core invariants
+
+---
+
+**Document Status:** Complete
+**Next Steps:** Implement test suite based on patterns documented here
+**Maintainer:** P1M3T1S4 Research Team