@ngocsangairvds/vsaf 3.2.16 → 4.0.1

package/tools/vds-scripts/scheduler_orchestrator/src/vds_scheduler_orchestrator/workflows/ecosystem_report.py

@@ -1,1406 +0,0 @@
-"""
-ecosystem_report.py — Daily ecosystem activity report workflow.
-
-Generates a comprehensive daily report analyzing:
-  - Git activity across all orchestrator repos (commits, branches, merges)
-  - Scheduler health (schedules, workflows, queue depths)
-  - Event bus activity (outbox volume, subscription health)
-  - Cross-orchestrator metrics and anomalies
-
-The report is written as a dated Markdown file to the canonical reports
-directory (``reports/ecosystem/YYYY-MM-DD-ecosystem-report.md``).
-
-Schedule
-  alias:    ecosystem.daily.report
-  cron:     0 6 * * *   (06:00 UTC daily)
-  queue:    ops-default  (no LLM cost; DB queries + git + filesystem I/O)
-  overlap:  skip         (skip if previous day's report is still running)
-
-Architecture
-────────────
-  ecosystem_daily_report_workflow(@DBOS.workflow)
-    ├─ _collect_git_activity(@DBOS.step)       → git log --since=yesterday
-    ├─ _collect_scheduler_status(@DBOS.step)   → sched.schedules + dbos.workflow_status
-    ├─ _collect_event_bus_metrics(@DBOS.step)  → sched.events_outbox + subscriptions
-    ├─ _collect_queue_metrics(@DBOS.step)      → dbos.workflow_status ENQUEUED/PENDING counts
-    ├─ _load_previous_run(@DBOS.step)          → sched.ecosystem_report_runs yesterday (TSK-3.1)
-    ├─ _compute_deltas(pure)                   → day-over-day delta bucketing (TSK-3.2)
-    ├─ _generate_and_write_report(@DBOS.step)  → markdown → reports/ecosystem/ (+ delta section TSK-3.3)
-    ├─ format_exec_summary(pure)               → ≤20-line exec summary for notifications (TSK-3.4)
-    ├─ _persist_report_run(@DBOS.step)         → upsert sched.ecosystem_report_runs (TSK-2.3)
-    ├─ _publish_completion_event(@DBOS.step)   → ecosystem.daily.completed event (+ exec_summary) (TSK-2.4)
-    └─ _publish_failure_event(@DBOS.step)      → ecosystem.daily.failed event on error (TSK-3.5)
-
-  check_missed_run(plain function)             → detect missing report past expected hour (TSK-3.5)
-
-Bootstrap
-  Call bootstrap_ecosystem_report_schedule() from app.py lifespan AFTER DBOS.launch().
-  Idempotent — DuplicateScheduleError / DuplicateAliasError silenced.
-
-Acceptance criteria:
-  - Workflow is @DBOS.workflow decorated; each collector is a @DBOS.step.
-  - Report file created at ``reports/ecosystem/YYYY-MM-DD-ecosystem-report.md``.
-  - Report contains: git summary, schedule list, workflow counts by status,
-    event outbox count (24h), queue depth snapshot, anomaly flags.
-  - Safe to re-run (idempotent file write with overwrite).
-"""
-
-from __future__ import annotations
-
-import asyncio
-from datetime import UTC, date, datetime, timedelta
-from typing import Any
-
-import structlog
-from dbos import DBOS
-from sqlalchemy import func, select, text
-from sqlalchemy.exc import SQLAlchemyError
-
-from vds_scheduler_orchestrator.config import get_config, get_ecosystem_config
-from vds_scheduler_orchestrator.db.models import (
-    EcosystemReportRun,
-    EventsOutbox,
-    Schedule,
-    Subscription,
-    WorkflowRegistry,
-)
-from vds_scheduler_orchestrator.scheduler.schedules import (
-    DuplicateScheduleError,
-)
-from vds_scheduler_orchestrator.scheduler.schedules import (
-    create as create_schedule,
-)
-from vds_scheduler_orchestrator.workflows.collectors.protocol import CollectorResult
-from vds_scheduler_orchestrator.workflows.registry import (
-    DuplicateAliasError,
-    _make_session,
-    register_workflows,
-)
-
-logger = structlog.get_logger(__name__)
-
-# ── Constants ─────────────────────────────────────────────────────────────────
-
-_REPORT_ALIAS = "ecosystem.daily.report"
-_REPORT_SCHEDULE_NAME = "ecosystem-daily-report"
-_REPORT_CRON = "0 6 * * *"  # 06:00 UTC daily
-_REPORT_QUEUE = "ops-default"
-
-
-# ── DBOS steps: data collection ───────────────────────────────────────────────
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _collect_git_activity() -> dict[str, Any]:
-    """
-    Collect git activity summary for all tracked repos since 00:00 UTC yesterday.
-
-    Returns:
-        {
-          "repos": {
-            "vds-scripts": {
-              "commits": int,
-              "authors": [str],
-              "branches_changed": [str],
-              "merge_commits": int,
-            },
-            ...
-          },
-          "since": "YYYY-MM-DDT00:00:00+00:00",
-        }
-    """
-    since = (datetime.now(UTC) - timedelta(days=1)).replace(hour=0, minute=0, second=0, microsecond=0)
-    since_iso = since.isoformat()
-
-    cfg = get_ecosystem_config()
-    repos_data: dict[str, Any] = {}
-    base = cfg.monorepo_root
-
-    for repo_rel in cfg.git_repos:
-        repo_path = base / repo_rel
-        if not (repo_path / ".git").exists():
-            logger.warning("git_activity.skip_no_git", repo=str(repo_path))
-            continue
-
-        # Commits since yesterday 00:00 UTC
-        proc_commits = await asyncio.create_subprocess_exec(
-            "git",
-            "-C",
-            str(repo_path),
-            "log",
-            f"--since={since_iso}",
-            "--pretty=format:%H|%an|%s",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        stdout_bytes, _ = await proc_commits.communicate()
-        commits_stdout = stdout_bytes.decode()
-        commits = [line for line in commits_stdout.strip().split("\n") if line]
-
-        authors = sorted({line.split("|")[1] for line in commits if "|" in line})
-        merge_commits = sum(1 for line in commits if line.split("|")[-1].startswith("Merge"))
-        proc_branches = await asyncio.create_subprocess_exec(
-            "git",
-            "-C",
-            str(repo_path),
-            "branch",
-            "-a",
-            "--contains",
-            "HEAD",
-            "--format=%(refname:short)",
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
-        )
-        branches_bytes, _ = await proc_branches.communicate()
-        branches_stdout = branches_bytes.decode()
-        branches = sorted({b for b in branches_stdout.strip().split("\n") if b})
-
-        repos_data[repo_rel] = {
-            "commits": len(commits),
-            "authors": authors,
-            "branches_changed": branches,
-            "merge_commits": merge_commits,
-        }
-
-    return {"repos": repos_data, "since": since_iso}
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _collect_scheduler_status() -> dict[str, Any]:
-    """
-    Collect scheduler domain status from sched.* tables.
-
-    Returns:
-        {
-          "schedules": {"total": int, "paused": int, "active": int, "by_orchestrator": {str: int}},
-          "aliases": {"total": int, "by_orchestrator": {str: int}},
-          "chains": {"total": int},
-        }
-    """
-    from vds_scheduler_orchestrator.db.models import ChainDefinition
-    from vds_scheduler_orchestrator.workflows.registry import _make_session
-
-    session = _make_session()
-    try:
-        total_schedules = session.scalar(select(func.count()).select_from(Schedule)) or 0
-        paused_schedules = (
-            session.scalar(select(func.count()).select_from(Schedule).where(Schedule.paused.is_(True))) or 0
-        )
-        active_schedules = total_schedules - paused_schedules
-
-        orch_counts = dict(
-            session.execute(
-                select(Schedule.owner_orchestrator, func.count()).group_by(Schedule.owner_orchestrator)
-            ).all()
-        )
-
-        total_aliases = session.scalar(select(func.count()).select_from(WorkflowRegistry)) or 0
-        alias_counts = dict(
-            session.execute(
-                select(WorkflowRegistry.owner_orchestrator, func.count()).group_by(WorkflowRegistry.owner_orchestrator)
-            ).all()
-        )
-
-        total_chains = session.scalar(select(func.count()).select_from(ChainDefinition)) or 0
-
-        return {
-            "schedules": {
-                "total": total_schedules,
-                "paused": paused_schedules,
-                "active": active_schedules,
-                "by_orchestrator": orch_counts,
-            },
-            "aliases": {
-                "total": total_aliases,
-                "by_orchestrator": alias_counts,
-            },
-            "chains": {"total": total_chains},
-        }
-    finally:
-        session.close()
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _collect_event_bus_metrics() -> dict[str, Any]:
-    """
-    Collect event bus metrics for the last 24 hours.
-
-    Returns:
-        {
-          "outbox_24h": int,
-          "subscriptions": {"total": int, "by_topic": {str: int}},
-          "latest_event_at": str | None,
-        }
-    """
-    from vds_scheduler_orchestrator.workflows.registry import _make_session
-
-    session = _make_session()
-    try:
-        since = datetime.now(UTC) - timedelta(hours=24)
-        outbox_24h = (
-            session.scalar(select(func.count()).select_from(EventsOutbox).where(EventsOutbox.committed_at >= since))
-            or 0
-        )
-
-        total_subs = session.scalar(select(func.count()).select_from(Subscription)) or 0
-        topic_counts = dict(
-            session.execute(select(Subscription.topic_pattern, func.count()).group_by(Subscription.topic_pattern)).all()
-        )
-
-        latest = session.scalar(select(EventsOutbox.committed_at).order_by(EventsOutbox.committed_at.desc()).limit(1))
-
-        return {
-            "outbox_24h": outbox_24h,
-            "subscriptions": {
-                "total": total_subs,
-                "by_topic": topic_counts,
-            },
-            "latest_event_at": latest.isoformat() if latest else None,
-        }
-    finally:
-        session.close()
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _collect_queue_metrics() -> dict[str, Any]:
-    """
-    Collect DBOS queue/workflow status metrics.
-
-    Returns:
-        {
-          "workflows_by_status": {str: int},
-          "enqueued_depth": int,
-          "pending_depth": int,
-          "success_24h": int,
-          "error_24h": int,
-        }
-    """
-    from vds_scheduler_orchestrator.workflows.registry import _make_session
-
-    session = _make_session()
-    try:
-        # DBOS workflow_status table lives in the dbos schema
-        status_counts = dict(
-            session.execute(
-                text("""
-                    SELECT status, COUNT(*)
-                    FROM dbos.workflow_status
-                    GROUP BY status
-                """)
-            ).all()
-        )
-
-        enqueued = status_counts.get("ENQUEUED", 0)
-        pending = status_counts.get("PENDING", 0)
-
-        # updated_at is bigint (epoch-ms); bind as int to avoid
-        # "operator does not exist: bigint >= timestamp with time zone" error.
-        since_ms = int((datetime.now(UTC) - timedelta(hours=24)).timestamp() * 1000)
-        success_24h = (
-            session.scalar(
-                text("""
-                SELECT COUNT(*) FROM dbos.workflow_status
-                WHERE status = 'SUCCESS' AND updated_at >= :since_ms
-            """),
-                {"since_ms": since_ms},
-            )
-            or 0
-        )
-
-        error_24h = (
-            session.scalar(
-                text("""
-                SELECT COUNT(*) FROM dbos.workflow_status
-                WHERE status = 'ERROR' AND updated_at >= :since_ms
-            """),
-                {"since_ms": since_ms},
-            )
-            or 0
-        )
-
-        return {
-            "workflows_by_status": status_counts,
-            "enqueued_depth": enqueued,
-            "pending_depth": pending,
-            "success_24h": success_24h,
-            "error_24h": error_24h,
-        }
-    finally:
-        session.close()
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _load_previous_run(report_date: date) -> dict[str, Any] | None:
-    """Load yesterday's report run from sched.ecosystem_report_runs. Returns None if no prior run."""
-    yesterday = report_date - timedelta(days=1)
-    session = _make_session()
-    try:
-        row = session.query(EcosystemReportRun).filter_by(report_date=yesterday).first()
-        if row is None:
-            logger.info("ecosystem_report.no_previous_run", yesterday=str(yesterday))
-            return None
-        return {
-            "report_date": str(row.report_date),
-            "error_24h": row.error_24h,
-            "success_24h": row.success_24h,
-            "pending_depth": row.pending_depth,
-            "enqueued_depth": row.enqueued_depth,
-            "health_score": row.health_score,
-            "anomalies": row.anomalies,
-            "git_summary": row.git_summary,
-        }
-    finally:
-        session.close()
-
-
-def _compute_deltas(
-    current: dict[str, Any],
-    previous: dict[str, Any] | None,
-) -> dict[str, Any] | None:
-    """Compute day-over-day deltas with regression bucketing.
-
-    Bucketing (aligned with progress-report-skill pattern):
-      critical: delta <= -15
-      minor:    delta <= -5
-      noise:    -5 < delta < 5
-      improvement: delta >= 5
-      major:    delta >= 15
-    """
-    if previous is None:
-        return None
-
-    def _bucket(delta: int, lower_is_better: bool = False) -> str:
-        """Classify a numeric delta into a severity bucket.
-
-        For 'lower is better' metrics (errors, pending), a negative delta
-        is improvement. For 'higher is better' metrics (success), a positive
-        delta is improvement.
-        """
-        # Normalize: positive = good direction, negative = bad direction
-        effective = -delta if lower_is_better else delta
-        if effective >= 15:
-            return "major"
-        if effective >= 5:
-            return "improvement"
-        if effective <= -15:
-            return "critical"
-        if effective <= -5:
-            return "minor"
-        return "noise"
-
-    def _arrow(delta: int) -> str:
-        """Return a Unicode arrow indicating delta direction."""
-        if delta > 0:
-            return "↑"
-        if delta < 0:
-            return "↓"
-        return "→"
-
-    error_delta = current.get("error_24h", 0) - previous.get("error_24h", 0)
-    success_delta = current.get("success_24h", 0) - previous.get("success_24h", 0)
-    pending_delta = current.get("pending_depth", 0) - previous.get("pending_depth", 0)
-    enqueued_delta = current.get("enqueued_depth", 0) - previous.get("enqueued_depth", 0)
-
-    return {
-        "error": {
-            "delta": error_delta,
-            "arrow": _arrow(error_delta),
-            "bucket": _bucket(error_delta, lower_is_better=True),
-        },
-        "success": {
-            "delta": success_delta,
-            "arrow": _arrow(success_delta),
-            "bucket": _bucket(success_delta, lower_is_better=False),
-        },
-        "pending": {
-            "delta": pending_delta,
-            "arrow": _arrow(pending_delta),
-            "bucket": _bucket(pending_delta, lower_is_better=True),
-        },
-        "enqueued": {
-            "delta": enqueued_delta,
-            "arrow": _arrow(enqueued_delta),
-            "bucket": _bucket(enqueued_delta, lower_is_better=True),
-        },
-    }
-
-
-# ── Anomaly aggregation (Wave 8 F1: persist alignment) ───────────────────────
-#
-# Cap on how many anomaly strings we will persist into the JSONB column. The
-# DB column itself is unbounded JSONB, but very long lists slow down downstream
-# alert consumers (``WHERE jsonb_array_length(anomalies) > 0`` is fine; any
-# fan-out that loads the full list is not). 50 is generous: the largest
-# observed live run had 7 anomalies; even a multi-collector outage tops out
-# around 20. If we hit the cap, we append a sentinel marker so operators can
-# tell a truncation happened from the JSONB alone (no need to cross-reference
-# the markdown).
-_MAX_PERSISTED_ANOMALIES = 50
-_TRUNCATION_SENTINEL_PREFIX = "[truncated:"
-
-
-def _aggregate_anomalies(
-    results: list[CollectorResult],
-    threshold_anomalies: list[str] | None = None,
-) -> list[str]:
-    """Return the canonical anomaly list for persistence.
-
-    The persisted JSONB column MUST match the v2 markdown's anomaly section
-    so downstream consumers (Slack alerting, dashboards, ``WHERE
-    jsonb_array_length(anomalies) > 0`` queries) fire on the same evidence
-    operators see in the rendered report. The v2 formatter's
-    ``_collect_anomalies(results)`` is the source of truth — this helper
-    mirrors that logic exactly, then appends the legacy threshold-based
-    anomalies (high error count, queue backlog, etc.) so the persisted blob
-    is a strict superset of both renderings.
-
-    Pipeline (each step idempotent):
-      1. Walk ``results`` in collector order, ``r.anomalies`` in emission
-         order — preserving ordering matters for operator scanning of the
-         JSONB output.
-      2. Append ``threshold_anomalies`` (legacy heuristic detections from
-         ``_generate_and_write_report``).
-      3. Sanitize every entry via ``report_formatter.sanitize_anomaly`` —
-         strips newlines, redacts SELECT…FROM… SQL leaks, length-bounds to
-         200 chars. Same rules the markdown uses.
-      4. Drop empty strings (``None`` / ``""`` from sanitization).
-      5. Truncate at ``_MAX_PERSISTED_ANOMALIES`` and append a sentinel
-         ``"[truncated: N of M]"`` row when the cap was hit.
-
-    Returns
-    -------
-    list[str]
-        Aggregated, sanitized, ordering-preserved anomaly strings. Safe to
-        pass directly to the JSONB column.
-    """
-    # Local import — keeps this module's cold-import cost flat and avoids
-    # any circular path through report_formatter's collector-protocol use.
-    from vds_scheduler_orchestrator.workflows.report_formatter import sanitize_anomaly
-
-    raw: list[str] = []
-    for r in results:
-        raw.extend(r.anomalies)
-    if threshold_anomalies:
-        raw.extend(threshold_anomalies)
-
-    cleaned: list[str] = []
-    for entry in raw:
-        sanitized = sanitize_anomaly(entry)
-        if sanitized:
-            cleaned.append(sanitized)
-
-    total = len(cleaned)
-    if total > _MAX_PERSISTED_ANOMALIES:
-        head = cleaned[:_MAX_PERSISTED_ANOMALIES]
-        head.append(f"{_TRUNCATION_SENTINEL_PREFIX} {_MAX_PERSISTED_ANOMALIES} of {total}]")
-        return head
-    return cleaned
-
-
-def _merge_golden_signals(results: list[CollectorResult]) -> dict[str, Any]:
-    """Merge golden signals from all collector results into a single dict for persistence."""
-    out = {"errors": [], "latency": [], "saturation": [], "traffic": []}
-    for r in results:
-        gs = r.golden_signals
-        for entry in gs.errors:
-            out["errors"].append(
-                {
-                    "label": entry.label,
-                    "value": entry.value,
-                    "display": entry.display,
-                    "threshold": entry.threshold,
-                    "polarity": entry.polarity,
-                }
-            )
-        for entry in gs.latency:
-            out["latency"].append(
-                {
-                    "label": entry.label,
-                    "value": entry.value,
-                    "display": entry.display,
-                    "threshold": entry.threshold,
-                    "polarity": entry.polarity,
-                }
-            )
-        for entry in gs.saturation:
-            out["saturation"].append(
-                {
-                    "label": entry.label,
-                    "value": entry.value,
-                    "display": entry.display,
-                    "threshold": entry.threshold,
-                    "polarity": entry.polarity,
-                }
-            )
-        for entry in gs.traffic:
-            out["traffic"].append(
-                {
-                    "label": entry.label,
-                    "value": entry.value,
-                    "display": entry.display,
-                    "threshold": entry.threshold,
-                    "polarity": entry.polarity,
-                }
-            )
-    return out
-
-
-def _compute_legacy_threshold_anomalies(
-    git_data: dict[str, Any],
-    scheduler_data: dict[str, Any],
-    event_data: dict[str, Any],
-    queue_data: dict[str, Any],
-    cfg: Any,
-) -> list[str]:
-    """Compute the threshold-based anomalies (high error count / queue backlog
-    / zero-outbox / high commit volume).
-
-    Extracted from ``_generate_and_write_report`` (Wave 8 Lane Upsilon Fix 2)
-    so the canonical workflow body can compute these heuristics WITHOUT
-    invoking the legacy short-report writer. The legacy writer was producing
-    a duplicate user-facing markdown file whose anomaly text contradicted
-    the full collector-aware report; only the full report is now emitted as
-    ``<date>-ecosystem-report.md``.
-    """
-    anomalies: list[str] = []
-
-    if queue_data["error_24h"] > cfg.error_threshold:
-        anomalies.append(f"High error count: {queue_data['error_24h']} workflows failed in last 24h")
-    if queue_data["pending_depth"] > cfg.pending_threshold:
-        anomalies.append(f"Queue backlog: {queue_data['pending_depth']} PENDING workflows")
-    if cfg.zero_outbox_alert and event_data["outbox_24h"] == 0 and scheduler_data["schedules"]["total"] > 0:
-        anomalies.append("Zero events in outbox last 24h despite active schedules")
-    for repo_name, repo_info in git_data.get("repos", {}).items():
-        if repo_info["commits"] > cfg.commit_threshold:
-            anomalies.append(f"High commit volume in {repo_name}: {repo_info['commits']} commits")
-
-    return anomalies
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _generate_and_write_report(
-    git_data: dict[str, Any],
-    scheduler_data: dict[str, Any],
-    event_data: dict[str, Any],
-    queue_data: dict[str, Any],
-    deltas: dict[str, Any] | None = None,
-) -> dict[str, Any]:
-    """
-    Generate the daily ecosystem report Markdown and write to disk.
-
-    Returns:
-        {"report_path": str, "anomalies": [str]}
-
-    Note (Wave 8 Lane Upsilon Fix 2): the workflow body no longer calls this
-    step — the v2 (collector-aware) full report is now the sole user-facing
-    markdown file. This step is preserved for backward-compatible callers
-    and the existing TSK-2.x test suite that exercises its anomaly
-    heuristics and markdown rendering surface.
-    """
-    cfg = get_ecosystem_config()
-    today = date.today().isoformat()
-    report_dir = cfg.resolved_report_dir
-    report_path = report_dir / f"{today}-ecosystem-report.md"
-    report_dir.mkdir(parents=True, exist_ok=True)
-
-    anomalies = _compute_legacy_threshold_anomalies(
-        git_data, scheduler_data, event_data, queue_data, cfg
-    )
-
-    lines: list[str] = []
-    lines.append(f"# Ecosystem Daily Report — {today}")
-    lines.append("")
-    lines.append(f"_Generated at {datetime.now(UTC).isoformat()} UTC_")
-    lines.append("")
-
-    # ── Executive Summary ────────────────────────────────────────────────────
-    lines.append("## Executive Summary")
-    lines.append("")
-    if anomalies:
-        lines.append("**⚠️ Anomalies Detected:**")
-        for a in anomalies:
-            lines.append(f"- {a}")
-    else:
-        lines.append("✅ No anomalies detected.")
-    lines.append("")
-    lines.append(
-        f"- **Schedules**: {scheduler_data['schedules']['active']} active / {scheduler_data['schedules']['paused']} paused"
-    )
-
-    # Workflows line with optional delta indicators
-    wf_line = f"- **Workflows (24h)**: {queue_data['success_24h']} success"
-    if deltas:
-        sd = deltas["success"]["delta"]
-        wf_line += f" ({deltas['success']['arrow']}{sd:+d} vs yesterday)"
-    wf_line += f" / {queue_data['error_24h']} error"
-    if deltas:
-        ed = deltas["error"]["delta"]
-        wf_line += f" ({deltas['error']['arrow']}{ed:+d} vs yesterday)"
-    lines.append(wf_line)
-
-    # Queue depth line with optional delta indicators
-    qd_line = f"- **Queue Depth**: {queue_data['enqueued_depth']} ENQUEUED"
-    if deltas:
-        eqd = deltas["enqueued"]["delta"]
-        qd_line += f" ({deltas['enqueued']['arrow']}{eqd:+d})"
-    qd_line += f" / {queue_data['pending_depth']} PENDING"
-    if deltas:
-        pd = deltas["pending"]["delta"]
-        qd_line += f" ({deltas['pending']['arrow']}{pd:+d})"
-    lines.append(qd_line)
-
-    lines.append(f"- **Events (24h)**: {event_data['outbox_24h']} outbox entries")
-    lines.append("")
-
-    # ── Day-over-Day Delta (TSK-3.3) ─────────────────────────────────────────
-    if deltas:
-        lines.append("## Day-over-Day Delta")
-        lines.append("")
-        lines.append("| Metric | Today | Yesterday | Delta | Trend |")
-        lines.append("|--------|-------|-----------|-------|-------|")
-
-        err_today = queue_data["error_24h"]
-        err_yest = err_today - deltas["error"]["delta"]
-        lines.append(
-            f"| Errors (24h) | {err_today} | {err_yest} "
-            f"| {deltas['error']['delta']:+d} | {deltas['error']['arrow']} {deltas['error']['bucket']} |"
-        )
-
-        suc_today = queue_data["success_24h"]
-        suc_yest = suc_today - deltas["success"]["delta"]
-        lines.append(
-            f"| Success (24h) | {suc_today} | {suc_yest} "
-            f"| {deltas['success']['delta']:+d} | {deltas['success']['arrow']} {deltas['success']['bucket']} |"
-        )
-
-        pen_today = queue_data["pending_depth"]
-        pen_yest = pen_today - deltas["pending"]["delta"]
-        lines.append(
-            f"| Pending depth | {pen_today} | {pen_yest} "
-            f"| {deltas['pending']['delta']:+d} | {deltas['pending']['arrow']} {deltas['pending']['bucket']} |"
-        )
-
-        enq_today = queue_data["enqueued_depth"]
-        enq_yest = enq_today - deltas["enqueued"]["delta"]
-        lines.append(
-            f"| Enqueued depth | {enq_today} | {enq_yest} "
-            f"| {deltas['enqueued']['delta']:+d} | {deltas['enqueued']['arrow']} {deltas['enqueued']['bucket']} |"
-        )
-        lines.append("")
-
-    # ── Git Activity ─────────────────────────────────────────────────────────
-    lines.append("## Git Activity (since 00:00 UTC yesterday)")
-    lines.append("")
-    for repo_name, repo_info in git_data.get("repos", {}).items():
-        lines.append(f"### {repo_name}")
-        lines.append(f"- Commits: **{repo_info['commits']}** (merges: {repo_info['merge_commits']})")
-        lines.append(f"- Authors: {', '.join(repo_info['authors']) or '—'}")
-        lines.append(f"- Branches: {', '.join(repo_info['branches_changed']) or '—'}")
-        lines.append("")
-
-    # ── Scheduler Status ─────────────────────────────────────────────────────
-    lines.append("## Scheduler Status")
-    lines.append("")
-    lines.append("### Schedules by Orchestrator")
-    for orch, count in sorted(scheduler_data["schedules"]["by_orchestrator"].items()):
-        lines.append(f"- `{orch}`: {count}")
-    lines.append("")
-    lines.append("### Workflow Aliases by Orchestrator")
-    for orch, count in sorted(scheduler_data["aliases"]["by_orchestrator"].items()):
-        lines.append(f"- `{orch}`: {count}")
-    lines.append("")
-    lines.append(f"### Chain Definitions: {scheduler_data['chains']['total']}")
-    lines.append("")
-
-    # ── Event Bus ────────────────────────────────────────────────────────────
-    lines.append("## Event Bus (24h)")
-    lines.append("")
-    lines.append(f"- Outbox entries: **{event_data['outbox_24h']}**")
-    lines.append(f"- Latest event: {event_data['latest_event_at'] or '—'}")
-    lines.append("- Subscriptions by topic:")
-    for topic, count in sorted(event_data["subscriptions"]["by_topic"].items()):
-        lines.append(f"  - `{topic}`: {count}")
-    lines.append("")
-
-    # ── Workflow Queue Health ────────────────────────────────────────────────
-    lines.append("## Workflow Queue Health")
-    lines.append("")
-    lines.append("### Status Distribution")
-    for status, count in sorted(queue_data["workflows_by_status"].items()):
-        lines.append(f"- `{status}`: {count}")
-    lines.append("")
-    lines.append(f"- **ENQUEUED depth**: {queue_data['enqueued_depth']}")
-    lines.append(f"- **PENDING depth**: {queue_data['pending_depth']}")
-    lines.append("")
-
-    # ── Footer ───────────────────────────────────────────────────────────────
-    lines.append("---")
-    lines.append("_Report generated by `ecosystem.daily.report` DBOS workflow_")
-    lines.append("")
-
-    report_path.write_text("\n".join(lines), encoding="utf-8")
-    logger.info("ecosystem_report.written", path=str(report_path), anomalies=len(anomalies))
-
-    return {"report_path": str(report_path), "anomalies": anomalies}
-
-
-# ── DBOS steps: persist & publish (TSK-2.3, TSK-2.4) ─────────────────────────
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _persist_report_run(
-    report_date: date,
-    report_path: str,
-    anomalies: list[str],
-    git_data: dict[str, Any],
-    scheduler_data: dict[str, Any],
-    event_data: dict[str, Any],
-    queue_data: dict[str, Any],
-    health_score: int | None = None,
-    golden_signals: dict[str, Any] | None = None,
-    prometheus_summary: dict[str, Any] | None = None,
-    infra_summary: dict[str, Any] | None = None,
-    test_summary: dict[str, Any] | None = None,
-    worktree_summary: dict[str, Any] | None = None,
-    spec_summary: dict[str, Any] | None = None,
-    memory_summary: dict[str, Any] | None = None,
-    llm_summary: dict[str, Any] | None = None,
-    dora_summary: dict[str, Any] | None = None,
-    trend_summary: dict[str, Any] | None = None,
-    security_summary: dict[str, Any] | None = None,
-    slack_delivered: bool = False,
-    slack_delivered_at: datetime | None = None,
-    generation_duration_ms: int | None = None,
-) -> str | None:
-    """Persist report metadata to sched.ecosystem_report_runs. Upsert on report_date.
-
-    Resilience contract (post-Phase-3, mirrors Pi's TrendForecast READ-path
-    fix in commit ``9bf51bdb``): the ORM model declares Phase 3 columns
-    (``dora_summary``, ``trend_summary``, ``security_summary``,
-    ``slack_delivered``, ``slack_delivered_at``) which are added by alembic
-    migration ``b2c3d4e5f8a9``. If that migration has NOT been applied to
-    the live database, SQLAlchemy will emit ``INSERT`` / ``UPDATE`` statements
-    that reference the new columns and the driver raises
-    ``psycopg2.errors.UndefinedColumn`` (surfaced as ``SQLAlchemyError`` here).
-
-    Rather than crashing the whole daily-report workflow on schema drift, we
-    catch ``SQLAlchemyError``, roll back, log a clean one-line warning that
-    points to the alembic upgrade as remediation, and return ``None``.
-    Once the migration is applied, persistence resumes normally on the next
-    run.
-
-    Returns
-    -------
-    str | None
-        The persisted ``run_id`` (UUID-as-text) on success, or ``None`` if
-        persistence was skipped due to schema drift. Other infrastructure
-        errors (non-SQLAlchemy ``RuntimeError``, network failures inside the
-        session manager, etc.) still propagate so DBOS retry logic can react.
-    """
-    session = _make_session()
-    try:
-        try:
-            existing = session.query(EcosystemReportRun).filter_by(report_date=report_date).first()
-            if existing:
-                existing.generated_at = datetime.now(UTC)
-                existing.report_path = report_path
-                existing.anomalies = anomalies
-                existing.git_summary = git_data
-                existing.scheduler_summary = scheduler_data
-                existing.event_bus_summary = event_data
-                existing.queue_summary = queue_data
-                existing.error_24h = queue_data.get("error_24h", 0)
-                existing.success_24h = queue_data.get("success_24h", 0)
-                existing.pending_depth = queue_data.get("pending_depth", 0)
-                existing.enqueued_depth = queue_data.get("enqueued_depth", 0)
-                existing.health_score = health_score
-                existing.golden_signals = golden_signals or {}
-                existing.prometheus_summary = prometheus_summary or {}
-                existing.infra_summary = infra_summary or {}
-                existing.test_summary = test_summary or {}
-                existing.worktree_summary = worktree_summary or {}
-                existing.spec_summary = spec_summary or {}
-                existing.memory_summary = memory_summary or {}
-                existing.llm_summary = llm_summary or {}
-                existing.dora_summary = dora_summary or {}
-                existing.trend_summary = trend_summary or {}
-                existing.security_summary = security_summary or {}
-                existing.slack_delivered = slack_delivered
-                existing.slack_delivered_at = slack_delivered_at
-                existing.generation_duration_ms = generation_duration_ms
-                run_id = existing.id
-            else:
-                run = EcosystemReportRun(
-                    report_date=report_date,
-                    generated_at=datetime.now(UTC),
-                    report_path=report_path,
-                    anomalies=anomalies,
-                    git_summary=git_data,
-                    scheduler_summary=scheduler_data,
-                    event_bus_summary=event_data,
-                    queue_summary=queue_data,
-                    error_24h=queue_data.get("error_24h", 0),
-                    success_24h=queue_data.get("success_24h", 0),
-                    pending_depth=queue_data.get("pending_depth", 0),
-                    enqueued_depth=queue_data.get("enqueued_depth", 0),
-                    health_score=health_score,
-                    golden_signals=golden_signals or {},
-                    prometheus_summary=prometheus_summary or {},
-                    infra_summary=infra_summary or {},
-                    test_summary=test_summary or {},
-                    worktree_summary=worktree_summary or {},
-                    spec_summary=spec_summary or {},
-                    memory_summary=memory_summary or {},
-                    llm_summary=llm_summary or {},
-                    dora_summary=dora_summary or {},
-                    trend_summary=trend_summary or {},
-                    security_summary=security_summary or {},
-                    slack_delivered=slack_delivered,
-                    slack_delivered_at=slack_delivered_at,
-                    generation_duration_ms=generation_duration_ms,
-                )
-                session.add(run)
-                session.flush()  # populate server-default id
-                run_id = run.id
-            session.commit()
-            logger.info("ecosystem_report.persisted", run_id=run_id, report_date=str(report_date))
-            return run_id
-        except SQLAlchemyError as exc:
-            # Schema drift (e.g. Phase 3 columns referenced by ORM but missing
-            # from live DB because alembic upgrade has not been applied) lands
-            # here as ``UndefinedColumn`` wrapped in ``SQLAlchemyError``. Roll
-            # back the transaction, log a clean single-line warning, and
-            # return ``None`` so the workflow continues without persisting.
-            try:
-                session.rollback()
-            except SQLAlchemyError:
-                # Rollback itself can fail on a torn connection; we have
-                # already decided to skip persistence, so swallow this too.
-                logger.debug("ecosystem_report.rollback_failed_post_persist_error")
-            logger.warning(
-                "ecosystem_report.persist_unavailable",
-                error=str(exc),
-                hint="alembic migration not applied — run 'alembic upgrade head' on scheduler DB to enable persistence",
-            )
-            return None
-    finally:
-        session.close()
-
-
-@DBOS.step(retries_allowed=True, max_attempts=3)
-async def _publish_completion_event(
-    report_date: date,
-    report_path: str,
-    anomaly_count: int,
-    error_24h: int,
-    success_24h: int,
-    health_score: int,
-    workflow_id: str,
-    exec_summary: str = "",
-) -> None:
-    """Publish ecosystem.daily.completed event to the event bus.
-
-    Per spec FR-2.3 the payload MUST carry the integer ``health_score``
-    (0–100) and the DBOS ``workflow_id`` so downstream subscribers can
-    correlate the event with the originating workflow run and surface the
-    health score without a re-query into ``sched.ecosystem_report_runs``.
-    """
-    from vds_scheduler_orchestrator.events.bus import publish
-
-    await publish(
-        topic="ecosystem.daily.completed",
-        payload={
-            "report_date": str(report_date),
-            "report_path": report_path,
-            "anomaly_count": anomaly_count,
-            "error_24h": error_24h,
-            "success_24h": success_24h,
-            "health_score": health_score,
-            "workflow_id": workflow_id,
-            "exec_summary": exec_summary,
-        },
-        trace_id=f"edr-{report_date}",
-    )
-    logger.info("ecosystem_report.event_published", topic="ecosystem.daily.completed")
-
-
-@DBOS.step(retries_allowed=True, max_attempts=2)
-async def _publish_failure_event(error_msg: str, report_date: date) -> None:
-    """Publish ecosystem.daily.failed event when the workflow errors."""
-    from vds_scheduler_orchestrator.events.bus import publish
-
-    await publish(
-        topic="ecosystem.daily.failed",
-        payload={"report_date": str(report_date), "error": error_msg},
-        trace_id=f"edr-fail-{report_date}",
-    )
-    logger.error("ecosystem_report.failed_event_published", error=error_msg)
-
-
-# ── DBOS step: Slack notification delivery (TSK-P3-1.2, FR-4.2) ───────────────
-
-
-# Slack incoming-webhook backoff schedule: 1s, 2s, 4s (3 retries total).
-# The function implements its own retry loop so DBOS retries are disabled
-# (``retries_allowed=False``) — we don't want DBOS to layer additional retries
-# on top of our exponential-backoff schedule.
-_SLACK_RETRY_BACKOFF_S: tuple[float, float, float] = (1.0, 2.0, 4.0)
-_SLACK_REQUEST_TIMEOUT_S: float = 10.0
-
-
-@DBOS.step(retries_allowed=False)
-async def _deliver_slack_notification(
-    webhook_url: str,
-    blocks: list[dict[str, Any]],
-) -> bool:
-    """POST a Block Kit message to a Slack incoming webhook.
-
-    Slack incoming-webhook contract (host ``hooks.slack.com``, NOT
-    ``api.slack.com``): the JSON body MUST be an object that wraps the
-    block list — ``{"blocks": [...]}``. A bare list is rejected by the
-    webhook receiver.
-
-    Retry policy
-    ------------
-    - 200 → success (return True).
-    - 429 / 5xx → retry with exponential backoff (1s, 2s, 4s) up to 3 attempts.
-    - Other 4xx → log and give up (return False) — these are caller errors
-      (malformed body, bad webhook URL) and retrying will not help.
-    - Network / transport error → retry on the same schedule.
-
-    The delivery step NEVER raises to the caller — failures return ``False``
-    so the workflow's per-call ``try/except`` can keep the outer pipeline
-    alive (NFR-6: never block report generation on Slack failure).
-
-    Parameters
-    ----------
-    webhook_url:
-        Slack incoming-webhook URL. The full URL is operator-provided
-        (caller is responsible for not passing a non-Slack URL — this
-        function does not validate the host).
-    blocks:
-        The Block Kit block list returned by ``_build_slack_blocks``.
-        Wrapped here as ``{"blocks": blocks}`` for the actual POST body.
-
-    Returns
-    -------
-    bool
-        ``True`` on HTTP 200, ``False`` on every other terminal outcome.
-    """
-    import httpx
-
-    # MUST wrap the list in an object — Slack rejects a bare JSON list.
-    payload: dict[str, Any] = {"blocks": blocks}
-
-    last_status: int | None = None
-    last_error: str | None = None
-
-    async with httpx.AsyncClient(timeout=_SLACK_REQUEST_TIMEOUT_S) as client:
-        for attempt, backoff in enumerate(_SLACK_RETRY_BACKOFF_S, start=1):
-            try:
-                response = await client.post(webhook_url, json=payload)
-            except httpx.HTTPError as exc:
-                last_error = str(exc)
-                logger.warning(
-                    "slack.delivery_transport_error",
-                    attempt=attempt,
-                    error=last_error,
-                )
-                # Transport failure — retry unless this was the last attempt.
-                if attempt < len(_SLACK_RETRY_BACKOFF_S):
-                    await asyncio.sleep(backoff)
-                    continue
-                return False
-
-            last_status = response.status_code
-            if response.status_code == 200:
-                logger.info("slack.delivery_succeeded", attempt=attempt)
-                return True
-
-            # 429 (rate limit) and 5xx are retriable per FR-4.2.
-            if response.status_code == 429 or 500 <= response.status_code < 600:
-                logger.warning(
-                    "slack.delivery_retriable_status",
-                    attempt=attempt,
-                    status=response.status_code,
-                )
-                if attempt < len(_SLACK_RETRY_BACKOFF_S):
-                    await asyncio.sleep(backoff)
-                    continue
-                return False
-
-            # Other 4xx — caller error; no retry.
-            logger.warning(
-                "slack.delivery_giving_up_4xx",
-                status=response.status_code,
-                body=response.text[:500],
-            )
-            return False
-
-    # Unreachable — loop exits via return inside the body. Defensive only.
-    logger.warning(
-        "slack.delivery_exhausted",
-        last_status=last_status,
-        last_error=last_error,
-    )
-    return False
-
-
-# ── DBOS workflow ─────────────────────────────────────────────────────────────
-
-
-@DBOS.workflow()
-async def ecosystem_daily_report_workflow(
-    scheduled_time: datetime,
-    context: Any,
-) -> dict[str, Any]:
-    """
-    Daily ecosystem report workflow.
-
-    Triggered at 06:00 UTC by the ``ecosystem.daily.report`` cron schedule.
-    Collects git, scheduler, event bus, and queue metrics; generates a
-    Markdown report; writes it to ``reports/ecosystem/``.
-
-    On any unhandled exception, publishes ``ecosystem.daily.failed`` before
-    re-raising so downstream alerting consumers are notified (TSK-3.5).
-    """
-    today = date.today()
-    logger.info("ecosystem_report.start", scheduled_at=scheduled_time.isoformat())
-
-    try:
-        # ── Phase 2: use collector protocol ──────────────────────────────────
-        import time
-
-        pipeline_start = time.monotonic()
-        cfg = get_ecosystem_config()
-        from vds_scheduler_orchestrator.workflows.collector_registry import (
-            get_enabled_collectors,
-        )
-        from vds_scheduler_orchestrator.workflows.health_score import (
-            compute_health_score_detail,
-            health_score_to_dict,
-        )
-        from vds_scheduler_orchestrator.workflows.report_formatter import (
-            format_adaptive_report,
-        )
-
-        collectors = get_enabled_collectors(cfg)
-
-        async def _run_collector(collector: Any) -> CollectorResult:
-            timeout_s: float = getattr(collector, "timeout_s", cfg.collector_timeout_s)
-            try:
-                return await asyncio.wait_for(
-                    collector.collect(), timeout=timeout_s
-                )
-            except TimeoutError:
-                logger.warning(
-                    "collector.timed_out",
-                    section=collector.section,
-                    timeout_s=timeout_s,
-                )
-                return CollectorResult(
-                    section=collector.section,
-                    anomalies=[
-                        f"[unavailable] {collector.section}: "
-                        f"timed out after {timeout_s}s"
-                    ],
-                    health_deductions=5,
-                )
-            except Exception as exc:
-                error_text = str(exc) or type(exc).__name__
-                logger.exception(
-                    "collector.failed",
-                    section=collector.section,
-                    error=error_text,
-                )
-                return CollectorResult(
-                    section=collector.section,
-                    anomalies=[
-                        f"[unavailable] {collector.section}: {error_text}"
-                    ],
-                    health_deductions=5,
-                )
-
-        # Phase 2 collectors are intentionally parallelized; per-collector
-        # wait_for keeps a slow source from consuming the full report budget.
-        results = list(await asyncio.gather(*(_run_collector(c) for c in collectors)))
-        generation_duration_ms = int((time.monotonic() - pipeline_start) * 1000)
-
-        # Build backward-compatible Phase 1 data dicts for existing persist/formatter
-        git_data = next(
-            (r.metrics for r in results if r.section == "Git Activity"),
-            {"repos": {}},
-        )
-        scheduler_data = next(
-            (r.metrics for r in results if r.section == "Scheduler Status"),
-            {
-                "schedules": {"total": 0, "active": 0, "paused": 0, "by_orchestrator": {}},
-                "aliases": {"total": 0, "by_orchestrator": {}},
-                "chains": {"total": 0},
-            },
-        )
-        event_data = next(
-            (r.metrics for r in results if r.section == "Event Bus"),
-            {"outbox_24h": 0, "subscriptions": {"total": 0, "by_topic": {}}, "latest_event_at": None},
-        )
-        queue_data = next(
-            (r.metrics for r in results if r.section == "Queue Metrics"),
-            {"workflows_by_status": {}, "enqueued_depth": 0, "pending_depth": 0, "success_24h": 0, "error_24h": 0},
-        )
-
-        # TSK-3.1: load yesterday's run for delta comparison
-        previous_run = await _load_previous_run(today)
-
-        # TSK-3.2: compute day-over-day deltas and Phase 2 health trend.
-        deltas = _compute_deltas(queue_data, previous_run)
-        previous_health = previous_run.get("health_score") if previous_run else None
-        health_detail = compute_health_score_detail(results, previous_health)
-        health_score = health_detail.score
-
-        # Wave 8 Lane Upsilon Fix 2: produce a SINGLE user-facing report
-        # file. The legacy ``_generate_and_write_report`` writer (Phase 1
-        # short summary) was emitting a second contradictory markdown
-        # alongside the v2 (collector-aware) full report — the legacy file
-        # said "✅ No anomalies detected" while the v2 file flagged real
-        # collector anomalies, because legacy used only threshold
-        # heuristics. We now compute the threshold heuristics inline (so
-        # persistence / event count still see them) and write only the
-        # full report to the canonical ``<date>-ecosystem-report.md``
-        # filename (no ``-v2`` suffix).
-        cfg = get_ecosystem_config()
-        legacy_threshold_anomalies = _compute_legacy_threshold_anomalies(
-            git_data, scheduler_data, event_data, queue_data, cfg
-        )
-
-        # Phase 2: generate golden-signals full report (the only markdown
-        # we now write to disk).
-        report_text = format_adaptive_report(
-            results,
-            health_score,
-            "full",
-            today,
-            deltas=deltas,
-        )
-
-        report_dir = cfg.resolved_report_dir
-        report_dir.mkdir(parents=True, exist_ok=True)
-        report_path = report_dir / f"{today.isoformat()}-ecosystem-report.md"
-        report_path.write_text(report_text, encoding="utf-8")
-        report_path_str = str(report_path)
-        logger.info("ecosystem_report.written", path=report_path_str)
-
-        # Wave 8 F1: aggregate anomalies from ALL CollectorResult.anomalies
-        # lists (the same source the markdown formatter renders) PLUS the
-        # legacy threshold-based detections. Persisting only the legacy
-        # list left the JSONB column empty even when collectors had
-        # emitted anomalies — a silent alerting blind spot for any
-        # consumer querying ``jsonb_array_length(anomalies) > 0``. We
-        # compute it once, here, and reuse for persistence + completion
-        # event count so the JSONB row, the published anomaly_count, and
-        # the markdown all stay in sync.
-        persisted_anomalies = _aggregate_anomalies(results, legacy_threshold_anomalies)
-
-        # TSK-3.4: generate exec summary for notification consumers (Phase 1 style)
-        from vds_scheduler_orchestrator.workflows.report_formatter import format_exec_summary
-
-        exec_summary = format_exec_summary(
-            report_date=today,
-            queue_data=queue_data,
-            scheduler_data=scheduler_data,
-            event_data=event_data,
-            anomalies=persisted_anomalies,
-            deltas=deltas,
-        )
-
-        # Phase 2: persist with health_score and golden signals
-        run_id = await _persist_report_run(
-            report_date=today,
-            report_path=report_path_str,
-            anomalies=persisted_anomalies,
-            git_data=git_data,
-            scheduler_data=scheduler_data,
-            event_data=event_data,
-            queue_data=queue_data,
-            health_score=health_score,
-            golden_signals={
-                **_merge_golden_signals(results),
-                "health": health_score_to_dict(health_detail),
-            },
-            prometheus_summary=next((r.metrics for r in results if r.section == "Prometheus"), {}),
-            infra_summary=next((r.metrics for r in results if r.section == "Infrastructure Health"), {}),
-            test_summary=next((r.metrics for r in results if r.section == "Test Suite"), {}),
-            worktree_summary=next((r.metrics for r in results if r.section == "Worktree Hygiene"), {}),
-            spec_summary=next((r.metrics for r in results if r.section == "Spec Progress"), {}),
-            memory_summary=next((r.metrics for r in results if r.section == "Memory Health"), {}),
-            llm_summary=next((r.metrics for r in results if r.section == "LLM Usage"), {}),
-            # ── Phase 3 collectors (FR-3.x): DORA, trend, security ────────────
-            # Slack delivery state is initialised to False/None — the actual
-            # delivery happens in the next step (``_deliver_slack_notification``)
-            # and is recorded for the next run via the upsert path.
-            dora_summary=next((r.metrics for r in results if r.section == "DORA Metrics"), {}),
-            trend_summary=next((r.metrics for r in results if r.section == "Trend Forecast"), {}),
-            security_summary=next((r.metrics for r in results if r.section == "Security Advisory"), {}),
-            slack_delivered=False,
-            slack_delivered_at=None,
-            generation_duration_ms=generation_duration_ms,
-        )
-
-        # TSK-P3-1.4: deliver Slack notification (FR-4.2). MUST NEVER BLOCK
-        # the workflow — wrap in try/except, log + continue. Skip entirely if
-        # the webhook URL is unset (default).
-        try:
-            if cfg.slack_webhook_url:
-                from vds_scheduler_orchestrator.workflows.slack_formatter import (
-                    _build_slack_blocks,
-                )
-
-                slack_blocks = _build_slack_blocks(
-                    health_score=health_score,
-                    exec_summary=exec_summary,
-                    anomalies=persisted_anomalies,
-                )
-                await _deliver_slack_notification(cfg.slack_webhook_url, slack_blocks)
-        except Exception as slack_exc:
-            logger.warning("slack_delivery_failed", error=str(slack_exc))
-
-        # TSK-2.4 + Wave 8 Lane Upsilon Fix 1: publish completion event to
-        # the event bus. Per spec FR-2.3 the payload now also carries the
-        # integer ``health_score`` and the DBOS ``workflow_id`` so
-        # downstream subscribers can correlate the event with the run row
-        # (``sched.ecosystem_report_runs``) and surface the score without
-        # a round-trip query. ``DBOS.workflow_id`` is the canonical
-        # accessor (mirrors ``envelope.py:103``); we coerce ``None`` →
-        # ``""`` for the rare unit-test path that exercises the step
-        # outside a workflow context.
-        await _publish_completion_event(
-            report_date=today,
-            report_path=report_path_str,
-            anomaly_count=len(persisted_anomalies),
-            error_24h=queue_data.get("error_24h", 0),
-            success_24h=queue_data.get("success_24h", 0),
-            health_score=health_score,
-            workflow_id=DBOS.workflow_id or "",
-            exec_summary=exec_summary,
-        )
-
-        logger.info(
-            "ecosystem_report.complete",
-            path=report_path_str,
-            anomalies=len(persisted_anomalies),
-            run_id=run_id,
-            health_score=health_score,
-        )
-
-        return {
-            "report_path": report_path_str,
-            "anomalies": persisted_anomalies,
-            "run_id": run_id,
-            "exec_summary": exec_summary,
-            "git_repos_scanned": len(git_data.get("repos", {})),
-            "schedules_active": scheduler_data["schedules"]["active"],
-            "workflows_success_24h": queue_data.get("success_24h", 0),
-            "workflows_error_24h": queue_data.get("error_24h", 0),
-            "health_score": health_score,
-            "collectors_run": len(results),
-        }
-    except Exception as exc:
-        await _publish_failure_event(str(exc), today)
-        raise
-
-
-# ── Self-monitoring (TSK-3.5) ─────────────────────────────────────────────────
-
-
-def check_missed_run(expected_hour: int = 6, grace_minutes: int = 30) -> dict[str, Any]:
-    """Check if today's report is missing past the expected time + grace period.
-
-    Callable externally (e.g. from a health-check endpoint or cron watchdog).
-    Not a DBOS step — intentionally plain so it can be invoked outside a
-    workflow context.
-
-    Returns
-    -------
-    dict
-        ``{"missed": bool, "report_date": str, "expected_by": str, "now": str}``
-    """
-    now = datetime.now(UTC)
-    today = now.date()
-    expected_by = datetime(
-        today.year,
-        today.month,
-        today.day,
-        expected_hour,
-        grace_minutes,
-        tzinfo=UTC,
-    )
-
-    if now < expected_by:
-        return {
-            "missed": False,
-            "report_date": str(today),
-            "expected_by": expected_by.isoformat(),
-            "now": now.isoformat(),
-        }
-
-    session = _make_session()
-    try:
-        row = session.query(EcosystemReportRun).filter_by(report_date=today).first()
-        return {
-            "missed": row is None,
-            "report_date": str(today),
-            "expected_by": expected_by.isoformat(),
-            "now": now.isoformat(),
-        }
-    finally:
-        session.close()
-
-
-# ── Bootstrap ─────────────────────────────────────────────────────────────────
-
-
-# Published event topics (subscription catalog for future consumers):
-#   - ecosystem.daily.completed
-#       payload: {report_date, report_path, anomaly_count, error_24h,
-#                 success_24h, exec_summary}
-#   - ecosystem.daily.failed
-#       payload: {report_date, error}
-_PUBLISHED_TOPICS = (
-    "ecosystem.daily.completed",
-    "ecosystem.daily.failed",
-)
-
-
-def bootstrap_ecosystem_report_schedule() -> None:
-    """
-    Register the ecosystem daily report alias + schedule idempotently.
-
-    Also registers published event topics in the subscription catalog so
-    future consumers can discover them (TSK-3.8).
-
-    Call from app.py lifespan AFTER DBOS.launch().
-    """
-    cfg = get_config()
-    try:
-        register_workflows(
-            {_REPORT_ALIAS: "vds_scheduler_orchestrator.workflows.ecosystem_report.ecosystem_daily_report_workflow"},
-            orchestrator="scheduler_orchestrator",
-            version=cfg.dbos_app_version,
-        )
-    except DuplicateAliasError:
-        logger.debug("ecosystem_report.alias_already_registered")
-
-    try:
-        create_schedule(
-            _REPORT_SCHEDULE_NAME,
-            owner_orchestrator="scheduler_orchestrator",
-            workflow_alias=_REPORT_ALIAS,
-            cron_expr=_REPORT_CRON,
-            queue_name=_REPORT_QUEUE,
-        )
-    except DuplicateScheduleError:
-        logger.debug("ecosystem_report.schedule_already_exists")
-
-    logger.info(
-        "ecosystem_report.topics_registered",
-        topics=list(_PUBLISHED_TOPICS),
-    )