elsabro 6.0.0 → 7.0.0

package/flow-engine/tests/integration.test.js

@@ -2,7 +2,7 @@
 
 const { describe, it } = require('node:test');
 const assert = require('node:assert/strict');
-const { FlowEngine, NotImplementedError } = require('../src/index');
+const { FlowEngine, NotImplementedError, DeprecatedNodeError } = require('../src/index');
 const { resolveTemplate } = require('../src/template');
 
 // Load the REAL flow
@@ -69,30 +69,31 @@ describe('Integration: Graph loading', () => {
     engine.loadFlow(flow);
     const meta = engine.getFlowMetadata();
     assert.equal(meta.sync_metadata.audit_result.total_nodes, 42);
-    assert.equal(meta.sync_metadata.audit_result.implemented, 19);
-    assert.equal(meta.sync_metadata.audit_result.partial, 3);
-    assert.equal(meta.sync_metadata.audit_result.not_implemented, 20);
+    assert.equal(meta.sync_metadata.audit_result.implemented, 40);
+    assert.equal(meta.sync_metadata.audit_result.partial, 0);
+    assert.equal(meta.sync_metadata.audit_result.not_implemented, 0);
+    assert.equal(meta.sync_metadata.audit_result.deprecated, 2);
   });
 
   it('counts implemented nodes correctly', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const implemented = engine.getNodesWhere(n => n.runtime_status === 'implemented');
-    assert.equal(implemented.length, 19);
+    assert.equal(implemented.length, 40);
   });
 
   it('counts not_implemented nodes correctly', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const notImpl = engine.getNodesWhere(n => n.runtime_status === 'not_implemented');
-    assert.equal(notImpl.length, 20);
+    assert.equal(notImpl.length, 0);
   });
 
   it('counts partial nodes correctly', () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const partial = engine.getNodesWhere(n => n.runtime_status === 'partial');
-    assert.equal(partial.length, 3);
+    assert.equal(partial.length, 0);
   });
 
   it('validates graph has no orphaned references', () => {
@@ -147,73 +148,284 @@ describe('Integration: Template resolution with real flow data', () => {
   });
 });
 
-describe('Integration: Default profile path (stops at interview_default)', () => {
-  it('traverses start → skill_discovery → load_context → profile_router → interview_default (NOT_IMPLEMENTED)', async () => {
+describe('Integration: Default profile path (traverses past interview_default)', () => {
+  it('traverses interview_default and continues to standard_analyze', async () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
-    const { log } = makeMockCallbacks();
     const callbacks = makeMockCallbacks();
 
-    await assert.rejects(
-      engine.run(
+    // Default path goes deep: interview_default → standard_analyze → merge_analysis → ...
+    // Eventually hits not_implemented nodes downstream or completes
+    // We just verify the interview node is traversed successfully
+    try {
+      await engine.run(
         { task: 'test integration', profile: 'default', complexity: 'medium' },
         callbacks
-      ),
-      (err) => {
-        assert.equal(err.name, 'NotImplementedError');
-        assert.ok(err.message.includes('interview_default'));
-        assert.ok(err.message.includes('not yet implemented'));
-        return true;
-      }
-    );
+      );
+    } catch (err) {
+      // May stop at a downstream not_implemented node — that's OK
+      assert.ok(!err.message.includes('interview_default'), 'Should NOT stop at interview_default');
+    }
 
-    // Verify the traversal path via callbacks log
     const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
-    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'interview_default']);
+    assert.ok(nodeStarts.includes('interview_default'), 'interview_default was visited');
+    assert.ok(nodeStarts.includes('standard_analyze'), 'standard_analyze was reached after interview');
+  });
+
+  it('interview_default calls onAgent with correct inputs', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    try {
+      await engine.run({ task: 'add auth', profile: 'default', complexity: 'medium' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    const agentCalls = callbacks.log.filter(e => e.type === 'agent' && e.id === 'interview_default');
+    assert.equal(agentCalls.length, 1, 'onAgent called once for interview_default');
+    assert.equal(agentCalls[0].agent, 'elsabro-analyst');
   });
 });
 
-describe('Integration: Yolo profile path (stops at interview_yolo)', () => {
-  it('routes to yolo interview via profile_router', async () => {
+describe('Integration: Yolo profile path (traverses past P2 nodes)', () => {
+  it('traverses yolo_execute and quick_verify after interview_yolo', async () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const callbacks = makeMockCallbacks();
 
-    await assert.rejects(
-      engine.run(
+    try {
+      await engine.run(
         { task: 'quick fix', profile: 'yolo', complexity: 'low' },
         callbacks
-      ),
-      (err) => {
-        assert.ok(err.message.includes('interview_yolo'));
-        return true;
-      }
-    );
+      );
+    } catch (err) {
+      // May hit max traversals in review loop or end successfully — OK
+      assert.ok(!err.message.includes('yolo_execute'), 'Should NOT stop at yolo_execute');
+      assert.ok(!err.message.includes('quick_verify'), 'Should NOT stop at quick_verify');
+    }
 
     const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
-    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'interview_yolo']);
+    assert.ok(nodeStarts.includes('interview_yolo'), 'interview_yolo was visited');
+    assert.ok(nodeStarts.includes('yolo_execute'), 'yolo_execute was visited');
+    assert.ok(nodeStarts.includes('quick_verify'), 'quick_verify was visited');
+    assert.ok(nodeStarts.includes('verify_check'), 'verify_check was reached after quick_verify');
+  });
+
+  it('yolo_execute calls onAgent with elsabro-yolo-dev', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    try {
+      await engine.run({ task: 'quick fix', profile: 'yolo', complexity: 'low' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    const agentCalls = callbacks.log.filter(e => e.type === 'agent' && e.id === 'yolo_execute');
+    assert.equal(agentCalls.length, 1, 'onAgent called once for yolo_execute');
+    assert.equal(agentCalls[0].agent, 'elsabro-yolo-dev');
+  });
+
+  it('quick_verify calls onAgent with elsabro-verifier', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    try {
+      await engine.run({ task: 'quick fix', profile: 'yolo', complexity: 'low' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    const agentCalls = callbacks.log.filter(e => e.type === 'agent' && e.id === 'quick_verify');
+    assert.equal(agentCalls.length, 1, 'onAgent called once for quick_verify');
+    assert.equal(agentCalls[0].agent, 'elsabro-verifier');
+  });
+
+  it('interview_yolo uses haiku model config', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interview_yolo');
+    assert.equal(node.config.model, 'haiku');
+  });
+});
+
+describe('Integration: BMAD profile path (traverses past bmad_interview_analysis)', () => {
+  it('traverses bmad_analyze sequence with both agent steps (Bug A fix)', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_analyze');
+    assert.equal(node.type, 'sequence');
+    assert.equal(node.runtime_status, 'implemented');
+    assert.equal(node.steps.length, 2);
+    assert.equal(node.steps[0].action, 'agent', 'prd step has action: agent');
+    assert.equal(node.steps[1].action, 'agent', 'architecture step has action: agent');
+    assert.equal(node.steps[0].as, 'prd');
+    assert.equal(node.steps[1].as, 'architecture');
+  });
+
+  it('bmad_interview_analysis uses analysis phase', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_interview_analysis');
+    assert.equal(node.inputs.phase, 'analysis');
+    assert.ok(node.inputs.topics.includes('usuarios objetivo'));
+  });
+});
+
+describe('Integration: Careful profile path (traverses past P2 nodes)', () => {
+  it('traverses careful_analyze and interrupt_plan_approval after interview_careful', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    try {
+      await engine.run(
+        { task: 'secure refactor', profile: 'careful', complexity: 'high' },
+        callbacks
+      );
+    } catch (err) {
+      // May stop downstream — OK
+      assert.ok(!err.message.includes('careful_analyze'), 'Should NOT stop at careful_analyze');
+      assert.ok(!err.message.includes('interrupt_plan_approval'), 'Should NOT stop at interrupt_plan_approval');
+    }
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.ok(nodeStarts.includes('interview_careful'), 'interview_careful was visited');
+    assert.ok(nodeStarts.includes('careful_analyze'), 'careful_analyze was visited');
+    assert.ok(nodeStarts.includes('interrupt_plan_approval'), 'interrupt_plan_approval was visited');
+    assert.ok(nodeStarts.includes('parallel_implementation'), 'parallel_implementation reached after approval');
+  });
+
+  it('careful_analyze steps call onAgent for each step', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const stepAgentCalls = [];
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onAgent: async (config) => {
+        stepAgentCalls.push({ agent: config.agent, as: config.as, id: config.id });
+        return { analysis: 'mock analysis result' };
+      }
+    };
+
+    try {
+      await engine.run({ task: 'secure refactor', profile: 'careful', complexity: 'high' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    // Sequence executor calls onAgent with { agent, model, inputs, as } (no id field)
+    const sequenceSteps = stepAgentCalls.filter(c => c.as && !c.id);
+    const stepNames = sequenceSteps.map(c => c.as);
+    assert.ok(stepNames.includes('requirements'), 'requirements step was executed');
+    assert.ok(stepNames.includes('risks'), 'risks step was executed');
+    assert.ok(stepNames.includes('detailed_plan'), 'detailed_plan step was executed');
+  });
+
+  it('interview_careful uses careful topics', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interview_careful');
+    assert.ok(node.inputs.topics.includes('requisitos funcionales'));
+    assert.ok(node.inputs.topics.includes('acceptance criteria'));
   });
 });
 
-describe('Integration: BMAD profile path (stops at bmad_interview_analysis)', () => {
-  it('routes to BMAD interview via profile_router', async () => {
+describe('Integration: Teams profile path (traverses past interview_teams)', () => {
+  it('traverses interview_teams then stops at teams_spawn (deprecated)', async () => {
     const engine = new FlowEngine();
     engine.loadFlow(flow);
     const callbacks = makeMockCallbacks();
 
     await assert.rejects(
       engine.run(
-        { task: 'build app', profile: 'bmad', complexity: 'high' },
+        { task: 'build dashboard', profile: 'teams', complexity: 'high' },
         callbacks
       ),
       (err) => {
-        assert.ok(err.message.includes('bmad_interview_analysis'));
+        assert.equal(err.name, 'DeprecatedNodeError', 'Should throw DeprecatedNodeError');
+        assert.ok(err.message.includes('teams_spawn'), 'Should stop at teams_spawn');
+        assert.ok(err.message.includes('deprecated'), 'Should mention deprecated');
         return true;
       }
     );
 
     const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
-    assert.deepEqual(nodeStarts, ['start', 'skill_discovery', 'load_context', 'profile_router', 'bmad_interview_analysis']);
+    assert.ok(nodeStarts.includes('interview_teams'), 'interview_teams was visited');
+    assert.ok(nodeStarts.includes('teams_spawn'), 'teams_spawn was reached after interview');
+  });
+
+  it('interview_teams uses teams topics', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interview_teams');
+    assert.ok(node.inputs.topics.includes('prioridades del equipo'));
+    assert.ok(node.inputs.topics.includes('integraciones'));
+  });
+});
+
+describe('Integration: Interview agent output storage', () => {
+  it('interview node output is stored at context.nodes[id].outputs.output', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const mockInterviewResult = { summary: 'User wants auth with JWT', decisions: ['use bcrypt'] };
+    let capturedContext = null;
+
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onAgent: async (config) => {
+        if (config.id === 'interview_yolo') {
+          return mockInterviewResult;
+        }
+        return { result: 'other agent' };
+      },
+      onCheckpoint: async (data) => {
+        // Capture context after interview_yolo completes
+        if (data.currentNode === 'interview_yolo') {
+          capturedContext = JSON.parse(JSON.stringify(data.context));
+        }
+      }
+    };
+
+    try {
+      await engine.run({ task: 'test output', profile: 'yolo', complexity: 'low' }, callbacks);
+    } catch { /* may stop at downstream not_implemented node */ }
+
+    assert.ok(capturedContext, 'Checkpoint captured after interview_yolo');
+    assert.deepEqual(
+      capturedContext.nodes.interview_yolo.outputs.output,
+      mockInterviewResult,
+      'Interview result stored at outputs.output'
+    );
+  });
+
+  it('all 5 interview nodes are marked as implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const interviewNodes = ['interview_default', 'interview_yolo', 'interview_careful', 'interview_teams', 'bmad_interview_analysis'];
+    for (const id of interviewNodes) {
+      const node = engine.getNode(id);
+      assert.equal(node.runtime_status, 'implemented', `${id} should be implemented`);
+      assert.equal(node.implemented_in, 'agents/elsabro-analyst.md#[INTERVIEW]', `${id} should reference analyst [INTERVIEW]`);
+      assert.deepEqual(node.gaps, [], `${id} should have no gaps`);
+    }
+  });
+
+  it('all 5 interview nodes use elsabro-analyst agent', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const interviewNodes = ['interview_default', 'interview_yolo', 'interview_careful', 'interview_teams', 'bmad_interview_analysis'];
+    for (const id of interviewNodes) {
+      const node = engine.getNode(id);
+      assert.equal(node.agent, 'elsabro-analyst', `${id} agent should be elsabro-analyst`);
+      assert.equal(node.inputs.command, '[INTERVIEW]', `${id} command should be [INTERVIEW]`);
+    }
+  });
+
+  it('interview nodes do not have custom outputs (use executor default)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const interviewNodes = ['interview_default', 'interview_yolo', 'interview_careful', 'interview_teams', 'bmad_interview_analysis'];
+    for (const id of interviewNodes) {
+      const node = engine.getNode(id);
+      assert.equal(node.outputs, undefined, `${id} should not have custom outputs field`);
+    }
   });
 });
 
@@ -249,3 +461,420 @@ describe('Integration: Node type coverage', () => {
     assert.equal(types.size, 9);
   });
 });
+
+describe('Integration: careful_analyze output mapping (Bug 2 fix)', () => {
+  it('careful_analyze step outputs are accessible at node outputs via outputs field', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    let capturedContext = null;
+
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onAgent: async (config) => {
+        if (config.as === 'requirements') return { detail: 'requirements analysis' };
+        if (config.as === 'risks') return { detail: 'risk analysis' };
+        if (config.as === 'detailed_plan') return { detail: 'implementation plan' };
+        return { result: 'other agent' };
+      },
+      onCheckpoint: async (data) => {
+        if (data.currentNode === 'careful_analyze') {
+          capturedContext = JSON.parse(JSON.stringify(data.context));
+        }
+      }
+    };
+
+    try {
+      await engine.run({ task: 'test outputs', profile: 'careful', complexity: 'high' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    assert.ok(capturedContext, 'Checkpoint captured after careful_analyze');
+    assert.ok(capturedContext.nodes.careful_analyze.outputs.requirements, 'requirements output exists');
+    assert.ok(capturedContext.nodes.careful_analyze.outputs.risks, 'risks output exists');
+    assert.ok(capturedContext.nodes.careful_analyze.outputs.detailed_plan, 'detailed_plan output exists');
+  });
+});
+
+describe('Integration: interrupt_plan_approval routing', () => {
+  it('routes to parallel_implementation on approve', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onInterrupt: async (display) => {
+        if (display.nodeId === 'interrupt_plan_approval') return 'approve';
+        const options = display.display.options || [];
+        return options.length > 0 ? options[0].id : 'approve';
+      }
+    };
+
+    try {
+      await engine.run({ task: 'test approval', profile: 'careful', complexity: 'high' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.ok(nodeStarts.includes('parallel_implementation'), 'approve routes to parallel_implementation');
+  });
+
+  it('routes to careful_analyze on modify (loop)', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    let interruptCount = 0;
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onInterrupt: async (display) => {
+        if (display.nodeId === 'interrupt_plan_approval') {
+          interruptCount++;
+          return interruptCount === 1 ? 'modify' : 'approve';
+        }
+        const options = display.display.options || [];
+        return options.length > 0 ? options[0].id : 'approve';
+      }
+    };
+
+    try {
+      await engine.run({ task: 'test modify loop', profile: 'careful', complexity: 'high' }, callbacks);
+    } catch { /* may stop downstream */ }
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    const carefulCount = nodeStarts.filter(id => id === 'careful_analyze').length;
+    assert.ok(carefulCount >= 2, `careful_analyze visited ${carefulCount} times (expected >= 2)`);
+  });
+
+  it('routes to end_cancelled on reject', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = {
+      ...makeMockCallbacks(),
+      onInterrupt: async (display) => {
+        if (display.nodeId === 'interrupt_plan_approval') return 'reject';
+        const options = display.display.options || [];
+        return options.length > 0 ? options[0].id : 'approve';
+      }
+    };
+
+    const result = await engine.run(
+      { task: 'test reject', profile: 'careful', complexity: 'high' },
+      callbacks
+    );
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+    assert.ok(nodeStarts.includes('end_cancelled'), 'reject routes to end_cancelled');
+  });
+});
+
+describe('Integration: Partial nodes upgraded to implemented (P2)', () => {
+  it('profile_router is now implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('profile_router');
+    assert.equal(node.runtime_status, 'implemented');
+    assert.deepEqual(node.gaps, []);
+  });
+
+  it('interrupt_manual_fix is now implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interrupt_manual_fix');
+    assert.equal(node.runtime_status, 'implemented');
+    assert.deepEqual(node.gaps, []);
+  });
+
+  it('wait_manual_fix is now implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('wait_manual_fix');
+    assert.equal(node.runtime_status, 'implemented');
+    assert.deepEqual(node.gaps, []);
+  });
+
+  it('no partial nodes remain in the flow', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const partial = engine.getNodesWhere(n => n.runtime_status === 'partial');
+    assert.equal(partial.length, 0, 'All partial nodes should be upgraded');
+  });
+});
+
+describe('Integration: P2 node metadata', () => {
+  it('all 4 new implemented nodes have correct metadata', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const p2Nodes = ['yolo_execute', 'quick_verify', 'careful_analyze', 'interrupt_plan_approval'];
+    for (const id of p2Nodes) {
+      const node = engine.getNode(id);
+      assert.equal(node.runtime_status, 'implemented', `${id} should be implemented`);
+      assert.ok(node.implemented_in, `${id} should have implemented_in`);
+      assert.deepEqual(node.gaps, [], `${id} should have no gaps`);
+    }
+  });
+
+  it('careful_analyze steps all have action: agent (Bug 1 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('careful_analyze');
+    for (const step of node.steps) {
+      assert.equal(step.action, 'agent', `Step "${step.as}" should have action: "agent"`);
+    }
+  });
+
+  it('careful_analyze has outputs mapping (Bug 2 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('careful_analyze');
+    assert.ok(node.outputs, 'careful_analyze should have outputs field');
+    assert.ok(node.outputs.requirements, 'should have requirements output mapping');
+    assert.ok(node.outputs.risks, 'should have risks output mapping');
+    assert.ok(node.outputs.detailed_plan, 'should have detailed_plan output mapping');
+  });
+
+  it('verify_check condition uses .output.passed path (Bug 3 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('verify_check');
+    assert.ok(node.condition.includes('.output.passed'), 'condition should use .output.passed path');
+    assert.ok(!node.condition.match(/outputs\.passed[^.]/), 'condition should NOT use .outputs.passed (without .output)');
+  });
+});
+
+// ==========================================================
+// P4: BMAD Full Path Integration Tests
+// ==========================================================
+
+describe('Integration: BMAD Full Path (P4 — 8 nodes implemented)', () => {
+  it('all 8 BMAD nodes are marked implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const bmadNodes = [
+      'bmad_analyze', 'interrupt_prd_approval', 'bmad_interview_planning',
+      'bmad_plan', 'interrupt_manifest', 'bmad_interview_solution',
+      'bmad_solution', 'interrupt_solution_approval'
+    ];
+    for (const id of bmadNodes) {
+      const node = engine.getNode(id);
+      assert.equal(node.runtime_status, 'implemented', `${id} should be implemented`);
+      assert.deepStrictEqual(node.gaps, [], `${id} should have no gaps`);
+    }
+  });
+
+  it('bmad_interview_planning has no custom outputs field (Bug B fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_interview_planning');
+    assert.equal(node.outputs, undefined, 'should NOT have custom outputs field');
+    assert.equal(node.type, 'agent');
+  });
+
+  it('bmad_interview_solution has no custom outputs field (Bug D fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_interview_solution');
+    assert.equal(node.outputs, undefined, 'should NOT have custom outputs field');
+    assert.equal(node.type, 'agent');
+  });
+
+  it('bmad_solution has no custom outputs field (Bug E fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_solution');
+    assert.equal(node.outputs, undefined, 'should NOT have custom outputs field');
+    assert.equal(node.type, 'agent');
+  });
+
+  it('bmad_plan step has action: agent (Bug C fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_plan');
+    assert.equal(node.steps[0].action, 'agent', 'stories step should have action: agent');
+    assert.equal(node.steps[0].as, 'stories');
+  });
+
+  it('bmad_plan references .outputs.output for interview context (F1 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_plan');
+    const interviewRef = node.steps[0].inputs.interview_context;
+    assert.ok(interviewRef.includes('.outputs.output'), 'should reference .outputs.output');
+    assert.ok(!interviewRef.includes('.outputs.interview_summary'), 'should NOT reference .outputs.interview_summary');
+  });
+
+  it('bmad_solution references .outputs.output for interview context (F2 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('bmad_solution');
+    const interviewRef = node.inputs.interview_context;
+    assert.ok(interviewRef.includes('.outputs.output'), 'should reference .outputs.output');
+    assert.ok(!interviewRef.includes('.outputs.interview_summary'), 'should NOT reference .outputs.interview_summary');
+  });
+
+  it('parallel_implementation references .outputs.output for bmad_solution (F3/F4 fix)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('parallel_implementation');
+    const branchInputs = JSON.stringify(node.branches);
+    assert.ok(branchInputs.includes('bmad_solution.outputs.output'), 'should reference .outputs.output');
+    assert.ok(!branchInputs.includes('bmad_solution.outputs.solution'), 'should NOT reference .outputs.solution');
+  });
+
+  it('interrupt_prd_approval routes correctly: approve/modify/reject', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interrupt_prd_approval');
+    assert.equal(node.routes.approve, 'bmad_interview_planning');
+    assert.equal(node.routes.modify, 'bmad_analyze');
+    assert.equal(node.routes.reject, 'end_cancelled');
+  });
+
+  it('interrupt_solution_approval routes correctly: approve/modify/reject', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interrupt_solution_approval');
+    assert.equal(node.routes.approve, 'parallel_implementation');
+    assert.equal(node.routes.modify, 'bmad_solution');
+    assert.equal(node.routes.reject, 'end_cancelled');
+  });
+
+  it('BMAD path traverses all 8 nodes and reaches shared pipeline', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    // BMAD flow will loop in review cycle (mock callbacks don't satisfy conditions)
+    // or succeed through post_mortem → end_success. We verify BMAD nodes were visited.
+    try {
+      await engine.run(
+        { task: 'build saas app', profile: 'bmad', complexity: 'high' },
+        callbacks
+      );
+    } catch (err) {
+      // Expected: max traversals in review loop (mock callbacks cause infinite loop)
+      assert.ok(
+        err.message.includes('maximum node traversals'),
+        `Expected max traversals, got: ${err.message}`
+      );
+    }
+
+    const nodeStarts = callbacks.log.filter(e => e.type === 'node_start').map(e => e.id);
+
+    // Verify all 8 BMAD nodes were traversed
+    const bmadNodes = [
+      'bmad_interview_analysis', 'bmad_analyze', 'interrupt_prd_approval',
+      'bmad_interview_planning', 'bmad_plan', 'interrupt_manifest',
+      'bmad_interview_solution', 'bmad_solution', 'interrupt_solution_approval'
+    ];
+    for (const id of bmadNodes) {
+      assert.ok(nodeStarts.includes(id), `visited ${id}`);
+    }
+
+    // Verify it joined the shared pipeline
+    assert.ok(nodeStarts.includes('parallel_implementation'), 'reached parallel_implementation');
+  });
+
+  it('only 3 nodes remain not_implemented after P4 (now 0 after P5)', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const notImpl = engine.getNodesWhere(n => n.runtime_status === 'not_implemented');
+    assert.equal(notImpl.length, 0, 'P5 resolved all not_implemented nodes');
+  });
+});
+
+// ============================================================
+// P5: Cleanup & Deprecation (3 nodes: deprecate 2, implement 1)
+// ============================================================
+
+describe('Integration: P5 Cleanup & Deprecation', () => {
+  it('teams_spawn has runtime_status: deprecated', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('teams_spawn');
+    assert.equal(node.runtime_status, 'deprecated');
+  });
+
+  it('teams_spawn has deprecated_reason field', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('teams_spawn');
+    assert.ok(node.deprecated_reason, 'should have deprecated_reason');
+    assert.ok(node.deprecated_reason.includes('IMPERATIVO_AGENT_TEAMS'), 'should mention replacement');
+  });
+
+  it('interrupt_teams_failed has runtime_status: deprecated', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interrupt_teams_failed');
+    assert.equal(node.runtime_status, 'deprecated');
+  });
+
+  it('interrupt_teams_failed has deprecated_reason field', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('interrupt_teams_failed');
+    assert.ok(node.deprecated_reason, 'should have deprecated_reason');
+    assert.ok(node.deprecated_reason.includes('teams_spawn'), 'should reference teams_spawn');
+  });
+
+  it('post_mortem has runtime_status: implemented', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('post_mortem');
+    assert.equal(node.runtime_status, 'implemented');
+  });
+
+  it('post_mortem step uses agent action with elsabro-tech-writer', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('post_mortem');
+    assert.equal(node.steps.length, 1, 'should have 1 step');
+    assert.equal(node.steps[0].action, 'agent', 'step action should be agent');
+    assert.equal(node.steps[0].agent, 'elsabro-tech-writer', 'agent should be tech-writer');
+    assert.equal(node.steps[0].as, 'learnings', 'step should store as learnings');
+  });
+
+  it('post_mortem routes to end_success', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const node = engine.getNode('post_mortem');
+    assert.equal(node.next, 'end_success');
+  });
+
+  it('DeprecatedNodeError is thrown for deprecated nodes', async () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const callbacks = makeMockCallbacks();
+
+    await assert.rejects(
+      engine.run(
+        { task: 'build dashboard', profile: 'teams', complexity: 'high' },
+        callbacks
+      ),
+      (err) => {
+        assert.equal(err.name, 'DeprecatedNodeError');
+        assert.equal(err.nodeId, 'teams_spawn');
+        assert.ok(err.reason.includes('IMPERATIVO_AGENT_TEAMS'));
+        return true;
+      }
+    );
+  });
+
+  it('0 not_implemented nodes remain after P5', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const notImpl = engine.getNodesWhere(n => n.runtime_status === 'not_implemented');
+    assert.equal(notImpl.length, 0);
+  });
+
+  it('exactly 2 deprecated nodes exist', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const deprecated = engine.getNodesWhere(n => n.runtime_status === 'deprecated');
+    const ids = deprecated.map(n => n.id).sort();
+    assert.equal(deprecated.length, 2);
+    assert.deepStrictEqual(ids, ['interrupt_teams_failed', 'teams_spawn']);
+  });
+
+  it('40 implemented nodes exist', () => {
+    const engine = new FlowEngine();
+    engine.loadFlow(flow);
+    const implemented = engine.getNodesWhere(n => n.runtime_status === 'implemented');
+    assert.equal(implemented.length, 40);
+  });
+});