@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/scheduler_orchestrator/tests/unit/test_ecosystem_report_coverage.py

@@ -1,1891 +0,0 @@
-"""Coverage tests for workflows/ecosystem_report.py (post-deploy v2.0.18 gap close).
-
-Targets the four DBOS step bodies + the report renderer + the bootstrap helper:
-
-  - _collect_git_activity        → git subprocess + missing-.git skip path
-  - _collect_scheduler_status    → sched.* aggregation queries
-  - _collect_event_bus_metrics   → outbox 24h + subscription topic counts
-  - _collect_queue_metrics       → dbos.workflow_status enqueued/pending/24h
-  - _generate_and_write_report   → markdown rendering + anomaly heuristics
-  - bootstrap_ecosystem_report_schedule → register_workflows + create idempotent
-
-The DBOS @workflow body itself is intentionally NOT exercised — it requires a
-live DBOS runtime (see test_evolution_auto_promote.py for the same boundary).
-The four steps it composes ARE exercised individually, which gives the workflow
-function adequate transitive coverage relative to the 80% line-coverage gate.
-
-All tests mock external surfaces (DBOS, Postgres sessions, asyncio.create_subprocess_exec,
-filesystem). No real network, no real DB, no real DBOS instance.
-"""
-
-from __future__ import annotations
-
-from datetime import UTC, date, datetime
-from pathlib import Path
-from typing import Any
-from unittest.mock import AsyncMock, MagicMock, patch
-
-import pytest
-
-from vds_scheduler_orchestrator.config import EcosystemReportConfig, _reset_ecosystem_config_for_testing
-
-# ── Config fixtures ───────────────────────────────────────────────────────────
-
-
-@pytest.fixture(autouse=True)
-def _reset_eco_config():
-    """Reset the ecosystem config singleton before/after each test."""
-    _reset_ecosystem_config_for_testing()
-    yield
-    _reset_ecosystem_config_for_testing()
-
-
-def _make_test_config(tmp_path: Path | None = None, **overrides) -> EcosystemReportConfig:
-    """Build a test EcosystemReportConfig with predictable defaults."""
-    defaults = {
-        "monorepo_root": Path("/fake/monorepo"),
-        "report_dir": tmp_path if tmp_path else Path("reports/ecosystem"),
-        "git_repos": ["WHO-project/vds-scripts", "WHO-project/vds-skills"],
-        "error_threshold": 10,
-        "pending_threshold": 50,
-        "commit_threshold": 50,
-        "zero_outbox_alert": True,
-    }
-    defaults.update(overrides)
-    return EcosystemReportConfig(**defaults)
-
-
-# ── Helpers ───────────────────────────────────────────────────────────────────
-
-
-def _unwrap(step: Any) -> Any:
-    """Return the raw async function under a @DBOS.step wrapper.
-
-    DBOS wraps the user function with __wrapped__ pointing at the original
-    coroutine. Falls back to the value itself if the attribute is absent
-    (e.g. when DBOS decoration is bypassed in some environments).
-    """
-    return getattr(step, "__wrapped__", step)
-
-
-def _make_session_mock(
-    *,
-    scalar_returns: list[Any] | None = None,
-    execute_returns: list[Any] | None = None,
-) -> MagicMock:
-    """Build a fake SQLAlchemy session whose scalar/execute return queued values.
-
-    scalar_returns: each call to session.scalar(...) pops the next value.
-    execute_returns: each call to session.execute(...) returns a stub whose
-        .all() yields the next list of rows.
-    """
-    session = MagicMock()
-    if scalar_returns is not None:
-        session.scalar.side_effect = list(scalar_returns)
-    if execute_returns is not None:
-        execute_results = []
-        for rows in execute_returns:
-            stub = MagicMock()
-            stub.all.return_value = rows
-            execute_results.append(stub)
-        session.execute.side_effect = execute_results
-    return session
-
-
-def _make_completed_proc(stdout: str = "") -> MagicMock:
-    """Build a fake CompletedProcess with the given stdout (legacy helper)."""
-    proc = MagicMock()
-    proc.stdout = stdout
-    proc.returncode = 0
-    return proc
-
-
-def _make_async_proc(stdout: str = "") -> MagicMock:
-    """Build a fake asyncio subprocess whose communicate() returns (stdout_bytes, b'')."""
-    proc = MagicMock()
-    proc.communicate = AsyncMock(return_value=(stdout.encode(), b""))
-    proc.returncode = 0
-    return proc
-
-
-# ── Tests: _collect_git_activity ──────────────────────────────────────────────
-
-
-class TestCollectGitActivity:
-    """_collect_git_activity() walks _REPOS, runs git log+branch, builds dict."""
-
-    async def test_skips_repo_without_git_directory(self) -> None:
-        """Repo without .git is logged-and-skipped, not crashed."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        cfg = _make_test_config()
-
-        # Make the .git path not exist
-        path_instance = MagicMock()
-        path_instance.__truediv__.return_value = path_instance
-        path_instance.exists.return_value = False
-
-        cfg_root_mock = MagicMock()
-        cfg_root_mock.__truediv__.return_value = path_instance
-
-        with (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-                return_value=cfg,
-            ),
-            patch.object(cfg, "monorepo_root", cfg_root_mock),
-        ):
-            result = await _unwrap(mod._collect_git_activity)()
-
-        assert result["repos"] == {}
-        assert "since" in result
-        assert result["since"].endswith("+00:00")
-
-    async def test_collects_commits_authors_branches_for_present_repo(self) -> None:
-        """Present .git repo → run git log+branch and parse output."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        commits_out = "\n".join(
-            [
-                "abc|alice|feat: add foo",
-                "def|bob|Merge branch 'x'",
-                "ghi|alice|fix: bar",
-            ]
-        )
-        branches_out = "main\nfeature/x\n"
-
-        cfg = _make_test_config()
-
-        # Path(...) chained calls all return the same instance whose .exists()=True.
-        path_instance = MagicMock()
-        path_instance.__truediv__.return_value = path_instance
-        path_instance.exists.return_value = True
-        path_instance.__str__ = lambda self: "/fake/repo"  # type: ignore[assignment]
-
-        with (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-                return_value=cfg,
-            ),
-            patch.object(cfg, "monorepo_root", path_instance),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.asyncio.create_subprocess_exec",
-                side_effect=[
-                    _make_async_proc(commits_out),
-                    _make_async_proc(branches_out),
-                    _make_async_proc(commits_out),
-                    _make_async_proc(branches_out),
-                ],
-            ),
-        ):
-            result = await _unwrap(mod._collect_git_activity)()
-
-        # Two repos in git_repos → both populated identically here.
-        assert len(result["repos"]) == 2
-        any_repo = next(iter(result["repos"].values()))
-        assert any_repo["commits"] == 3
-        assert any_repo["merge_commits"] == 1
-        assert sorted(any_repo["authors"]) == ["alice", "bob"]
-        assert "main" in any_repo["branches_changed"]
-        assert "feature/x" in any_repo["branches_changed"]
-
-    async def test_handles_empty_git_log_output(self) -> None:
-        """Empty git log output → zero commits, no authors, no merges."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        cfg = _make_test_config()
-
-        path_instance = MagicMock()
-        path_instance.__truediv__.return_value = path_instance
-        path_instance.exists.return_value = True
-
-        with (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-                return_value=cfg,
-            ),
-            patch.object(cfg, "monorepo_root", path_instance),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.asyncio.create_subprocess_exec",
-                return_value=_make_async_proc(""),
-            ),
-        ):
-            result = await _unwrap(mod._collect_git_activity)()
-
-        for repo_info in result["repos"].values():
-            assert repo_info["commits"] == 0
-            assert repo_info["authors"] == []
-            assert repo_info["merge_commits"] == 0
-
-
-# ── Tests: _collect_scheduler_status ──────────────────────────────────────────
-
-
-class TestCollectSchedulerStatus:
-    """_collect_scheduler_status() aggregates schedule/alias/chain counts."""
-
-    async def test_returns_well_formed_dict_with_zero_counts(self) -> None:
-        """Empty DB → all counts zero, by_orchestrator dicts empty."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        # Order: total_schedules, paused_schedules, total_aliases, total_chains.
-        session = _make_session_mock(
-            scalar_returns=[0, 0, 0, 0],
-            execute_returns=[[], []],  # orch_counts, alias_counts
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_scheduler_status)()
-
-        assert result["schedules"] == {
-            "total": 0,
-            "paused": 0,
-            "active": 0,
-            "by_orchestrator": {},
-        }
-        assert result["aliases"] == {"total": 0, "by_orchestrator": {}}
-        assert result["chains"] == {"total": 0}
-        session.close.assert_called_once()
-
-    async def test_populates_by_orchestrator_breakdowns(self) -> None:
-        """Non-empty execute() rows → orchestrator dict populated, active = total - paused."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = _make_session_mock(
-            scalar_returns=[10, 3, 5, 2],  # 10 total, 3 paused → 7 active
-            execute_returns=[
-                [("audit_orchestrator", 6), ("scheduler_orchestrator", 4)],
-                [("audit_orchestrator", 3), ("scheduler_orchestrator", 2)],
-            ],
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_scheduler_status)()
-
-        assert result["schedules"]["total"] == 10
-        assert result["schedules"]["paused"] == 3
-        assert result["schedules"]["active"] == 7
-        assert result["schedules"]["by_orchestrator"]["audit_orchestrator"] == 6
-        assert result["aliases"]["total"] == 5
-        assert result["aliases"]["by_orchestrator"]["scheduler_orchestrator"] == 2
-        assert result["chains"]["total"] == 2
-
-    async def test_session_closed_even_on_exception(self) -> None:
-        """If a query raises, session.close() still runs (try/finally)."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.scalar.side_effect = RuntimeError("boom")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ), pytest.raises(RuntimeError, match="boom"):
-            await _unwrap(mod._collect_scheduler_status)()
-
-        session.close.assert_called_once()
-
-
-# ── Tests: _collect_event_bus_metrics ─────────────────────────────────────────
-
-
-class TestCollectEventBusMetrics:
-    """_collect_event_bus_metrics() summarizes outbox + subscription state."""
-
-    async def test_returns_zero_outbox_with_no_latest_event(self) -> None:
-        """No outbox rows + no subscriptions → outbox_24h=0, latest_event_at=None."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        # Order: outbox_24h, total_subs, latest_event (None).
-        session = _make_session_mock(
-            scalar_returns=[0, 0, None],
-            execute_returns=[[]],
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_event_bus_metrics)()
-
-        assert result == {
-            "outbox_24h": 0,
-            "subscriptions": {"total": 0, "by_topic": {}},
-            "latest_event_at": None,
-        }
-        session.close.assert_called_once()
-
-    async def test_serializes_latest_event_timestamp(self) -> None:
-        """latest_event_at returns an ISO8601 string when a row exists."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        latest_dt = datetime(2026, 4, 26, 10, 30, 0, tzinfo=UTC)
-        session = _make_session_mock(
-            scalar_returns=[42, 7, latest_dt],
-            execute_returns=[[("audit.*", 4), ("schedule.*", 3)]],
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_event_bus_metrics)()
-
-        assert result["outbox_24h"] == 42
-        assert result["subscriptions"]["total"] == 7
-        assert result["subscriptions"]["by_topic"]["audit.*"] == 4
-        assert result["latest_event_at"] == latest_dt.isoformat()
-
-    async def test_session_closed_even_on_exception(self) -> None:
-        """try/finally guarantees session.close() under exception."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.scalar.side_effect = RuntimeError("evt boom")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ), pytest.raises(RuntimeError, match="evt boom"):
-            await _unwrap(mod._collect_event_bus_metrics)()
-
-        session.close.assert_called_once()
-
-
-# ── Tests: _collect_queue_metrics ─────────────────────────────────────────────
-
-
-class TestCollectQueueMetrics:
-    """_collect_queue_metrics() reads dbos.workflow_status counts + 24h totals."""
-
-    async def test_extracts_enqueued_and_pending_from_status_counts(self) -> None:
-        """status_counts dict populates ENQUEUED/PENDING depth; 24h scalars used."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = _make_session_mock(
-            scalar_returns=[100, 5],  # success_24h, error_24h
-            execute_returns=[
-                [("ENQUEUED", 12), ("PENDING", 30), ("SUCCESS", 800), ("ERROR", 5)],
-            ],
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_queue_metrics)()
-
-        assert result["enqueued_depth"] == 12
-        assert result["pending_depth"] == 30
-        assert result["success_24h"] == 100
-        assert result["error_24h"] == 5
-        assert result["workflows_by_status"]["SUCCESS"] == 800
-
-    async def test_defaults_missing_status_keys_to_zero(self) -> None:
-        """When ENQUEUED / PENDING are absent from status_counts, depth=0."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = _make_session_mock(
-            scalar_returns=[0, 0],
-            execute_returns=[[("SUCCESS", 1)]],  # no ENQUEUED, no PENDING
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._collect_queue_metrics)()
-
-        assert result["enqueued_depth"] == 0
-        assert result["pending_depth"] == 0
-
-    async def test_since_ms_bound_parameter_is_int_not_datetime(self) -> None:
-        """since_ms bound to scalar() calls must be int (epoch-ms), not datetime.
-
-        Postgres column dbos.workflow_status.updated_at is bigint (epoch-ms).
-        Binding a datetime raises:
-            ERROR: operator does not exist: bigint >= timestamp with time zone
-        This test guards against regressions to the pre-fix datetime binding.
-        """
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        bound_params: list[dict] = []
-
-        def _capture_scalar(sql, params=None):
-            if params is not None:
-                bound_params.append(dict(params))
-            return 0
-
-        session = MagicMock()
-        # execute() for the GROUP BY status query
-        execute_stub = MagicMock()
-        execute_stub.all.return_value = []
-        session.execute.return_value = execute_stub
-        session.scalar.side_effect = _capture_scalar
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ):
-            await _unwrap(mod._collect_queue_metrics)()
-
-        # scalar() is called twice: success_24h and error_24h
-        assert len(bound_params) == 2, f"Expected 2 scalar calls, got {len(bound_params)}"
-        for call_params in bound_params:
-            since_value = call_params.get("since_ms")
-            assert since_value is not None, "Expected 'since_ms' key in bound params"
-            assert isinstance(since_value, int), (
-                f"since_ms must be int (epoch-ms), got {type(since_value).__name__}: {since_value!r}"
-            )
-            # Sanity: value should be a plausible epoch-ms (after year 2020)
-            assert since_value > 1_577_836_800_000, (
-                f"since_ms {since_value} is too small to be a valid epoch-ms timestamp"
-            )
-
-    async def test_session_closed_even_on_exception(self) -> None:
-        """try/finally guarantees close() in queue-metrics path."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.execute.side_effect = RuntimeError("queue boom")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.registry._make_session",
-            return_value=session,
-        ), pytest.raises(RuntimeError, match="queue boom"):
-            await _unwrap(mod._collect_queue_metrics)()
-
-        session.close.assert_called_once()
-
-
-# ── Tests: _generate_and_write_report ─────────────────────────────────────────
-
-
-def _baseline_data() -> tuple[dict, dict, dict, dict]:
-    """Return (git, scheduler, event, queue) data with no anomalies."""
-    git_data = {
-        "repos": {
-            "WHO-project/vds-scripts": {
-                "commits": 4,
-                "authors": ["alice", "bob"],
-                "branches_changed": ["main"],
-                "merge_commits": 1,
-            },
-        },
-        "since": "2026-04-25T00:00:00+00:00",
-    }
-    scheduler_data = {
-        "schedules": {
-            "total": 8,
-            "paused": 1,
-            "active": 7,
-            "by_orchestrator": {"audit_orchestrator": 4, "scheduler_orchestrator": 4},
-        },
-        "aliases": {
-            "total": 5,
-            "by_orchestrator": {"audit_orchestrator": 3},
-        },
-        "chains": {"total": 2},
-    }
-    event_data = {
-        "outbox_24h": 25,
-        "subscriptions": {"total": 3, "by_topic": {"audit.*": 2, "schedule.*": 1}},
-        "latest_event_at": "2026-04-26T05:00:00+00:00",
-    }
-    queue_data = {
-        "workflows_by_status": {"SUCCESS": 100, "ENQUEUED": 2, "PENDING": 1},
-        "enqueued_depth": 2,
-        "pending_depth": 1,
-        "success_24h": 100,
-        "error_24h": 1,
-    }
-    return git_data, scheduler_data, event_data, queue_data
-
-
-class TestGenerateAndWriteReport:
-    """_generate_and_write_report() renders Markdown + applies anomaly heuristics."""
-
-    async def test_writes_report_with_no_anomalies(self, tmp_path) -> None:
-        """Healthy data → file written, anomalies list empty, ✅ marker present."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert result["anomalies"] == []
-        report_files = list(tmp_path.iterdir())
-        assert len(report_files) == 1
-        text = report_files[0].read_text(encoding="utf-8")
-        assert "Ecosystem Daily Report" in text
-        assert "No anomalies detected" in text
-        assert "WHO-project/vds-scripts" in text
-        assert "audit_orchestrator" in text
-        assert "Chain Definitions: 2" in text
-
-    async def test_flags_high_error_count_anomaly(self, tmp_path) -> None:
-        """error_24h > 10 → 'High error count' anomaly recorded."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        q_data["error_24h"] = 25
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert any("High error count" in a for a in result["anomalies"])
-
-    async def test_flags_queue_backlog_anomaly(self, tmp_path) -> None:
-        """pending_depth > 50 → 'Queue backlog' anomaly recorded."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        q_data["pending_depth"] = 75
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert any("Queue backlog" in a for a in result["anomalies"])
-
-    async def test_flags_zero_outbox_with_active_schedules(self, tmp_path) -> None:
-        """outbox_24h=0 AND schedules.total>0 → 'Zero events' anomaly."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        evt_data["outbox_24h"] = 0
-        # schedules.total stays at 8 from baseline → triggers anomaly.
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert any("Zero events" in a for a in result["anomalies"])
-
-    async def test_flags_high_commit_volume_per_repo(self, tmp_path) -> None:
-        """A repo with > 50 commits surfaces 'High commit volume' anomaly."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        git_data["repos"]["WHO-project/vds-scripts"]["commits"] = 99
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert any("High commit volume" in a for a in result["anomalies"])
-
-    async def test_anomaly_section_lists_warning_marker(self, tmp_path) -> None:
-        """When anomalies exist, the markdown body includes the ⚠️ marker."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        q_data["error_24h"] = 100  # force anomaly
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        text = (tmp_path / list(tmp_path.iterdir())[0].name).read_text(encoding="utf-8")
-        assert "Anomalies Detected" in text
-        assert result["anomalies"]
-
-    async def test_handles_empty_authors_and_branches(self, tmp_path) -> None:
-        """Empty authors/branches lists render an em-dash placeholder safely."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        git_data["repos"]["WHO-project/vds-scripts"]["authors"] = []
-        git_data["repos"]["WHO-project/vds-scripts"]["branches_changed"] = []
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        text = (tmp_path / list(tmp_path.iterdir())[0].name).read_text(encoding="utf-8")
-        assert "Authors: —" in text
-        assert "Branches: —" in text
-
-    async def test_handles_missing_latest_event_at(self, tmp_path) -> None:
-        """latest_event_at=None renders as em-dash placeholder."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        evt_data["latest_event_at"] = None
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        text = (tmp_path / list(tmp_path.iterdir())[0].name).read_text(encoding="utf-8")
-        assert "Latest event: —" in text
-
-    async def test_returns_report_path_string(self, tmp_path) -> None:
-        """report_path in result is a str, ends with -ecosystem-report.md."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        cfg = _make_test_config(tmp_path=tmp_path)
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(git_data, sched_data, evt_data, q_data)
-
-        assert isinstance(result["report_path"], str)
-        assert result["report_path"].endswith("-ecosystem-report.md")
-
-
-# ── Tests: bootstrap_ecosystem_report_schedule ────────────────────────────────
-
-
-class TestBootstrapEcosystemReportSchedule:
-    """bootstrap_ecosystem_report_schedule() registers alias + schedule idempotently."""
-
-    def _patches(
-        self,
-        mock_register: MagicMock,
-        mock_create: MagicMock,
-        mock_cfg: MagicMock | None = None,
-    ):
-        """Build the patch context manager stack used by every bootstrap test.
-
-        The bootstrap function imports get_config, register_workflows, and
-        create at module top, so the patch targets are the local module names.
-        """
-        if mock_cfg is None:
-            mock_cfg = MagicMock(dbos_app_version="test-1.0")
-        return (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.get_config",
-                return_value=mock_cfg,
-            ),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.register_workflows",
-                mock_register,
-            ),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.create_schedule",
-                mock_create,
-            ),
-        )
-
-    def test_registers_workflow_alias(self) -> None:
-        """register_workflows is called with the ecosystem.daily.report alias."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            bootstrap_ecosystem_report_schedule,
-        )
-
-        mock_register = MagicMock()
-        mock_create = MagicMock()
-        with (
-            (p1 := self._patches(mock_register, mock_create)[0]),
-            (p2 := self._patches(mock_register, mock_create)[1]),
-            (p3 := self._patches(mock_register, mock_create)[2]),
-        ):
-            _ = (p1, p2, p3)
-            bootstrap_ecosystem_report_schedule()
-
-        registrations: dict[str, str] = mock_register.call_args.args[0]
-        assert "ecosystem.daily.report" in registrations
-        fqn = registrations["ecosystem.daily.report"]
-        assert "ecosystem_daily_report_workflow" in fqn
-
-    def test_creates_schedule_with_correct_cron_and_queue(self) -> None:
-        """create_schedule is called with cron='0 6 * * *' and queue='ops-default'."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            bootstrap_ecosystem_report_schedule,
-        )
-
-        mock_register = MagicMock()
-        mock_create = MagicMock()
-        patches = self._patches(mock_register, mock_create)
-        with patches[0], patches[1], patches[2]:
-            bootstrap_ecosystem_report_schedule()
-
-        kwargs = mock_create.call_args.kwargs
-        args = mock_create.call_args.args
-        assert args[0] == "ecosystem-daily-report"
-        assert kwargs["cron_expr"] == "0 6 * * *"
-        assert kwargs["queue_name"] == "ops-default"
-        assert kwargs["workflow_alias"] == "ecosystem.daily.report"
-        assert kwargs["owner_orchestrator"] == "scheduler_orchestrator"
-
-    def test_idempotent_on_duplicate_alias(self) -> None:
-        """DuplicateAliasError from register_workflows is silenced."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            bootstrap_ecosystem_report_schedule,
-        )
-        from vds_scheduler_orchestrator.workflows.registry import DuplicateAliasError
-
-        mock_register = MagicMock(side_effect=DuplicateAliasError("ecosystem.daily.report"))
-        mock_create = MagicMock()
-        patches = self._patches(mock_register, mock_create)
-        with patches[0], patches[1], patches[2]:
-            # MUST NOT raise — and must still proceed to create_schedule.
-            bootstrap_ecosystem_report_schedule()
-
-        mock_create.assert_called_once()
-
-    def test_idempotent_on_duplicate_schedule(self) -> None:
-        """DuplicateScheduleError from create is silenced."""
-        from vds_scheduler_orchestrator.scheduler.schedules import (
-            DuplicateScheduleError,
-        )
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            bootstrap_ecosystem_report_schedule,
-        )
-
-        mock_register = MagicMock()
-        mock_create = MagicMock(side_effect=DuplicateScheduleError("ecosystem-daily-report"))
-        patches = self._patches(mock_register, mock_create)
-        with patches[0], patches[1], patches[2]:
-            # MUST NOT raise.
-            bootstrap_ecosystem_report_schedule()
-
-        mock_register.assert_called_once()
-        mock_create.assert_called_once()
-
-    def test_passes_dbos_app_version_to_register(self) -> None:
-        """register_workflows is given the version from get_config()."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            bootstrap_ecosystem_report_schedule,
-        )
-
-        mock_register = MagicMock()
-        mock_create = MagicMock()
-        cfg = MagicMock(dbos_app_version="v9.9.9")
-        patches = self._patches(mock_register, mock_create, mock_cfg=cfg)
-        with patches[0], patches[1], patches[2]:
-            bootstrap_ecosystem_report_schedule()
-
-        kwargs = mock_register.call_args.kwargs
-        assert kwargs.get("version") == "v9.9.9"
-        assert kwargs.get("orchestrator") == "scheduler_orchestrator"
-
-
-# ── Tests: _persist_report_run (TSK-2.6) ─────────────────────────────────────
-
-
-def _persist_call_kwargs() -> dict[str, Any]:
-    """Standard kwargs for calling _persist_report_run in tests."""
-    return {
-        "report_date": date(2026, 4, 27),
-        "report_path": "reports/ecosystem/2026-04-27-ecosystem-report.md",
-        "anomalies": ["High error rate"],
-        "git_data": {"repos": {}},
-        "scheduler_data": {"schedules": {"total": 5}},
-        "event_data": {"outbox_24h": 10},
-        "queue_data": {"error_24h": 3, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1},
-    }
-
-
-class TestPersistReportRun:
-    """_persist_report_run() upserts a row in sched.ecosystem_report_runs."""
-
-    async def test_inserts_new_row_when_no_existing(self) -> None:
-        """No existing row for report_date → session.add() called, commit() called."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None  # no existing row
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        session.add.assert_called_once()
-        session.flush.assert_called_once()
-        session.commit.assert_called_once()
-        session.close.assert_called_once()
-
-    async def test_updates_existing_row(self) -> None:
-        """Existing row for report_date → fields updated in-place, no session.add()."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        existing = MagicMock()
-        existing.id = "run-existing-123"
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = existing
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        # Should NOT add a new row — update in place.
-        session.add.assert_not_called()
-        session.commit.assert_called_once()
-        # Verify fields were updated on the existing object.
-        assert existing.report_path == "reports/ecosystem/2026-04-27-ecosystem-report.md"
-        assert existing.anomalies == ["High error rate"]
-        assert existing.error_24h == 3
-        assert existing.success_24h == 90
-        assert existing.pending_depth == 2
-        assert existing.enqueued_depth == 1
-        assert result == "run-existing-123"
-
-    async def test_returns_run_id(self) -> None:
-        """Return value is the run id (string) from the new row."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None
-
-        # After session.add + flush, run.id is populated by the ORM.
-        # We simulate this by patching EcosystemReportRun so the constructed
-        # instance has a known id after flush.
-        fake_run = MagicMock()
-        fake_run.id = "new-run-456"
-
-        with (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-                return_value=session,
-            ),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.EcosystemReportRun",
-                return_value=fake_run,
-            ),
-        ):
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        assert result == "new-run-456"
-        assert isinstance(result, str)
-
-    async def test_session_closed_on_exception(self) -> None:
-        """If a query raises, session.close() is still called (try/finally)."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.query.side_effect = RuntimeError("db gone")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ), pytest.raises(RuntimeError, match="db gone"):
-            await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        session.close.assert_called_once()
-
-    async def test_handles_undefined_column_gracefully(self) -> None:
-        """Phase 3 columns missing from live DB → SQLAlchemyError caught,
-        rollback called, ``None`` returned, no exception propagated."""
-        from sqlalchemy.exc import ProgrammingError
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        # Simulate ``psycopg2.errors.UndefinedColumn`` wrapped by SQLAlchemy.
-        # ``ProgrammingError`` is the concrete SQLAlchemyError subclass that
-        # carries DDL-class server errors like UndefinedColumn.
-        underlying = Exception('column "dora_summary" of relation "ecosystem_report_runs" does not exist')
-        session.query.side_effect = ProgrammingError(
-            statement="INSERT INTO sched.ecosystem_report_runs ...",
-            params={},
-            orig=underlying,
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            # MUST NOT raise — graceful degradation.
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        # Returned None because persistence was skipped on schema drift.
-        assert result is None
-        # Rolled back the doomed transaction.
-        session.rollback.assert_called_once()
-        # session.close() still called via finally.
-        session.close.assert_called_once()
-        # session.commit() NOT called — we bailed before commit.
-        session.commit.assert_not_called()
-
-    async def test_handles_sqlalchemy_error_on_insert(self) -> None:
-        """SQLAlchemyError raised from session.add()/flush() path is also
-        caught — covers the INSERT branch when no existing row matches."""
-        from sqlalchemy.exc import OperationalError
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None  # take INSERT branch
-        # flush() raises (e.g. constraint check or schema mismatch on insert).
-        session.flush.side_effect = OperationalError(
-            statement="INSERT ...",
-            params={},
-            orig=Exception("relation does not exist"),
-        )
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        assert result is None
-        session.rollback.assert_called_once()
-        session.close.assert_called_once()
-
-    async def test_rollback_failure_swallowed(self) -> None:
-        """Rollback itself failing must not raise — defensive double-guard."""
-        from sqlalchemy.exc import ProgrammingError, SQLAlchemyError
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.query.side_effect = ProgrammingError(
-            statement="SELECT ...",
-            params={},
-            orig=Exception("schema drift"),
-        )
-        # Rollback also fails (torn connection, dead session, etc.)
-        session.rollback.side_effect = SQLAlchemyError("connection lost")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            # Still must not raise to caller.
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        assert result is None
-        session.close.assert_called_once()
-
-    async def test_succeeds_when_all_columns_present(self) -> None:
-        """Regression guard: when no schema drift, persistence works normally
-        and returns the run id (no SQLAlchemyError path triggered)."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None
-
-        fake_run = MagicMock()
-        fake_run.id = "happy-path-id"
-
-        with (
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-                return_value=session,
-            ),
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report.EcosystemReportRun",
-                return_value=fake_run,
-            ),
-        ):
-            result = await _unwrap(mod._persist_report_run)(**_persist_call_kwargs())
-
-        assert result == "happy-path-id"
-        session.add.assert_called_once()
-        session.flush.assert_called_once()
-        session.commit.assert_called_once()
-        session.rollback.assert_not_called()
-        session.close.assert_called_once()
-
-
-# ── Tests: _publish_completion_event (TSK-2.7) ───────────────────────────────
-
-
-class TestPublishCompletionEvent:
-    """_publish_completion_event() publishes ecosystem.daily.completed to the event bus."""
-
-    def _call_kwargs(self) -> dict[str, Any]:
-        return {
-            "report_date": date(2026, 4, 27),
-            "report_path": "reports/ecosystem/2026-04-27-ecosystem-report.md",
-            "anomaly_count": 2,
-            "error_24h": 3,
-            "success_24h": 90,
-            "health_score": 87,
-            "workflow_id": "wf-2026-04-27-abc123",
-        }
-
-    async def test_publishes_correct_topic(self) -> None:
-        """bus.publish is called with topic='ecosystem.daily.completed'."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        mock_publish.assert_called_once()
-        assert mock_publish.call_args.kwargs.get("topic") == "ecosystem.daily.completed"
-
-    async def test_publishes_correct_payload_shape(self) -> None:
-        """Payload contains report_date, report_path, anomaly_count, error_24h,
-        success_24h, health_score, workflow_id, exec_summary (FR-2.3)."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        payload = mock_publish.call_args.kwargs["payload"]
-        assert payload == {
-            "report_date": "2026-04-27",
-            "report_path": "reports/ecosystem/2026-04-27-ecosystem-report.md",
-            "anomaly_count": 2,
-            "error_24h": 3,
-            "success_24h": 90,
-            "health_score": 87,
-            "workflow_id": "wf-2026-04-27-abc123",
-            "exec_summary": "",
-        }
-
-    async def test_passes_trace_id(self) -> None:
-        """trace_id kwarg is passed as 'edr-{report_date}'."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        assert mock_publish.call_args.kwargs["trace_id"] == "edr-2026-04-27"
-
-    # ── Wave 8 Lane Upsilon Fix 1 — FR-2.3 payload completeness ──────────────
-
-    async def test_payload_contains_health_score_as_int(self) -> None:
-        """FR-2.3: payload['health_score'] is the integer 0–100 health score."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        payload = mock_publish.call_args.kwargs["payload"]
-        assert "health_score" in payload, "FR-2.3: payload must include health_score"
-        assert isinstance(payload["health_score"], int)
-        assert payload["health_score"] == 87
-
-    async def test_payload_contains_workflow_id_as_str(self) -> None:
-        """FR-2.3: payload['workflow_id'] is a string carrying the DBOS workflow id."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        payload = mock_publish.call_args.kwargs["payload"]
-        assert "workflow_id" in payload, "FR-2.3: payload must include workflow_id"
-        assert isinstance(payload["workflow_id"], str)
-        assert payload["workflow_id"] == "wf-2026-04-27-abc123"
-
-    async def test_payload_preserves_previously_required_keys(self) -> None:
-        """FR-2.3: pre-existing payload keys remain present alongside the new fields."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_completion_event)(**self._call_kwargs())
-
-        payload = mock_publish.call_args.kwargs["payload"]
-        for required in (
-            "report_date",
-            "report_path",
-            "anomaly_count",
-            "error_24h",
-            "success_24h",
-            "exec_summary",
-        ):
-            assert required in payload, f"payload missing pre-existing key: {required}"
-
-
-# ── Tests: _load_previous_run (TSK-3.6) ──────────────────────────────────────
-
-
-class TestLoadPreviousRun:
-    """_load_previous_run() queries yesterday's ecosystem_report_runs row."""
-
-    async def test_returns_none_when_no_prior_run(self) -> None:
-        """No row for yesterday → returns None."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._load_previous_run)(report_date=date(2026, 4, 27))
-
-        assert result is None
-        session.close.assert_called_once()
-
-    async def test_returns_dict_when_prior_run_exists(self) -> None:
-        """Existing row → returns dict with expected keys."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        row = MagicMock()
-        row.report_date = date(2026, 4, 26)
-        row.error_24h = 3
-        row.success_24h = 90
-        row.pending_depth = 2
-        row.enqueued_depth = 1
-        row.anomalies = ["High error count"]
-        row.git_summary = {"repos": {}}
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = row
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            result = await _unwrap(mod._load_previous_run)(report_date=date(2026, 4, 27))
-
-        assert result is not None
-        assert result["report_date"] == "2026-04-26"
-        assert result["error_24h"] == 3
-        assert result["success_24h"] == 90
-        assert result["pending_depth"] == 2
-        assert result["enqueued_depth"] == 1
-        assert result["anomalies"] == ["High error count"]
-        assert result["git_summary"] == {"repos": {}}
-        session.close.assert_called_once()
-
-    async def test_session_closed_on_exception(self) -> None:
-        """session.close() called even when query raises."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        session = MagicMock()
-        session.query.side_effect = RuntimeError("db down")
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ), pytest.raises(RuntimeError, match="db down"):
-            await _unwrap(mod._load_previous_run)(report_date=date(2026, 4, 27))
-
-        session.close.assert_called_once()
-
-
-# ── Tests: _compute_deltas (TSK-3.6) ─────────────────────────────────────────
-
-
-class TestComputeDeltas:
-    """_compute_deltas() computes day-over-day deltas with bucketing."""
-
-    def test_returns_none_when_no_previous(self) -> None:
-        """previous=None → returns None."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        result = _compute_deltas({"error_24h": 5, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}, None)
-        assert result is None
-
-    def test_computes_positive_deltas(self) -> None:
-        """error goes 2→5 → delta=3, arrow='↑'."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 5, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 2, "success_24h": 85, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["error"]["delta"] == 3
-        assert result["error"]["arrow"] == "↑"
-
-    def test_computes_negative_deltas(self) -> None:
-        """error goes 10→3 → delta=-7, arrow='↓', bucket='improvement' (lower is better)."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 3, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 10, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["error"]["delta"] == -7
-        assert result["error"]["arrow"] == "↓"
-        assert result["error"]["bucket"] == "improvement"
-
-    def test_zero_delta_is_noise(self) -> None:
-        """Same values → arrow='→', bucket='noise'."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 5, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 5, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["error"]["arrow"] == "→"
-        assert result["error"]["bucket"] == "noise"
-        assert result["success"]["arrow"] == "→"
-        assert result["success"]["bucket"] == "noise"
-
-    def test_critical_bucket_at_minus_15(self) -> None:
-        """success delta of -15 (higher is better) → bucket='critical'."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 0, "success_24h": 75, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 0, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["success"]["delta"] == -15
-        assert result["success"]["bucket"] == "critical"
-
-    def test_lower_is_better_polarity(self) -> None:
-        """error goes 20→2 (delta=-18): lower is better → bucket='major' (big improvement)."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 2, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 20, "success_24h": 90, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["error"]["delta"] == -18
-        assert result["error"]["bucket"] == "major"
-
-    def test_higher_is_better_polarity(self) -> None:
-        """success goes 100→120 (delta=+20): higher is better → bucket='major'."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import _compute_deltas
-
-        current = {"error_24h": 0, "success_24h": 120, "pending_depth": 2, "enqueued_depth": 1}
-        previous = {"error_24h": 0, "success_24h": 100, "pending_depth": 2, "enqueued_depth": 1}
-        result = _compute_deltas(current, previous)
-
-        assert result is not None
-        assert result["success"]["delta"] == 20
-        assert result["success"]["bucket"] == "major"
-
-
-# ── Tests: _generate_and_write_report with deltas (TSK-3.6) ──────────────────
-
-
-class TestReportWithDeltas:
-    """_generate_and_write_report renders Day-over-Day Delta section conditionally."""
-
-    def _sample_data(self) -> tuple[dict, dict, dict, dict]:
-        git_data: dict[str, Any] = {
-            "repos": {
-                "WHO-project/vds-scripts": {
-                    "commits": 5,
-                    "merge_commits": 1,
-                    "authors": ["alice"],
-                    "branches_changed": ["main"],
-                }
-            }
-        }
-        scheduler_data: dict[str, Any] = {
-            "schedules": {"total": 10, "paused": 2, "active": 8, "by_orchestrator": {"scheduler_orchestrator": 10}},
-            "aliases": {"total": 5, "by_orchestrator": {"scheduler_orchestrator": 5}},
-            "chains": {"total": 2},
-        }
-        event_data: dict[str, Any] = {
-            "outbox_24h": 42,
-            "subscriptions": {"total": 7, "by_topic": {"audit.*": 4, "schedule.*": 3}},
-            "latest_event_at": "2026-04-27T06:00:00+00:00",
-        }
-        queue_data: dict[str, Any] = {
-            "error_24h": 5,
-            "success_24h": 90,
-            "pending_depth": 3,
-            "enqueued_depth": 1,
-            "workflows_by_status": {"SUCCESS": 90, "ERROR": 5, "PENDING": 3, "ENQUEUED": 1},
-        }
-        return git_data, scheduler_data, event_data, queue_data
-
-    async def test_report_includes_delta_section_when_deltas_present(self, tmp_path: Path) -> None:
-        """When deltas are provided, 'Day-over-Day Delta' appears in the report."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, scheduler_data, event_data, queue_data = self._sample_data()
-        deltas = {
-            "error": {"delta": 3, "arrow": "↑", "bucket": "noise"},
-            "success": {"delta": 5, "arrow": "↑", "bucket": "improvement"},
-            "pending": {"delta": -1, "arrow": "↓", "bucket": "noise"},
-            "enqueued": {"delta": 0, "arrow": "→", "bucket": "noise"},
-        }
-
-        cfg = _make_test_config(tmp_path=tmp_path)
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(
-                git_data,
-                scheduler_data,
-                event_data,
-                queue_data,
-                deltas=deltas,
-            )
-
-        report_content = Path(result["report_path"]).read_text()
-        assert "Day-over-Day Delta" in report_content
-
-    async def test_report_omits_delta_section_when_no_deltas(self, tmp_path: Path) -> None:
-        """When deltas=None, 'Day-over-Day Delta' does NOT appear in the report."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        git_data, scheduler_data, event_data, queue_data = self._sample_data()
-
-        cfg = _make_test_config(tmp_path=tmp_path)
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report.get_ecosystem_config",
-            return_value=cfg,
-        ):
-            result = await _unwrap(mod._generate_and_write_report)(
-                git_data,
-                scheduler_data,
-                event_data,
-                queue_data,
-                deltas=None,
-            )
-
-        report_content = Path(result["report_path"]).read_text()
-        assert "Day-over-Day Delta" not in report_content
-
-
-# ── Tests: _publish_failure_event (TSK-3.7) ──────────────────────────────────
-
-
-class TestPublishFailureEvent:
-    """_publish_failure_event() publishes ecosystem.daily.failed to the event bus."""
-
-    async def test_publishes_failure_topic(self) -> None:
-        """bus.publish is called with topic='ecosystem.daily.failed'."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_failure_event)(error_msg="something broke", report_date=date(2026, 4, 27))
-
-        mock_publish.assert_called_once()
-        assert mock_publish.call_args.kwargs.get("topic") == "ecosystem.daily.failed"
-
-    async def test_includes_error_in_payload(self) -> None:
-        """Payload contains the error message string."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        mock_publish = AsyncMock()
-
-        with patch("vds_scheduler_orchestrator.events.bus.publish", mock_publish):
-            await _unwrap(mod._publish_failure_event)(error_msg="db timeout", report_date=date(2026, 4, 27))
-
-        payload = mock_publish.call_args.kwargs["payload"]
-        assert payload["error"] == "db timeout"
-        assert payload["report_date"] == "2026-04-27"
-
-
-# ── Tests: check_missed_run (TSK-3.7) ────────────────────────────────────────
-
-
-class TestCheckMissedRun:
-    """check_missed_run() detects whether today's report is overdue."""
-
-    def test_not_missed_before_grace_period(self) -> None:
-        """Before expected_hour + grace → missed=False, no DB query."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import check_missed_run
-
-        early_morning = datetime(2026, 4, 27, 5, 0, 0, tzinfo=UTC)
-
-        with patch("vds_scheduler_orchestrator.workflows.ecosystem_report.datetime") as mock_dt:
-            mock_dt.now.return_value = early_morning
-            mock_dt.side_effect = lambda *a, **kw: datetime(*a, **kw)
-            result = check_missed_run(expected_hour=6, grace_minutes=30)
-
-        assert result["missed"] is False
-
-    def test_missed_after_grace_period_with_no_row(self) -> None:
-        """After grace period with no DB row → missed=True."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import check_missed_run
-
-        test_date = date(2026, 4, 27)
-        late_morning = datetime(2026, 4, 27, 7, 0, 0, tzinfo=UTC)
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = None
-
-        with (
-            patch("vds_scheduler_orchestrator.workflows.ecosystem_report.datetime") as mock_dt,
-            patch("vds_scheduler_orchestrator.workflows.ecosystem_report.date") as mock_date,
-            patch(
-                "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-                return_value=session,
-            ),
-        ):
-            mock_dt.now.return_value = late_morning
-            mock_dt.side_effect = lambda *a, **kw: datetime(*a, **kw)
-            mock_date.today.return_value = test_date
-            result = check_missed_run(expected_hour=6, grace_minutes=30)
-
-        assert result["missed"] is True
-        session.close.assert_called_once()
-
-
-# ── Tests: Progressive Disclosure formatters (TSK-3.7) ────────────────────────
-
-
-class TestProgressiveDisclosure:
-    """format_exec_summary and format_summary respect line-count contracts."""
-
-    def _sample_args(self) -> dict[str, Any]:
-        return {
-            "report_date": date(2026, 4, 27),
-            "queue_data": {"error_24h": 5, "success_24h": 90, "pending_depth": 3, "enqueued_depth": 1},
-            "scheduler_data": {"schedules": {"active": 8, "paused": 2, "total": 10, "by_orchestrator": {}}},
-            "event_data": {"outbox_24h": 42, "subscriptions": {"total": 7, "by_topic": {}}, "latest_event_at": None},
-            "anomalies": ["High error count: 5 workflows failed in last 24h", "Queue backlog: 50 PENDING workflows"],
-        }
-
-    def test_exec_summary_within_20_lines(self) -> None:
-        """format_exec_summary output is ≤ 20 lines."""
-        from vds_scheduler_orchestrator.workflows.report_formatter import format_exec_summary
-
-        args = self._sample_args()
-        output = format_exec_summary(**args)
-        line_count = len(output.strip().split("\n"))
-        assert line_count <= 20, f"exec summary has {line_count} lines, expected ≤ 20"
-
-    def test_summary_within_80_lines(self) -> None:
-        """format_summary output is ≤ 80 lines."""
-        from vds_scheduler_orchestrator.workflows.report_formatter import format_summary
-
-        args = self._sample_args()
-        args["git_data"] = {
-            "repos": {
-                "WHO-project/vds-scripts": {
-                    "commits": 5,
-                    "authors": ["alice", "bob"],
-                    "merge_commits": 1,
-                    "branches_changed": ["main"],
-                }
-            }
-        }
-        output = format_summary(**args)
-        line_count = len(output.strip().split("\n"))
-        assert line_count <= 80, f"summary has {line_count} lines, expected ≤ 80"
-
-    def test_exec_summary_shows_anomalies(self) -> None:
-        """Anomaly text appears in exec summary output."""
-        from vds_scheduler_orchestrator.workflows.report_formatter import format_exec_summary
-
-        args = self._sample_args()
-        output = format_exec_summary(**args)
-        assert "anomalies" in output.lower()
-        assert "High error count" in output
-
-
-# ── Tests: Wave 8 F1 — _aggregate_anomalies + persist alignment ──────────────
-#
-# Bug evidence (Lane Aleph audit, 2026-05-01 02:52 UTC live run):
-#   - sched.ecosystem_report_runs.anomalies JSONB == []  (length 0)
-#   - 2026-05-01-ecosystem-report-v2.md showed "⚠️ Anomalies (7)" with 7 lines
-#
-# Root cause: _persist_report_run was passed report_meta["anomalies"] which
-# is the legacy threshold-based list from _generate_and_write_report (only
-# inspects queue/event/git thresholds — does NOT walk CollectorResult.anomalies).
-# The v2 markdown formatter sources from results via _collect_anomalies(results),
-# so the persisted JSONB and the rendered markdown diverged.
-#
-# Fix: _aggregate_anomalies() in ecosystem_report.py walks results AND legacy
-# threshold list, sanitizes, and is plumbed into _persist_report_run.
-
-
-class TestAggregateAnomalies:
-    """_aggregate_anomalies() merges per-collector anomalies + threshold heuristics
-    so the persisted JSONB column matches what the v2 markdown shows."""
-
-    def _make_result(self, section: str, anomalies: list[str]) -> Any:
-        """Build a CollectorResult stub with the given anomaly list."""
-        from vds_scheduler_orchestrator.workflows.collectors.protocol import (
-            CollectorResult,
-        )
-
-        return CollectorResult(section=section, anomalies=anomalies)
-
-    def test_synthesizes_anomalies_from_three_collectors(self) -> None:
-        """Three collectors each emit anomalies → aggregated list contains all of them."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [
-            self._make_result("Infrastructure Health", ["docker collector failed"]),
-            self._make_result("Memory Health", ["redis collector failed"]),
-            self._make_result("Trend Forecast", ["Trend bootstrap incomplete"]),
-        ]
-
-        agg = _aggregate_anomalies(results, threshold_anomalies=[])
-
-        assert len(agg) == 3
-        assert "docker collector failed" in agg
-        assert "redis collector failed" in agg
-        assert "Trend bootstrap incomplete" in agg
-
-    def test_no_anomalies_returns_empty_list(self) -> None:
-        """All collectors clean + no threshold anomalies → JSONB serializable []."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [
-            self._make_result("Git Activity", []),
-            self._make_result("Queue Metrics", []),
-        ]
-        agg = _aggregate_anomalies(results, threshold_anomalies=[])
-
-        assert agg == []
-        # JSONB serializability — round-trip through json.
-        import json
-
-        assert json.loads(json.dumps(agg)) == []
-
-    def test_anomaly_with_newlines_is_sanitized(self) -> None:
-        """Newlines in anomaly strings are flattened to '; ' before persistence
-        so the JSONB row stays single-line per entry (matches markdown rendering)."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [
-            self._make_result("Test Suite", ["first line\nsecond line\nthird line"]),
-        ]
-        agg = _aggregate_anomalies(results, threshold_anomalies=[])
-
-        assert len(agg) == 1
-        assert "\n" not in agg[0]
-        # sanitize_anomaly() replaces \n with "; ".
-        assert "first line" in agg[0]
-        assert "second line" in agg[0]
-        assert "third line" in agg[0]
-
-    def test_anomaly_ordering_preserved(self) -> None:
-        """Aggregation order: collector order, then within-collector emission order,
-        then legacy threshold anomalies — so operators can scan JSONB top-down
-        and see the same sequence the v2 markdown renders."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [
-            self._make_result("A", ["a1", "a2"]),
-            self._make_result("B", ["b1"]),
-            self._make_result("C", ["c1", "c2", "c3"]),
-        ]
-        threshold = ["threshold-1", "threshold-2"]
-
-        agg = _aggregate_anomalies(results, threshold_anomalies=threshold)
-
-        assert agg == ["a1", "a2", "b1", "c1", "c2", "c3", "threshold-1", "threshold-2"]
-
-    def test_truncates_with_sentinel_when_exceeds_cap(self) -> None:
-        """When the combined list exceeds _MAX_PERSISTED_ANOMALIES, the persisted
-        list ends with a sentinel marker so operators see the truncation
-        without cross-referencing the markdown."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _MAX_PERSISTED_ANOMALIES,
-            _TRUNCATION_SENTINEL_PREFIX,
-            _aggregate_anomalies,
-        )
-
-        # 73 anomalies — comfortably above the 50-cap default.
-        flood = [f"anomaly-{i}" for i in range(73)]
-        results = [self._make_result("Flood", flood)]
-        agg = _aggregate_anomalies(results, threshold_anomalies=[])
-
-        # One slot is consumed by the sentinel, so we still keep at most
-        # _MAX_PERSISTED_ANOMALIES + 1 entries total.
-        assert len(agg) == _MAX_PERSISTED_ANOMALIES + 1
-        assert agg[_MAX_PERSISTED_ANOMALIES].startswith(_TRUNCATION_SENTINEL_PREFIX)
-        # Sentinel records both the kept count and the original total.
-        assert "73" in agg[_MAX_PERSISTED_ANOMALIES]
-
-    def test_threshold_anomalies_appended_after_collector_anomalies(self) -> None:
-        """Legacy threshold heuristics from _generate_and_write_report are
-        preserved as a strict superset — collector anomalies first, threshold
-        last — so persisted JSONB never loses the legacy detections."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [self._make_result("X", ["collector anomaly"])]
-        threshold = ["High error count: 99 workflows failed in last 24h"]
-
-        agg = _aggregate_anomalies(results, threshold_anomalies=threshold)
-
-        assert agg[0] == "collector anomaly"
-        assert "High error count" in agg[1]
-
-    def test_empty_strings_dropped(self) -> None:
-        """sanitize_anomaly('') returns '' — those entries must NOT appear in
-        the persisted list (they would render as empty bullets in markdown
-        and as null-ish entries in JSONB)."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _aggregate_anomalies,
-        )
-
-        results = [self._make_result("X", ["", "real anomaly", ""])]
-        agg = _aggregate_anomalies(results, threshold_anomalies=["", "kept"])
-
-        assert agg == ["real anomaly", "kept"]
-
-
-class TestPersistAggregatedAnomaliesEnd2End:
-    """End-to-end: workflow body computes aggregated anomalies → passes them
-    to _persist_report_run → stored on the row → readback matches.
-
-    This is the regression guard for the original bug: the JSONB column
-    was getting [] while the markdown showed N anomalies."""
-
-    async def test_persist_writes_aggregated_list_to_row(self) -> None:
-        """_persist_report_run with the aggregated list assigns it to row.anomalies."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        existing = MagicMock()
-        existing.id = "run-aggregated-789"
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = existing
-
-        # Caller (workflow body) precomputed the aggregated list — this is
-        # the contract the fix establishes.
-        aggregated = [
-            "docker collector failed",
-            "redis collector failed",
-            "DORA bootstrap incomplete",
-            "Trend bootstrap incomplete",
-            "LLM bootstrap incomplete",
-            "High error count: 12 workflows failed in last 24h",
-            "Queue backlog: 60 PENDING workflows",
-        ]
-
-        kwargs = _persist_call_kwargs()
-        kwargs["anomalies"] = aggregated
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            run_id = await _unwrap(mod._persist_report_run)(**kwargs)
-
-        # Row carries the full aggregated list (length 7), NOT [].
-        assert existing.anomalies == aggregated
-        assert len(existing.anomalies) == 7
-        assert run_id == "run-aggregated-789"
-
-    async def test_persist_with_empty_aggregated_list(self) -> None:
-        """Backward-compat: empty aggregated list still persists as [] (not None)."""
-        from vds_scheduler_orchestrator.workflows import ecosystem_report as mod
-
-        existing = MagicMock()
-        existing.id = "run-empty-aggregated"
-
-        session = MagicMock()
-        query_chain = MagicMock()
-        session.query.return_value = query_chain
-        query_chain.filter_by.return_value = query_chain
-        query_chain.first.return_value = existing
-
-        kwargs = _persist_call_kwargs()
-        kwargs["anomalies"] = []
-
-        with patch(
-            "vds_scheduler_orchestrator.workflows.ecosystem_report._make_session",
-            return_value=session,
-        ):
-            await _unwrap(mod._persist_report_run)(**kwargs)
-
-        assert existing.anomalies == []
-
-
-# ── Tests: Wave 8 Lane Upsilon Fix 2 — single-file output ────────────────────
-#
-# Bug evidence (Lane Aleph audit): each workflow run wrote TWO contradictory
-# markdown files into ``reports/ecosystem/``:
-#   - ``<date>-ecosystem-report.md``     → legacy 50-line short summary
-#                                          ("✅ No anomalies detected")
-#   - ``<date>-ecosystem-report-v2.md``  → 124-line collector-aware full
-#                                          report ("⚠️ Anomalies (7)")
-#
-# Fix: the workflow body now writes ONLY the collector-aware full report and
-# uses the canonical ``<date>-ecosystem-report.md`` filename (no -v2 suffix).
-# The legacy threshold heuristics still feed persistence + the completion
-# event count via ``_compute_legacy_threshold_anomalies`` (extracted helper).
-
-
-class TestSingleFileOutputContract:
-    """Workflow body emits a single canonical markdown per run (FR-1.x cleanup).
-
-    These are structural / source-level checks on the workflow body. The
-    ``@DBOS.workflow`` body itself is not exercised end-to-end in unit tests
-    (see the module docstring: it requires a live DBOS runtime), so we
-    instead assert the contract by inspecting the source text and exercising
-    the helper surfaces it now relies on.
-    """
-
-    def test_workflow_body_no_longer_writes_v2_suffix(self) -> None:
-        """Workflow body must NOT reference the legacy ``-v2.md`` suffix."""
-        import inspect
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report
-
-        src = inspect.getsource(ecosystem_report.ecosystem_daily_report_workflow)
-        assert "-ecosystem-report-v2.md" not in src, (
-            "Workflow body still writes the duplicate v2-suffixed file"
-        )
-        assert "v2_path" not in src, (
-            "Workflow body still constructs a v2_path variable"
-        )
-
-    def test_workflow_body_writes_canonical_filename(self) -> None:
-        """Workflow body emits ``<date>-ecosystem-report.md`` (no v2 suffix)."""
-        import inspect
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report
-
-        src = inspect.getsource(ecosystem_report.ecosystem_daily_report_workflow)
-        # The canonical filename pattern must still be assembled by the body.
-        assert "-ecosystem-report.md" in src
-        # And the body must invoke the full-report formatter (the surviving
-        # writer) rather than fan out to the legacy short-report step.
-        assert "format_adaptive_report" in src
-
-    def test_workflow_body_no_longer_calls_legacy_writer_step(self) -> None:
-        """``_generate_and_write_report`` is no longer invoked from the body.
-
-        It is preserved as a module-level function for back-compat with the
-        TSK-2.x test suite, but the workflow now computes its threshold
-        anomalies through the extracted ``_compute_legacy_threshold_anomalies``
-        helper instead of fan-out to the legacy step.
-        """
-        import inspect
-
-        from vds_scheduler_orchestrator.workflows import ecosystem_report
-
-        src = inspect.getsource(ecosystem_report.ecosystem_daily_report_workflow)
-        assert "_generate_and_write_report(" not in src, (
-            "Workflow body still invokes the legacy short-report writer; "
-            "Fix 2 contract requires it be replaced with the inline "
-            "_compute_legacy_threshold_anomalies helper."
-        )
-        assert "_compute_legacy_threshold_anomalies(" in src
-
-    def test_full_report_writer_produces_one_file_with_canonical_name(self, tmp_path) -> None:
-        """Direct exercise of the ``format_adaptive_report`` writer used by
-        the workflow body: render once, write once, name matches the
-        canonical ``<YYYY-MM-DD>-ecosystem-report.md`` pattern with no
-        ``-v2`` suffix."""
-        from datetime import date as _date
-
-        from vds_scheduler_orchestrator.workflows.report_formatter import (
-            format_adaptive_report,
-        )
-
-        today = _date(2026, 5, 1)
-        report_text = format_adaptive_report([], 100, "full", today, deltas=None)
-
-        # Mirror the exact path-construction the workflow body uses.
-        report_path = tmp_path / f"{today.isoformat()}-ecosystem-report.md"
-        report_path.write_text(report_text, encoding="utf-8")
-
-        files = list(tmp_path.iterdir())
-        # Exactly ONE markdown file per run (regression guard for the
-        # legacy-vs-v2 duplicate).
-        assert len(files) == 1, f"expected one report file, got {[f.name for f in files]}"
-
-        # Filename matches ``<YYYY-MM-DD>-ecosystem-report.md`` with no
-        # ``-v2`` (or any other) suffix.
-        name = files[0].name
-        assert name == "2026-05-01-ecosystem-report.md"
-        assert not name.endswith("-v2.md")
-        assert "-v2" not in name
-
-    def test_compute_legacy_threshold_anomalies_helper_is_pure(self) -> None:
-        """The extracted helper computes the legacy threshold anomalies
-        without any I/O — it is the surface the workflow body now uses
-        instead of the legacy step."""
-        from vds_scheduler_orchestrator.workflows.ecosystem_report import (
-            _compute_legacy_threshold_anomalies,
-        )
-
-        cfg = _make_test_config()
-        git_data, sched_data, evt_data, q_data = _baseline_data()
-        # Force every threshold to fire.
-        q_data["error_24h"] = 999
-        q_data["pending_depth"] = 999
-        evt_data["outbox_24h"] = 0  # combined with sched.total > 0 → trips
-        git_data["repos"]["WHO-project/vds-scripts"]["commits"] = 999
-
-        anomalies = _compute_legacy_threshold_anomalies(
-            git_data, sched_data, evt_data, q_data, cfg
-        )
-
-        # All four legacy heuristics fire — no I/O, no file write.
-        assert any("High error count" in a for a in anomalies)
-        assert any("Queue backlog" in a for a in anomalies)
-        assert any("Zero events" in a for a in anomalies)
-        assert any("High commit volume" in a for a in anomalies)