devrel-origin 0.2.14__tar.gz → 0.2.16__tar.gz

{devrel_origin-0.2.14/src/devrel_origin.egg-info → devrel_origin-0.2.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: devrel-origin
-Version: 0.2.14
+Version: 0.2.16
 Summary: A 15-agent CLI that runs DevRel, sales, and marketing on your repo. BYO Anthropic or OpenRouter key.
 Author-email: Daria Dovzhikova <dovzhikova@gmail.com>
 License-Expression: MIT

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "devrel-origin"
-version = "0.2.14"
+version = "0.2.16"
 description = "A 15-agent CLI that runs DevRel, sales, and marketing on your repo. BYO Anthropic or OpenRouter key."
 readme = "README.md"
 requires-python = ">=3.12"

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/cli/doctor.py

@@ -4,8 +4,10 @@ from __future__ import annotations
 
 import json
 import os
+import shutil
 import sys
 from dataclasses import asdict, dataclass
+from importlib.util import find_spec
 
 import typer
 from rich.console import Console
@@ -118,6 +120,25 @@ def _run_checks(paths: ProjectPaths) -> list[CheckResult]:
     else:
         results.append(CheckResult("kb_files", "warn", "kb/ missing"))
 
+    # Optional video toolchain for Vox. Missing pieces should never block the
+    # core content pipeline, but doctor should tell users the exact render fix.
+    if shutil.which("ffmpeg"):
+        results.append(CheckResult("video_ffmpeg", "pass", "installed"))
+    else:
+        results.append(
+            CheckResult("video_ffmpeg", "warn", "not installed; run `brew install ffmpeg`")
+        )
+    if find_spec("playwright") is not None:
+        results.append(CheckResult("video_playwright", "pass", "installed"))
+    else:
+        results.append(
+            CheckResult(
+                "video_playwright",
+                "warn",
+                "not installed; run `pip install 'devrel-origin\\[video]' && python -m playwright install chromium`",
+            )
+        )
+
     return results
 
 

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/core/argus.py

@@ -76,6 +76,10 @@ class Recommendation:
     source_ids: list[str] = field(default_factory=list)
     first_seen_period: str | None = None  # set by _persist_sync; ISO timestamp
 
+    def __post_init__(self) -> None:
+        self.evidence = _coerce_str_list(self.evidence)
+        self.source_ids = _coerce_str_list(self.source_ids)
+
 
 @dataclass
 class PerformanceReport:
@@ -114,15 +118,40 @@ def _metric_to_jsonable(m: PerformanceMetric) -> dict:
     }
 
 
+def _coerce_str_list(value: Any) -> list[str]:
+    if value is None:
+        return []
+    if isinstance(value, str):
+        return [value]
+    if isinstance(value, (list, tuple, set)):
+        items = value
+    else:
+        items = [value]
+
+    out: list[str] = []
+    for item in items:
+        if item is None:
+            continue
+        if isinstance(item, str):
+            text = item
+        elif isinstance(item, (dict, list, tuple, set)):
+            text = json.dumps(item, sort_keys=True)
+        else:
+            text = str(item)
+        if text:
+            out.append(text)
+    return out
+
+
 def _rec_to_jsonable(r: Recommendation) -> dict:
     return {
         "action": r.action,
         "target": r.target,
         "target_type": r.target_type,
         "rationale": r.rationale,
-        "evidence": list(r.evidence),
+        "evidence": _coerce_str_list(r.evidence),
         "confidence": r.confidence,
-        "source_ids": list(r.source_ids),
+        "source_ids": _coerce_str_list(r.source_ids),
         "first_seen_period": r.first_seen_period,
     }
 
@@ -133,7 +162,7 @@ def _report_to_jsonable(r: PerformanceReport) -> dict:
         "period_end": r.period_end.isoformat(),
         "top_performers": [_metric_to_jsonable(m) for m in r.top_performers],
         "bottom_performers": [_metric_to_jsonable(m) for m in r.bottom_performers],
-        "trend_signals": list(r.trend_signals),
+        "trend_signals": _coerce_str_list(r.trend_signals),
         "recommendations": [_rec_to_jsonable(rec) for rec in r.recommendations],
         "sources_ok": dict(r.sources_ok),
         "insufficient_data": r.insufficient_data,
@@ -374,14 +403,16 @@ def _render_brief(rec: Recommendation, period: str) -> str:
     lines.append("## Why")
     lines.append(rec.rationale)
     lines.append("")
-    if rec.evidence:
+    evidence = _coerce_str_list(rec.evidence)
+    if evidence:
         lines.append("## Evidence")
-        for ev in rec.evidence:
+        for ev in evidence:
             lines.append(f"- {ev}")
         lines.append("")
-    if rec.source_ids:
+    source_ids = _coerce_str_list(rec.source_ids)
+    if source_ids:
         lines.append("## Source content")
-        for sid in rec.source_ids:
+        for sid in source_ids:
             lines.append(f"- `{sid}`")
         lines.append("")
     lines.append("## Next step")
@@ -441,9 +472,10 @@ def _render_markdown(report: PerformanceReport) -> str:
     lines.append("")
 
     lines.append("## Trend signals")
-    if not report.trend_signals:
+    trend_signals = _coerce_str_list(report.trend_signals)
+    if not trend_signals:
         lines.append("_None._")
-    for sig in report.trend_signals:
+    for sig in trend_signals:
         lines.append(f"- {sig}")
     lines.append("")
 
@@ -472,9 +504,10 @@ def _render_markdown(report: PerformanceReport) -> str:
                 lines.append(
                     f"- **{r.target}** (conf {r.confidence:.2f}){stale_tag} — {r.rationale}"
                 )
-                if r.source_ids:
-                    lines.append(f"  - sources: {', '.join(r.source_ids)}")
-                for ev in r.evidence:
+                source_ids = _coerce_str_list(r.source_ids)
+                if source_ids:
+                    lines.append(f"  - sources: {', '.join(source_ids)}")
+                for ev in _coerce_str_list(r.evidence):
                     lines.append(f"  - evidence: {ev}")
             lines.append("")
     return "\n".join(lines).rstrip() + "\n"

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/core/atlas.py

@@ -13,6 +13,7 @@ import random
 import re
 import shutil
 import subprocess
+import time
 from contextlib import nullcontext as _nullcontext, suppress
 from dataclasses import dataclass, field
 from datetime import datetime, timedelta, timezone
@@ -675,6 +676,27 @@ class Atlas:
             ],
         }
 
+    @staticmethod
+    def _build_kai_task(content_brief: dict[str, Any]) -> str:
+        """Build Kai's task without turning absent evidence into requirements."""
+        has_issues = bool(content_brief.get("github_issues"))
+        has_source_files = bool(content_brief.get("source_files"))
+        issue_instruction = (
+            "Reference real GitHub issues from Sage's triage."
+            if has_issues
+            else "Avoid GitHub issue claims unless Sage supplied real issue evidence."
+        )
+        source_instruction = (
+            "Use actual file paths, commands, and APIs from the source code."
+            if has_source_files
+            else "Avoid source-code and file-path claims unless Dex supplied source evidence."
+        )
+        return (
+            "Write a technical tutorial addressing the #1 developer pain point. "
+            "Ground the content in the knowledge base and Dex's architecture analysis. "
+            f"{issue_instruction} {source_instruction}"
+        )
+
     def _slug(self, value: str, fallback: str) -> str:
         slug = re.sub(r"[^a-z0-9]+", "-", value.lower()).strip("-")
         return slug[:80] or fallback
@@ -734,13 +756,38 @@ class Atlas:
         the last completed checkpoint instead of re-running everything.
         Produces a run report with timing, cost, and quality data.
         """
-        from devrel_origin.tools.run_report import RunReport
+        from devrel_origin.tools.run_report import AgentTiming, RunReport
 
         run_report = RunReport(
             week_of=self.context.week_of,
             started_at=datetime.now().isoformat(),
         )
 
+        async def timed_delegate(
+            stage: int,
+            agent_name: str,
+            task: str,
+            context: Optional[dict[str, Any]] = None,
+        ) -> DelegationResult:
+            started_at = datetime.now(timezone.utc)
+            t0 = time.monotonic()
+            result = await self.delegate(agent_name, task, context)
+            completed_at = datetime.now(timezone.utc)
+            run_report.agent_timings.append(
+                AgentTiming(
+                    agent=agent_name,
+                    stage=stage,
+                    started_at=started_at.isoformat(),
+                    completed_at=completed_at.isoformat(),
+                    duration_seconds=time.monotonic() - t0,
+                    success=result.success,
+                    error=result.error or "",
+                )
+            )
+            if not result.success and result.error:
+                run_report.errors.append(f"{agent_name}: {result.error}")
+            return result
+
         # Check for existing checkpoint to resume from
         checkpoint = self._load_checkpoint(self.archive_dir, self.context.week_of)
         resume_stage = 0
@@ -765,7 +812,8 @@ class Atlas:
 
         # Stage 0: Watchdog health check (pre-flight)
         if resume_stage <= 0 and "watchdog" not in completed_agents:
-            watchdog_result = await self.delegate(
+            watchdog_result = await timed_delegate(
+                0,
                 "watchdog",
                 "Run system health check. Verify all integrations are "
                 "reachable and check for stale agent outputs from last cycle.",
@@ -793,7 +841,7 @@ class Atlas:
                         "Produce an architecture overview and API reference."
                     ),
                 }
-                coros = [self.delegate(a, tasks_1[a]) for a in stage_1_pending]
+                coros = [timed_delegate(1, a, tasks_1[a]) for a in stage_1_pending]
                 results = await asyncio.gather(*coros)
                 for agent_name, res in zip(stage_1_pending, results, strict=True):
                     if res.success:
@@ -822,7 +870,7 @@ class Atlas:
                         "severity."
                     ),
                 }
-                coros = [self.delegate(a, tasks_2[a]) for a in stage_2_pending]
+                coros = [timed_delegate(2, a, tasks_2[a]) for a in stage_2_pending]
                 results = await asyncio.gather(*coros)
                 for agent_name, res in zip(stage_2_pending, results, strict=True):
                     if res.success:
@@ -838,21 +886,17 @@ class Atlas:
             stage_3_agents = ["nova", "kai"]
             stage_3_pending = [a for a in stage_3_agents if a not in completed_agents]
             if stage_3_pending:
+                content_brief = self._build_content_brief()
                 tasks_3 = {
                     "nova": (
                         "Design activation experiments based on the top pain points. "
                         "Include pre-registration, power analysis, and success criteria."
                     ),
-                    "kai": (
-                        "Write a technical tutorial addressing the #1 developer pain point. "
-                        "Ground the content in the knowledge base and Dex's architecture "
-                        "analysis. Reference real GitHub issues from Sage's triage. "
-                        "Use actual file paths, commands, and APIs from the source code."
-                    ),
+                    "kai": self._build_kai_task(content_brief),
                 }
-                content_brief = self._build_content_brief()
                 coros = [
-                    self.delegate(
+                    timed_delegate(
+                        3,
                         a,
                         tasks_3[a],
                         context={"content_brief": content_brief} if a == "kai" else None,
@@ -871,7 +915,8 @@ class Atlas:
 
         # Stage 4: Vox (uses Kai's content)
         if resume_stage <= 4 and "vox" not in completed_agents:
-            video_result = await self.delegate(
+            video_result = await timed_delegate(
+                4,
                 "vox",
                 "Generate a video tutorial from Kai's written content. "
                 "Record screen walkthrough with narration and overlays.",
@@ -883,7 +928,8 @@ class Atlas:
 
         # Stage 5: Sentinel brand audit — audit all generated content
         if resume_stage <= 5 and "sentinel" not in completed_agents:
-            sentinel_result = await self.delegate(
+            sentinel_result = await timed_delegate(
+                5,
                 "sentinel",
                 "Audit all generated content for brand voice consistency, "
                 "ICP alignment, messaging coherence, and technical accuracy.",

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/core/vox.py

@@ -44,6 +44,40 @@ def _check_playwright() -> bool:
         return False
 
 
+def _missing_video_dependencies(
+    *,
+    has_ffmpeg: bool,
+    has_playwright: bool,
+    has_openai_key: bool,
+) -> list[dict[str, str]]:
+    missing: list[dict[str, str]] = []
+    if not has_ffmpeg:
+        missing.append(
+            {
+                "name": "ffmpeg",
+                "fix": "Install FFmpeg, for example `brew install ffmpeg` on macOS.",
+            }
+        )
+    if not has_playwright:
+        missing.append(
+            {
+                "name": "playwright",
+                "fix": (
+                    "Install video extras and browsers: "
+                    "`pip install 'devrel-origin[video]' && python -m playwright install chromium`."
+                ),
+            }
+        )
+    if not has_openai_key:
+        missing.append(
+            {
+                "name": "OPENAI_API_KEY",
+                "fix": "Set `OPENAI_API_KEY` or run `devrel auth` before rendering video.",
+            }
+        )
+    return missing
+
+
 class Vox:
     """
     Video Tutorial agent that produces screen-recorded tutorials.
@@ -94,7 +128,11 @@ Keep narration concise and developer-focused. Show, don't tell."""
         if not self._has_ffmpeg:
             logger.warning("FFmpeg not found — video rendering will be skipped")
         if not self._has_playwright:
-            logger.warning("Playwright not installed — recording will be skipped")
+            logger.warning(
+                "Playwright not installed — recording will be skipped. "
+                "Install video extras and browsers: `pip install 'devrel-origin[video]' "
+                "&& python -m playwright install chromium`."
+            )
 
     async def execute(
         self,
@@ -170,17 +208,29 @@ Keep narration concise and developer-focused. Show, don't tell."""
             "status": "script_only",
         }
 
-        can_render = self._has_ffmpeg and self._has_playwright and self.openai_api_key
+        missing_dependencies = _missing_video_dependencies(
+            has_ffmpeg=self._has_ffmpeg,
+            has_playwright=self._has_playwright,
+            has_openai_key=bool(self.openai_api_key),
+        )
+        result["video_produced"] = False
+        result["recording_skipped"] = bool(missing_dependencies)
+        result["missing_dependencies"] = missing_dependencies
+
+        can_render = not missing_dependencies
         if can_render:
             try:
                 output_path = await self._run_full_pipeline(tutorial)
                 result["status"] = "generated"
                 result["output_path"] = str(output_path)
                 result["total_duration"] = tutorial.total_duration
+                result["video_produced"] = True
+                result["recording_skipped"] = False
             except Exception as exc:
                 logger.error(f"Video pipeline failed: {exc}")
                 result["status"] = "script_only"
                 result["pipeline_error"] = str(exc)
+                result["recording_skipped"] = True
 
         return result
 

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/project/state.py

@@ -15,7 +15,7 @@ from contextlib import contextmanager
 from pathlib import Path
 from typing import Iterator
 
-SCHEMA_VERSION = 5
+SCHEMA_VERSION = 6
 
 SCHEMA = """
 CREATE TABLE IF NOT EXISTS schema_meta (
@@ -159,9 +159,56 @@ CREATE TABLE IF NOT EXISTS cro_funnel_metrics (
 
 CREATE INDEX IF NOT EXISTS idx_cro_funnel_period
     ON cro_funnel_metrics(funnel_id, period_end DESC);
+
+CREATE TABLE IF NOT EXISTS social_mentions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    platform TEXT NOT NULL,
+    post_id TEXT NOT NULL,
+    title TEXT,
+    url TEXT,
+    author TEXT,
+    content TEXT,
+    sentiment TEXT,
+    posted_at TEXT NOT NULL,
+    subreddit TEXT,
+    upvotes INTEGER NOT NULL DEFAULT 0,
+    comments INTEGER NOT NULL DEFAULT 0,
+    engagement_score REAL NOT NULL DEFAULT 0,
+    is_own_post INTEGER NOT NULL DEFAULT 0,
+    is_question INTEGER NOT NULL DEFAULT 0,
+    requires_response INTEGER NOT NULL DEFAULT 0,
+    created_at TEXT NOT NULL DEFAULT (datetime('now')),
+    UNIQUE (platform, post_id)
+);
+
+CREATE INDEX IF NOT EXISTS idx_social_mentions_posted_at
+    ON social_mentions(posted_at DESC);
+
+CREATE INDEX IF NOT EXISTS idx_social_mentions_own_period
+    ON social_mentions(is_own_post, posted_at DESC);
 """
 
 
+_SOCIAL_MENTIONS_COLUMNS: dict[str, str] = {
+    "platform": "TEXT NOT NULL DEFAULT ''",
+    "post_id": "TEXT NOT NULL DEFAULT ''",
+    "title": "TEXT",
+    "url": "TEXT",
+    "author": "TEXT",
+    "content": "TEXT",
+    "sentiment": "TEXT",
+    "posted_at": "TEXT NOT NULL DEFAULT ''",
+    "subreddit": "TEXT",
+    "upvotes": "INTEGER NOT NULL DEFAULT 0",
+    "comments": "INTEGER NOT NULL DEFAULT 0",
+    "engagement_score": "REAL NOT NULL DEFAULT 0",
+    "is_own_post": "INTEGER NOT NULL DEFAULT 0",
+    "is_question": "INTEGER NOT NULL DEFAULT 0",
+    "requires_response": "INTEGER NOT NULL DEFAULT 0",
+    "created_at": "TEXT NOT NULL DEFAULT ''",
+}
+
+
 def _migrate_to_v5(conn: sqlite3.Connection) -> None:
     """Add pillar + target_kind columns to analytics_recommendations if absent.
 
@@ -200,6 +247,67 @@ def _migrate_to_v5(conn: sqlite3.Connection) -> None:
     )
 
 
+def _migrate_to_v6(conn: sqlite3.Connection) -> None:
+    """Ensure Echo/Argus social mention storage exists and has v6 columns."""
+    conn.execute(
+        """
+        CREATE TABLE IF NOT EXISTS social_mentions (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            platform TEXT NOT NULL,
+            post_id TEXT NOT NULL,
+            title TEXT,
+            url TEXT,
+            author TEXT,
+            content TEXT,
+            sentiment TEXT,
+            posted_at TEXT NOT NULL,
+            subreddit TEXT,
+            upvotes INTEGER NOT NULL DEFAULT 0,
+            comments INTEGER NOT NULL DEFAULT 0,
+            engagement_score REAL NOT NULL DEFAULT 0,
+            is_own_post INTEGER NOT NULL DEFAULT 0,
+            is_question INTEGER NOT NULL DEFAULT 0,
+            requires_response INTEGER NOT NULL DEFAULT 0,
+            created_at TEXT NOT NULL DEFAULT (datetime('now')),
+            UNIQUE (platform, post_id)
+        )
+        """
+    )
+    cur = conn.execute("PRAGMA table_info(social_mentions)")
+    cols = {row[1] for row in cur.fetchall()}
+    for col, ddl in _SOCIAL_MENTIONS_COLUMNS.items():
+        if col not in cols:
+            conn.execute(f"ALTER TABLE social_mentions ADD COLUMN {col} {ddl}")
+
+    cols = {row[1] for row in conn.execute("PRAGMA table_info(social_mentions)").fetchall()}
+    if "score" in cols:
+        conn.execute(
+            "UPDATE social_mentions "
+            "SET engagement_score = COALESCE(NULLIF(engagement_score, 0), score, 0)"
+        )
+    if "engagement" in cols:
+        conn.execute(
+            "UPDATE social_mentions "
+            "SET engagement_score = COALESCE(NULLIF(engagement_score, 0), engagement, 0), "
+            "    upvotes = COALESCE(NULLIF(upvotes, 0), engagement, 0)"
+        )
+    if "url" in cols:
+        fallback_id = "CAST(id AS TEXT)" if "id" in cols else "rowid"
+        conn.execute(
+            "UPDATE social_mentions "
+            f"SET post_id = COALESCE(NULLIF(post_id, ''), NULLIF(url, ''), {fallback_id}) "
+            "WHERE post_id IS NULL OR post_id = ''"
+        )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_social_mentions_posted_at "
+        "ON social_mentions(posted_at DESC)"
+    )
+    conn.execute(
+        "CREATE INDEX IF NOT EXISTS idx_social_mentions_own_period "
+        "ON social_mentions(is_own_post, posted_at DESC)"
+    )
+
+
 def init_db(db_path: Path) -> None:
     """Create the DB file and apply the schema. Idempotent: preserves
     existing data and bumps schema_meta to the current SCHEMA_VERSION."""
@@ -207,6 +315,7 @@ def init_db(db_path: Path) -> None:
     with sqlite3.connect(db_path) as conn:
         conn.executescript(SCHEMA)
         _migrate_to_v5(conn)
+        _migrate_to_v6(conn)
         conn.execute(
             "INSERT OR REPLACE INTO schema_meta (version, applied_at) VALUES (?, datetime('now'))",
             (SCHEMA_VERSION,),

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/quality/editorial.py

@@ -10,7 +10,7 @@ Stage flow:
   6. Persona             — Haiku score 1-10 + weak sections
   7. Readability         — pure-Python FRE/sentence-stats/jargon check
   → If 6 or 7 fail: re-run stage 4 once with the failed rubric, then
-    re-run 5/6/7 once. Second failure of 6/7 logs and ships flagged.
+    re-run 5/6/7 once. Second persona failure aborts loudly.
   8. Brand audit         — Sentinel (caller's responsibility; orchestrator
                             does not invoke Sentinel because it lives in
                             core/sentinel.py and would create a quality→core
@@ -328,17 +328,16 @@ async def run_pipeline(
         readability2 = _readability_stage(text=text, content_type=content_type, style_md=style_md)
         stages.append(readability2)
 
-        # Readability re-runs are informational only — short test/mock text
-        # often fails MSL but the persona pass is what gates "ship vs flag".
-        # Only persona2 failure flips the flagged bit.
+        # Readability re-runs are informational only because short test/mock
+        # text often fails MSL. Persona is the hard ship/no-ship gate.
         if persona2.issues:
-            logger.warning(
-                "editorial pipeline shipping with flagged=True for content_type=%s "
-                "(persona score %s)",
+            issue_text = "; ".join(persona2.issues)
+            logger.error(
+                "editorial pipeline aborting for content_type=%s after persona repair failed: %s",
                 content_type,
-                persona2.score,
+                issue_text,
             )
-            flagged = True
+            raise AbortLoud(f"Persona gate failed after repair for {content_type}: {issue_text}")
 
     revision_trace = {
         "content_type": content_type,

{devrel_origin-0.2.14 → devrel_origin-0.2.16}/src/devrel_origin/tools/analytics.py

@@ -54,14 +54,17 @@ class PostHogCollector:
 
     def __init__(self, client: "PostHogClient"):
         self.client = client
+        self.last_ok = True
 
     async def collect(self, period: Period) -> list[PerformanceMetric]:
         _start, end = period
         try:
             rows = await self.client.fetch_events_by_url(start=_start, end=end)
         except Exception as exc:  # noqa: BLE001
+            self.last_ok = False
             logger.warning("PostHogCollector failed: %s", exc)
             return []
+        self.last_ok = True
 
         metrics: list[PerformanceMetric] = []
         for row in rows:
@@ -95,14 +98,19 @@ class GitHubCollector:
 
     def __init__(self, client):
         self.client = client
+        self.last_ok = True
 
     async def collect(self, period: Period) -> list[PerformanceMetric]:
         _start, end = period
         try:
             stats = await self.client.get_repo_stats()
+            if not isinstance(stats, dict):
+                raise TypeError("github stats payload is not a dict")
         except Exception as exc:  # noqa: BLE001
+            self.last_ok = False
             logger.warning("GitHubCollector failed: %s", exc)
             return []
+        self.last_ok = True
 
         repo = getattr(self.client, "repo_full_name", "unknown/unknown")
         return [
@@ -152,14 +160,22 @@ class InstantlyCollector:
 
     def __init__(self, client):
         self.client = client
+        self.last_ok = True
 
     async def collect(self, period: Period) -> list[PerformanceMetric]:
+        if self.client is None:
+            self.last_ok = False
+            logger.info("InstantlyCollector: client not configured, skipping")
+            return []
+
         start, end = period
         try:
             rows = await self.client.list_campaigns_with_analytics()
         except Exception as exc:  # noqa: BLE001
+            self.last_ok = False
             logger.warning("InstantlyCollector failed: %s", exc)
             return []
+        self.last_ok = True
 
         metrics: list[PerformanceMetric] = []
         for row in rows:
@@ -218,6 +234,7 @@ class SocialCollector:
     def __init__(self, state_db_path: Path):
         self.state_db_path = state_db_path
         self._schema_verified = False
+        self.last_ok = True
 
     def _verify_schema(self, conn: sqlite3.Connection) -> bool:
         """Confirm social_mentions has all required columns.
@@ -269,6 +286,7 @@ class SocialCollector:
     async def collect(self, period: Period) -> list[PerformanceMetric]:
         start, end = period
         if not self.state_db_path.is_file():
+            self.last_ok = False
             logger.info("SocialCollector: state.db not present, skipping")
             return []
 
@@ -278,7 +296,9 @@ class SocialCollector:
             end.isoformat(),
         )
         if rows is None:
+            self.last_ok = False
             return []
+        self.last_ok = True
 
         metrics: list[PerformanceMetric] = []
         for row in rows: