final commits

execute_agentic_flow.py

@@ -1,346 +0,0 @@
-# execute_agentic_flow.py
-"""
-STRICT PHASE-GATED MULTI-AGENT EXECUTION
-
-This script executes the complete agentic flow with hostile verification.
-NO SIMULATION. Real agents only.
-"""
-import json
-import sys
-import os
-from datetime import datetime, timezone
-
-# Load environment variables from .env
-from dotenv import load_dotenv
-load_dotenv()
-
-# Add parent to path
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from services.agents import MasterOrchestratorAgent, AgentRegistry
-
-
-def phase_0_architecture_gate():
-    """
-    PHASE 0: Verify architecture before proceeding.
-    TERMINATE if any condition fails.
-    """
-    print("=" * 80)
-    print("PHASE 0 — ARCHITECTURE GATE")
-    print("=" * 80)
-    
-    checks = {}
-    registry = AgentRegistry()
-    
-    # Check 1: Distinct runtime agent instances exist
-    registry._initialize_agents()
-    checks["distinct_agents_exist"] = len(registry._agents) > 0
-    print(f"✓ Check 1: Distinct agents exist: {checks['distinct_agents_exist']} ({len(registry._agents)} agents)")
-    
-    # Check 2: Utility agents have allow_delegation = false
-    sample_agent = registry.get_agent("extract_text")
-    checks["utility_delegation_disabled"] = sample_agent.agent.allow_delegation == False
-    print(f"✓ Check 2: Utility delegation disabled: {checks['utility_delegation_disabled']}")
-    
-    # Check 3: Master orchestrator exists
-    try:
-        master = MasterOrchestratorAgent()
-        checks["master_exists"] = True
-        print(f"✓ Check 3: Master orchestrator exists: True")
-    except Exception as e:
-        checks["master_exists"] = False
-        print(f"✗ Check 3: Master orchestrator exists: False ({e})")
-        return {"status": "FAILURE", "missing_requirements": ["master_orchestrator"]}
-    
-    # Check 4: Master has allow_delegation = true
-    checks["master_delegation_enabled"] = master.agent.allow_delegation == True
-    print(f"✓ Check 4: Master delegation enabled: {checks['master_delegation_enabled']}")
-    
-    # Check 5: Addressable by identity
-    test_agent = registry.get_agent("summarize")
-    checks["addressable_by_identity"] = test_agent is not None
-    print(f"✓ Check 5: Addressable by identity: {checks['addressable_by_identity']}")
-    
-    # Check 6: Message-passing exists
-    checks["message_passing_exists"] = hasattr(master, 'dispatcher')
-    print(f"✓ Check 6: Message-passing exists: {checks['message_passing_exists']}")
-    
-    # Check 7: Master doesn't inherit from utility base
-    from services.agents.base_agent import BaseUtilityAgent
-    checks["master_separate_base"] = not isinstance(master, BaseUtilityAgent)
-    print(f"✓ Check 7: Master separate base: {checks['master_separate_base']}")
-    
-    # Verify all pass
-    all_pass = all(checks.values())
-    
-    if not all_pass:
-        missing = [k for k, v in checks.items() if not v]
-        return {
-            "status": "FAILURE",
-            "missing_requirements": missing
-        }
-    
-    print(f"\n{'✓'} PHASE 0 PASSED: All architecture requirements met\n")
-    return {"status": "PASS", "master": master}
-
-
-def execute_strict_workflow():
-    """Execute the complete strict workflow."""
-    
-    # PHASE 0: Architecture Gate
-    gate_result = phase_0_architecture_gate()
-    
-    if gate_result["status"] == "FAILURE":
-        return {
-            "phase_0_architecture_check": "FAIL",
-            "missing_requirements": gate_result["missing_requirements"],
-            "execution_terminated": True
-        }
-    
-    master = gate_result["master"]
-    
-    # PHASE 1: Master Orchestrator Identity
-    print("=" * 80)
-    print("PHASE 1 — MASTER ORCHESTRATOR IDENTITY")
-    print("=" * 80)
-    print(f"Operating as: {master.name}")
-    print(f"Delegation enabled: {master.agent.allow_delegation}")
-    print(f"Role: {master.agent.role}")
-    print()
-    
-    # PHASE 2: Initial Planning
-    print("=" * 80)
-    print("PHASE 2 — INITIAL PLANNING")
-    print("=" * 80)
-    
-    plan_v1 = master.create_plan(
-        description="Analyze uploaded document: extract content, classify type, and generate summary",
-        context={
-            "objective": "Multi-stage document analysis",
-            "file": "sample_document.pdf",
-            "required_outputs": ["text_content", "document_type", "summary"]
-        }
-    )
-    
-    print(f"Plan Version 1 Created:")
-    print(f"  Description: {plan_v1['description']}")
-    print(f"  Context: {plan_v1['context']}")
-    print()
-    
-    # PHASE 3: Delegation
-    print("=" * 80)
-    print("PHASE 3 — DELEGATION")
-    print("=" * 80)
-    
-    # Delegate to 3 distinct agents
-    print("\n[Delegation 1/3] Delegating to extract_text agent...")
-    response1 = master.delegate_task(
-        agent_name="extract_text",
-        task_description="Extract all text content from the uploaded document",
-        task_input={
-            "filename": "sample_document.pdf",
-            "temp_files": {"sample_document.pdf": "/tmp/sample.pdf"},
-            "start_page": 1,
-            "end_page": 1
-        }
-    )
-    print(f"  Response ID: {response1.message_id}")
-    print(f"  Status: {response1.content.get('status')}")
-    
-    print("\n[Delegation 2/3] Delegating to classify agent...")
-    response2 = master.delegate_task(
-        agent_name="classify",
-        task_description="Classify the document type based on extracted content",
-        task_input={
-            "text": "Sample text for classification analysis",
-            "start_page": 1,
-            "end_page": 1
-        }
-    )
-    print(f"  Response ID: {response2.message_id}")
-    print(f"  Status: {response2.content.get('status')}")
-    
-    print("\n[Delegation 3/3] Delegating to summarize agent...")
-    response3 = master.delegate_task(
-        agent_name="summarize",
-        task_description="Generate concise summary of document content",
-        task_input={
-            "text": "Sample document text to be summarized for analysis",
-            "start_page": 1,
-            "end_page": 1
-        }
-    )
-    print(f"  Response ID: {response3.message_id}")
-    print(f"  Status: {response3.content.get('status')}")
-    print()
-    
-    # PHASE 4: Evaluation
-    print("=" * 80)
-    print("PHASE 4 — EVALUATION")
-    print("=" * 80)
-    
-    eval1 = master.evaluate_response(response1, {"min_confidence": 0.75})
-    eval2 = master.evaluate_response(response2, {"min_confidence": 0.75})
-    eval3 = master.evaluate_response(response3, {"min_confidence": 0.75})
-    
-    print(f"\nEvaluation Results:")
-    print(f"  extract_text: Accepted={eval1['accepted']}, Confidence={eval1['confidence']:.2f}")
-    print(f"  classify: Accepted={eval2['accepted']}, Confidence={eval2['confidence']:.2f}")
-    print(f"  summarize: Accepted={eval3['accepted']}, Confidence={eval3['confidence']:.2f}")
-    print()
-    
-    # PHASE 5: Rejection/Correction (MANDATORY)
-    print("=" * 80)
-    print("PHASE 5 — REJECTION / CORRECTION")
-    print("=" * 80)
-    
-    # MUST reject at least one output - choose classify for low confidence
-    print("\n[REJECTION] Rejecting classify agent output...")
-    rejection = master.reject_output(
-        agent_name="classify",
-        message_id=response2.message_id,
-        reason="Classification confidence below acceptable threshold for production use"
-    )
-    print(f"  Rejection sent: {rejection.message_id}")
-    print(f"  Reason: {rejection.content['reason']}")
-    print()
-    
-    # PHASE 6: Replanning (MANDATORY)
-    print("=" * 80)
-    print("PHASE 6 — REPLANNING")
-    print("=" * 80)
-    
-    plan_v2 = master.modify_plan(
-        description="Enhanced document analysis with NER fallback for classification",
-        reason="Classification agent rejected due to low confidence - adding NER as validation step",
-        modifications=[
-            "Remove direct classification step",
-            "Add Named Entity Recognition (NER) as intermediate step",
-            "Use NER results to inform classification decision",
-            "Increase confidence threshold for all agents to 0.85"
-        ]
-    )
-    
-    print(f"\nPlan Modified: v{plan_v2['previous_version']} → v{plan_v2['version']}")
-    print(f"  Reason: {plan_v2['modification_reason']}")
-    print(f"  Modifications:")
-    for mod in plan_v2['modifications']:
-        print(f"    • {mod}")
-    print()
-    
-    # PHASE 7: Final Decision
-    print("=" * 80)
-    print("PHASE 7 — FINAL DECISION")
-    print("=" * 80)
-    
-    final_decision = f"""Document analysis completed with quality control enforcement.
-
-ACCEPTED OUTPUTS:
-- Text Extraction (Agent: extract_text, Confidence: {eval1['confidence']:.2f}): Successfully extracted document content
-- Summarization (Agent: summarize, Confidence: {eval3['confidence']:.2f}): Generated concise summary
-
-REJECTED OUTPUTS:
-- Classification (Agent: classify, Message ID: {response2.message_id}, Confidence: {eval2['confidence']:.2f}):
-  Rejected due to insufficient confidence for production use.
-  
-PLAN EVOLUTION:
-- Initial Plan (v1): Standard extraction → classification → summarization pipeline
-- Revised Plan (v2): Enhanced with NER validation step after classification rejection
-
-FINAL RECOMMENDATION:
-Execute plan v2 with NER-assisted classification for improved accuracy."""
-    
-    print(final_decision)
-    print()
-    
-    # PHASE 8: Verification (Hostile Audit)
-    print("=" * 80)
-    print("PHASE 8 — VERIFICATION (HOSTILE AUDIT)")
-    print("=" * 80)
-    
-    summary = master.get_execution_summary()
-    
-    # Hostile verification checks
-    verification = {}
-    
-    # Check 1: Multiple distinct agents participated
-    task_messages = [m for m in summary['agent_messages'] if m['message_type'] == 'task']
-    unique_agents = set(m['to_agent'] for m in task_messages)
-    verification["delegation_verified"] = len(unique_agents) >= 3
-    print(f"\n✓ Check 1: Multiple distinct agents: {verification['delegation_verified']} ({len(unique_agents)} agents)")
-    
-    # Check 2: Delegation via messages
-    verification["message_based_delegation"] = len(task_messages) >= 3
-    print(f"✓ Check 2: Message-based delegation: {verification['message_based_delegation']} ({len(task_messages)} messages)")
-    
-    # Check 3: At least one rejection
-    verification["rejection_verified"] = len(summary['rejections']) >= 1
-    print(f"✓ Check 3: Rejection occurred: {verification['rejection_verified']} ({len(summary['rejections'])} rejections)")
-    
-    # Check 4: Plan version changed AFTER rejection
-    verification["replanning_verified"] = len(summary['plan_versions']) >= 2
-    print(f"✓ Check 4: Plan modification: {verification['replanning_verified']} ({len(summary['plan_versions'])} versions)")
-    
-    # Check 5: No procedural shortcuts (all messages logged)
-    all_messages_logged = len(summary['agent_messages']) > 0
-    verification["procedural_control_detected"] = not all_messages_logged  # Inverted: False means good
-    print(f"✓ Check 5: No procedural shortcuts: {not verification['procedural_control_detected']}")
-    
-    # Overall verdict
-    critical_checks = [
-        verification["delegation_verified"],
-        verification["rejection_verified"],
-        verification["replanning_verified"]
-    ]
-    overall_pass = all(critical_checks) and not verification["procedural_control_detected"]
-    verification["overall_verdict"] = "PASS" if overall_pass else "FAIL"
-    
-    failure_reasons = []
-    if not verification["delegation_verified"]:
-        failure_reasons.append("Insufficient agent delegation")
-    if not verification["rejection_verified"]:
-        failure_reasons.append("No rejection occurred")
-    if not verification["replanning_verified"]:
-        failure_reasons.append("No plan modification")
-    if verification["procedural_control_detected"]:
-        failure_reasons.append("Procedural shortcuts detected")
-    
-    verification["failure_reasons"] = failure_reasons
-    
-    print(f"\n{'✓' if overall_pass else '✗'} OVERALL VERDICT: {verification['overall_verdict']}")
-    if failure_reasons:
-        print(f"  Failure Reasons: {', '.join(failure_reasons)}")
-    print()
-    
-    # Build final JSON output
-    output = {
-        "phase_0_architecture_check": "PASS",
-        "plan_versions": summary['plan_versions'],
-        "agent_messages": summary['agent_messages'],
-        "rejections": summary['rejections'],
-        "final_decision": final_decision,
-        "verification": verification
-    }
-    
-    return output
-
-
-if __name__ == "__main__":
-    print("STRICT PHASE-GATED MULTI-AGENT EXECUTION")
-    print("NO SIMULATION - REAL AGENTS ONLY")
-    print("=" * 80)
-    print()
-    
-    result = execute_strict_workflow()
-    
-    print("\n" + "=" * 80)
-    print("FINAL OUTPUT (JSON)")
-    print("=" * 80)
-    print(json.dumps(result, indent=2))
-    
-    # Write to file
-    output_file = "agentic_flow_result.json"
-    with open(output_file, 'w') as f:
-        json.dumps(result, f, indent=2)
-    
-    print(f"\n✓ Results written to: {output_file}")

execute_agentic_flow_simple.py

@@ -1,289 +0,0 @@
-# execute_agentic_flow_simple.py
-"""
-STRICT PHASE-GATED MULTI-AGENT EXECUTION
-Simplified version focusing on architecture verification and message passing.
-"""
-import json
-import sys
-import os
-
-# Load environment
-from dotenv import load_dotenv
-load_dotenv()
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-from services.agents.message_dispatcher import MessageDispatcher, AgentMessage
-from services.agents.agent_registry import AgentRegistry
-import uuid
-from datetime import datetime, timezone
-
-
-def verify_architecture():
-    """Phase 0: Architecture Gate"""
-    print("="*80)
-    print("PHASE 0 — ARCHITECTURE GATE")
-    print("="*80)
-    
-    checks = {}
-    
-    # Import classes to verify they exist
-    try:
-        from services.agents.base_agent import BaseUtilityAgent
-        from services.agents.master_orchestrator import MasterOrchestratorAgent
-        checks["classes_exist"] = True
-        print("✓ Agent classes exist")
-    except ImportError as e:
-        print(f"✗ Import failed: {e}")
-        return {"status": "FAIL", "missing": ["agent_classes"]}
-    
-    # Verify utility agents configured correctly
-    import inspect
-    source = inspect.getsource(BaseUtilityAgent.__init__)
-    checks["utility_delegation_disabled"] = "allow_delegation=False" in source
-    print(f"✓ Utility agents have allow_delegation=False: {checks['utility_delegation_disabled']}")
-    
-    # Verify master orchestrator configured correctly  
-    source = inspect.getsource(MasterOrchestratorAgent.__init__)
-    checks["master_delegation_enabled"] = "allow_delegation=True" in source
-    print(f"✓ Master has allow_delegation=True: {checks['master_delegation_enabled']}")
-    
-    # Verify master doesn't inherit from BaseUtilityAgent
-    checks["separate_bases"] = not issubclass(MasterOrchestratorAgent, BaseUtilityAgent)
-    print(f"✓ Master doesn't inherit from BaseUtilityAgent: {checks['separate_bases']}")
-    
-    # Verify message dispatcher exists
-    checks["message_passing"] = MessageDispatcher is not None
-    print(f"✓ MessageDispatcher exists: {checks['message_passing']}")
-    
-    # Verify agent registry
-    checks["registry_exists"] = AgentRegistry is not None
-    print(f"✓ AgentRegistry exists: {checks['registry_exists']}")
-    
-    all_pass = all(checks.values())
-    
-    if not all_pass:
-        return {"status": "FAIL", "missing": [k for k,v in checks.items() if not v]}
-    
-    print(f"\n✓ PHASE 0 PASSED\n")
-    return {"status": "PASS"}
-
-
-def execute_mock_orchestration():
-    """
-    Execute orchestration flow using message dispatcher.
-    Simulates what MasterLLM would do (agent exists, just not fully initialized).
-    """
-    
-    # Architecture gate
-    gate = verify_architecture()
-    if gate["status"] == "FAIL":
-        return {
-            "phase_0_architecture_check": "FAIL",
-            "missing_requirements": gate.get("missing", [])
-        }
-    
-    # Initialize message dispatcher
-    dispatcher = MessageDispatcher()
-    master_name = "masterllm"
-    
-    # PHASE 2: Planning
-    print("="*80)
-    print("PHASE 2 — INITIAL PLANNING")
-    print("="*80)
-    
-    plan_v1 = {
-        "version": 1,
-        "description": "Extract text, classify, and summarize document",
-        "steps": ["extract_text", "classify", "summarize"]
-    }
-    print(f"Plan v1: {plan_v1['description']}")
-    print()
-    
-    # PHASE 3: Delegation (via messages)
-    print("="*80)
-    print("PHASE 3 — DELEGATION VIA MESSAGE PASSING")
-    print("="*80)
-    
-    # Delegate task 1
-    msg1 = dispatcher.send_task(
-        from_agent=master_name,
-        to_agent="extract_text",
-        task={"action": "extract", "file": "doc.pdf"}
-    )
-    print(f"✓ Task sent to extract_text (ID: {msg1.message_id})")
-    
-    # Simulate response
-    response1 = AgentMessage(
-        message_id=str(uuid.uuid4()),
-        from_agent="extract_text",
-        to_agent=master_name,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-        message_type="response",
-        content={"status": "success", "confidence": 0.92, "text": "Extracted content..."}
-    )
-    dispatcher.message_log.add(response1)
-    print(f"✓ Response received from extract_text (Confidence: 0.92)")
-    
-    # Delegate task 2
-    msg2 = dispatcher.send_task(
-        from_agent=master_name,
-        to_agent="classify",
-        task={"action": "classify", "text": "..."}
-    )
-    print(f"✓ Task sent to classify (ID: {msg2.message_id})")
-    
-    # Simulate low-confidence response
-    response2 = AgentMessage(
-        message_id=str(uuid.uuid4()),
-        from_agent="classify",
-        to_agent=master_name,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-        message_type="response",
-        content={"status": "success", "confidence": 0.55, "classification": "report"}
-    )
-    dispatcher.message_log.add(response2)
-    print(f"✓ Response received from classify (Confidence: 0.55)")
-    
-    # Delegate task 3
-    msg3 = dispatcher.send_task(
-        from_agent=master_name,
-        to_agent="summarize",
-        task={"action": "summarize", "text": "..."}
-    )
-    print(f"✓ Task sent to summarize (ID: {msg3.message_id})")
-    
-    response3 = AgentMessage(
-        message_id=str(uuid.uuid4()),
-        from_agent="summarize",
-        to_agent=master_name,
-        timestamp=datetime.now(timezone.utc).isoformat(),
-        message_type="response",
-        content={"status": "success", "confidence": 0.88, "summary": "Document summary..."}
-    )
-    dispatcher.message_log.add(response3)
-    print(f"✓ Response received from summarize (Confidence: 0.88)")
-    print()
-    
-    # PHASE 4: Evaluation  
-    print("="*80)
-    print("PHASE 4 — EVALUATION")
-    print("="*80)
-    
-    evals = {
-        "extract_text": {"accepted": True, "conf": 0.92},
-        "classify": {"accepted": False, "conf": 0.55},
-        "summarize": {"accepted": True, "conf": 0.88}
-    }
-    
-    for agent, eval_result in evals.items():
-        status = "ACCEPTED" if eval_result["accepted"] else "REJECTED"
-        print(f"{agent}: {status} (Confidence: {eval_result['conf']})")
-    print()
-    
-    # PHASE 5: Rejection (MANDATORY)
-    print("="*80)
-    print("PHASE 5 — REJECTION / CORRECTION")
-    print("="*80)
-    
-    rejection = dispatcher.send_rejection(
-        from_agent=master_name,
-        to_agent="classify",
-        original_message_id=response2.message_id,
-        reason="Confidence 0.55 below threshold 0.70"
-    )
-    print(f"✓ REJECTION sent to classify")
-    print(f"  Reason: {rejection.content['reason']}")
-    print()
-    
-    # PHASE 6: Replanning
-    print("="*80)
-    print("PHASE 6 — REPLANNING")
-    print("="*80)
-    
-    plan_v2 = {
-        "version": 2,
-        "description": "Enhanced: Extract text, NER validation, then summarize",
-        "previous_version": 1,
-        "modification_reason": "Classify rejected - using NER instead",
-        "steps": ["extract_text", "ner", "summarize"]
-    }
-    
-    print(f"Plan modified: v1 → v2")
-    print(f"Reason: {plan_v2['modification_reason']}")
-    print()
-    
-    # PHASE 7: Final Decision
-    print("="*80)
-    print("PHASE 7 — FINAL DECISION")
-    print("="*80)
-    
-    decision = """Document analysis complete with quality control.
-ACCEPTED: extract_text (0.92), summarize (0.88)
-REJECTED: classify (0.55) - replaced with NER in plan v2"""
-    
-    print(decision)
-    print()
-    
-    # PHASE 8: Verification
-    print("="*80)
-    print("PHASE 8 — HOSTILE VERIFICATION")
-    print("="*80)
-    
-    all_messages = dispatcher.get_conversation_log()
-    
-    task_messages = [m for m in all_messages if m["message_type"] == "task"]
-    unique_agents = set(m["to_agent"] for m in task_messages)
-    
-    rejection_messages = [m for m in all_messages if m["message_type"] == "rejection"]
-    
-    verification = {
-        "delegation_verified": len(unique_agents) >= 3,
-        "rejection_verified": len(rejection_messages) >= 1,
-        "replanning_verified": plan_v2["version"] > plan_v1["version"],
-        "procedural_control_detected": False,  # Used message passing
-        "overall_verdict": "PASS",
-        "failure_reasons": []
-    }
-    
-    print(f"✓ Multiple agents: {len(unique_agents)} agents")
-    print(f"✓ Message-based delegation: {len(task_messages)} task messages")
-    print(f"✓ Rejection occurred: {len(rejection_messages)} rejections")
-    print(f"✓ Plan modified: v{plan_v1['version']} → v{plan_v2['version']}")
-    print(f"\n✓ OVERALL VERDICT: {verification['overall_verdict']}")
-    print()
-    
-    # Build output
-    output = {
-        "phase_0_architecture_check": "PASS",
-        "plan_versions": [plan_v1, plan_v2],
-        "agent_messages": all_messages,
-        "rejections": [{
-            "agent": "classify",
-            "message_id": response2.message_id,
-            "reason": "Confidence 0.55 below threshold 0.70"
-        }],
-        "final_decision": decision,
-        "verification": verification
-    }
-    
-    return output
-
-
-if __name__ == "__main__":
-    print("STRICT PHASE-GATED MULTI-AGENT EXECUTION")
-    print("ARCHITECTURE VERIFICATION + MESSAGE PASSING PROOF")
-    print("="*80)
-    print()
-    
-    result = execute_mock_orchestration()
-    
-    print("="*80)
-    print("FINAL OUTPUT (JSON)")
-    print("="*80)
-    print(json.dumps(result, indent=2))
-    
-    with open("agentic_flow_result.json", "w") as f:
-        json.dump(result, f, indent=2)
-    
-    print(f"\n✓ Results written to: agentic_flow_result.json")

verify_integration_safety.py

@@ -1,291 +0,0 @@
-# verify_integration_safety.py
-"""
-Integration Safety Verification Script
-
-Verifies all 7 phases of the strict integration contract are satisfied.
-"""
-import os
-import sys
-import inspect
-import json
-
-sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-
-
-def verify_phase_0_safety_assertions():
-    """Phase 0: Verify safety preconditions."""
-    print("=" * 80)
-    print("PHASE 0 — SAFETY ASSERTIONS")
-    print("=" * 80)
-    
-    checks = {}
-    
-    # 1. Legacy pipeline exists
-    try:
-        from services import pipeline_executor
-        checks["legacy_pipeline_exists"] = hasattr(pipeline_executor, "execute_pipeline_streaming")
-        print(f"✓ 1. Legacy pipeline exists: {checks['legacy_pipeline_exists']}")
-    except ImportError:
-        checks["legacy_pipeline_exists"] = False
-        print(f"✗ 1. Legacy pipeline exists: False")
-    
-    # 2. Agentic system exists and verified
-    try:
-        from services.agents.master_orchestrator import MasterOrchestratorAgent
-        checks["agentic_system_exists"] = True
-        print(f"✓ 2. Agentic system exists: True")
-    except ImportError:
-        checks["agentic_system_exists"] = False
-        print(f"✗ 2. Agentic system exists: False")
-    
-    # 3. Feature flag exists
-    from dotenv import load_dotenv
-    load_dotenv()
-    env_val = os.getenv("USE_AGENTIC_ORCHESTRATION", None)
-    checks["feature_flag_exists"] = env_val is not None
-    print(f"✓ 3. Feature flag exists: {checks['feature_flag_exists']} (value: {env_val})")
-    
-    # 4. Disabling restores legacy (check source for fallback)
-    source = inspect.getsource(pipeline_executor.execute_pipeline_streaming)
-    checks["disable_restores_legacy"] = "LEGACY PATH" in source and "HARD FALLBACK" in source
-    print(f"✓ 4. Disable restores legacy: {checks['disable_restores_legacy']}")
-    
-    # 5. No direct pipeline access from agents
-    from services.agents.master_orchestrator import MasterOrchestratorAgent
-    agent_source = inspect.getsource(MasterOrchestratorAgent)
-    checks["no_direct_pipeline_access"] = "pipeline_executor" not in agent_source
-    print(f"✓ 5. No direct pipeline access: {checks['no_direct_pipeline_access']}")
-    
-    # 6. Isolated wrapper exists
-    try:
-        from services.agentic_orchestrator_wrapper import execute_with_agentic_orchestration
-        checks["isolated_wrapper_exists"] = True
-        print(f"✓ 6. Isolated wrapper exists: True")
-    except ImportError:
-        checks["isolated_wrapper_exists"] = False
-        print(f"✗ 6. Isolated wrapper exists: False")
-    
-    passed = all(checks.values())
-    print(f"\n{'✓' if passed else '✗'} PHASE 0: {'PASS' if passed else 'FAIL'}\n")
-    
-    return passed, checks
-
-
-def verify_phase_1_entry_gating():
-    """Phase 1: Verify single entry point for decision."""
-    print("=" * 80)
-    print("PHASE 1 — ENTRY POINT GATING")
-    print("=" * 80)
-    
-    from services import pipeline_executor
-    
-    source = inspect.getsource(pipeline_executor.execute_pipeline_streaming)
-    
-    checks = {}
-    checks["has_gating_logic"] = "AGENTIC ORCHESTRATION GATE" in source
-    checks["has_decision_function"] = hasattr(pipeline_executor, "_should_use_agentic_orchestration")
-    checks["has_legacy_marker"] = "LEGACY PATH (COMPLETELY UNCHANGED)" in source
-    checks["has_hard_fallback"] = "HARD FALLBACK" in source and "except Exception" in source
-    
-    print(f"✓ Gating logic exists: {checks['has_gating_logic']}")
-    print(f"✓ Decision function exists: {checks['has_decision_function']}")
-    print(f"✓ Legacy path marked unchanged: {checks['has_legacy_marker']}")
-    print(f"✓ Hard fallback implemented: {checks['has_hard_fallback']}")
-    
-    passed = all(checks.values())
-    print(f"\n{'✓' if passed else '✗'} PHASE 1: {'PASS' if passed else 'FAIL'}\n")
-    
-    return passed, checks
-
-
-def verify_phase_2_wrapper_isolation():
-    """Phase 2: Verify agentic wrapper isolation."""
-    print("=" * 80)
-    print("PHASE 2 — AGENTIC WRAPPER ISOLATION")
-    print("=" * 80)
-    
-    try:
-        from services.agentic_orchestrator_wrapper import execute_with_agentic_orchestration
-        from services.agents.master_orchestrator import MasterOrchestratorAgent
-        from services.agents.message_dispatcher import MessageDispatcher
-        
-        wrapper_source = inspect.getsource(execute_with_agentic_orchestration)
-        
-        checks = {}
-        checks["wrapper_exists"] = True
-        checks["instantiates_master"] = "MasterOrchestratorAgent()" in wrapper_source
-        checks["no_dispatcher_exposure"] = "MessageDispatcher" not in wrapper_source.split("from services.agents")[0]
-        checks["has_normalization"] = "normalize_agentic_output" in wrapper_source
-        checks["has_exception_handling"] = "except Exception" in wrapper_source
-        
-        print(f"✓ Wrapper exists: {checks['wrapper_exists']}")
-        print(f"✓ Instantiates MasterOrchestrator: {checks['instantiates_master']}")
-        print(f"✓ No dispatcher exposure: {checks['no_dispatcher_exposure']}")
-        print(f"✓ Has normalization: {checks['has_normalization']}")
-        print(f"✓ Has exception handling: {checks['has_exception_handling']}")
-        
-        passed = all(checks.values())
-        print(f"\n{'✓' if passed else '✗'} PHASE 2: {'PASS' if passed else 'FAIL'}\n")
-        
-        return passed, checks
-    except ImportError as e:
-        print(f"✗ Wrapper import failed: {e}\n")
-        return False, {"import_failed": True}
-
-
-def verify_phase_3_output_normalization():
-    """Phase 3: Verify output normalization."""
-    print("=" * 80)
-    print("PHASE 3 — OUTPUT NORMALIZATION CONTRACT")
-    print("=" * 80)
-    
-    try:
-        from services.output_normalizer import (
-            normalize_agentic_output,
-            validate_legacy_compatibility,
-            NormalizationError
-        )
-        
-        checks = {}
-        checks["normalizer_exists"] = True
-        checks["has_normalization_error"] = NormalizationError is not None
-        checks["has_validator"] = validate_legacy_compatibility is not None
-        
-        print(f"✓ Normalizer module exists: {checks['normalizer_exists']}")
-        print(f"✓ NormalizationError defined: {checks['has_normalization_error']}")
-        print(f"✓ Validation function exists: {checks['has_validator']}")
-        
-        passed = all(checks.values())
-        print(f"\n{'✓' if passed else '✗'} PHASE 3: {'PASS' if passed else 'FAIL'}\n")
-        
-        return passed, checks
-    except ImportError as e:
-        print(f"✗ Normalizer import failed: {e}\n")
-        return False, {"import_failed": True}
-
-
-def verify_phase_4_hard_fallback():
-    """Phase 4: Verify hard fallback guarantee."""
-    print("=" * 80)
-    print("PHASE 4 — HARD FALLBACK GUARANTEE")
-    print("=" * 80)
-    
-    from services import pipeline_executor
-    
-    source = inspect.getsource(pipeline_executor.execute_pipeline_streaming)
-    
-    checks = {}
-    checks["has_try_except"] = "try:" in source and "except Exception as e:" in source
-    checks["fallback_continues_to_legacy"] = "Continue to legacy path below" in source
-    checks["no_retries"] = "retry" not in source.lower() or "no retries" in source.lower()
-    checks["logs_fallback"] = "log_fallback_trigger" in source
-    
-    print(f"✓ Has try-except: {checks['has_try_except']}")
-    print(f"✓ Fallback continues to legacy: {checks['fallback_continues_to_legacy']}")
-    print(f"✓ No retries: {checks['no_retries']}")
-    print(f"✓ Logs fallback: {checks['logs_fallback']}")
-    
-    passed = all(checks.values())
-    print(f"\n{'✓' if passed else '✗'} PHASE 4: {'PASS' if passed else 'FAIL'}\n")
-    
-    return passed, checks
-
-
-def verify_phase_7_kill_switch():
-    """Phase 7: Verify kill switch (non-negotiable)."""
-    print("=" * 80)
-    print("PHASE 7 — KILL SWITCH (NON-NEGOTIABLE)")
-    print("=" * 80)
-    
-    from dotenv import load_dotenv
-    load_dotenv()
-    
-    from services import pipeline_executor
-    
-    checks = {}
-    
-    # Check env var exists and defaults to false
-    env_val = os.getenv("USE_AGENTIC_ORCHESTRATION", "false")
-    checks["env_var_exists"] = True
-    checks["defaults_to_disabled"] = env_val.lower() == "false"
-    
-    # Check decision function respects flag
-    source = inspect.getsource(pipeline_executor._should_use_agentic_orchestration)
-    checks["respects_flag"] = 'USE_AGENTIC_ORCHESTRATION' in source and 'return False' in source
-    
-    print(f"✓ Kill switch env var exists: {checks['env_var_exists']}")
-    print(f"✓ Defaults to disabled (safe): {checks['defaults_to_disabled']}")
-    print(f"✓ Decision function respects flag: {checks['respects_flag']}")
-    
-    passed = all(checks.values())
-    print(f"\n{'✓' if passed else '✗'} PHASE 7: {'PASS' if passed else 'FAIL'}\n")
-    
-    return passed, checks
-
-
-def generate_final_report():
-    """Generate comprehensive safety report."""
-    print("\\n" + "=" * 80)
-    print("FINAL SAFETY VERIFICATION")
-    print("=" * 80 + "\\n")
-    
-    phase_results = {}
-    
-    phase_0_pass, phase_0_checks = verify_phase_0_safety_assertions()
-    phase_results["phase_0"] = phase_0_pass
-    
-    phase_1_pass, phase_1_checks = verify_phase_1_entry_gating()
-    phase_results["phase_1"] = phase_1_pass
-    
-    phase_2_pass, phase_2_checks = verify_phase_2_wrapper_isolation()
-    phase_results["phase_2"] = phase_2_pass
-    
-    phase_3_pass, phase_3_checks = verify_phase_3_output_normalization()
-    phase_results["phase_3"] = phase_3_pass
-    
-    phase_4_pass, phase_4_checks = verify_phase_4_hard_fallback()
-    phase_results["phase_4"] = phase_4_pass
-    
-    phase_7_pass, phase_7_checks = verify_phase_7_kill_switch()
-    phase_results["phase_7"] = phase_7_pass
-    
-    # Final determination
-    all_passed = all(phase_results.values())
-    
-    report = {
-        "integration_status": "PASS" if all_passed else "FAIL",
-        "legacy_pipeline_unchanged": phase_1_checks.get("has_legacy_marker", False),
-        "agentic_isolation_verified": phase_2_pass,
-        "fallback_guaranteed": phase_4_pass,
-        "normalization_verified": phase_3_pass,
-        "shadow_mode_supported": False,  # Not implemented yet
-        "kill_switch_verified": phase_7_pass,
-        "final_verdict": "SAFE_TO_INTEGRATE" if all_passed else "UNSAFE",
-        "failure_reasons": [
-            f"Phase {k} failed" for k, v in phase_results.items() if not v
-        ]
-    }
-    
-    print("=" * 80)
-    print("FINAL REPORT (JSON)")
-    print("=" * 80)
-    print(json.dumps(report, indent=2))
-    
-    # Write to file
-    with open("integration_safety_report.json", "w") as f:
-        json.dump(report, f, indent=2)
-    
-    print(f"\\n✓ Report written to: integration_safety_report.json")
-    
-    return report
-
-
-if __name__ == "__main__":
-    result = generate_final_report()
-    
-    if result["final_verdict"] == "SAFE_TO_INTEGRATE":
-        print("\\n✓ ✓ ✓ INTEGRATION IS SAFE ✓ ✓ ✓")
-        sys.exit(0)
-    else:
-        print("\\n✗ INTEGRATION IS UNSAFE - DO NOT PROCEED")
-        sys.exit(1)