#!/usr/bin/env python3
"""
Tests for Story 6.08 (Track B): CoherenceOrchestrator — 8-Step Flow Coordinator

Black Box tests (BB): verify the public contract from the outside.
    BB1: 3-task DAG, all workers succeed → CoherenceResult(success=True)
    BB2: 1 of 3 workers fail → workers_failed=1, success=False (scar written)
    BB3: All workers fail → success=False, workers_failed=3, scar written
    BB4: Scar event written to events.jsonl on any worker failure

White Box tests (WB): verify internal step ordering and mechanics.
    WB1: 8 steps fire in correct order (MAP → BARRIER → REDUCE/COMMIT → RELEASE → SCAR)
    WB2: dag_pusher.push_dag called with (session_id, tasks) in Step 1
    WB3: staging_area.wait_for_all called with (session_id, len(tasks), timeout_ms=60000)
    WB4: occ_engine.execute_commit called with (session_id, expected_workers=len(tasks))
    WB5: Total timeout enforced at 120s via asyncio.wait_for

Integration test (IT):
    IT1: All components wired together → full pipeline → CoherenceResult

Package test (PKG):
    PKG1: CoherenceOrchestrator and CoherenceResult importable from core.coherence

Story: 6.08
File under test: core/coherence/coherence_orchestrator.py

ALL tests use mocks — NO real Redis, Qdrant, or filesystem I/O.
    (events.jsonl writes are either patched or verified via tmpdir)
NO SQLite anywhere in this module.
"""

from __future__ import annotations

import asyncio
import json
import sys
import tempfile
from pathlib import Path
from unittest.mock import AsyncMock, MagicMock, call, patch

import pytest

sys.path.insert(0, "/mnt/e/genesis-system")

# ---------------------------------------------------------------------------
# Module under test
# ---------------------------------------------------------------------------

from core.coherence.coherence_orchestrator import (
    CoherenceOrchestrator,
    CoherenceResult,
    ORCHESTRATION_TIMEOUT_SECONDS,
    EVENTS_LOG_PATH,
)


# ---------------------------------------------------------------------------
# Async helper
# ---------------------------------------------------------------------------


def run(coro):
    """Run a coroutine synchronously (no pytest-asyncio required)."""
    loop = asyncio.new_event_loop()
    try:
        return loop.run_until_complete(coro)
    finally:
        loop.close()


# ---------------------------------------------------------------------------
# Mock builder helpers
# ---------------------------------------------------------------------------


def _make_dag_pusher(entry_ids: list[str] | None = None) -> MagicMock:
    """Return a mock TaskDAGPusher."""
    if entry_ids is None:
        entry_ids = ["1234567890000-0", "1234567890001-0", "1234567890002-0"]
    pusher = MagicMock()
    pusher.push_dag = AsyncMock(return_value=entry_ids)
    return pusher


def _make_staging_area(deltas: list | None = None) -> MagicMock:
    """Return a mock StagingArea that yields deltas from wait_for_all."""
    if deltas is None:
        deltas = [{"agent_id": "agent-0", "session_id": "sess-test"}]
    staging = MagicMock()
    staging.wait_for_all = AsyncMock(return_value=deltas)
    return staging


def _make_occ_engine(success: bool = True, version: int = 5) -> MagicMock:
    """Return a mock OCCCommitEngine with a successful or failed execute_commit."""
    occ_result = MagicMock()
    occ_result.success = success
    occ_result.merged_patch = [{"op": "add", "path": "/merged", "value": True}] if success else []
    occ_result.version = version + 1 if success else version
    occ_result.saga_status = "completed" if success else "conflict_exhausted"

    engine = MagicMock()
    engine.execute_commit = AsyncMock(return_value=occ_result)
    return engine


def _make_bulkhead(
    worker_count: int = 3,
    failed_indices: list[int] | None = None,
) -> MagicMock:
    """
    Return a mock BulkheadGuard.

    Args:
        worker_count:   Total number of tasks (one result per task).
        failed_indices: Zero-based indices of tasks that should be marked as failed.
    """
    if failed_indices is None:
        failed_indices = []

    results = []
    for i in range(worker_count):
        r = MagicMock()
        r.success = i not in failed_indices
        r.agent_id = f"task-{i}"
        r.error = "worker crashed" if i in failed_indices else None
        results.append(r)

    guard = MagicMock()
    guard.run_with_bulkhead = AsyncMock(return_value=results)
    return guard


def _sample_tasks(count: int = 3) -> list[dict]:
    """Return `count` minimal task dicts."""
    return [
        {"task_type": f"type-{i}", "payload": {"index": i}}
        for i in range(count)
    ]


# ---------------------------------------------------------------------------
# Patch _write_event to avoid real filesystem I/O in most tests
# ---------------------------------------------------------------------------

PATCH_WRITE_EVENT = "core.coherence.coherence_orchestrator.CoherenceOrchestrator._write_event"


# ===========================================================================
# BLACK BOX TESTS
# ===========================================================================


def test_bb1_three_tasks_all_succeed_returns_success_true():
    """
    BB1: 3-task DAG, all workers succeed, OCC commits successfully.
         CoherenceResult(success=True, workers_succeeded=3, workers_failed=0).
    """
    tasks = _sample_tasks(3)
    pusher = _make_dag_pusher()
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=3, failed_indices=[])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-test", tasks))

    assert isinstance(result, CoherenceResult)
    assert result.success is True
    assert result.workers_succeeded == 3
    assert result.workers_failed == 0
    assert result.saga_id != ""
    assert isinstance(result.committed_state, dict)


def test_bb2_one_of_three_workers_fails_sets_workers_failed_1():
    """
    BB2: 1 of 3 workers fail → workers_failed=1, success=False (partial failure).
    """
    tasks = _sample_tasks(3)
    pusher = _make_dag_pusher()
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=3, failed_indices=[1])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-partial", tasks))

    assert result.workers_failed == 1
    assert result.workers_succeeded == 2
    # success=False because at least one worker failed
    assert result.success is False


def test_bb3_all_workers_fail_success_false_workers_failed_3():
    """
    BB3: All 3 workers fail → success=False, workers_failed=3.
    """
    tasks = _sample_tasks(3)
    pusher = _make_dag_pusher()
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)  # OCC would succeed but workers failed
    bulkhead = _make_bulkhead(worker_count=3, failed_indices=[0, 1, 2])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-all-fail", tasks))

    assert result.success is False
    assert result.workers_failed == 3
    assert result.workers_succeeded == 0


def test_bb4_scar_written_on_worker_failure():
    """
    BB4: When any worker fails, _write_event is called with event_type='scar'.
    """
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=2, failed_indices=[0])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    captured_events: list[tuple] = []

    def capture_write_event(event_type, payload):
        captured_events.append((event_type, payload))

    with patch(PATCH_WRITE_EVENT, side_effect=capture_write_event):
        result = run(orchestrator.execute("sess-scar", tasks))

    # Scar event must be present
    scar_events = [e for e in captured_events if e[0] == "scar"]
    assert len(scar_events) >= 1, "Expected at least one 'scar' event"
    scar_payload = scar_events[0][1]
    assert scar_payload["workers_failed"] == 1


def test_bb5_no_workers_failed_no_scar_written():
    """
    BB5: When all workers succeed, no scar event is written.
         Only a 'release' event should appear.
    """
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=2, failed_indices=[])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    captured_events: list[tuple] = []

    def capture_write_event(event_type, payload):
        captured_events.append((event_type, payload))

    with patch(PATCH_WRITE_EVENT, side_effect=capture_write_event):
        result = run(orchestrator.execute("sess-no-scar", tasks))

    scar_events = [e for e in captured_events if e[0] == "scar"]
    assert len(scar_events) == 0, f"Unexpected scar events: {scar_events}"
    release_events = [e for e in captured_events if e[0] == "release"]
    assert len(release_events) == 1


# ===========================================================================
# WHITE BOX TESTS
# ===========================================================================


def test_wb1_steps_fire_in_order_map_barrier_commit_release():
    """
    WB1: MAP → BARRIER (staging.wait_for_all) → COMMIT (occ_engine.execute_commit)
         → RELEASE (_write_event 'release') fire in the correct order.

    Verified by checking call order of mocked methods.
    """
    tasks = _sample_tasks(2)
    call_order: list[str] = []

    pusher = MagicMock()

    async def push_dag(session_id, tasks):
        call_order.append("MAP")
        return ["id-0", "id-1"]

    pusher.push_dag = push_dag

    staging = MagicMock()

    async def wait_for_all(session_id, expected_count, timeout_ms):
        call_order.append("BARRIER")
        return []

    staging.wait_for_all = wait_for_all

    engine = MagicMock()

    async def execute_commit(session_id, expected_workers):
        call_order.append("COMMIT")
        r = MagicMock()
        r.success = True
        r.merged_patch = []
        r.version = 1
        r.saga_status = "completed"
        return r

    engine.execute_commit = execute_commit

    bulkhead = _make_bulkhead(worker_count=2, failed_indices=[])

    write_event_calls: list[str] = []

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    original_write = orchestrator._write_event

    def capturing_write(event_type, payload):
        call_order.append(f"EVENT:{event_type}")

    with patch(PATCH_WRITE_EVENT, side_effect=capturing_write):
        result = run(orchestrator.execute("sess-order", tasks))

    assert call_order.index("MAP") < call_order.index("BARRIER"), "MAP must precede BARRIER"
    assert call_order.index("BARRIER") < call_order.index("COMMIT"), "BARRIER must precede COMMIT"
    release_idx = next(
        (i for i, s in enumerate(call_order) if s == "EVENT:release"), None
    )
    assert release_idx is not None, "release event must be written"
    assert call_order.index("COMMIT") < release_idx, "COMMIT must precede RELEASE"


def test_wb2_dag_pusher_called_with_session_id_and_tasks():
    """
    WB2: Step 1 (MAP) calls dag_pusher.push_dag(session_id, tasks) exactly once.
    """
    tasks = _sample_tasks(3)
    pusher = _make_dag_pusher()
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=3)

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        run(orchestrator.execute("sess-wb2", tasks))

    pusher.push_dag.assert_awaited_once_with("sess-wb2", tasks)


def test_wb3_staging_wait_for_all_called_with_correct_args():
    """
    WB3: Step 4 (BARRIER) calls staging_area.wait_for_all(session_id, len(tasks), timeout_ms=60000).
    """
    tasks = _sample_tasks(4)
    pusher = _make_dag_pusher(entry_ids=[f"id-{i}" for i in range(4)])
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=4)

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        run(orchestrator.execute("sess-wb3", tasks))

    staging.wait_for_all.assert_awaited_once_with(
        "sess-wb3",
        expected_count=4,
        timeout_ms=60_000,
    )


def test_wb4_occ_engine_called_with_session_id_and_expected_workers():
    """
    WB4: Steps 5+6 (REDUCE/COMMIT) call occ_engine.execute_commit(session_id, expected_workers=len(tasks)).
    """
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=2)

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        run(orchestrator.execute("sess-wb4", tasks))

    engine.execute_commit.assert_awaited_once_with(
        "sess-wb4",
        expected_workers=2,
    )


def test_wb5_orchestration_timeout_120_seconds():
    """
    WB5: ORCHESTRATION_TIMEOUT_SECONDS constant is 120.
         asyncio.wait_for is used with this timeout.
    """
    assert ORCHESTRATION_TIMEOUT_SECONDS == 120


def test_wb5b_timeout_raises_asyncio_timeout_error():
    """
    WB5b: When the pipeline hangs, asyncio.TimeoutError is raised after timeout.
    """
    tasks = _sample_tasks(1)
    pusher = MagicMock()

    async def hanging_push(session_id, tasks_arg):
        # Simulate a pipeline that never completes
        await asyncio.sleep(9999)

    pusher.push_dag = hanging_push

    orchestrator = CoherenceOrchestrator(dag_pusher=pusher)

    async def _run_with_tiny_timeout():
        return await asyncio.wait_for(
            orchestrator._execute_pipeline("sess-timeout", tasks, "saga-timeout"),
            timeout=0.01,
        )

    with pytest.raises(asyncio.TimeoutError):
        run(_run_with_tiny_timeout())


# ===========================================================================
# INTEGRATION TEST
# ===========================================================================


def test_it1_all_components_wired_full_pipeline():
    """
    IT1: All 5 components injected → full 8-step pipeline runs →
         CoherenceResult with correct success/worker counts.
    """
    tasks = _sample_tasks(3)
    pusher = _make_dag_pusher()
    staging = _make_staging_area(deltas=[
        {"agent_id": f"agent-{i}", "session_id": "sess-it1"} for i in range(3)
    ])
    engine = _make_occ_engine(success=True, version=10)
    bulkhead = _make_bulkhead(worker_count=3, failed_indices=[])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
        qdrant_client=None,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-it1", tasks))

    assert result.success is True
    assert result.workers_succeeded == 3
    assert result.workers_failed == 0
    assert isinstance(result.saga_id, str) and len(result.saga_id) == 36
    assert "merged_patch" in result.committed_state

    # Verify all dependency calls were made
    pusher.push_dag.assert_awaited_once_with("sess-it1", tasks)
    staging.wait_for_all.assert_awaited_once()
    engine.execute_commit.assert_awaited_once()
    bulkhead.run_with_bulkhead.assert_awaited_once()


# ===========================================================================
# ADDITIONAL EDGE CASE TESTS
# ===========================================================================


def test_no_dag_pusher_skips_map_step():
    """When dag_pusher=None, MAP step is skipped without error."""
    tasks = _sample_tasks(2)
    staging = _make_staging_area()
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=2)

    orchestrator = CoherenceOrchestrator(
        dag_pusher=None,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-no-pusher", tasks))

    # Pipeline should still complete
    assert isinstance(result, CoherenceResult)


def test_no_staging_area_skips_barrier_step():
    """When staging_area=None, BARRIER step is skipped without error."""
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    engine = _make_occ_engine(success=True)
    bulkhead = _make_bulkhead(worker_count=2)

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=None,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-no-staging", tasks))

    assert isinstance(result, CoherenceResult)


def test_no_occ_engine_skips_commit_step():
    """When occ_engine=None, COMMIT step is skipped. success=True only if workers all pass."""
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    staging = _make_staging_area()
    bulkhead = _make_bulkhead(worker_count=2, failed_indices=[])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=None,
        bulkhead=bulkhead,
    )

    with patch(PATCH_WRITE_EVENT):
        result = run(orchestrator.execute("sess-no-occ", tasks))

    assert isinstance(result, CoherenceResult)
    # No OCC engine → commit_success treated as True (workers decide overall success)
    assert result.success is True


def test_occ_commit_failure_sets_success_false():
    """When OCC commit fails, CoherenceResult.success=False."""
    tasks = _sample_tasks(2)
    pusher = _make_dag_pusher(entry_ids=["id-0", "id-1"])
    staging = _make_staging_area()
    engine = _make_occ_engine(success=False)  # OCC fails
    bulkhead = _make_bulkhead(worker_count=2, failed_indices=[])

    orchestrator = CoherenceOrchestrator(
        dag_pusher=pusher,
        staging_area=staging,
        occ_engine=engine,
        bulkhead=bulkhead,
    )

    captured_events: list[tuple] = []

    def capture_write_event(event_type, payload):
        captured_events.append((event_type, payload))

    with patch(PATCH_WRITE_EVENT, side_effect=capture_write_event):
        result = run(orchestrator.execute("sess-occ-fail", tasks))

    assert result.success is False
    # Scar should be written for commit failure
    scar_events = [e for e in captured_events if e[0] == "scar"]
    assert len(scar_events) >= 1


def test_saga_id_is_unique_per_call():
    """Each call to execute() generates a unique saga_id."""
    tasks = _sample_tasks(1)
    orchestrator = CoherenceOrchestrator()

    with patch(PATCH_WRITE_EVENT):
        result1 = run(orchestrator.execute("sess-unique", tasks))
        result2 = run(orchestrator.execute("sess-unique", tasks))

    assert result1.saga_id != result2.saga_id


def test_coherence_result_dataclass_fields():
    """CoherenceResult dataclass has the expected fields."""
    r = CoherenceResult(
        success=True,
        committed_state={"k": "v"},
        saga_id="saga-123",
        workers_succeeded=3,
        workers_failed=0,
    )
    assert r.success is True
    assert r.committed_state == {"k": "v"}
    assert r.saga_id == "saga-123"
    assert r.workers_succeeded == 3
    assert r.workers_failed == 0


def test_write_event_creates_file_and_appends_json(tmp_path):
    """
    _write_event creates the events log file and appends valid JSON lines.
    Uses tmpdir to avoid touching the real events.jsonl.
    """
    import core.coherence.coherence_orchestrator as mod

    fake_log = tmp_path / "events.jsonl"
    original_path = mod.EVENTS_LOG_PATH
    mod.EVENTS_LOG_PATH = fake_log

    try:
        orchestrator = CoherenceOrchestrator()
        orchestrator._write_event("test_event", {"saga_id": "xyz", "x": 1})
        orchestrator._write_event("test_event_2", {"saga_id": "xyz", "y": 2})

        lines = fake_log.read_text().strip().split("\n")
        assert len(lines) == 2

        entry1 = json.loads(lines[0])
        assert entry1["event_type"] == "test_event"
        assert entry1["x"] == 1
        assert "timestamp" in entry1

        entry2 = json.loads(lines[1])
        assert entry2["event_type"] == "test_event_2"
        assert entry2["y"] == 2
    finally:
        mod.EVENTS_LOG_PATH = original_path


# ===========================================================================
# PACKAGE EXPORT TESTS
# ===========================================================================


def test_pkg1_coherence_orchestrator_importable_from_core_coherence():
    """PKG1a: CoherenceOrchestrator importable from core.coherence."""
    from core.coherence import CoherenceOrchestrator as CO
    assert CO is CoherenceOrchestrator


def test_pkg1_coherence_result_importable_from_core_coherence():
    """PKG1b: CoherenceResult importable from core.coherence."""
    from core.coherence import CoherenceResult as CR
    assert CR is CoherenceResult


def test_pkg1_timeout_constant_importable():
    """PKG1c: ORCHESTRATION_TIMEOUT_SECONDS importable from core.coherence."""
    from core.coherence import ORCHESTRATION_TIMEOUT_SECONDS as OTS
    assert OTS == 120


# ===========================================================================
# Standalone runner (pytest preferred, fallback to direct execution)
# ===========================================================================

if __name__ == "__main__":
    import traceback

    tests = [
        ("BB1: 3 tasks, all succeed → success=True", test_bb1_three_tasks_all_succeed_returns_success_true),
        ("BB2: 1 of 3 workers fail → workers_failed=1, success=False", test_bb2_one_of_three_workers_fails_sets_workers_failed_1),
        ("BB3: All workers fail → success=False, workers_failed=3", test_bb3_all_workers_fail_success_false_workers_failed_3),
        ("BB4: Scar written on worker failure", test_bb4_scar_written_on_worker_failure),
        ("BB5: No scar written on all-success", test_bb5_no_workers_failed_no_scar_written),
        ("WB1: 8 steps fire in correct order", test_wb1_steps_fire_in_order_map_barrier_commit_release),
        ("WB2: dag_pusher.push_dag called with (session_id, tasks)", test_wb2_dag_pusher_called_with_session_id_and_tasks),
        ("WB3: staging.wait_for_all called with correct args", test_wb3_staging_wait_for_all_called_with_correct_args),
        ("WB4: occ_engine.execute_commit called with correct args", test_wb4_occ_engine_called_with_session_id_and_expected_workers),
        ("WB5: ORCHESTRATION_TIMEOUT_SECONDS == 120", test_wb5_orchestration_timeout_120_seconds),
        ("WB5b: Timeout raises asyncio.TimeoutError", test_wb5b_timeout_raises_asyncio_timeout_error),
        ("IT1: All components wired → full pipeline", test_it1_all_components_wired_full_pipeline),
        ("EDGE: No dag_pusher skips MAP", test_no_dag_pusher_skips_map_step),
        ("EDGE: No staging_area skips BARRIER", test_no_staging_area_skips_barrier_step),
        ("EDGE: No occ_engine skips COMMIT", test_no_occ_engine_skips_commit_step),
        ("EDGE: OCC commit failure → success=False + scar", test_occ_commit_failure_sets_success_false),
        ("EDGE: saga_id unique per call", test_saga_id_is_unique_per_call),
        ("EDGE: CoherenceResult dataclass fields", test_coherence_result_dataclass_fields),
        ("EDGE: _write_event creates and appends JSON lines", lambda: test_write_event_creates_file_and_appends_json(Path(tempfile.mkdtemp()))),
        ("PKG1a: CoherenceOrchestrator importable from core.coherence", test_pkg1_coherence_orchestrator_importable_from_core_coherence),
        ("PKG1b: CoherenceResult importable from core.coherence", test_pkg1_coherence_result_importable_from_core_coherence),
        ("PKG1c: ORCHESTRATION_TIMEOUT_SECONDS importable", test_pkg1_timeout_constant_importable),
    ]

    passed = 0
    total = len(tests)
    for name, fn in tests:
        try:
            fn()
            print(f"  [PASS] {name}")
            passed += 1
        except Exception as exc:
            print(f"  [FAIL] {name}: {exc}")
            traceback.print_exc()

    print(f"\n{passed}/{total} tests passed")
    if passed == total:
        print("ALL TESTS PASSED -- Story 6.08 (Track B)")
    else:
        sys.exit(1)